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