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 - 2017, 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
.LongFilePathSupport
import OpenLongFilePath
as open
41 from Common
.MultipleWorkspace
import MultipleWorkspace
as mws
42 import Common
.GlobalData
as GlobalData
43 from AutoGen
.AutoGen
import ModuleAutoGen
44 from Common
.Misc
import PathClass
45 from Common
.String
import NormPath
46 from Common
.DataType
import *
48 from Common
.Expression
import ValueExpressionEx
50 ## Pattern to extract contents in EDK DXS files
51 gDxsDependencyPattern
= re
.compile(r
"DEPENDENCY_START(.+)DEPENDENCY_END", re
.DOTALL
)
53 ## Pattern to find total FV total size, occupied size in flash report intermediate file
54 gFvTotalSizePattern
= re
.compile(r
"EFI_FV_TOTAL_SIZE = (0x[0-9a-fA-F]+)")
55 gFvTakenSizePattern
= re
.compile(r
"EFI_FV_TAKEN_SIZE = (0x[0-9a-fA-F]+)")
57 ## Pattern to find module size and time stamp in module summary report intermediate file
58 gModuleSizePattern
= re
.compile(r
"MODULE_SIZE = (\d+)")
59 gTimeStampPattern
= re
.compile(r
"TIME_STAMP = (\d+)")
61 ## Pattern to find GUID value in flash description files
62 gPcdGuidPattern
= re
.compile(r
"PCD\((\w+)[.](\w+)\)")
64 ## Pattern to collect offset, GUID value pair in the flash report intermediate file
65 gOffsetGuidPattern
= re
.compile(r
"(0x[0-9A-Fa-f]+) ([-A-Fa-f0-9]+)")
67 ## Pattern to find module base address and entry point in fixed flash map file
68 gModulePattern
= r
"\n[-\w]+\s*\(([^,]+),\s*BaseAddress=%(Address)s,\s*EntryPoint=%(Address)s\)\s*\(GUID=([-0-9A-Fa-f]+)[^)]*\)"
69 gMapFileItemPattern
= re
.compile(gModulePattern
% {"Address" : "(-?0[xX][0-9A-Fa-f]+)"})
71 ## Pattern to find all module referenced header files in source files
72 gIncludePattern
= re
.compile(r
'#include\s*["<]([^">]+)[">]')
73 gIncludePattern2
= re
.compile(r
"#include\s+EFI_([A-Z_]+)\s*[(]\s*(\w+)\s*[)]")
75 ## Pattern to find the entry point for EDK module using EDKII Glue library
76 gGlueLibEntryPoint
= re
.compile(r
"__EDKII_GLUE_MODULE_ENTRY_POINT__\s*=\s*(\w+)")
78 ## Tags for MaxLength of line in report
81 ## Tags for end of line in report
84 ## Tags for section start, end and separator
85 gSectionStart
= ">" + "=" * (gLineMaxLength
- 2) + "<"
86 gSectionEnd
= "<" + "=" * (gLineMaxLength
- 2) + ">" + "\n"
87 gSectionSep
= "=" * gLineMaxLength
89 ## Tags for subsection start, end and separator
90 gSubSectionStart
= ">" + "-" * (gLineMaxLength
- 2) + "<"
91 gSubSectionEnd
= "<" + "-" * (gLineMaxLength
- 2) + ">"
92 gSubSectionSep
= "-" * gLineMaxLength
95 ## The look up table to map PCD type to pair of report display type and DEC type
97 'FixedAtBuild' : ('FIXED', 'FixedAtBuild'),
98 'PatchableInModule': ('PATCH', 'PatchableInModule'),
99 'FeatureFlag' : ('FLAG', 'FeatureFlag'),
100 'Dynamic' : ('DYN', 'Dynamic'),
101 'DynamicHii' : ('DYNHII', 'Dynamic'),
102 'DynamicVpd' : ('DYNVPD', 'Dynamic'),
103 'DynamicEx' : ('DEX', 'DynamicEx'),
104 'DynamicExHii' : ('DEXHII', 'DynamicEx'),
105 'DynamicExVpd' : ('DEXVPD', 'DynamicEx'),
108 ## The look up table to map module type to driver type
110 'SEC' : '0x3 (SECURITY_CORE)',
111 'PEI_CORE' : '0x4 (PEI_CORE)',
112 'PEIM' : '0x6 (PEIM)',
113 'DXE_CORE' : '0x5 (DXE_CORE)',
114 'DXE_DRIVER' : '0x7 (DRIVER)',
115 'DXE_SAL_DRIVER' : '0x7 (DRIVER)',
116 'DXE_SMM_DRIVER' : '0x7 (DRIVER)',
117 'DXE_RUNTIME_DRIVER': '0x7 (DRIVER)',
118 'UEFI_DRIVER' : '0x7 (DRIVER)',
119 'UEFI_APPLICATION' : '0x9 (APPLICATION)',
120 'SMM_CORE' : '0xD (SMM_CORE)',
121 'SMM_DRIVER' : '0xA (SMM)', # Extension of module type to support PI 1.1 SMM drivers
122 'MM_STANDALONE' : '0xE (MM_STANDALONE)',
123 'MM_CORE_STANDALONE' : '0xF (MM_CORE_STANDALONE)'
126 ## The look up table of the supported opcode in the dependency expression binaries
127 gOpCodeList
= ["BEFORE", "AFTER", "PUSH", "AND", "OR", "NOT", "TRUE", "FALSE", "END", "SOR"]
130 # Writes a string to the file object.
132 # This function writes a string to the file object and a new line is appended
133 # afterwards. It may optionally wraps the string for better readability.
135 # @File The file object to write
136 # @String The string to be written to the file
137 # @Wrapper Indicates whether to wrap the string
139 def FileWrite(File
, String
, Wrapper
=False):
141 String
= textwrap
.fill(String
, 120)
142 File
.write(String
+ gEndOfLine
)
144 def ByteArrayForamt(Value
):
148 if Value
.startswith('{') and Value
.endswith('}'):
150 ValueList
= Value
.split(',')
151 if len(ValueList
) >= SplitNum
:
155 Len
= len(ValueList
)/SplitNum
156 for i
, element
in enumerate(ValueList
):
157 ValueList
[i
] = '0x%02X' % int(element
.strip(), 16)
161 End
= min(SplitNum
*(Id
+1), len(ValueList
))
162 Str
= ','.join(ValueList
[SplitNum
*Id
: End
])
163 if End
== len(ValueList
):
165 ArrayList
.append(Str
)
169 ArrayList
.append(Str
)
172 ArrayList
= [Value
+ '}']
173 return IsByteArray
, ArrayList
176 # Find all the header file that the module source directly includes.
178 # This function scans source code to find all header files the module may
179 # include. This is not accurate but very effective to find all the header
180 # file the module might include with #include statement.
182 # @Source The source file name
183 # @IncludePathList The list of include path to find the source file.
184 # @IncludeFiles The dictionary of current found include files.
186 def FindIncludeFiles(Source
, IncludePathList
, IncludeFiles
):
187 FileContents
= open(Source
).read()
189 # Find header files with pattern #include "XXX.h" or #include <XXX.h>
191 for Match
in gIncludePattern
.finditer(FileContents
):
192 FileName
= Match
.group(1).strip()
193 for Dir
in [os
.path
.dirname(Source
)] + IncludePathList
:
194 FullFileName
= os
.path
.normpath(os
.path
.join(Dir
, FileName
))
195 if os
.path
.exists(FullFileName
):
196 IncludeFiles
[FullFileName
.lower().replace("\\", "/")] = FullFileName
200 # Find header files with pattern like #include EFI_PPI_CONSUMER(XXX)
202 for Match
in gIncludePattern2
.finditer(FileContents
):
204 Type
= Match
.group(1)
205 if "ARCH_PROTOCOL" in Type
:
206 FileName
= "ArchProtocol/%(Key)s/%(Key)s.h" % {"Key" : Key
}
207 elif "PROTOCOL" in Type
:
208 FileName
= "Protocol/%(Key)s/%(Key)s.h" % {"Key" : Key
}
210 FileName
= "Ppi/%(Key)s/%(Key)s.h" % {"Key" : Key
}
212 FileName
= "Guid/%(Key)s/%(Key)s.h" % {"Key" : Key
}
215 for Dir
in IncludePathList
:
216 FullFileName
= os
.path
.normpath(os
.path
.join(Dir
, FileName
))
217 if os
.path
.exists(FullFileName
):
218 IncludeFiles
[FullFileName
.lower().replace("\\", "/")] = FullFileName
221 ## Split each lines in file
223 # This method is used to split the lines in file to make the length of each line
224 # less than MaxLength.
226 # @param Content The content of file
227 # @param MaxLength The Max Length of the line
229 def FileLinesSplit(Content
=None, MaxLength
=None):
230 ContentList
= Content
.split(TAB_LINE_BREAK
)
233 for Line
in ContentList
:
234 while len(Line
.rstrip()) > MaxLength
:
235 LineSpaceIndex
= Line
.rfind(TAB_SPACE_SPLIT
, 0, MaxLength
)
236 LineSlashIndex
= Line
.rfind(TAB_SLASH
, 0, MaxLength
)
237 LineBackSlashIndex
= Line
.rfind(TAB_BACK_SLASH
, 0, MaxLength
)
238 if max(LineSpaceIndex
, LineSlashIndex
, LineBackSlashIndex
) > 0:
239 LineBreakIndex
= max(LineSpaceIndex
, LineSlashIndex
, LineBackSlashIndex
)
241 LineBreakIndex
= MaxLength
242 NewContentList
.append(Line
[:LineBreakIndex
])
243 Line
= Line
[LineBreakIndex
:]
245 NewContentList
.append(Line
)
246 for NewLine
in NewContentList
:
247 NewContent
+= NewLine
+ TAB_LINE_BREAK
249 NewContent
= NewContent
.replace(TAB_LINE_BREAK
, gEndOfLine
).replace('\r\r\n', gEndOfLine
)
255 # Parse binary dependency expression section
257 # This utility class parses the dependency expression section and translate the readable
258 # GUID name and value.
260 class DepexParser(object):
262 # Constructor function for class DepexParser
264 # This constructor function collect GUID values so that the readable
265 # GUID name can be translated.
267 # @param self The object pointer
268 # @param Wa Workspace context information
270 def __init__(self
, Wa
):
272 for Pa
in Wa
.AutoGenObjectList
:
273 for Package
in Pa
.PackageList
:
274 for Protocol
in Package
.Protocols
:
275 GuidValue
= GuidStructureStringToGuidString(Package
.Protocols
[Protocol
])
276 self
._GuidDb
[GuidValue
.upper()] = Protocol
277 for Ppi
in Package
.Ppis
:
278 GuidValue
= GuidStructureStringToGuidString(Package
.Ppis
[Ppi
])
279 self
._GuidDb
[GuidValue
.upper()] = Ppi
280 for Guid
in Package
.Guids
:
281 GuidValue
= GuidStructureStringToGuidString(Package
.Guids
[Guid
])
282 self
._GuidDb
[GuidValue
.upper()] = Guid
285 # Parse the binary dependency expression files.
287 # This function parses the binary dependency expression file and translate it
288 # to the instruction list.
290 # @param self The object pointer
291 # @param DepexFileName The file name of binary dependency expression file.
293 def ParseDepexFile(self
, DepexFileName
):
294 DepexFile
= open(DepexFileName
, "rb")
296 OpCode
= DepexFile
.read(1)
298 Statement
= gOpCodeList
[struct
.unpack("B", OpCode
)[0]]
299 if Statement
in ["BEFORE", "AFTER", "PUSH"]:
300 GuidValue
= "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X" % \
301 struct
.unpack("=LHHBBBBBBBB", DepexFile
.read(16))
302 GuidString
= self
._GuidDb
.get(GuidValue
, GuidValue
)
303 Statement
= "%s %s" % (Statement
, GuidString
)
304 DepexStatement
.append(Statement
)
305 OpCode
= DepexFile
.read(1)
307 return DepexStatement
310 # Reports library information
312 # This class reports the module library subsection in the build report file.
314 class LibraryReport(object):
316 # Constructor function for class LibraryReport
318 # This constructor function generates LibraryReport object for
321 # @param self The object pointer
322 # @param M Module context information
324 def __init__(self
, M
):
325 self
.LibraryList
= []
326 if int(str(M
.AutoGenVersion
), 0) >= 0x00010005:
327 self
._EdkIIModule
= True
329 self
._EdkIIModule
= False
331 for Lib
in M
.DependentLibraryList
:
332 LibInfPath
= str(Lib
)
333 LibClassList
= Lib
.LibraryClass
[0].LibraryClass
334 LibConstructorList
= Lib
.ConstructorList
335 LibDesstructorList
= Lib
.DestructorList
336 LibDepexList
= Lib
.DepexExpression
[M
.Arch
, M
.ModuleType
]
337 for LibAutoGen
in M
.LibraryAutoGenList
:
338 if LibInfPath
== LibAutoGen
.MetaFile
.Path
:
339 LibTime
= LibAutoGen
.BuildTime
341 self
.LibraryList
.append((LibInfPath
, LibClassList
, LibConstructorList
, LibDesstructorList
, LibDepexList
, LibTime
))
344 # Generate report for module library information
346 # This function generates report for the module library.
347 # If the module is EDKII style one, the additional library class, library
348 # constructor/destructor and dependency expression may also be reported.
350 # @param self The object pointer
351 # @param File The file object for report
353 def GenerateReport(self
, File
):
354 if len(self
.LibraryList
) > 0:
355 FileWrite(File
, gSubSectionStart
)
356 FileWrite(File
, TAB_BRG_LIBRARY
)
357 FileWrite(File
, gSubSectionSep
)
358 for LibraryItem
in self
.LibraryList
:
359 LibInfPath
= LibraryItem
[0]
360 FileWrite(File
, LibInfPath
)
363 # Report library class, library constructor and destructor for
364 # EDKII style module.
366 if self
._EdkIIModule
:
367 LibClass
= LibraryItem
[1]
369 LibConstructor
= " ".join(LibraryItem
[2])
371 EdkIILibInfo
+= " C = " + LibConstructor
372 LibDestructor
= " ".join(LibraryItem
[3])
374 EdkIILibInfo
+= " D = " + LibDestructor
375 LibDepex
= " ".join(LibraryItem
[4])
377 EdkIILibInfo
+= " Depex = " + LibDepex
379 EdkIILibInfo
+= " Time = " + LibraryItem
[5]
381 FileWrite(File
, "{%s: %s}" % (LibClass
, EdkIILibInfo
))
383 FileWrite(File
, "{%s}" % LibClass
)
385 FileWrite(File
, gSubSectionEnd
)
388 # Reports dependency expression information
390 # This class reports the module dependency expression subsection in the build report file.
392 class DepexReport(object):
394 # Constructor function for class DepexReport
396 # This constructor function generates DepexReport object for
397 # a module. If the module source contains the DXS file (usually EDK
398 # style module), it uses the dependency in DXS file; otherwise,
399 # it uses the dependency expression from its own INF [Depex] section
400 # and then merges with the ones from its dependent library INF.
402 # @param self The object pointer
403 # @param M Module context information
405 def __init__(self
, M
):
407 self
._DepexFileName
= os
.path
.join(M
.BuildDir
, "OUTPUT", M
.Module
.BaseName
+ ".depex")
408 ModuleType
= M
.ModuleType
410 ModuleType
= gComponentType2ModuleType
.get(M
.ComponentType
, "")
412 if ModuleType
in ["SEC", "PEI_CORE", "DXE_CORE", "SMM_CORE", "MM_CORE_STANDALONE", "UEFI_APPLICATION"]:
415 for Source
in M
.SourceFileList
:
416 if os
.path
.splitext(Source
.Path
)[1].lower() == ".dxs":
417 Match
= gDxsDependencyPattern
.search(open(Source
.Path
).read())
419 self
.Depex
= Match
.group(1).strip()
423 self
.Depex
= M
.DepexExpressionList
.get(M
.ModuleType
, "")
424 self
.ModuleDepex
= " ".join(M
.Module
.DepexExpression
[M
.Arch
, M
.ModuleType
])
425 if not self
.ModuleDepex
:
426 self
.ModuleDepex
= "(None)"
429 for Lib
in M
.DependentLibraryList
:
430 LibDepex
= " ".join(Lib
.DepexExpression
[M
.Arch
, M
.ModuleType
]).strip()
432 LibDepexList
.append("(" + LibDepex
+ ")")
433 self
.LibraryDepex
= " AND ".join(LibDepexList
)
434 if not self
.LibraryDepex
:
435 self
.LibraryDepex
= "(None)"
439 # Generate report for module dependency expression information
441 # This function generates report for the module dependency expression.
443 # @param self The object pointer
444 # @param File The file object for report
445 # @param GlobalDepexParser The platform global Dependency expression parser object
447 def GenerateReport(self
, File
, GlobalDepexParser
):
450 FileWrite(File
, gSubSectionStart
)
451 if os
.path
.isfile(self
._DepexFileName
):
453 DepexStatements
= GlobalDepexParser
.ParseDepexFile(self
._DepexFileName
)
454 FileWrite(File
, "Final Dependency Expression (DEPEX) Instructions")
455 for DepexStatement
in DepexStatements
:
456 FileWrite(File
, " %s" % DepexStatement
)
457 FileWrite(File
, gSubSectionSep
)
459 EdkLogger
.warn(None, "Dependency expression file is corrupted", self
._DepexFileName
)
461 FileWrite(File
, "Dependency Expression (DEPEX) from %s" % self
.Source
)
463 if self
.Source
== "INF":
464 FileWrite(File
, "%s" % self
.Depex
, True)
465 FileWrite(File
, gSubSectionSep
)
466 FileWrite(File
, "From Module INF: %s" % self
.ModuleDepex
, True)
467 FileWrite(File
, "From Library INF: %s" % self
.LibraryDepex
, True)
469 FileWrite(File
, "%s" % self
.Depex
)
470 FileWrite(File
, gSubSectionEnd
)
473 # Reports dependency expression information
475 # This class reports the module build flags subsection in the build report file.
477 class BuildFlagsReport(object):
479 # Constructor function for class BuildFlagsReport
481 # This constructor function generates BuildFlagsReport object for
482 # a module. It reports the build tool chain tag and all relevant
483 # build flags to build the module.
485 # @param self The object pointer
486 # @param M Module context information
488 def __init__(self
, M
):
491 # Add build flags according to source file extension so that
492 # irrelevant ones can be filtered out.
494 for Source
in M
.SourceFileList
:
495 Ext
= os
.path
.splitext(Source
.File
)[1].lower()
496 if Ext
in [".c", ".cc", ".cpp"]:
497 BuildOptions
["CC"] = 1
498 elif Ext
in [".s", ".asm"]:
499 BuildOptions
["PP"] = 1
500 BuildOptions
["ASM"] = 1
501 elif Ext
in [".vfr"]:
502 BuildOptions
["VFRPP"] = 1
503 BuildOptions
["VFR"] = 1
504 elif Ext
in [".dxs"]:
505 BuildOptions
["APP"] = 1
506 BuildOptions
["CC"] = 1
507 elif Ext
in [".asl"]:
508 BuildOptions
["ASLPP"] = 1
509 BuildOptions
["ASL"] = 1
510 elif Ext
in [".aslc"]:
511 BuildOptions
["ASLCC"] = 1
512 BuildOptions
["ASLDLINK"] = 1
513 BuildOptions
["CC"] = 1
514 elif Ext
in [".asm16"]:
515 BuildOptions
["ASMLINK"] = 1
516 BuildOptions
["SLINK"] = 1
517 BuildOptions
["DLINK"] = 1
520 # Save module build flags.
522 self
.ToolChainTag
= M
.ToolChain
524 for Tool
in BuildOptions
:
525 self
.BuildFlags
[Tool
+ "_FLAGS"] = M
.BuildOption
.get(Tool
, {}).get("FLAGS", "")
528 # Generate report for module build flags information
530 # This function generates report for the module build flags expression.
532 # @param self The object pointer
533 # @param File The file object for report
535 def GenerateReport(self
, File
):
536 FileWrite(File
, gSubSectionStart
)
537 FileWrite(File
, "Build Flags")
538 FileWrite(File
, "Tool Chain Tag: %s" % self
.ToolChainTag
)
539 for Tool
in self
.BuildFlags
:
540 FileWrite(File
, gSubSectionSep
)
541 FileWrite(File
, "%s = %s" % (Tool
, self
.BuildFlags
[Tool
]), True)
543 FileWrite(File
, gSubSectionEnd
)
547 # Reports individual module information
549 # This class reports the module section in the build report file.
550 # It comprises of module summary, module PCD, library, dependency expression,
551 # build flags sections.
553 class ModuleReport(object):
555 # Constructor function for class ModuleReport
557 # This constructor function generates ModuleReport object for
558 # a separate module in a platform build.
560 # @param self The object pointer
561 # @param M Module context information
562 # @param ReportType The kind of report items in the final report file
564 def __init__(self
, M
, ReportType
):
565 self
.ModuleName
= M
.Module
.BaseName
566 self
.ModuleInfPath
= M
.MetaFile
.File
567 self
.FileGuid
= M
.Guid
569 self
.BuildTimeStamp
= None
573 ModuleType
= M
.ModuleType
575 ModuleType
= gComponentType2ModuleType
.get(M
.ComponentType
, "")
577 # If a module complies to PI 1.1, promote Module type to "SMM_DRIVER"
579 if ModuleType
== "DXE_SMM_DRIVER":
580 PiSpec
= M
.Module
.Specification
.get("PI_SPECIFICATION_VERSION", "0x00010000")
581 if int(PiSpec
, 0) >= 0x0001000A:
582 ModuleType
= "SMM_DRIVER"
583 self
.DriverType
= gDriverTypeMap
.get(ModuleType
, "0x2 (FREE_FORM)")
584 self
.UefiSpecVersion
= M
.Module
.Specification
.get("UEFI_SPECIFICATION_VERSION", "")
585 self
.PiSpecVersion
= M
.Module
.Specification
.get("PI_SPECIFICATION_VERSION", "")
586 self
.PciDeviceId
= M
.Module
.Defines
.get("PCI_DEVICE_ID", "")
587 self
.PciVendorId
= M
.Module
.Defines
.get("PCI_VENDOR_ID", "")
588 self
.PciClassCode
= M
.Module
.Defines
.get("PCI_CLASS_CODE", "")
589 self
.BuildTime
= M
.BuildTime
591 self
._BuildDir
= M
.BuildDir
592 self
.ModulePcdSet
= {}
593 if "PCD" in ReportType
:
595 # Collect all module used PCD set: module INF referenced directly or indirectly.
596 # It also saves module INF default values of them in case they exist.
598 for Pcd
in M
.ModulePcdList
+ M
.LibraryPcdList
:
599 self
.ModulePcdSet
.setdefault((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Pcd
.Type
), (Pcd
.InfDefaultValue
, Pcd
.DefaultValue
))
601 self
.LibraryReport
= None
602 if "LIBRARY" in ReportType
:
603 self
.LibraryReport
= LibraryReport(M
)
605 self
.DepexReport
= None
606 if "DEPEX" in ReportType
:
607 self
.DepexReport
= DepexReport(M
)
609 if "BUILD_FLAGS" in ReportType
:
610 self
.BuildFlagsReport
= BuildFlagsReport(M
)
614 # Generate report for module information
616 # This function generates report for separate module expression
617 # in a platform build.
619 # @param self The object pointer
620 # @param File The file object for report
621 # @param GlobalPcdReport The platform global PCD report object
622 # @param GlobalPredictionReport The platform global Prediction report object
623 # @param GlobalDepexParser The platform global Dependency expression parser object
624 # @param ReportType The kind of report items in the final report file
626 def GenerateReport(self
, File
, GlobalPcdReport
, GlobalPredictionReport
, GlobalDepexParser
, ReportType
):
627 FileWrite(File
, gSectionStart
)
629 FwReportFileName
= os
.path
.join(self
._BuildDir
, "DEBUG", self
.ModuleName
+ ".txt")
630 if os
.path
.isfile(FwReportFileName
):
632 FileContents
= open(FwReportFileName
).read()
633 Match
= gModuleSizePattern
.search(FileContents
)
635 self
.Size
= int(Match
.group(1))
637 Match
= gTimeStampPattern
.search(FileContents
)
639 self
.BuildTimeStamp
= datetime
.fromtimestamp(int(Match
.group(1)))
641 EdkLogger
.warn(None, "Fail to read report file", FwReportFileName
)
643 if "HASH" in ReportType
:
644 OutputDir
= os
.path
.join(self
._BuildDir
, "OUTPUT")
645 DefaultEFIfile
= os
.path
.join(OutputDir
, self
.ModuleName
+ ".efi")
646 if os
.path
.isfile(DefaultEFIfile
):
647 Tempfile
= os
.path
.join(OutputDir
, self
.ModuleName
+ "_hash.tmp")
648 # rebase the efi image since its base address may not zero
649 cmd
= ["GenFw", "--rebase", str(0), "-o", Tempfile
, DefaultEFIfile
]
651 PopenObject
= subprocess
.Popen(' '.join(cmd
), stdout
=subprocess
.PIPE
, stderr
=subprocess
.PIPE
, shell
=True)
653 EdkLogger
.error("GenFw", COMMAND_FAILURE
, ExtraData
="%s: %s" % (str(X
), cmd
[0]))
654 EndOfProcedure
= threading
.Event()
655 EndOfProcedure
.clear()
656 if PopenObject
.stderr
:
657 StdErrThread
= threading
.Thread(target
=ReadMessage
, args
=(PopenObject
.stderr
, EdkLogger
.quiet
, EndOfProcedure
))
658 StdErrThread
.setName("STDERR-Redirector")
659 StdErrThread
.setDaemon(False)
661 # waiting for program exit
663 if PopenObject
.stderr
:
665 if PopenObject
.returncode
!= 0:
666 EdkLogger
.error("GenFw", COMMAND_FAILURE
, "Failed to generate firmware hash image for %s" % (DefaultEFIfile
))
667 if os
.path
.isfile(Tempfile
):
668 self
.Hash
= hashlib
.sha1()
669 buf
= open(Tempfile
, 'rb').read()
670 if self
.Hash
.update(buf
):
671 self
.Hash
= self
.Hash
.update(buf
)
672 self
.Hash
= self
.Hash
.hexdigest()
675 FileWrite(File
, "Module Summary")
676 FileWrite(File
, "Module Name: %s" % self
.ModuleName
)
677 FileWrite(File
, "Module INF Path: %s" % self
.ModuleInfPath
)
678 FileWrite(File
, "File GUID: %s" % self
.FileGuid
)
680 FileWrite(File
, "Size: 0x%X (%.2fK)" % (self
.Size
, self
.Size
/ 1024.0))
682 FileWrite(File
, "SHA1 HASH: %s *%s" % (self
.Hash
, self
.ModuleName
+ ".efi"))
683 if self
.BuildTimeStamp
:
684 FileWrite(File
, "Build Time Stamp: %s" % self
.BuildTimeStamp
)
686 FileWrite(File
, "Module Build Time: %s" % self
.BuildTime
)
688 FileWrite(File
, "Driver Type: %s" % self
.DriverType
)
689 if self
.UefiSpecVersion
:
690 FileWrite(File
, "UEFI Spec Version: %s" % self
.UefiSpecVersion
)
691 if self
.PiSpecVersion
:
692 FileWrite(File
, "PI Spec Version: %s" % self
.PiSpecVersion
)
694 FileWrite(File
, "PCI Device ID: %s" % self
.PciDeviceId
)
696 FileWrite(File
, "PCI Vendor ID: %s" % self
.PciVendorId
)
697 if self
.PciClassCode
:
698 FileWrite(File
, "PCI Class Code: %s" % self
.PciClassCode
)
700 FileWrite(File
, gSectionSep
)
702 if "PCD" in ReportType
:
703 GlobalPcdReport
.GenerateReport(File
, self
.ModulePcdSet
)
705 if "LIBRARY" in ReportType
:
706 self
.LibraryReport
.GenerateReport(File
)
708 if "DEPEX" in ReportType
:
709 self
.DepexReport
.GenerateReport(File
, GlobalDepexParser
)
711 if "BUILD_FLAGS" in ReportType
:
712 self
.BuildFlagsReport
.GenerateReport(File
)
714 if "FIXED_ADDRESS" in ReportType
and self
.FileGuid
:
715 GlobalPredictionReport
.GenerateReport(File
, self
.FileGuid
)
717 FileWrite(File
, gSectionEnd
)
719 def ReadMessage(From
, To
, ExitFlag
):
721 # read one line a time
722 Line
= From
.readline()
723 # empty string means "end"
724 if Line
!= None and Line
!= "":
732 # Reports platform and module PCD information
734 # This class reports the platform PCD section and module PCD subsection
735 # in the build report file.
737 class PcdReport(object):
739 # Constructor function for class PcdReport
741 # This constructor function generates PcdReport object a platform build.
742 # It collects the whole PCD database from platform DSC files, platform
743 # flash description file and package DEC files.
745 # @param self The object pointer
746 # @param Wa Workspace context information
748 def __init__(self
, Wa
):
751 self
.ConditionalPcds
= {}
755 self
.FdfPcdSet
= Wa
.FdfProfile
.PcdDict
759 self
.ModulePcdOverride
= {}
760 for Pa
in Wa
.AutoGenObjectList
:
763 # Collect all platform referenced PCDs and grouped them by PCD token space
766 for Pcd
in Pa
.AllPcdList
:
767 PcdList
= self
.AllPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
768 if Pcd
not in PcdList
:
770 if len(Pcd
.TokenCName
) > self
.MaxLen
:
771 self
.MaxLen
= len(Pcd
.TokenCName
)
773 # Collect the PCD defined in DSC/FDF file, but not used in module
775 UnusedPcdFullList
= []
776 for item
in Pa
.Platform
.Pcds
:
777 Pcd
= Pa
.Platform
.Pcds
[item
]
779 # check the Pcd in FDF file, whether it is used in module first
780 for T
in ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"]:
781 PcdList
= self
.AllPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(T
, [])
787 for package
in Pa
.PackageList
:
788 for T
in ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"]:
789 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, T
) in package
.Pcds
:
792 if not Pcd
.DatumType
:
793 Pcd
.DatumType
= package
.Pcds
[(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, T
)].DatumType
797 if not Pcd
.DatumType
:
799 # Try to remove Hii and Vpd suffix
800 if PcdType
.startswith("DynamicEx"):
801 PcdType
= "DynamicEx"
802 elif PcdType
.startswith("Dynamic"):
804 for package
in Pa
.PackageList
:
805 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, PcdType
) in package
.Pcds
:
806 Pcd
.DatumType
= package
.Pcds
[(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, PcdType
)].DatumType
809 PcdList
= self
.AllPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
810 if Pcd
not in PcdList
and Pcd
not in UnusedPcdFullList
:
811 UnusedPcdFullList
.append(Pcd
)
812 if len(Pcd
.TokenCName
) > self
.MaxLen
:
813 self
.MaxLen
= len(Pcd
.TokenCName
)
815 if GlobalData
.gConditionalPcds
:
816 for PcdItem
in GlobalData
.gConditionalPcds
:
818 (TokenSpaceGuidCName
, TokenCName
) = PcdItem
.split('.')
819 if (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
.keys():
820 Pcd
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)]
821 PcdList
= self
.ConditionalPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
822 if Pcd
not in PcdList
:
826 if UnusedPcdFullList
:
827 for Pcd
in UnusedPcdFullList
:
828 if Pcd
.TokenSpaceGuidCName
+ '.' + Pcd
.TokenCName
in GlobalData
.gConditionalPcds
:
830 UnusedPcdList
.append(Pcd
)
832 for Pcd
in UnusedPcdList
:
833 PcdList
= self
.UnusedPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
834 if Pcd
not in PcdList
:
837 for Module
in Pa
.Platform
.Modules
.values():
839 # Collect module override PCDs
841 for ModulePcd
in Module
.M
.ModulePcdList
+ Module
.M
.LibraryPcdList
:
842 TokenCName
= ModulePcd
.TokenCName
843 TokenSpaceGuid
= ModulePcd
.TokenSpaceGuidCName
844 ModuleDefault
= ModulePcd
.DefaultValue
845 ModulePath
= os
.path
.basename(Module
.M
.MetaFile
.File
)
846 self
.ModulePcdOverride
.setdefault((TokenCName
, TokenSpaceGuid
), {})[ModulePath
] = ModuleDefault
850 # Collect PCD DEC default value.
852 self
.DecPcdDefault
= {}
854 for Pa
in Wa
.AutoGenObjectList
:
855 for Package
in Pa
.PackageList
:
856 Guids
= Package
.Guids
857 self
._GuidDict
.update(Guids
)
858 for (TokenCName
, TokenSpaceGuidCName
, DecType
) in Package
.Pcds
:
859 DecDefaultValue
= Package
.Pcds
[TokenCName
, TokenSpaceGuidCName
, DecType
].DefaultValue
860 self
.DecPcdDefault
.setdefault((TokenCName
, TokenSpaceGuidCName
, DecType
), DecDefaultValue
)
862 # Collect PCDs defined in DSC common section
864 self
.DscPcdDefault
= {}
865 for Pa
in Wa
.AutoGenObjectList
:
866 for (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
867 DscDefaultValue
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)].DefaultValue
869 self
.DscPcdDefault
[(TokenCName
, TokenSpaceGuidCName
)] = DscDefaultValue
871 def GenerateReport(self
, File
, ModulePcdSet
):
872 if self
.ConditionalPcds
:
873 self
.GenerateReportDetail(File
, ModulePcdSet
, 1)
875 self
.GenerateReportDetail(File
, ModulePcdSet
, 2)
876 self
.GenerateReportDetail(File
, ModulePcdSet
)
879 # Generate report for PCD information
881 # This function generates report for separate module expression
882 # in a platform build.
884 # @param self The object pointer
885 # @param File The file object for report
886 # @param ModulePcdSet Set of all PCDs referenced by module or None for
887 # platform PCD report
888 # @param ReportySubType 0 means platform/module PCD report, 1 means Conditional
889 # directives section report, 2 means Unused Pcds section report
890 # @param DscOverridePcds Module DSC override PCDs set
892 def GenerateReportDetail(self
, File
, ModulePcdSet
, ReportSubType
= 0):
893 PcdDict
= self
.AllPcds
894 if ReportSubType
== 1:
895 PcdDict
= self
.ConditionalPcds
896 elif ReportSubType
== 2:
897 PcdDict
= self
.UnusedPcds
899 if ModulePcdSet
== None:
900 FileWrite(File
, gSectionStart
)
901 if ReportSubType
== 1:
902 FileWrite(File
, "Conditional Directives used by the build system")
903 elif ReportSubType
== 2:
904 FileWrite(File
, "PCDs not used by modules or in conditional directives")
906 FileWrite(File
, "Platform Configuration Database Report")
908 FileWrite(File
, " *B - PCD override in the build option")
909 FileWrite(File
, " *P - Platform scoped PCD override in DSC file")
910 FileWrite(File
, " *F - Platform scoped PCD override in FDF file")
911 if not ReportSubType
:
912 FileWrite(File
, " *M - Module scoped PCD override")
913 FileWrite(File
, gSectionSep
)
915 if not ReportSubType
and ModulePcdSet
:
917 # For module PCD sub-section
919 FileWrite(File
, gSubSectionStart
)
920 FileWrite(File
, TAB_BRG_PCD
)
921 FileWrite(File
, gSubSectionSep
)
925 # Group PCD by their token space GUID C Name
928 for Type
in PcdDict
[Key
]:
930 # Group PCD by their usage type
932 TypeName
, DecType
= gPcdTypeMap
.get(Type
, ("", Type
))
933 for Pcd
in PcdDict
[Key
][Type
]:
934 PcdTokenCName
= Pcd
.TokenCName
936 if GlobalData
.MixedPcd
:
937 for PcdKey
in GlobalData
.MixedPcd
:
938 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
) in GlobalData
.MixedPcd
[PcdKey
]:
939 PcdTokenCName
= PcdKey
[0]
941 if MixedPcdFlag
and not ModulePcdSet
:
944 # Get PCD default value and their override relationship
946 DecDefaultValue
= self
.DecPcdDefault
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, DecType
))
947 DscDefaultValue
= self
.DscPcdDefault
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
))
948 DscDefaultValBak
= DscDefaultValue
949 DscDefaultValue
= self
.FdfPcdSet
.get((Pcd
.TokenCName
, Key
), DscDefaultValue
)
951 DscDefaultValue
= ValueExpressionEx(DscDefaultValue
, Pcd
.DatumType
, self
._GuidDict
)(True)
952 InfDefaultValue
= None
954 PcdValue
= DecDefaultValue
956 PcdValue
= DscDefaultValue
957 if ModulePcdSet
!= None:
958 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Type
) not in ModulePcdSet
:
960 InfDefault
, PcdValue
= ModulePcdSet
[Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Type
]
964 BuildOptionMatch
= False
965 if GlobalData
.BuildOptionPcd
:
966 for pcd
in GlobalData
.BuildOptionPcd
:
967 if (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
) == (pcd
[0], pcd
[1]):
969 BuildOptionMatch
= True
973 if ModulePcdSet
== None:
979 if Pcd
.DatumType
in ('UINT8', 'UINT16', 'UINT32', 'UINT64'):
980 PcdValueNumber
= int(PcdValue
.strip(), 0)
981 if DecDefaultValue
== None:
984 DecDefaultValueNumber
= int(DecDefaultValue
.strip(), 0)
985 DecMatch
= (DecDefaultValueNumber
== PcdValueNumber
)
987 if InfDefaultValue
== None:
990 InfDefaultValueNumber
= int(InfDefaultValue
.strip(), 0)
991 InfMatch
= (InfDefaultValueNumber
== PcdValueNumber
)
993 if DscDefaultValue
== None:
996 DscDefaultValueNumber
= int(DscDefaultValue
.strip(), 0)
997 DscMatch
= (DscDefaultValueNumber
== PcdValueNumber
)
999 if DecDefaultValue
== None:
1002 DecMatch
= (DecDefaultValue
.strip() == PcdValue
.strip())
1004 if InfDefaultValue
== None:
1007 InfMatch
= (InfDefaultValue
.strip() == PcdValue
.strip())
1009 if DscDefaultValue
== None:
1012 DscMatch
= (DscDefaultValue
.strip() == PcdValue
.strip())
1015 if GlobalData
.gStructurePcd
and (self
.Arch
in GlobalData
.gStructurePcd
.keys()) and ((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
) in GlobalData
.gStructurePcd
[self
.Arch
]):
1017 if TypeName
in ('DYNVPD', 'DEXVPD'):
1018 SkuInfoList
= Pcd
.SkuInfoList
1019 Pcd
= GlobalData
.gStructurePcd
[self
.Arch
][(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
)]
1020 Pcd
.DatumType
= Pcd
.StructName
1021 if TypeName
in ('DYNVPD', 'DEXVPD'):
1022 Pcd
.SkuInfoList
= SkuInfoList
1023 if Pcd
.SkuOverrideValues
:
1027 # Report PCD item according to their override relationship
1029 if DecMatch
and InfMatch
:
1030 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, ' ')
1031 elif BuildOptionMatch
:
1032 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*B')
1035 if (Pcd
.TokenCName
, Key
) in self
.FdfPcdSet
:
1036 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*F')
1038 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*P')
1040 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*M')
1042 if ModulePcdSet
== None:
1045 if not TypeName
in ('PATCH', 'FLAG', 'FIXED'):
1047 if not BuildOptionMatch
:
1048 ModuleOverride
= self
.ModulePcdOverride
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
), {})
1049 for ModulePath
in ModuleOverride
:
1050 ModuleDefault
= ModuleOverride
[ModulePath
]
1051 if Pcd
.DatumType
in ('UINT8', 'UINT16', 'UINT32', 'UINT64'):
1052 ModulePcdDefaultValueNumber
= int(ModuleDefault
.strip(), 0)
1053 Match
= (ModulePcdDefaultValueNumber
== PcdValueNumber
)
1055 Match
= (ModuleDefault
.strip() == PcdValue
.strip())
1058 IsByteArray
, ArrayList
= ByteArrayForamt(ModuleDefault
.strip())
1060 FileWrite(File
, ' *M %-*s = %s' % (self
.MaxLen
+ 19, ModulePath
, '{'))
1061 for Array
in ArrayList
:
1062 FileWrite(File
, '%s' % (Array
))
1064 FileWrite(File
, ' *M %-*s = %s' % (self
.MaxLen
+ 19, ModulePath
, ModuleDefault
.strip()))
1066 if ModulePcdSet
== None:
1067 FileWrite(File
, gSectionEnd
)
1069 if not ReportSubType
and ModulePcdSet
:
1070 FileWrite(File
, gSubSectionEnd
)
1073 def PrintPcdDefault(self
, File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
):
1074 if not DscMatch
and DscDefaultValue
!= None:
1075 Value
= DscDefaultValue
.strip()
1076 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1078 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DSC DEFAULT', "{"))
1079 for Array
in ArrayList
:
1080 FileWrite(File
, '%s' % (Array
))
1082 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DSC DEFAULT', Value
))
1083 if not InfMatch
and InfDefaultValue
!= None:
1084 Value
= InfDefaultValue
.strip()
1085 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1087 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'INF DEFAULT', "{"))
1088 for Array
in ArrayList
:
1089 FileWrite(File
, '%s' % (Array
))
1091 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'INF DEFAULT', Value
))
1093 if not DecMatch
and DecDefaultValue
!= None:
1094 Value
= DecDefaultValue
.strip()
1095 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1097 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DEC DEFAULT', "{"))
1098 for Array
in ArrayList
:
1099 FileWrite(File
, '%s' % (Array
))
1101 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DEC DEFAULT', Value
))
1103 self
.PrintStructureInfo(File
, Pcd
.DefaultValues
)
1105 def PrintPcdValue(self
, File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, Flag
= ' '):
1106 if not Pcd
.SkuInfoList
:
1107 Value
= Pcd
.DefaultValue
1108 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1110 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1111 for Array
in ArrayList
:
1112 FileWrite(File
, '%s' % (Array
))
1114 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1116 OverrideValues
= Pcd
.SkuOverrideValues
1118 Keys
= OverrideValues
.keys()
1119 Data
= OverrideValues
[Keys
[0]]
1120 Struct
= Data
.values()[0]
1121 self
.PrintStructureInfo(File
, Struct
)
1122 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1125 SkuList
= sorted(Pcd
.SkuInfoList
.keys())
1127 SkuInfo
= Pcd
.SkuInfoList
[Sku
]
1128 if TypeName
in ('DYNHII', 'DEXHII'):
1129 if SkuInfo
.DefaultStoreDict
:
1130 DefaultStoreList
= sorted(SkuInfo
.DefaultStoreDict
.keys())
1131 for DefaultStore
in DefaultStoreList
:
1132 Value
= SkuInfo
.DefaultStoreDict
[DefaultStore
]
1133 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1137 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuInfo
.SkuIdName
+ ')', '(' + DefaultStore
+ ')', '{'))
1138 for Array
in ArrayList
:
1139 FileWrite(File
, '%s' % (Array
))
1141 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuInfo
.SkuIdName
+ ')', '(' + DefaultStore
+ ')', Value
))
1144 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuInfo
.SkuIdName
+ ')', '(' + DefaultStore
+ ')', '{'))
1145 for Array
in ArrayList
:
1146 FileWrite(File
, '%s' % (Array
))
1148 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuInfo
.SkuIdName
+ ')', '(' + DefaultStore
+ ')', Value
))
1149 FileWrite(File
, '%*s: %s: %s' % (self
.MaxLen
+ 4, SkuInfo
.VariableGuid
, SkuInfo
.VariableName
, SkuInfo
.VariableOffset
))
1151 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1152 Struct
= OverrideValues
[DefaultStore
]
1153 self
.PrintStructureInfo(File
, Struct
)
1154 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1155 elif TypeName
in ('DYNVPD', 'DEXVPD'):
1156 Value
= SkuInfo
.DefaultValue
1157 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1161 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuInfo
.SkuIdName
+ ')', "{"))
1162 for Array
in ArrayList
:
1163 FileWrite(File
, '%s' % (Array
))
1165 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuInfo
.SkuIdName
+ ')', Value
))
1168 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuInfo
.SkuIdName
+ ')', "{"))
1169 for Array
in ArrayList
:
1170 FileWrite(File
, '%s' % (Array
))
1172 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuInfo
.SkuIdName
+ ')', Value
))
1173 FileWrite(File
, '%*s' % (self
.MaxLen
+ 4, SkuInfo
.VpdOffset
))
1175 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1177 Keys
= OverrideValues
.keys()
1178 Struct
= OverrideValues
[Keys
[0]]
1179 self
.PrintStructureInfo(File
, Struct
)
1180 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1182 Value
= SkuInfo
.DefaultValue
1183 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1187 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuInfo
.SkuIdName
+ ')', '{'))
1188 for Array
in ArrayList
:
1189 FileWrite(File
, '%s' % (Array
))
1191 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuInfo
.SkuIdName
+ ')', Value
))
1194 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuInfo
.SkuIdName
+ ')', '{'))
1195 for Array
in ArrayList
:
1196 FileWrite(File
, '%s' % (Array
))
1198 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuInfo
.SkuIdName
+ ')', Value
))
1200 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1202 Keys
= OverrideValues
.keys()
1203 Struct
= OverrideValues
[Keys
[0]]
1204 self
.PrintStructureInfo(File
, Struct
)
1205 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1207 def PrintStructureInfo(self
, File
, Struct
):
1208 NewInfo
= collections
.OrderedDict()
1209 for Key
, Value
in Struct
.items():
1210 if Key
not in NewInfo
:
1211 NewInfo
[Key
] = Value
[0]
1214 NewInfo
[Key
] = Value
[0]
1216 for item
in NewInfo
:
1217 FileWrite(File
, ' %-*s = %s' % (self
.MaxLen
+ 4, '.' + item
, NewInfo
[item
]))
1219 def StrtoHex(self
, value
):
1221 value
= hex(int(value
))
1224 if value
.startswith("L\"") and value
.endswith("\""):
1226 for ch
in value
[2:-1]:
1227 valuelist
.append(hex(ord(ch
)))
1228 valuelist
.append('0x00')
1230 elif value
.startswith("\"") and value
.endswith("\""):
1231 return hex(ord(value
[1:-1]))
1232 elif value
.startswith("{") and value
.endswith("}"):
1234 if ',' not in value
:
1236 for ch
in value
[1:-1].split(','):
1238 if ch
.startswith('0x') or ch
.startswith('0X'):
1239 valuelist
.append(ch
)
1242 valuelist
.append(hex(int(ch
.strip())))
1250 # Reports platform and module Prediction information
1252 # This class reports the platform execution order prediction section and
1253 # module load fixed address prediction subsection in the build report file.
1255 class PredictionReport(object):
1257 # Constructor function for class PredictionReport
1259 # This constructor function generates PredictionReport object for the platform.
1261 # @param self: The object pointer
1262 # @param Wa Workspace context information
1264 def __init__(self
, Wa
):
1265 self
._MapFileName
= os
.path
.join(Wa
.BuildDir
, Wa
.Name
+ ".map")
1266 self
._MapFileParsed
= False
1267 self
._EotToolInvoked
= False
1268 self
._FvDir
= Wa
.FvDir
1269 self
._EotDir
= Wa
.BuildDir
1270 self
._FfsEntryPoint
= {}
1272 self
._SourceList
= []
1273 self
.FixedMapDict
= {}
1278 # Collect all platform reference source files and GUID C Name
1280 for Pa
in Wa
.AutoGenObjectList
:
1281 for Module
in Pa
.LibraryAutoGenList
+ Pa
.ModuleAutoGenList
:
1283 # BASE typed modules are EFI agnostic, so we need not scan
1284 # their source code to find PPI/Protocol produce or consume
1287 if Module
.ModuleType
== "BASE":
1290 # Add module referenced source files
1292 self
._SourceList
.append(str(Module
))
1294 for Source
in Module
.SourceFileList
:
1295 if os
.path
.splitext(str(Source
))[1].lower() == ".c":
1296 self
._SourceList
.append(" " + str(Source
))
1297 FindIncludeFiles(Source
.Path
, Module
.IncludePathList
, IncludeList
)
1298 for IncludeFile
in IncludeList
.values():
1299 self
._SourceList
.append(" " + IncludeFile
)
1301 for Guid
in Module
.PpiList
:
1302 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.PpiList
[Guid
])
1303 for Guid
in Module
.ProtocolList
:
1304 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.ProtocolList
[Guid
])
1305 for Guid
in Module
.GuidList
:
1306 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.GuidList
[Guid
])
1308 if Module
.Guid
and not Module
.IsLibrary
:
1309 EntryPoint
= " ".join(Module
.Module
.ModuleEntryPointList
)
1310 if int(str(Module
.AutoGenVersion
), 0) >= 0x00010005:
1311 RealEntryPoint
= "_ModuleEntryPoint"
1313 RealEntryPoint
= EntryPoint
1314 if EntryPoint
== "_ModuleEntryPoint":
1315 CCFlags
= Module
.BuildOption
.get("CC", {}).get("FLAGS", "")
1316 Match
= gGlueLibEntryPoint
.search(CCFlags
)
1318 EntryPoint
= Match
.group(1)
1320 self
._FfsEntryPoint
[Module
.Guid
.upper()] = (EntryPoint
, RealEntryPoint
)
1324 # Collect platform firmware volume list as the input of EOT.
1328 for Fd
in Wa
.FdfProfile
.FdDict
:
1329 for FdRegion
in Wa
.FdfProfile
.FdDict
[Fd
].RegionList
:
1330 if FdRegion
.RegionType
!= "FV":
1332 for FvName
in FdRegion
.RegionDataList
:
1333 if FvName
in self
._FvList
:
1335 self
._FvList
.append(FvName
)
1336 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1337 for Section
in Ffs
.SectionList
:
1339 for FvSection
in Section
.SectionList
:
1340 if FvSection
.FvName
in self
._FvList
:
1342 self
._FvList
.append(FvSection
.FvName
)
1343 except AttributeError:
1348 # Parse platform fixed address map files
1350 # This function parses the platform final fixed address map file to get
1351 # the database of predicted fixed address for module image base, entry point
1354 # @param self: The object pointer
1356 def _ParseMapFile(self
):
1357 if self
._MapFileParsed
:
1359 self
._MapFileParsed
= True
1360 if os
.path
.isfile(self
._MapFileName
):
1362 FileContents
= open(self
._MapFileName
).read()
1363 for Match
in gMapFileItemPattern
.finditer(FileContents
):
1364 AddressType
= Match
.group(1)
1365 BaseAddress
= Match
.group(2)
1366 EntryPoint
= Match
.group(3)
1367 Guid
= Match
.group(4).upper()
1368 List
= self
.FixedMapDict
.setdefault(Guid
, [])
1369 List
.append((AddressType
, BaseAddress
, "*I"))
1370 List
.append((AddressType
, EntryPoint
, "*E"))
1372 EdkLogger
.warn(None, "Cannot open file to read", self
._MapFileName
)
1375 # Invokes EOT tool to get the predicted the execution order.
1377 # This function invokes EOT tool to calculate the predicted dispatch order
1379 # @param self: The object pointer
1381 def _InvokeEotTool(self
):
1382 if self
._EotToolInvoked
:
1385 self
._EotToolInvoked
= True
1387 for FvName
in self
._FvList
:
1388 FvFile
= os
.path
.join(self
._FvDir
, FvName
+ ".Fv")
1389 if os
.path
.isfile(FvFile
):
1390 FvFileList
.append(FvFile
)
1392 if len(FvFileList
) == 0:
1395 # Write source file list and GUID file list to an intermediate file
1396 # as the input for EOT tool and dispatch List as the output file
1399 SourceList
= os
.path
.join(self
._EotDir
, "SourceFile.txt")
1400 GuidList
= os
.path
.join(self
._EotDir
, "GuidList.txt")
1401 DispatchList
= os
.path
.join(self
._EotDir
, "Dispatch.txt")
1403 TempFile
= open(SourceList
, "w+")
1404 for Item
in self
._SourceList
:
1405 FileWrite(TempFile
, Item
)
1407 TempFile
= open(GuidList
, "w+")
1408 for Key
in self
._GuidMap
:
1409 FileWrite(TempFile
, "%s %s" % (Key
, self
._GuidMap
[Key
]))
1413 from Eot
.Eot
import Eot
1416 # Invoke EOT tool and echo its runtime performance
1418 EotStartTime
= time
.time()
1419 Eot(CommandLineOption
=False, SourceFileList
=SourceList
, GuidList
=GuidList
,
1420 FvFileList
=' '.join(FvFileList
), Dispatch
=DispatchList
, IsInit
=True)
1421 EotEndTime
= time
.time()
1422 EotDuration
= time
.strftime("%H:%M:%S", time
.gmtime(int(round(EotEndTime
- EotStartTime
))))
1423 EdkLogger
.quiet("EOT run time: %s\n" % EotDuration
)
1426 # Parse the output of EOT tool
1428 for Line
in open(DispatchList
):
1429 if len(Line
.split()) < 4:
1431 (Guid
, Phase
, FfsName
, FilePath
) = Line
.split()
1432 Symbol
= self
._FfsEntryPoint
.get(Guid
, [FfsName
, ""])[0]
1433 if len(Symbol
) > self
.MaxLen
:
1434 self
.MaxLen
= len(Symbol
)
1435 self
.ItemList
.append((Phase
, Symbol
, FilePath
))
1437 EdkLogger
.quiet("(Python %s on %s\n%s)" % (platform
.python_version(), sys
.platform
, traceback
.format_exc()))
1438 EdkLogger
.warn(None, "Failed to generate execution order prediction report, for some error occurred in executing EOT.")
1442 # Generate platform execution order report
1444 # This function generates the predicted module execution order.
1446 # @param self The object pointer
1447 # @param File The file object for report
1449 def _GenerateExecutionOrderReport(self
, File
):
1450 self
._InvokeEotTool
()
1451 if len(self
.ItemList
) == 0:
1453 FileWrite(File
, gSectionStart
)
1454 FileWrite(File
, "Execution Order Prediction")
1455 FileWrite(File
, "*P PEI phase")
1456 FileWrite(File
, "*D DXE phase")
1457 FileWrite(File
, "*E Module INF entry point name")
1458 FileWrite(File
, "*N Module notification function name")
1460 FileWrite(File
, "Type %-*s %s" % (self
.MaxLen
, "Symbol", "Module INF Path"))
1461 FileWrite(File
, gSectionSep
)
1462 for Item
in self
.ItemList
:
1463 FileWrite(File
, "*%sE %-*s %s" % (Item
[0], self
.MaxLen
, Item
[1], Item
[2]))
1465 FileWrite(File
, gSectionStart
)
1468 # Generate Fixed Address report.
1470 # This function generate the predicted fixed address report for a module
1471 # specified by Guid.
1473 # @param self The object pointer
1474 # @param File The file object for report
1475 # @param Guid The module Guid value.
1476 # @param NotifyList The list of all notify function in a module
1478 def _GenerateFixedAddressReport(self
, File
, Guid
, NotifyList
):
1479 self
._ParseMapFile
()
1480 FixedAddressList
= self
.FixedMapDict
.get(Guid
)
1481 if not FixedAddressList
:
1484 FileWrite(File
, gSubSectionStart
)
1485 FileWrite(File
, "Fixed Address Prediction")
1486 FileWrite(File
, "*I Image Loading Address")
1487 FileWrite(File
, "*E Entry Point Address")
1488 FileWrite(File
, "*N Notification Function Address")
1489 FileWrite(File
, "*F Flash Address")
1490 FileWrite(File
, "*M Memory Address")
1491 FileWrite(File
, "*S SMM RAM Offset")
1492 FileWrite(File
, "TOM Top of Memory")
1494 FileWrite(File
, "Type Address Name")
1495 FileWrite(File
, gSubSectionSep
)
1496 for Item
in FixedAddressList
:
1501 Name
= "(Image Base)"
1502 elif Symbol
== "*E":
1503 Name
= self
._FfsEntryPoint
.get(Guid
, ["", "_ModuleEntryPoint"])[1]
1504 elif Symbol
in NotifyList
:
1512 elif "Memory" in Type
:
1518 Value
= "TOM" + Value
1520 FileWrite(File
, "%s %-16s %s" % (Symbol
, Value
, Name
))
1523 # Generate report for the prediction part
1525 # This function generate the predicted fixed address report for a module or
1526 # predicted module execution order for a platform.
1527 # If the input Guid is None, then, it generates the predicted module execution order;
1528 # otherwise it generated the module fixed loading address for the module specified by
1531 # @param self The object pointer
1532 # @param File The file object for report
1533 # @param Guid The module Guid value.
1535 def GenerateReport(self
, File
, Guid
):
1537 self
._GenerateFixedAddressReport
(File
, Guid
.upper(), [])
1539 self
._GenerateExecutionOrderReport
(File
)
1542 # Reports FD region information
1544 # This class reports the FD subsection in the build report file.
1545 # It collects region information of platform flash device.
1546 # If the region is a firmware volume, it lists the set of modules
1547 # and its space information; otherwise, it only lists its region name,
1548 # base address and size in its sub-section header.
1549 # If there are nesting FVs, the nested FVs will list immediate after
1550 # this FD region subsection
1552 class FdRegionReport(object):
1554 # Discover all the nested FV name list.
1556 # This is an internal worker function to discover the all the nested FV information
1557 # in the parent firmware volume. It uses deep first search algorithm recursively to
1558 # find all the FV list name and append them to the list.
1560 # @param self The object pointer
1561 # @param FvName The name of current firmware file system
1562 # @param Wa Workspace context information
1564 def _DiscoverNestedFvList(self
, FvName
, Wa
):
1565 FvDictKey
=FvName
.upper()
1566 if FvDictKey
in Wa
.FdfProfile
.FvDict
:
1567 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1568 for Section
in Ffs
.SectionList
:
1570 for FvSection
in Section
.SectionList
:
1571 if FvSection
.FvName
in self
.FvList
:
1573 self
._GuidsDb
[Ffs
.NameGuid
.upper()] = FvSection
.FvName
1574 self
.FvList
.append(FvSection
.FvName
)
1575 self
.FvInfo
[FvSection
.FvName
] = ("Nested FV", 0, 0)
1576 self
._DiscoverNestedFvList
(FvSection
.FvName
, Wa
)
1577 except AttributeError:
1581 # Constructor function for class FdRegionReport
1583 # This constructor function generates FdRegionReport object for a specified FdRegion.
1584 # If the FdRegion is a firmware volume, it will recursively find all its nested Firmware
1585 # volume list. This function also collects GUID map in order to dump module identification
1586 # in the final report.
1588 # @param self: The object pointer
1589 # @param FdRegion The current FdRegion object
1590 # @param Wa Workspace context information
1592 def __init__(self
, FdRegion
, Wa
):
1593 self
.Type
= FdRegion
.RegionType
1594 self
.BaseAddress
= FdRegion
.Offset
1595 self
.Size
= FdRegion
.Size
1599 self
._FvDir
= Wa
.FvDir
1602 # If the input FdRegion is not a firmware volume,
1605 if self
.Type
!= "FV":
1609 # Find all nested FVs in the FdRegion
1611 for FvName
in FdRegion
.RegionDataList
:
1612 if FvName
in self
.FvList
:
1614 self
.FvList
.append(FvName
)
1615 self
.FvInfo
[FvName
] = ("Fd Region", self
.BaseAddress
, self
.Size
)
1616 self
._DiscoverNestedFvList
(FvName
, Wa
)
1620 # Collect PCDs declared in DEC files.
1622 for Pa
in Wa
.AutoGenObjectList
:
1623 for Package
in Pa
.PackageList
:
1624 for (TokenCName
, TokenSpaceGuidCName
, DecType
) in Package
.Pcds
:
1625 DecDefaultValue
= Package
.Pcds
[TokenCName
, TokenSpaceGuidCName
, DecType
].DefaultValue
1626 PlatformPcds
[(TokenCName
, TokenSpaceGuidCName
)] = DecDefaultValue
1628 # Collect PCDs defined in DSC file
1630 for Pa
in Wa
.AutoGenObjectList
:
1631 for (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
1632 DscDefaultValue
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)].DefaultValue
1633 PlatformPcds
[(TokenCName
, TokenSpaceGuidCName
)] = DscDefaultValue
1636 # Add PEI and DXE a priori files GUIDs defined in PI specification.
1638 self
._GuidsDb
["1B45CC0A-156A-428A-AF62-49864DA0E6E6"] = "PEI Apriori"
1639 self
._GuidsDb
["FC510EE7-FFDC-11D4-BD41-0080C73C8881"] = "DXE Apriori"
1641 # Add ACPI table storage file
1643 self
._GuidsDb
["7E374E25-8E01-4FEE-87F2-390C23C606CD"] = "ACPI table storage"
1645 for Pa
in Wa
.AutoGenObjectList
:
1646 for ModuleKey
in Pa
.Platform
.Modules
:
1647 M
= Pa
.Platform
.Modules
[ModuleKey
].M
1648 InfPath
= mws
.join(Wa
.WorkspaceDir
, M
.MetaFile
.File
)
1649 self
._GuidsDb
[M
.Guid
.upper()] = "%s (%s)" % (M
.Module
.BaseName
, InfPath
)
1652 # Collect the GUID map in the FV firmware volume
1654 for FvName
in self
.FvList
:
1655 FvDictKey
=FvName
.upper()
1656 if FvDictKey
in Wa
.FdfProfile
.FvDict
:
1657 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1660 # collect GUID map for binary EFI file in FDF file.
1662 Guid
= Ffs
.NameGuid
.upper()
1663 Match
= gPcdGuidPattern
.match(Ffs
.NameGuid
)
1665 PcdTokenspace
= Match
.group(1)
1666 PcdToken
= Match
.group(2)
1667 if (PcdToken
, PcdTokenspace
) in PlatformPcds
:
1668 GuidValue
= PlatformPcds
[(PcdToken
, PcdTokenspace
)]
1669 Guid
= GuidStructureByteArrayToGuidString(GuidValue
).upper()
1670 for Section
in Ffs
.SectionList
:
1672 ModuleSectFile
= mws
.join(Wa
.WorkspaceDir
, Section
.SectFileName
)
1673 self
._GuidsDb
[Guid
] = ModuleSectFile
1674 except AttributeError:
1676 except AttributeError:
1681 # Internal worker function to generate report for the FD region
1683 # This internal worker function to generate report for the FD region.
1684 # It the type is firmware volume, it lists offset and module identification.
1686 # @param self The object pointer
1687 # @param File The file object for report
1688 # @param Title The title for the FD subsection
1689 # @param BaseAddress The base address for the FD region
1690 # @param Size The size of the FD region
1691 # @param FvName The FV name if the FD region is a firmware volume
1693 def _GenerateReport(self
, File
, Title
, Type
, BaseAddress
, Size
=0, FvName
=None):
1694 FileWrite(File
, gSubSectionStart
)
1695 FileWrite(File
, Title
)
1696 FileWrite(File
, "Type: %s" % Type
)
1697 FileWrite(File
, "Base Address: 0x%X" % BaseAddress
)
1699 if self
.Type
== "FV":
1703 FvReportFileName
= os
.path
.join(self
._FvDir
, FvName
+ ".Fv.txt")
1706 # Collect size info in the firmware volume.
1708 FvReport
= open(FvReportFileName
).read()
1709 Match
= gFvTotalSizePattern
.search(FvReport
)
1711 FvTotalSize
= int(Match
.group(1), 16)
1712 Match
= gFvTakenSizePattern
.search(FvReport
)
1714 FvTakenSize
= int(Match
.group(1), 16)
1715 FvFreeSize
= FvTotalSize
- FvTakenSize
1717 # Write size information to the report file.
1719 FileWrite(File
, "Size: 0x%X (%.0fK)" % (FvTotalSize
, FvTotalSize
/ 1024.0))
1720 FileWrite(File
, "Fv Name: %s (%.1f%% Full)" % (FvName
, FvTakenSize
* 100.0 / FvTotalSize
))
1721 FileWrite(File
, "Occupied Size: 0x%X (%.0fK)" % (FvTakenSize
, FvTakenSize
/ 1024.0))
1722 FileWrite(File
, "Free Size: 0x%X (%.0fK)" % (FvFreeSize
, FvFreeSize
/ 1024.0))
1723 FileWrite(File
, "Offset Module")
1724 FileWrite(File
, gSubSectionSep
)
1726 # Write module offset and module identification to the report file.
1729 for Match
in gOffsetGuidPattern
.finditer(FvReport
):
1730 Guid
= Match
.group(2).upper()
1731 OffsetInfo
[Match
.group(1)] = self
._GuidsDb
.get(Guid
, Guid
)
1732 OffsetList
= OffsetInfo
.keys()
1734 for Offset
in OffsetList
:
1735 FileWrite (File
, "%s %s" % (Offset
, OffsetInfo
[Offset
]))
1737 EdkLogger
.warn(None, "Fail to read report file", FvReportFileName
)
1739 FileWrite(File
, "Size: 0x%X (%.0fK)" % (Size
, Size
/ 1024.0))
1740 FileWrite(File
, gSubSectionEnd
)
1743 # Generate report for the FD region
1745 # This function generates report for the FD region.
1747 # @param self The object pointer
1748 # @param File The file object for report
1750 def GenerateReport(self
, File
):
1751 if (len(self
.FvList
) > 0):
1752 for FvItem
in self
.FvList
:
1753 Info
= self
.FvInfo
[FvItem
]
1754 self
._GenerateReport
(File
, Info
[0], "FV", Info
[1], Info
[2], FvItem
)
1756 self
._GenerateReport
(File
, "FD Region", self
.Type
, self
.BaseAddress
, self
.Size
)
1759 # Reports FD information
1761 # This class reports the FD section in the build report file.
1762 # It collects flash device information for a platform.
1764 class FdReport(object):
1766 # Constructor function for class FdReport
1768 # This constructor function generates FdReport object for a specified
1771 # @param self The object pointer
1772 # @param Fd The current Firmware device object
1773 # @param Wa Workspace context information
1775 def __init__(self
, Fd
, Wa
):
1776 self
.FdName
= Fd
.FdUiName
1777 self
.BaseAddress
= Fd
.BaseAddress
1779 self
.FdRegionList
= [FdRegionReport(FdRegion
, Wa
) for FdRegion
in Fd
.RegionList
]
1780 self
.FvPath
= os
.path
.join(Wa
.BuildDir
, "FV")
1781 self
.VpdFilePath
= os
.path
.join(self
.FvPath
, "%s.map" % Wa
.Platform
.VpdToolGuid
)
1782 self
.VPDBaseAddress
= 0
1784 self
.VPDInfoList
= []
1785 for index
, FdRegion
in enumerate(Fd
.RegionList
):
1786 if str(FdRegion
.RegionType
) is 'FILE' and Wa
.Platform
.VpdToolGuid
in str(FdRegion
.RegionDataList
):
1787 self
.VPDBaseAddress
= self
.FdRegionList
[index
].BaseAddress
1788 self
.VPDSize
= self
.FdRegionList
[index
].Size
1791 if os
.path
.isfile(self
.VpdFilePath
):
1792 fd
= open(self
.VpdFilePath
, "r")
1793 Lines
= fd
.readlines()
1796 if len(Line
) == 0 or Line
.startswith("#"):
1799 PcdName
, SkuId
, Offset
, Size
, Value
= Line
.split("#")[0].split("|")
1800 PcdName
, SkuId
, Offset
, Size
, Value
= PcdName
.strip(), SkuId
.strip(), Offset
.strip(), Size
.strip(), Value
.strip()
1801 if Offset
.lower().startswith('0x'):
1802 Offset
= '0x%08X' % (int(Offset
, 16) + self
.VPDBaseAddress
)
1804 Offset
= '0x%08X' % (int(Offset
, 10) + self
.VPDBaseAddress
)
1805 self
.VPDInfoList
.append("%s | %s | %s | %s | %s" % (PcdName
, SkuId
, Offset
, Size
, Value
))
1807 EdkLogger
.error("BuildReport", CODE_ERROR
, "Fail to parse VPD information file %s" % self
.VpdFilePath
)
1811 # Generate report for the firmware device.
1813 # This function generates report for the firmware device.
1815 # @param self The object pointer
1816 # @param File The file object for report
1818 def GenerateReport(self
, File
):
1819 FileWrite(File
, gSectionStart
)
1820 FileWrite(File
, "Firmware Device (FD)")
1821 FileWrite(File
, "FD Name: %s" % self
.FdName
)
1822 FileWrite(File
, "Base Address: %s" % self
.BaseAddress
)
1823 FileWrite(File
, "Size: 0x%X (%.0fK)" % (self
.Size
, self
.Size
/ 1024.0))
1824 if len(self
.FdRegionList
) > 0:
1825 FileWrite(File
, gSectionSep
)
1826 for FdRegionItem
in self
.FdRegionList
:
1827 FdRegionItem
.GenerateReport(File
)
1829 if len(self
.VPDInfoList
) > 0:
1830 FileWrite(File
, gSubSectionStart
)
1831 FileWrite(File
, "FD VPD Region")
1832 FileWrite(File
, "Base Address: 0x%X" % self
.VPDBaseAddress
)
1833 FileWrite(File
, "Size: 0x%X (%.0fK)" % (self
.VPDSize
, self
.VPDSize
/ 1024.0))
1834 FileWrite(File
, gSubSectionSep
)
1835 for item
in self
.VPDInfoList
:
1836 ValueList
= item
.split('|')
1837 Value
= ValueList
[-1].strip()
1838 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1840 ValueList
[-1] = ' {'
1841 FileWrite(File
, '|'.join(ValueList
))
1842 for Array
in ArrayList
:
1843 FileWrite(File
, '%s' % (Array
))
1845 FileWrite(File
, item
)
1846 FileWrite(File
, gSubSectionEnd
)
1847 FileWrite(File
, gSectionEnd
)
1852 # Reports platform information
1854 # This class reports the whole platform information
1856 class PlatformReport(object):
1858 # Constructor function for class PlatformReport
1860 # This constructor function generates PlatformReport object a platform build.
1861 # It generates report for platform summary, flash, global PCDs and detailed
1862 # module information for modules involved in platform build.
1864 # @param self The object pointer
1865 # @param Wa Workspace context information
1866 # @param MaList The list of modules in the platform build
1868 def __init__(self
, Wa
, MaList
, ReportType
):
1869 self
._WorkspaceDir
= Wa
.WorkspaceDir
1870 self
.PlatformName
= Wa
.Name
1871 self
.PlatformDscPath
= Wa
.Platform
1872 self
.Architectures
= " ".join(Wa
.ArchList
)
1873 self
.ToolChain
= Wa
.ToolChain
1874 self
.Target
= Wa
.BuildTarget
1875 self
.OutputPath
= os
.path
.join(Wa
.WorkspaceDir
, Wa
.OutputDir
)
1876 self
.BuildEnvironment
= platform
.platform()
1878 self
.PcdReport
= None
1879 if "PCD" in ReportType
:
1880 self
.PcdReport
= PcdReport(Wa
)
1882 self
.FdReportList
= []
1883 if "FLASH" in ReportType
and Wa
.FdfProfile
and MaList
== None:
1884 for Fd
in Wa
.FdfProfile
.FdDict
:
1885 self
.FdReportList
.append(FdReport(Wa
.FdfProfile
.FdDict
[Fd
], Wa
))
1887 self
.PredictionReport
= None
1888 if "FIXED_ADDRESS" in ReportType
or "EXECUTION_ORDER" in ReportType
:
1889 self
.PredictionReport
= PredictionReport(Wa
)
1891 self
.DepexParser
= None
1892 if "DEPEX" in ReportType
:
1893 self
.DepexParser
= DepexParser(Wa
)
1895 self
.ModuleReportList
= []
1897 self
._IsModuleBuild
= True
1899 self
.ModuleReportList
.append(ModuleReport(Ma
, ReportType
))
1901 self
._IsModuleBuild
= False
1902 for Pa
in Wa
.AutoGenObjectList
:
1903 ModuleAutoGenList
= []
1904 for ModuleKey
in Pa
.Platform
.Modules
:
1905 ModuleAutoGenList
.append(Pa
.Platform
.Modules
[ModuleKey
].M
)
1906 if GlobalData
.gFdfParser
!= None:
1907 if Pa
.Arch
in GlobalData
.gFdfParser
.Profile
.InfDict
:
1908 INFList
= GlobalData
.gFdfParser
.Profile
.InfDict
[Pa
.Arch
]
1909 for InfName
in INFList
:
1910 InfClass
= PathClass(NormPath(InfName
), Wa
.WorkspaceDir
, Pa
.Arch
)
1911 Ma
= ModuleAutoGen(Wa
, InfClass
, Pa
.BuildTarget
, Pa
.ToolChain
, Pa
.Arch
, Wa
.MetaFile
)
1914 if Ma
not in ModuleAutoGenList
:
1915 ModuleAutoGenList
.append(Ma
)
1916 for MGen
in ModuleAutoGenList
:
1917 self
.ModuleReportList
.append(ModuleReport(MGen
, ReportType
))
1922 # Generate report for the whole platform.
1924 # This function generates report for platform information.
1925 # It comprises of platform summary, global PCD, flash and
1926 # module list sections.
1928 # @param self The object pointer
1929 # @param File The file object for report
1930 # @param BuildDuration The total time to build the modules
1931 # @param AutoGenTime The total time of AutoGen Phase
1932 # @param MakeTime The total time of Make Phase
1933 # @param GenFdsTime The total time of GenFds Phase
1934 # @param ReportType The kind of report items in the final report file
1936 def GenerateReport(self
, File
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
, ReportType
):
1937 FileWrite(File
, "Platform Summary")
1938 FileWrite(File
, "Platform Name: %s" % self
.PlatformName
)
1939 FileWrite(File
, "Platform DSC Path: %s" % self
.PlatformDscPath
)
1940 FileWrite(File
, "Architectures: %s" % self
.Architectures
)
1941 FileWrite(File
, "Tool Chain: %s" % self
.ToolChain
)
1942 FileWrite(File
, "Target: %s" % self
.Target
)
1943 if GlobalData
.gSkuids
:
1944 FileWrite(File
, "SKUID: %s" % " ".join(GlobalData
.gSkuids
))
1945 if GlobalData
.gDefaultStores
:
1946 FileWrite(File
, "DefaultStore: %s" % " ".join(GlobalData
.gDefaultStores
))
1947 FileWrite(File
, "Output Path: %s" % self
.OutputPath
)
1948 FileWrite(File
, "Build Environment: %s" % self
.BuildEnvironment
)
1949 FileWrite(File
, "Build Duration: %s" % BuildDuration
)
1951 FileWrite(File
, "AutoGen Duration: %s" % AutoGenTime
)
1953 FileWrite(File
, "Make Duration: %s" % MakeTime
)
1955 FileWrite(File
, "GenFds Duration: %s" % GenFdsTime
)
1956 FileWrite(File
, "Report Content: %s" % ", ".join(ReportType
))
1958 if GlobalData
.MixedPcd
:
1959 FileWrite(File
, gSectionStart
)
1960 FileWrite(File
, "The following PCDs use different access methods:")
1961 FileWrite(File
, gSectionSep
)
1962 for PcdItem
in GlobalData
.MixedPcd
:
1963 FileWrite(File
, "%s.%s" % (str(PcdItem
[1]), str(PcdItem
[0])))
1964 FileWrite(File
, gSectionEnd
)
1966 if not self
._IsModuleBuild
:
1967 if "PCD" in ReportType
:
1968 self
.PcdReport
.GenerateReport(File
, None)
1970 if "FLASH" in ReportType
:
1971 for FdReportListItem
in self
.FdReportList
:
1972 FdReportListItem
.GenerateReport(File
)
1974 for ModuleReportItem
in self
.ModuleReportList
:
1975 ModuleReportItem
.GenerateReport(File
, self
.PcdReport
, self
.PredictionReport
, self
.DepexParser
, ReportType
)
1977 if not self
._IsModuleBuild
:
1978 if "EXECUTION_ORDER" in ReportType
:
1979 self
.PredictionReport
.GenerateReport(File
, None)
1981 ## BuildReport class
1983 # This base class contain the routines to collect data and then
1984 # applies certain format to the output report
1986 class BuildReport(object):
1988 # Constructor function for class BuildReport
1990 # This constructor function generates BuildReport object a platform build.
1991 # It generates report for platform summary, flash, global PCDs and detailed
1992 # module information for modules involved in platform build.
1994 # @param self The object pointer
1995 # @param ReportFile The file name to save report file
1996 # @param ReportType The kind of report items in the final report file
1998 def __init__(self
, ReportFile
, ReportType
):
1999 self
.ReportFile
= ReportFile
2001 self
.ReportList
= []
2002 self
.ReportType
= []
2004 for ReportTypeItem
in ReportType
:
2005 if ReportTypeItem
not in self
.ReportType
:
2006 self
.ReportType
.append(ReportTypeItem
)
2008 self
.ReportType
= ["PCD", "LIBRARY", "BUILD_FLAGS", "DEPEX", "HASH", "FLASH", "FIXED_ADDRESS"]
2010 # Adds platform report to the list
2012 # This function adds a platform report to the final report list.
2014 # @param self The object pointer
2015 # @param Wa Workspace context information
2016 # @param MaList The list of modules in the platform build
2018 def AddPlatformReport(self
, Wa
, MaList
=None):
2020 self
.ReportList
.append((Wa
, MaList
))
2023 # Generates the final report.
2025 # This function generates platform build report. It invokes GenerateReport()
2026 # method for every platform report in the list.
2028 # @param self The object pointer
2029 # @param BuildDuration The total time to build the modules
2030 # @param AutoGenTime The total time of AutoGen phase
2031 # @param MakeTime The total time of Make phase
2032 # @param GenFdsTime The total time of GenFds phase
2034 def GenerateReport(self
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
):
2038 for (Wa
, MaList
) in self
.ReportList
:
2039 PlatformReport(Wa
, MaList
, self
.ReportType
).GenerateReport(File
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
, self
.ReportType
)
2040 Content
= FileLinesSplit(File
.getvalue(), gLineMaxLength
)
2041 SaveFileOnChange(self
.ReportFile
, Content
, True)
2042 EdkLogger
.quiet("Build report can be found at %s" % os
.path
.abspath(self
.ReportFile
))
2044 EdkLogger
.error(None, FILE_WRITE_FAILURE
, ExtraData
=self
.ReportFile
)
2046 EdkLogger
.error("BuildReport", CODE_ERROR
, "Unknown fatal error when generating build report", ExtraData
=self
.ReportFile
, RaiseError
=False)
2047 EdkLogger
.quiet("(Python %s on %s\n%s)" % (platform
.python_version(), sys
.platform
, traceback
.format_exc()))
2050 # This acts like the main() function for the script, unless it is 'import'ed into another script.
2051 if __name__
== '__main__':