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
):
881 if self
.ConditionalPcds
:
882 self
.GenerateReportDetail(File
, ModulePcdSet
, 1)
884 self
.GenerateReportDetail(File
, ModulePcdSet
, 2)
885 self
.GenerateReportDetail(File
, ModulePcdSet
)
888 # Generate report for PCD information
890 # This function generates report for separate module expression
891 # in a platform build.
893 # @param self The object pointer
894 # @param File The file object for report
895 # @param ModulePcdSet Set of all PCDs referenced by module or None for
896 # platform PCD report
897 # @param ReportySubType 0 means platform/module PCD report, 1 means Conditional
898 # directives section report, 2 means Unused Pcds section report
899 # @param DscOverridePcds Module DSC override PCDs set
901 def GenerateReportDetail(self
, File
, ModulePcdSet
, ReportSubType
= 0):
902 PcdDict
= self
.AllPcds
903 if ReportSubType
== 1:
904 PcdDict
= self
.ConditionalPcds
905 elif ReportSubType
== 2:
906 PcdDict
= self
.UnusedPcds
909 FileWrite(File
, gSectionStart
)
910 if ReportSubType
== 1:
911 FileWrite(File
, "Conditional Directives used by the build system")
912 elif ReportSubType
== 2:
913 FileWrite(File
, "PCDs not used by modules or in conditional directives")
915 FileWrite(File
, "Platform Configuration Database Report")
917 FileWrite(File
, " *B - PCD override in the build option")
918 FileWrite(File
, " *P - Platform scoped PCD override in DSC file")
919 FileWrite(File
, " *F - Platform scoped PCD override in FDF file")
920 if not ReportSubType
:
921 FileWrite(File
, " *M - Module scoped PCD override")
922 FileWrite(File
, gSectionSep
)
924 if not ReportSubType
and ModulePcdSet
:
926 # For module PCD sub-section
928 FileWrite(File
, gSubSectionStart
)
929 FileWrite(File
, TAB_BRG_PCD
)
930 FileWrite(File
, gSubSectionSep
)
934 # Group PCD by their token space GUID C Name
937 for Type
in PcdDict
[Key
]:
939 # Group PCD by their usage type
941 TypeName
, DecType
= gPcdTypeMap
.get(Type
, ("", Type
))
942 for Pcd
in PcdDict
[Key
][Type
]:
943 PcdTokenCName
= Pcd
.TokenCName
945 if GlobalData
.MixedPcd
:
946 for PcdKey
in GlobalData
.MixedPcd
:
947 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
) in GlobalData
.MixedPcd
[PcdKey
]:
948 PcdTokenCName
= PcdKey
[0]
950 if MixedPcdFlag
and not ModulePcdSet
:
953 # Get PCD default value and their override relationship
955 DecDefaultValue
= self
.DecPcdDefault
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, DecType
))
956 DscDefaultValue
= self
.DscPcdDefault
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
))
957 DscDefaultValBak
= DscDefaultValue
958 DscDefaultValue
= self
.FdfPcdSet
.get((Pcd
.TokenCName
, Key
), DscDefaultValue
)
959 if DscDefaultValue
!= DscDefaultValBak
:
961 DscDefaultValue
= ValueExpressionEx(DscDefaultValue
, Pcd
.DatumType
, self
._GuidDict
)(True)
962 except BadExpression
, DscDefaultValue
:
963 EdkLogger
.error('BuildReport', FORMAT_INVALID
, "PCD Value: %s, Type: %s" %(DscDefaultValue
, Pcd
.DatumType
))
965 InfDefaultValue
= None
967 PcdValue
= DecDefaultValue
969 PcdValue
= DscDefaultValue
970 if ModulePcdSet
is not None:
971 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Type
) not in ModulePcdSet
:
973 InfDefault
, PcdValue
= ModulePcdSet
[Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Type
]
974 Pcd
.DefaultValue
= PcdValue
978 BuildOptionMatch
= False
979 if GlobalData
.BuildOptionPcd
:
980 for pcd
in GlobalData
.BuildOptionPcd
:
981 if (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
) == (pcd
[0], pcd
[1]):
985 Pcd
.DefaultValue
= PcdValue
986 BuildOptionMatch
= True
990 if ModulePcdSet
is None:
996 if Pcd
.DatumType
in ('UINT8', 'UINT16', 'UINT32', 'UINT64'):
997 PcdValueNumber
= int(PcdValue
.strip(), 0)
998 if DecDefaultValue
is None:
1001 DecDefaultValueNumber
= int(DecDefaultValue
.strip(), 0)
1002 DecMatch
= (DecDefaultValueNumber
== PcdValueNumber
)
1004 if InfDefaultValue
is None:
1007 InfDefaultValueNumber
= int(InfDefaultValue
.strip(), 0)
1008 InfMatch
= (InfDefaultValueNumber
== PcdValueNumber
)
1010 if DscDefaultValue
is None:
1013 DscDefaultValueNumber
= int(DscDefaultValue
.strip(), 0)
1014 DscMatch
= (DscDefaultValueNumber
== PcdValueNumber
)
1016 if DecDefaultValue
is None:
1019 DecMatch
= (DecDefaultValue
.strip() == PcdValue
.strip())
1021 if InfDefaultValue
is None:
1024 InfMatch
= (InfDefaultValue
.strip() == PcdValue
.strip())
1026 if DscDefaultValue
is None:
1029 DscMatch
= (DscDefaultValue
.strip() == PcdValue
.strip())
1032 if GlobalData
.gStructurePcd
and (self
.Arch
in GlobalData
.gStructurePcd
.keys()) and ((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
) in GlobalData
.gStructurePcd
[self
.Arch
]):
1034 if TypeName
in ('DYNVPD', 'DEXVPD'):
1035 SkuInfoList
= Pcd
.SkuInfoList
1036 Pcd
= GlobalData
.gStructurePcd
[self
.Arch
][(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
)]
1037 Pcd
.DatumType
= Pcd
.StructName
1038 if TypeName
in ('DYNVPD', 'DEXVPD'):
1039 Pcd
.SkuInfoList
= SkuInfoList
1040 if Pcd
.PcdFieldValueFromComm
:
1041 BuildOptionMatch
= True
1043 elif Pcd
.SkuOverrideValues
:
1045 if not Pcd
.SkuInfoList
:
1046 OverrideValues
= Pcd
.SkuOverrideValues
1048 Keys
= OverrideValues
.keys()
1049 Data
= OverrideValues
[Keys
[0]]
1050 Struct
= Data
.values()[0]
1051 DscOverride
= self
.ParseStruct(Struct
)
1053 SkuList
= sorted(Pcd
.SkuInfoList
.keys())
1055 SkuInfo
= Pcd
.SkuInfoList
[Sku
]
1056 if TypeName
in ('DYNHII', 'DEXHII'):
1057 if SkuInfo
.DefaultStoreDict
:
1058 DefaultStoreList
= sorted(SkuInfo
.DefaultStoreDict
.keys())
1059 for DefaultStore
in DefaultStoreList
:
1060 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1061 DscOverride
= self
.ParseStruct(OverrideValues
[DefaultStore
])
1065 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1067 Keys
= OverrideValues
.keys()
1068 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[Keys
[0]])
1069 DscOverride
= self
.ParseStruct(OverrideFieldStruct
)
1077 # Report PCD item according to their override relationship
1079 if DecMatch
and InfMatch
:
1080 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, ' ')
1081 elif BuildOptionMatch
:
1082 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*B')
1085 if (Pcd
.TokenCName
, Key
) in self
.FdfPcdSet
:
1086 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*F')
1088 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*P')
1090 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*M')
1092 if ModulePcdSet
is None:
1095 if not TypeName
in ('PATCH', 'FLAG', 'FIXED'):
1097 if not BuildOptionMatch
:
1098 ModuleOverride
= self
.ModulePcdOverride
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
), {})
1099 for ModulePath
in ModuleOverride
:
1100 ModuleDefault
= ModuleOverride
[ModulePath
]
1101 if Pcd
.DatumType
in ('UINT8', 'UINT16', 'UINT32', 'UINT64'):
1102 ModulePcdDefaultValueNumber
= int(ModuleDefault
.strip(), 0)
1103 Match
= (ModulePcdDefaultValueNumber
== PcdValueNumber
)
1105 Match
= (ModuleDefault
.strip() == PcdValue
.strip())
1108 IsByteArray
, ArrayList
= ByteArrayForamt(ModuleDefault
.strip())
1110 FileWrite(File
, ' *M %-*s = %s' % (self
.MaxLen
+ 19, ModulePath
, '{'))
1111 for Array
in ArrayList
:
1112 FileWrite(File
, '%s' % (Array
))
1114 FileWrite(File
, ' *M %-*s = %s' % (self
.MaxLen
+ 19, ModulePath
, ModuleDefault
.strip()))
1116 if ModulePcdSet
is None:
1117 FileWrite(File
, gSectionEnd
)
1119 if not ReportSubType
and ModulePcdSet
:
1120 FileWrite(File
, gSubSectionEnd
)
1122 def ParseStruct(self
, struct
):
1123 HasDscOverride
= False
1125 for _
, Values
in struct
.items():
1126 if Values
[1] and Values
[1].endswith('.dsc'):
1127 HasDscOverride
= True
1129 return HasDscOverride
1131 def PrintPcdDefault(self
, File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
):
1132 if not DscMatch
and DscDefaultValue
is not None:
1133 Value
= DscDefaultValue
.strip()
1134 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1136 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DSC DEFAULT', "{"))
1137 for Array
in ArrayList
:
1138 FileWrite(File
, '%s' % (Array
))
1140 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DSC DEFAULT', Value
))
1141 if not InfMatch
and InfDefaultValue
is not None:
1142 Value
= InfDefaultValue
.strip()
1143 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1145 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'INF DEFAULT', "{"))
1146 for Array
in ArrayList
:
1147 FileWrite(File
, '%s' % (Array
))
1149 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'INF DEFAULT', Value
))
1151 if not DecMatch
and DecDefaultValue
is not None:
1152 Value
= DecDefaultValue
.strip()
1153 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1155 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DEC DEFAULT', "{"))
1156 for Array
in ArrayList
:
1157 FileWrite(File
, '%s' % (Array
))
1159 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DEC DEFAULT', Value
))
1161 self
.PrintStructureInfo(File
, Pcd
.DefaultValues
)
1162 if DecMatch
and IsStructure
:
1163 self
.PrintStructureInfo(File
, Pcd
.DefaultValues
)
1165 def PrintPcdValue(self
, File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, Flag
= ' '):
1166 if not Pcd
.SkuInfoList
:
1167 Value
= Pcd
.DefaultValue
1168 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1170 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1171 for Array
in ArrayList
:
1172 FileWrite(File
, '%s' % (Array
))
1174 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1176 OverrideValues
= Pcd
.SkuOverrideValues
1178 Keys
= OverrideValues
.keys()
1179 Data
= OverrideValues
[Keys
[0]]
1180 Struct
= Data
.values()[0]
1181 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, Struct
)
1182 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1183 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1186 SkuList
= sorted(Pcd
.SkuInfoList
.keys())
1188 SkuInfo
= Pcd
.SkuInfoList
[Sku
]
1189 SkuIdName
= SkuInfo
.SkuIdName
1190 if TypeName
in ('DYNHII', 'DEXHII'):
1191 if SkuInfo
.DefaultStoreDict
:
1192 DefaultStoreList
= sorted(SkuInfo
.DefaultStoreDict
.keys())
1193 for DefaultStore
in DefaultStoreList
:
1194 Value
= SkuInfo
.DefaultStoreDict
[DefaultStore
]
1195 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1199 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1200 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1201 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1202 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '{'))
1203 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1204 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', '{'))
1206 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', '{'))
1207 for Array
in ArrayList
:
1208 FileWrite(File
, '%s' % (Array
))
1210 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1211 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1212 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1213 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1214 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1215 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', Value
))
1217 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', Value
))
1220 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1221 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1222 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1223 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '{'))
1224 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1225 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', '{'))
1227 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', '{'))
1228 for Array
in ArrayList
:
1229 FileWrite(File
, '%s' % (Array
))
1231 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1232 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1233 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1234 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1235 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1236 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', Value
))
1238 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', Value
))
1239 FileWrite(File
, '%*s: %s: %s' % (self
.MaxLen
+ 4, SkuInfo
.VariableGuid
, SkuInfo
.VariableName
, SkuInfo
.VariableOffset
))
1241 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1242 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[DefaultStore
])
1243 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1244 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1246 Value
= SkuInfo
.DefaultValue
1247 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1252 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', "{"))
1254 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', "{"))
1255 for Array
in ArrayList
:
1256 FileWrite(File
, '%s' % (Array
))
1259 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1261 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1265 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', "{"))
1267 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', "{"))
1268 for Array
in ArrayList
:
1269 FileWrite(File
, '%s' % (Array
))
1272 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1274 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1275 if TypeName
in ('DYNVPD', 'DEXVPD'):
1276 FileWrite(File
, '%*s' % (self
.MaxLen
+ 4, SkuInfo
.VpdOffset
))
1278 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1280 Keys
= OverrideValues
.keys()
1281 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[Keys
[0]])
1282 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1283 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1285 def OverrideFieldValue(self
, Pcd
, OverrideStruct
):
1286 OverrideFieldStruct
= collections
.OrderedDict()
1288 for Key
, Values
in OverrideStruct
.items():
1289 if Values
[1] and Values
[1].endswith('.dsc'):
1290 OverrideFieldStruct
[Key
] = Values
1291 if Pcd
.PcdFieldValueFromComm
:
1292 for Key
, Values
in Pcd
.PcdFieldValueFromComm
.items():
1293 OverrideFieldStruct
[Key
] = Values
1294 return OverrideFieldStruct
1296 def PrintStructureInfo(self
, File
, Struct
):
1297 for Key
, Value
in Struct
.items():
1298 if Value
[1] and 'build command options' in Value
[1]:
1299 FileWrite(File
, ' *B %-*s = %s' % (self
.MaxLen
+ 4, '.' + Key
, Value
[0]))
1301 FileWrite(File
, ' %-*s = %s' % (self
.MaxLen
+ 4, '.' + Key
, Value
[0]))
1303 def StrtoHex(self
, value
):
1305 value
= hex(int(value
))
1308 if value
.startswith("L\"") and value
.endswith("\""):
1310 for ch
in value
[2:-1]:
1311 valuelist
.append(hex(ord(ch
)))
1312 valuelist
.append('0x00')
1314 elif value
.startswith("\"") and value
.endswith("\""):
1315 return hex(ord(value
[1:-1]))
1316 elif value
.startswith("{") and value
.endswith("}"):
1318 if ',' not in value
:
1320 for ch
in value
[1:-1].split(','):
1322 if ch
.startswith('0x') or ch
.startswith('0X'):
1323 valuelist
.append(ch
)
1326 valuelist
.append(hex(int(ch
.strip())))
1334 # Reports platform and module Prediction information
1336 # This class reports the platform execution order prediction section and
1337 # module load fixed address prediction subsection in the build report file.
1339 class PredictionReport(object):
1341 # Constructor function for class PredictionReport
1343 # This constructor function generates PredictionReport object for the platform.
1345 # @param self: The object pointer
1346 # @param Wa Workspace context information
1348 def __init__(self
, Wa
):
1349 self
._MapFileName
= os
.path
.join(Wa
.BuildDir
, Wa
.Name
+ ".map")
1350 self
._MapFileParsed
= False
1351 self
._EotToolInvoked
= False
1352 self
._FvDir
= Wa
.FvDir
1353 self
._EotDir
= Wa
.BuildDir
1354 self
._FfsEntryPoint
= {}
1356 self
._SourceList
= []
1357 self
.FixedMapDict
= {}
1362 # Collect all platform reference source files and GUID C Name
1364 for Pa
in Wa
.AutoGenObjectList
:
1365 for Module
in Pa
.LibraryAutoGenList
+ Pa
.ModuleAutoGenList
:
1367 # BASE typed modules are EFI agnostic, so we need not scan
1368 # their source code to find PPI/Protocol produce or consume
1371 if Module
.ModuleType
== "BASE":
1374 # Add module referenced source files
1376 self
._SourceList
.append(str(Module
))
1378 for Source
in Module
.SourceFileList
:
1379 if os
.path
.splitext(str(Source
))[1].lower() == ".c":
1380 self
._SourceList
.append(" " + str(Source
))
1381 FindIncludeFiles(Source
.Path
, Module
.IncludePathList
, IncludeList
)
1382 for IncludeFile
in IncludeList
.values():
1383 self
._SourceList
.append(" " + IncludeFile
)
1385 for Guid
in Module
.PpiList
:
1386 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.PpiList
[Guid
])
1387 for Guid
in Module
.ProtocolList
:
1388 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.ProtocolList
[Guid
])
1389 for Guid
in Module
.GuidList
:
1390 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.GuidList
[Guid
])
1392 if Module
.Guid
and not Module
.IsLibrary
:
1393 EntryPoint
= " ".join(Module
.Module
.ModuleEntryPointList
)
1394 if int(str(Module
.AutoGenVersion
), 0) >= 0x00010005:
1395 RealEntryPoint
= "_ModuleEntryPoint"
1397 RealEntryPoint
= EntryPoint
1398 if EntryPoint
== "_ModuleEntryPoint":
1399 CCFlags
= Module
.BuildOption
.get("CC", {}).get("FLAGS", "")
1400 Match
= gGlueLibEntryPoint
.search(CCFlags
)
1402 EntryPoint
= Match
.group(1)
1404 self
._FfsEntryPoint
[Module
.Guid
.upper()] = (EntryPoint
, RealEntryPoint
)
1408 # Collect platform firmware volume list as the input of EOT.
1412 for Fd
in Wa
.FdfProfile
.FdDict
:
1413 for FdRegion
in Wa
.FdfProfile
.FdDict
[Fd
].RegionList
:
1414 if FdRegion
.RegionType
!= "FV":
1416 for FvName
in FdRegion
.RegionDataList
:
1417 if FvName
in self
._FvList
:
1419 self
._FvList
.append(FvName
)
1420 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1421 for Section
in Ffs
.SectionList
:
1423 for FvSection
in Section
.SectionList
:
1424 if FvSection
.FvName
in self
._FvList
:
1426 self
._FvList
.append(FvSection
.FvName
)
1427 except AttributeError:
1432 # Parse platform fixed address map files
1434 # This function parses the platform final fixed address map file to get
1435 # the database of predicted fixed address for module image base, entry point
1438 # @param self: The object pointer
1440 def _ParseMapFile(self
):
1441 if self
._MapFileParsed
:
1443 self
._MapFileParsed
= True
1444 if os
.path
.isfile(self
._MapFileName
):
1446 FileContents
= open(self
._MapFileName
).read()
1447 for Match
in gMapFileItemPattern
.finditer(FileContents
):
1448 AddressType
= Match
.group(1)
1449 BaseAddress
= Match
.group(2)
1450 EntryPoint
= Match
.group(3)
1451 Guid
= Match
.group(4).upper()
1452 List
= self
.FixedMapDict
.setdefault(Guid
, [])
1453 List
.append((AddressType
, BaseAddress
, "*I"))
1454 List
.append((AddressType
, EntryPoint
, "*E"))
1456 EdkLogger
.warn(None, "Cannot open file to read", self
._MapFileName
)
1459 # Invokes EOT tool to get the predicted the execution order.
1461 # This function invokes EOT tool to calculate the predicted dispatch order
1463 # @param self: The object pointer
1465 def _InvokeEotTool(self
):
1466 if self
._EotToolInvoked
:
1469 self
._EotToolInvoked
= True
1471 for FvName
in self
._FvList
:
1472 FvFile
= os
.path
.join(self
._FvDir
, FvName
+ ".Fv")
1473 if os
.path
.isfile(FvFile
):
1474 FvFileList
.append(FvFile
)
1476 if len(FvFileList
) == 0:
1479 # Write source file list and GUID file list to an intermediate file
1480 # as the input for EOT tool and dispatch List as the output file
1483 SourceList
= os
.path
.join(self
._EotDir
, "SourceFile.txt")
1484 GuidList
= os
.path
.join(self
._EotDir
, "GuidList.txt")
1485 DispatchList
= os
.path
.join(self
._EotDir
, "Dispatch.txt")
1487 TempFile
= open(SourceList
, "w+")
1488 for Item
in self
._SourceList
:
1489 FileWrite(TempFile
, Item
)
1491 TempFile
= open(GuidList
, "w+")
1492 for Key
in self
._GuidMap
:
1493 FileWrite(TempFile
, "%s %s" % (Key
, self
._GuidMap
[Key
]))
1497 from Eot
.Eot
import Eot
1500 # Invoke EOT tool and echo its runtime performance
1502 EotStartTime
= time
.time()
1503 Eot(CommandLineOption
=False, SourceFileList
=SourceList
, GuidList
=GuidList
,
1504 FvFileList
=' '.join(FvFileList
), Dispatch
=DispatchList
, IsInit
=True)
1505 EotEndTime
= time
.time()
1506 EotDuration
= time
.strftime("%H:%M:%S", time
.gmtime(int(round(EotEndTime
- EotStartTime
))))
1507 EdkLogger
.quiet("EOT run time: %s\n" % EotDuration
)
1510 # Parse the output of EOT tool
1512 for Line
in open(DispatchList
):
1513 if len(Line
.split()) < 4:
1515 (Guid
, Phase
, FfsName
, FilePath
) = Line
.split()
1516 Symbol
= self
._FfsEntryPoint
.get(Guid
, [FfsName
, ""])[0]
1517 if len(Symbol
) > self
.MaxLen
:
1518 self
.MaxLen
= len(Symbol
)
1519 self
.ItemList
.append((Phase
, Symbol
, FilePath
))
1521 EdkLogger
.quiet("(Python %s on %s\n%s)" % (platform
.python_version(), sys
.platform
, traceback
.format_exc()))
1522 EdkLogger
.warn(None, "Failed to generate execution order prediction report, for some error occurred in executing EOT.")
1526 # Generate platform execution order report
1528 # This function generates the predicted module execution order.
1530 # @param self The object pointer
1531 # @param File The file object for report
1533 def _GenerateExecutionOrderReport(self
, File
):
1534 self
._InvokeEotTool
()
1535 if len(self
.ItemList
) == 0:
1537 FileWrite(File
, gSectionStart
)
1538 FileWrite(File
, "Execution Order Prediction")
1539 FileWrite(File
, "*P PEI phase")
1540 FileWrite(File
, "*D DXE phase")
1541 FileWrite(File
, "*E Module INF entry point name")
1542 FileWrite(File
, "*N Module notification function name")
1544 FileWrite(File
, "Type %-*s %s" % (self
.MaxLen
, "Symbol", "Module INF Path"))
1545 FileWrite(File
, gSectionSep
)
1546 for Item
in self
.ItemList
:
1547 FileWrite(File
, "*%sE %-*s %s" % (Item
[0], self
.MaxLen
, Item
[1], Item
[2]))
1549 FileWrite(File
, gSectionStart
)
1552 # Generate Fixed Address report.
1554 # This function generate the predicted fixed address report for a module
1555 # specified by Guid.
1557 # @param self The object pointer
1558 # @param File The file object for report
1559 # @param Guid The module Guid value.
1560 # @param NotifyList The list of all notify function in a module
1562 def _GenerateFixedAddressReport(self
, File
, Guid
, NotifyList
):
1563 self
._ParseMapFile
()
1564 FixedAddressList
= self
.FixedMapDict
.get(Guid
)
1565 if not FixedAddressList
:
1568 FileWrite(File
, gSubSectionStart
)
1569 FileWrite(File
, "Fixed Address Prediction")
1570 FileWrite(File
, "*I Image Loading Address")
1571 FileWrite(File
, "*E Entry Point Address")
1572 FileWrite(File
, "*N Notification Function Address")
1573 FileWrite(File
, "*F Flash Address")
1574 FileWrite(File
, "*M Memory Address")
1575 FileWrite(File
, "*S SMM RAM Offset")
1576 FileWrite(File
, "TOM Top of Memory")
1578 FileWrite(File
, "Type Address Name")
1579 FileWrite(File
, gSubSectionSep
)
1580 for Item
in FixedAddressList
:
1585 Name
= "(Image Base)"
1586 elif Symbol
== "*E":
1587 Name
= self
._FfsEntryPoint
.get(Guid
, ["", "_ModuleEntryPoint"])[1]
1588 elif Symbol
in NotifyList
:
1596 elif "Memory" in Type
:
1602 Value
= "TOM" + Value
1604 FileWrite(File
, "%s %-16s %s" % (Symbol
, Value
, Name
))
1607 # Generate report for the prediction part
1609 # This function generate the predicted fixed address report for a module or
1610 # predicted module execution order for a platform.
1611 # If the input Guid is None, then, it generates the predicted module execution order;
1612 # otherwise it generated the module fixed loading address for the module specified by
1615 # @param self The object pointer
1616 # @param File The file object for report
1617 # @param Guid The module Guid value.
1619 def GenerateReport(self
, File
, Guid
):
1621 self
._GenerateFixedAddressReport
(File
, Guid
.upper(), [])
1623 self
._GenerateExecutionOrderReport
(File
)
1626 # Reports FD region information
1628 # This class reports the FD subsection in the build report file.
1629 # It collects region information of platform flash device.
1630 # If the region is a firmware volume, it lists the set of modules
1631 # and its space information; otherwise, it only lists its region name,
1632 # base address and size in its sub-section header.
1633 # If there are nesting FVs, the nested FVs will list immediate after
1634 # this FD region subsection
1636 class FdRegionReport(object):
1638 # Discover all the nested FV name list.
1640 # This is an internal worker function to discover the all the nested FV information
1641 # in the parent firmware volume. It uses deep first search algorithm recursively to
1642 # find all the FV list name and append them to the list.
1644 # @param self The object pointer
1645 # @param FvName The name of current firmware file system
1646 # @param Wa Workspace context information
1648 def _DiscoverNestedFvList(self
, FvName
, Wa
):
1649 FvDictKey
=FvName
.upper()
1650 if FvDictKey
in Wa
.FdfProfile
.FvDict
:
1651 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1652 for Section
in Ffs
.SectionList
:
1654 for FvSection
in Section
.SectionList
:
1655 if FvSection
.FvName
in self
.FvList
:
1657 self
._GuidsDb
[Ffs
.NameGuid
.upper()] = FvSection
.FvName
1658 self
.FvList
.append(FvSection
.FvName
)
1659 self
.FvInfo
[FvSection
.FvName
] = ("Nested FV", 0, 0)
1660 self
._DiscoverNestedFvList
(FvSection
.FvName
, Wa
)
1661 except AttributeError:
1665 # Constructor function for class FdRegionReport
1667 # This constructor function generates FdRegionReport object for a specified FdRegion.
1668 # If the FdRegion is a firmware volume, it will recursively find all its nested Firmware
1669 # volume list. This function also collects GUID map in order to dump module identification
1670 # in the final report.
1672 # @param self: The object pointer
1673 # @param FdRegion The current FdRegion object
1674 # @param Wa Workspace context information
1676 def __init__(self
, FdRegion
, Wa
):
1677 self
.Type
= FdRegion
.RegionType
1678 self
.BaseAddress
= FdRegion
.Offset
1679 self
.Size
= FdRegion
.Size
1683 self
._FvDir
= Wa
.FvDir
1684 self
._WorkspaceDir
= Wa
.WorkspaceDir
1687 # If the input FdRegion is not a firmware volume,
1690 if self
.Type
!= "FV":
1694 # Find all nested FVs in the FdRegion
1696 for FvName
in FdRegion
.RegionDataList
:
1697 if FvName
in self
.FvList
:
1699 self
.FvList
.append(FvName
)
1700 self
.FvInfo
[FvName
] = ("Fd Region", self
.BaseAddress
, self
.Size
)
1701 self
._DiscoverNestedFvList
(FvName
, Wa
)
1705 # Collect PCDs declared in DEC files.
1707 for Pa
in Wa
.AutoGenObjectList
:
1708 for Package
in Pa
.PackageList
:
1709 for (TokenCName
, TokenSpaceGuidCName
, DecType
) in Package
.Pcds
:
1710 DecDefaultValue
= Package
.Pcds
[TokenCName
, TokenSpaceGuidCName
, DecType
].DefaultValue
1711 PlatformPcds
[(TokenCName
, TokenSpaceGuidCName
)] = DecDefaultValue
1713 # Collect PCDs defined in DSC file
1715 for Pa
in Wa
.AutoGenObjectList
:
1716 for (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
1717 DscDefaultValue
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)].DefaultValue
1718 PlatformPcds
[(TokenCName
, TokenSpaceGuidCName
)] = DscDefaultValue
1721 # Add PEI and DXE a priori files GUIDs defined in PI specification.
1723 self
._GuidsDb
["1B45CC0A-156A-428A-AF62-49864DA0E6E6"] = "PEI Apriori"
1724 self
._GuidsDb
["FC510EE7-FFDC-11D4-BD41-0080C73C8881"] = "DXE Apriori"
1726 # Add ACPI table storage file
1728 self
._GuidsDb
["7E374E25-8E01-4FEE-87F2-390C23C606CD"] = "ACPI table storage"
1730 for Pa
in Wa
.AutoGenObjectList
:
1731 for ModuleKey
in Pa
.Platform
.Modules
:
1732 M
= Pa
.Platform
.Modules
[ModuleKey
].M
1733 InfPath
= mws
.join(Wa
.WorkspaceDir
, M
.MetaFile
.File
)
1734 self
._GuidsDb
[M
.Guid
.upper()] = "%s (%s)" % (M
.Module
.BaseName
, InfPath
)
1737 # Collect the GUID map in the FV firmware volume
1739 for FvName
in self
.FvList
:
1740 FvDictKey
=FvName
.upper()
1741 if FvDictKey
in Wa
.FdfProfile
.FvDict
:
1742 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1745 # collect GUID map for binary EFI file in FDF file.
1747 Guid
= Ffs
.NameGuid
.upper()
1748 Match
= gPcdGuidPattern
.match(Ffs
.NameGuid
)
1750 PcdTokenspace
= Match
.group(1)
1751 PcdToken
= Match
.group(2)
1752 if (PcdToken
, PcdTokenspace
) in PlatformPcds
:
1753 GuidValue
= PlatformPcds
[(PcdToken
, PcdTokenspace
)]
1754 Guid
= GuidStructureByteArrayToGuidString(GuidValue
).upper()
1755 for Section
in Ffs
.SectionList
:
1757 ModuleSectFile
= mws
.join(Wa
.WorkspaceDir
, Section
.SectFileName
)
1758 self
._GuidsDb
[Guid
] = ModuleSectFile
1759 except AttributeError:
1761 except AttributeError:
1766 # Internal worker function to generate report for the FD region
1768 # This internal worker function to generate report for the FD region.
1769 # It the type is firmware volume, it lists offset and module identification.
1771 # @param self The object pointer
1772 # @param File The file object for report
1773 # @param Title The title for the FD subsection
1774 # @param BaseAddress The base address for the FD region
1775 # @param Size The size of the FD region
1776 # @param FvName The FV name if the FD region is a firmware volume
1778 def _GenerateReport(self
, File
, Title
, Type
, BaseAddress
, Size
=0, FvName
=None):
1779 FileWrite(File
, gSubSectionStart
)
1780 FileWrite(File
, Title
)
1781 FileWrite(File
, "Type: %s" % Type
)
1782 FileWrite(File
, "Base Address: 0x%X" % BaseAddress
)
1784 if self
.Type
== "FV":
1788 if FvName
.upper().endswith('.FV'):
1789 FileExt
= FvName
+ ".txt"
1791 FileExt
= FvName
+ ".Fv.txt"
1793 if not os
.path
.isfile(FileExt
):
1794 FvReportFileName
= mws
.join(self
._WorkspaceDir
, FileExt
)
1795 if not os
.path
.isfile(FvReportFileName
):
1796 FvReportFileName
= os
.path
.join(self
._FvDir
, FileExt
)
1799 # Collect size info in the firmware volume.
1801 FvReport
= open(FvReportFileName
).read()
1802 Match
= gFvTotalSizePattern
.search(FvReport
)
1804 FvTotalSize
= int(Match
.group(1), 16)
1805 Match
= gFvTakenSizePattern
.search(FvReport
)
1807 FvTakenSize
= int(Match
.group(1), 16)
1808 FvFreeSize
= FvTotalSize
- FvTakenSize
1810 # Write size information to the report file.
1812 FileWrite(File
, "Size: 0x%X (%.0fK)" % (FvTotalSize
, FvTotalSize
/ 1024.0))
1813 FileWrite(File
, "Fv Name: %s (%.1f%% Full)" % (FvName
, FvTakenSize
* 100.0 / FvTotalSize
))
1814 FileWrite(File
, "Occupied Size: 0x%X (%.0fK)" % (FvTakenSize
, FvTakenSize
/ 1024.0))
1815 FileWrite(File
, "Free Size: 0x%X (%.0fK)" % (FvFreeSize
, FvFreeSize
/ 1024.0))
1816 FileWrite(File
, "Offset Module")
1817 FileWrite(File
, gSubSectionSep
)
1819 # Write module offset and module identification to the report file.
1822 for Match
in gOffsetGuidPattern
.finditer(FvReport
):
1823 Guid
= Match
.group(2).upper()
1824 OffsetInfo
[Match
.group(1)] = self
._GuidsDb
.get(Guid
, Guid
)
1825 OffsetList
= OffsetInfo
.keys()
1827 for Offset
in OffsetList
:
1828 FileWrite (File
, "%s %s" % (Offset
, OffsetInfo
[Offset
]))
1830 EdkLogger
.warn(None, "Fail to read report file", FvReportFileName
)
1832 FileWrite(File
, "Size: 0x%X (%.0fK)" % (Size
, Size
/ 1024.0))
1833 FileWrite(File
, gSubSectionEnd
)
1836 # Generate report for the FD region
1838 # This function generates report for the FD region.
1840 # @param self The object pointer
1841 # @param File The file object for report
1843 def GenerateReport(self
, File
):
1844 if (len(self
.FvList
) > 0):
1845 for FvItem
in self
.FvList
:
1846 Info
= self
.FvInfo
[FvItem
]
1847 self
._GenerateReport
(File
, Info
[0], "FV", Info
[1], Info
[2], FvItem
)
1849 self
._GenerateReport
(File
, "FD Region", self
.Type
, self
.BaseAddress
, self
.Size
)
1852 # Reports FD information
1854 # This class reports the FD section in the build report file.
1855 # It collects flash device information for a platform.
1857 class FdReport(object):
1859 # Constructor function for class FdReport
1861 # This constructor function generates FdReport object for a specified
1864 # @param self The object pointer
1865 # @param Fd The current Firmware device object
1866 # @param Wa Workspace context information
1868 def __init__(self
, Fd
, Wa
):
1869 self
.FdName
= Fd
.FdUiName
1870 self
.BaseAddress
= Fd
.BaseAddress
1872 self
.FdRegionList
= [FdRegionReport(FdRegion
, Wa
) for FdRegion
in Fd
.RegionList
]
1873 self
.FvPath
= os
.path
.join(Wa
.BuildDir
, "FV")
1874 self
.VpdFilePath
= os
.path
.join(self
.FvPath
, "%s.map" % Wa
.Platform
.VpdToolGuid
)
1875 self
.VPDBaseAddress
= 0
1877 self
.VPDInfoList
= []
1878 for index
, FdRegion
in enumerate(Fd
.RegionList
):
1879 if str(FdRegion
.RegionType
) is 'FILE' and Wa
.Platform
.VpdToolGuid
in str(FdRegion
.RegionDataList
):
1880 self
.VPDBaseAddress
= self
.FdRegionList
[index
].BaseAddress
1881 self
.VPDSize
= self
.FdRegionList
[index
].Size
1884 if os
.path
.isfile(self
.VpdFilePath
):
1885 fd
= open(self
.VpdFilePath
, "r")
1886 Lines
= fd
.readlines()
1889 if len(Line
) == 0 or Line
.startswith("#"):
1892 PcdName
, SkuId
, Offset
, Size
, Value
= Line
.split("#")[0].split("|")
1893 PcdName
, SkuId
, Offset
, Size
, Value
= PcdName
.strip(), SkuId
.strip(), Offset
.strip(), Size
.strip(), Value
.strip()
1894 if Offset
.lower().startswith('0x'):
1895 Offset
= '0x%08X' % (int(Offset
, 16) + self
.VPDBaseAddress
)
1897 Offset
= '0x%08X' % (int(Offset
, 10) + self
.VPDBaseAddress
)
1898 self
.VPDInfoList
.append("%s | %s | %s | %s | %s" % (PcdName
, SkuId
, Offset
, Size
, Value
))
1900 EdkLogger
.error("BuildReport", CODE_ERROR
, "Fail to parse VPD information file %s" % self
.VpdFilePath
)
1904 # Generate report for the firmware device.
1906 # This function generates report for the firmware device.
1908 # @param self The object pointer
1909 # @param File The file object for report
1911 def GenerateReport(self
, File
):
1912 FileWrite(File
, gSectionStart
)
1913 FileWrite(File
, "Firmware Device (FD)")
1914 FileWrite(File
, "FD Name: %s" % self
.FdName
)
1915 FileWrite(File
, "Base Address: %s" % self
.BaseAddress
)
1916 FileWrite(File
, "Size: 0x%X (%.0fK)" % (self
.Size
, self
.Size
/ 1024.0))
1917 if len(self
.FdRegionList
) > 0:
1918 FileWrite(File
, gSectionSep
)
1919 for FdRegionItem
in self
.FdRegionList
:
1920 FdRegionItem
.GenerateReport(File
)
1922 if len(self
.VPDInfoList
) > 0:
1923 FileWrite(File
, gSubSectionStart
)
1924 FileWrite(File
, "FD VPD Region")
1925 FileWrite(File
, "Base Address: 0x%X" % self
.VPDBaseAddress
)
1926 FileWrite(File
, "Size: 0x%X (%.0fK)" % (self
.VPDSize
, self
.VPDSize
/ 1024.0))
1927 FileWrite(File
, gSubSectionSep
)
1928 for item
in self
.VPDInfoList
:
1929 ValueList
= item
.split('|')
1930 Value
= ValueList
[-1].strip()
1931 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1933 ValueList
[-1] = ' {'
1934 FileWrite(File
, '|'.join(ValueList
))
1935 for Array
in ArrayList
:
1936 FileWrite(File
, '%s' % (Array
))
1938 FileWrite(File
, item
)
1939 FileWrite(File
, gSubSectionEnd
)
1940 FileWrite(File
, gSectionEnd
)
1945 # Reports platform information
1947 # This class reports the whole platform information
1949 class PlatformReport(object):
1951 # Constructor function for class PlatformReport
1953 # This constructor function generates PlatformReport object a platform build.
1954 # It generates report for platform summary, flash, global PCDs and detailed
1955 # module information for modules involved in platform build.
1957 # @param self The object pointer
1958 # @param Wa Workspace context information
1959 # @param MaList The list of modules in the platform build
1961 def __init__(self
, Wa
, MaList
, ReportType
):
1962 self
._WorkspaceDir
= Wa
.WorkspaceDir
1963 self
.PlatformName
= Wa
.Name
1964 self
.PlatformDscPath
= Wa
.Platform
1965 self
.Architectures
= " ".join(Wa
.ArchList
)
1966 self
.ToolChain
= Wa
.ToolChain
1967 self
.Target
= Wa
.BuildTarget
1968 self
.OutputPath
= os
.path
.join(Wa
.WorkspaceDir
, Wa
.OutputDir
)
1969 self
.BuildEnvironment
= platform
.platform()
1971 self
.PcdReport
= None
1972 if "PCD" in ReportType
:
1973 self
.PcdReport
= PcdReport(Wa
)
1975 self
.FdReportList
= []
1976 if "FLASH" in ReportType
and Wa
.FdfProfile
and MaList
is None:
1977 for Fd
in Wa
.FdfProfile
.FdDict
:
1978 self
.FdReportList
.append(FdReport(Wa
.FdfProfile
.FdDict
[Fd
], Wa
))
1980 self
.PredictionReport
= None
1981 if "FIXED_ADDRESS" in ReportType
or "EXECUTION_ORDER" in ReportType
:
1982 self
.PredictionReport
= PredictionReport(Wa
)
1984 self
.DepexParser
= None
1985 if "DEPEX" in ReportType
:
1986 self
.DepexParser
= DepexParser(Wa
)
1988 self
.ModuleReportList
= []
1989 if MaList
is not None:
1990 self
._IsModuleBuild
= True
1992 self
.ModuleReportList
.append(ModuleReport(Ma
, ReportType
))
1994 self
._IsModuleBuild
= False
1995 for Pa
in Wa
.AutoGenObjectList
:
1996 ModuleAutoGenList
= []
1997 for ModuleKey
in Pa
.Platform
.Modules
:
1998 ModuleAutoGenList
.append(Pa
.Platform
.Modules
[ModuleKey
].M
)
1999 if GlobalData
.gFdfParser
is not None:
2000 if Pa
.Arch
in GlobalData
.gFdfParser
.Profile
.InfDict
:
2001 INFList
= GlobalData
.gFdfParser
.Profile
.InfDict
[Pa
.Arch
]
2002 for InfName
in INFList
:
2003 InfClass
= PathClass(NormPath(InfName
), Wa
.WorkspaceDir
, Pa
.Arch
)
2004 Ma
= ModuleAutoGen(Wa
, InfClass
, Pa
.BuildTarget
, Pa
.ToolChain
, Pa
.Arch
, Wa
.MetaFile
)
2007 if Ma
not in ModuleAutoGenList
:
2008 ModuleAutoGenList
.append(Ma
)
2009 for MGen
in ModuleAutoGenList
:
2010 self
.ModuleReportList
.append(ModuleReport(MGen
, ReportType
))
2015 # Generate report for the whole platform.
2017 # This function generates report for platform information.
2018 # It comprises of platform summary, global PCD, flash and
2019 # module list sections.
2021 # @param self The object pointer
2022 # @param File The file object for report
2023 # @param BuildDuration The total time to build the modules
2024 # @param AutoGenTime The total time of AutoGen Phase
2025 # @param MakeTime The total time of Make Phase
2026 # @param GenFdsTime The total time of GenFds Phase
2027 # @param ReportType The kind of report items in the final report file
2029 def GenerateReport(self
, File
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
, ReportType
):
2030 FileWrite(File
, "Platform Summary")
2031 FileWrite(File
, "Platform Name: %s" % self
.PlatformName
)
2032 FileWrite(File
, "Platform DSC Path: %s" % self
.PlatformDscPath
)
2033 FileWrite(File
, "Architectures: %s" % self
.Architectures
)
2034 FileWrite(File
, "Tool Chain: %s" % self
.ToolChain
)
2035 FileWrite(File
, "Target: %s" % self
.Target
)
2036 if GlobalData
.gSkuids
:
2037 FileWrite(File
, "SKUID: %s" % " ".join(GlobalData
.gSkuids
))
2038 if GlobalData
.gDefaultStores
:
2039 FileWrite(File
, "DefaultStore: %s" % " ".join(GlobalData
.gDefaultStores
))
2040 FileWrite(File
, "Output Path: %s" % self
.OutputPath
)
2041 FileWrite(File
, "Build Environment: %s" % self
.BuildEnvironment
)
2042 FileWrite(File
, "Build Duration: %s" % BuildDuration
)
2044 FileWrite(File
, "AutoGen Duration: %s" % AutoGenTime
)
2046 FileWrite(File
, "Make Duration: %s" % MakeTime
)
2048 FileWrite(File
, "GenFds Duration: %s" % GenFdsTime
)
2049 FileWrite(File
, "Report Content: %s" % ", ".join(ReportType
))
2051 if GlobalData
.MixedPcd
:
2052 FileWrite(File
, gSectionStart
)
2053 FileWrite(File
, "The following PCDs use different access methods:")
2054 FileWrite(File
, gSectionSep
)
2055 for PcdItem
in GlobalData
.MixedPcd
:
2056 FileWrite(File
, "%s.%s" % (str(PcdItem
[1]), str(PcdItem
[0])))
2057 FileWrite(File
, gSectionEnd
)
2059 if not self
._IsModuleBuild
:
2060 if "PCD" in ReportType
:
2061 self
.PcdReport
.GenerateReport(File
, None)
2063 if "FLASH" in ReportType
:
2064 for FdReportListItem
in self
.FdReportList
:
2065 FdReportListItem
.GenerateReport(File
)
2067 for ModuleReportItem
in self
.ModuleReportList
:
2068 ModuleReportItem
.GenerateReport(File
, self
.PcdReport
, self
.PredictionReport
, self
.DepexParser
, ReportType
)
2070 if not self
._IsModuleBuild
:
2071 if "EXECUTION_ORDER" in ReportType
:
2072 self
.PredictionReport
.GenerateReport(File
, None)
2074 ## BuildReport class
2076 # This base class contain the routines to collect data and then
2077 # applies certain format to the output report
2079 class BuildReport(object):
2081 # Constructor function for class BuildReport
2083 # This constructor function generates BuildReport object a platform build.
2084 # It generates report for platform summary, flash, global PCDs and detailed
2085 # module information for modules involved in platform build.
2087 # @param self The object pointer
2088 # @param ReportFile The file name to save report file
2089 # @param ReportType The kind of report items in the final report file
2091 def __init__(self
, ReportFile
, ReportType
):
2092 self
.ReportFile
= ReportFile
2094 self
.ReportList
= []
2095 self
.ReportType
= []
2097 for ReportTypeItem
in ReportType
:
2098 if ReportTypeItem
not in self
.ReportType
:
2099 self
.ReportType
.append(ReportTypeItem
)
2101 self
.ReportType
= ["PCD", "LIBRARY", "BUILD_FLAGS", "DEPEX", "HASH", "FLASH", "FIXED_ADDRESS"]
2103 # Adds platform report to the list
2105 # This function adds a platform report to the final report list.
2107 # @param self The object pointer
2108 # @param Wa Workspace context information
2109 # @param MaList The list of modules in the platform build
2111 def AddPlatformReport(self
, Wa
, MaList
=None):
2113 self
.ReportList
.append((Wa
, MaList
))
2116 # Generates the final report.
2118 # This function generates platform build report. It invokes GenerateReport()
2119 # method for every platform report in the list.
2121 # @param self The object pointer
2122 # @param BuildDuration The total time to build the modules
2123 # @param AutoGenTime The total time of AutoGen phase
2124 # @param MakeTime The total time of Make phase
2125 # @param GenFdsTime The total time of GenFds phase
2127 def GenerateReport(self
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
):
2131 for (Wa
, MaList
) in self
.ReportList
:
2132 PlatformReport(Wa
, MaList
, self
.ReportType
).GenerateReport(File
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
, self
.ReportType
)
2133 Content
= FileLinesSplit(File
.getvalue(), gLineMaxLength
)
2134 SaveFileOnChange(self
.ReportFile
, Content
, True)
2135 EdkLogger
.quiet("Build report can be found at %s" % os
.path
.abspath(self
.ReportFile
))
2137 EdkLogger
.error(None, FILE_WRITE_FAILURE
, ExtraData
=self
.ReportFile
)
2139 EdkLogger
.error("BuildReport", CODE_ERROR
, "Unknown fatal error when generating build report", ExtraData
=self
.ReportFile
, RaiseError
=False)
2140 EdkLogger
.quiet("(Python %s on %s\n%s)" % (platform
.python_version(), sys
.platform
, traceback
.format_exc()))
2143 # This acts like the main() function for the script, unless it is 'import'ed into another script.
2144 if __name__
== '__main__':