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
.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
.DefaultStoreSingle
= True
760 self
.SkuSingle
= True
761 if GlobalData
.gDefaultStores
and len(GlobalData
.gDefaultStores
) > 1:
762 self
.DefaultStoreSingle
= False
763 if GlobalData
.gSkuids
and len(GlobalData
.gSkuids
) > 1:
764 self
.SkuSingle
= False
766 self
.ModulePcdOverride
= {}
767 for Pa
in Wa
.AutoGenObjectList
:
770 # Collect all platform referenced PCDs and grouped them by PCD token space
773 for Pcd
in Pa
.AllPcdList
:
774 PcdList
= self
.AllPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
775 if Pcd
not in PcdList
:
777 if len(Pcd
.TokenCName
) > self
.MaxLen
:
778 self
.MaxLen
= len(Pcd
.TokenCName
)
780 # Collect the PCD defined in DSC/FDF file, but not used in module
782 UnusedPcdFullList
= []
783 for item
in Pa
.Platform
.Pcds
:
784 Pcd
= Pa
.Platform
.Pcds
[item
]
786 # check the Pcd in FDF file, whether it is used in module first
787 for T
in ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"]:
788 PcdList
= self
.AllPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(T
, [])
794 for package
in Pa
.PackageList
:
795 for T
in ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"]:
796 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, T
) in package
.Pcds
:
799 if not Pcd
.DatumType
:
800 Pcd
.DatumType
= package
.Pcds
[(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, T
)].DatumType
804 if not Pcd
.DatumType
:
806 # Try to remove Hii and Vpd suffix
807 if PcdType
.startswith("DynamicEx"):
808 PcdType
= "DynamicEx"
809 elif PcdType
.startswith("Dynamic"):
811 for package
in Pa
.PackageList
:
812 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, PcdType
) in package
.Pcds
:
813 Pcd
.DatumType
= package
.Pcds
[(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, PcdType
)].DatumType
816 PcdList
= self
.AllPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
817 if Pcd
not in PcdList
and Pcd
not in UnusedPcdFullList
:
818 UnusedPcdFullList
.append(Pcd
)
819 if len(Pcd
.TokenCName
) > self
.MaxLen
:
820 self
.MaxLen
= len(Pcd
.TokenCName
)
822 if GlobalData
.gConditionalPcds
:
823 for PcdItem
in GlobalData
.gConditionalPcds
:
825 (TokenSpaceGuidCName
, TokenCName
) = PcdItem
.split('.')
826 if (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
.keys():
827 Pcd
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)]
828 PcdList
= self
.ConditionalPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
829 if Pcd
not in PcdList
:
833 if UnusedPcdFullList
:
834 for Pcd
in UnusedPcdFullList
:
835 if Pcd
.TokenSpaceGuidCName
+ '.' + Pcd
.TokenCName
in GlobalData
.gConditionalPcds
:
837 UnusedPcdList
.append(Pcd
)
839 for Pcd
in UnusedPcdList
:
840 PcdList
= self
.UnusedPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
841 if Pcd
not in PcdList
:
844 for Module
in Pa
.Platform
.Modules
.values():
846 # Collect module override PCDs
848 for ModulePcd
in Module
.M
.ModulePcdList
+ Module
.M
.LibraryPcdList
:
849 TokenCName
= ModulePcd
.TokenCName
850 TokenSpaceGuid
= ModulePcd
.TokenSpaceGuidCName
851 ModuleDefault
= ModulePcd
.DefaultValue
852 ModulePath
= os
.path
.basename(Module
.M
.MetaFile
.File
)
853 self
.ModulePcdOverride
.setdefault((TokenCName
, TokenSpaceGuid
), {})[ModulePath
] = ModuleDefault
857 # Collect PCD DEC default value.
859 self
.DecPcdDefault
= {}
861 for Pa
in Wa
.AutoGenObjectList
:
862 for Package
in Pa
.PackageList
:
863 Guids
= Package
.Guids
864 self
._GuidDict
.update(Guids
)
865 for (TokenCName
, TokenSpaceGuidCName
, DecType
) in Package
.Pcds
:
866 DecDefaultValue
= Package
.Pcds
[TokenCName
, TokenSpaceGuidCName
, DecType
].DefaultValue
867 self
.DecPcdDefault
.setdefault((TokenCName
, TokenSpaceGuidCName
, DecType
), DecDefaultValue
)
869 # Collect PCDs defined in DSC common section
871 self
.DscPcdDefault
= {}
872 for Pa
in Wa
.AutoGenObjectList
:
873 for (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
874 DscDefaultValue
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)].DscDefaultValue
876 self
.DscPcdDefault
[(TokenCName
, TokenSpaceGuidCName
)] = DscDefaultValue
878 def GenerateReport(self
, File
, ModulePcdSet
):
879 if self
.ConditionalPcds
:
880 self
.GenerateReportDetail(File
, ModulePcdSet
, 1)
882 self
.GenerateReportDetail(File
, ModulePcdSet
, 2)
883 self
.GenerateReportDetail(File
, ModulePcdSet
)
886 # Generate report for PCD information
888 # This function generates report for separate module expression
889 # in a platform build.
891 # @param self The object pointer
892 # @param File The file object for report
893 # @param ModulePcdSet Set of all PCDs referenced by module or None for
894 # platform PCD report
895 # @param ReportySubType 0 means platform/module PCD report, 1 means Conditional
896 # directives section report, 2 means Unused Pcds section report
897 # @param DscOverridePcds Module DSC override PCDs set
899 def GenerateReportDetail(self
, File
, ModulePcdSet
, ReportSubType
= 0):
900 PcdDict
= self
.AllPcds
901 if ReportSubType
== 1:
902 PcdDict
= self
.ConditionalPcds
903 elif ReportSubType
== 2:
904 PcdDict
= self
.UnusedPcds
906 if ModulePcdSet
== None:
907 FileWrite(File
, gSectionStart
)
908 if ReportSubType
== 1:
909 FileWrite(File
, "Conditional Directives used by the build system")
910 elif ReportSubType
== 2:
911 FileWrite(File
, "PCDs not used by modules or in conditional directives")
913 FileWrite(File
, "Platform Configuration Database Report")
915 FileWrite(File
, " *B - PCD override in the build option")
916 FileWrite(File
, " *P - Platform scoped PCD override in DSC file")
917 FileWrite(File
, " *F - Platform scoped PCD override in FDF file")
918 if not ReportSubType
:
919 FileWrite(File
, " *M - Module scoped PCD override")
920 FileWrite(File
, gSectionSep
)
922 if not ReportSubType
and ModulePcdSet
:
924 # For module PCD sub-section
926 FileWrite(File
, gSubSectionStart
)
927 FileWrite(File
, TAB_BRG_PCD
)
928 FileWrite(File
, gSubSectionSep
)
932 # Group PCD by their token space GUID C Name
935 for Type
in PcdDict
[Key
]:
937 # Group PCD by their usage type
939 TypeName
, DecType
= gPcdTypeMap
.get(Type
, ("", Type
))
940 for Pcd
in PcdDict
[Key
][Type
]:
941 PcdTokenCName
= Pcd
.TokenCName
943 if GlobalData
.MixedPcd
:
944 for PcdKey
in GlobalData
.MixedPcd
:
945 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
) in GlobalData
.MixedPcd
[PcdKey
]:
946 PcdTokenCName
= PcdKey
[0]
948 if MixedPcdFlag
and not ModulePcdSet
:
951 # Get PCD default value and their override relationship
953 DecDefaultValue
= self
.DecPcdDefault
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, DecType
))
954 DscDefaultValue
= self
.DscPcdDefault
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
))
955 DscDefaultValBak
= DscDefaultValue
956 DscDefaultValue
= self
.FdfPcdSet
.get((Pcd
.TokenCName
, Key
), DscDefaultValue
)
958 DscDefaultValue
= ValueExpressionEx(DscDefaultValue
, Pcd
.DatumType
, self
._GuidDict
)(True)
959 InfDefaultValue
= None
961 PcdValue
= DecDefaultValue
963 PcdValue
= DscDefaultValue
964 if ModulePcdSet
!= None:
965 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Type
) not in ModulePcdSet
:
967 InfDefault
, PcdValue
= ModulePcdSet
[Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Type
]
971 BuildOptionMatch
= False
972 if GlobalData
.BuildOptionPcd
:
973 for pcd
in GlobalData
.BuildOptionPcd
:
974 if (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
) == (pcd
[0], pcd
[1]):
976 BuildOptionMatch
= True
980 if ModulePcdSet
== None:
986 if Pcd
.DatumType
in ('UINT8', 'UINT16', 'UINT32', 'UINT64'):
987 PcdValueNumber
= int(PcdValue
.strip(), 0)
988 if DecDefaultValue
== None:
991 DecDefaultValueNumber
= int(DecDefaultValue
.strip(), 0)
992 DecMatch
= (DecDefaultValueNumber
== PcdValueNumber
)
994 if InfDefaultValue
== None:
997 InfDefaultValueNumber
= int(InfDefaultValue
.strip(), 0)
998 InfMatch
= (InfDefaultValueNumber
== PcdValueNumber
)
1000 if DscDefaultValue
== None:
1003 DscDefaultValueNumber
= int(DscDefaultValue
.strip(), 0)
1004 DscMatch
= (DscDefaultValueNumber
== PcdValueNumber
)
1006 if DecDefaultValue
== None:
1009 DecMatch
= (DecDefaultValue
.strip() == PcdValue
.strip())
1011 if InfDefaultValue
== None:
1014 InfMatch
= (InfDefaultValue
.strip() == PcdValue
.strip())
1016 if DscDefaultValue
== None:
1019 DscMatch
= (DscDefaultValue
.strip() == PcdValue
.strip())
1022 if GlobalData
.gStructurePcd
and (self
.Arch
in GlobalData
.gStructurePcd
.keys()) and ((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
) in GlobalData
.gStructurePcd
[self
.Arch
]):
1024 if TypeName
in ('DYNVPD', 'DEXVPD'):
1025 SkuInfoList
= Pcd
.SkuInfoList
1026 Pcd
= GlobalData
.gStructurePcd
[self
.Arch
][(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
)]
1027 Pcd
.DatumType
= Pcd
.StructName
1028 if TypeName
in ('DYNVPD', 'DEXVPD'):
1029 Pcd
.SkuInfoList
= SkuInfoList
1030 if Pcd
.SkuOverrideValues
:
1034 # Report PCD item according to their override relationship
1036 if DecMatch
and InfMatch
:
1037 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, ' ')
1038 elif BuildOptionMatch
:
1039 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*B')
1042 if (Pcd
.TokenCName
, Key
) in self
.FdfPcdSet
:
1043 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*F')
1045 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*P')
1047 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*M')
1049 if ModulePcdSet
== None:
1052 if not TypeName
in ('PATCH', 'FLAG', 'FIXED'):
1054 if not BuildOptionMatch
:
1055 ModuleOverride
= self
.ModulePcdOverride
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
), {})
1056 for ModulePath
in ModuleOverride
:
1057 ModuleDefault
= ModuleOverride
[ModulePath
]
1058 if Pcd
.DatumType
in ('UINT8', 'UINT16', 'UINT32', 'UINT64'):
1059 ModulePcdDefaultValueNumber
= int(ModuleDefault
.strip(), 0)
1060 Match
= (ModulePcdDefaultValueNumber
== PcdValueNumber
)
1062 Match
= (ModuleDefault
.strip() == PcdValue
.strip())
1065 IsByteArray
, ArrayList
= ByteArrayForamt(ModuleDefault
.strip())
1067 FileWrite(File
, ' *M %-*s = %s' % (self
.MaxLen
+ 19, ModulePath
, '{'))
1068 for Array
in ArrayList
:
1069 FileWrite(File
, '%s' % (Array
))
1071 FileWrite(File
, ' *M %-*s = %s' % (self
.MaxLen
+ 19, ModulePath
, ModuleDefault
.strip()))
1073 if ModulePcdSet
== None:
1074 FileWrite(File
, gSectionEnd
)
1076 if not ReportSubType
and ModulePcdSet
:
1077 FileWrite(File
, gSubSectionEnd
)
1080 def PrintPcdDefault(self
, File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
):
1081 if not DscMatch
and DscDefaultValue
!= None:
1082 Value
= DscDefaultValue
.strip()
1083 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1085 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DSC DEFAULT', "{"))
1086 for Array
in ArrayList
:
1087 FileWrite(File
, '%s' % (Array
))
1089 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DSC DEFAULT', Value
))
1090 if not InfMatch
and InfDefaultValue
!= None:
1091 Value
= InfDefaultValue
.strip()
1092 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1094 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'INF DEFAULT', "{"))
1095 for Array
in ArrayList
:
1096 FileWrite(File
, '%s' % (Array
))
1098 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'INF DEFAULT', Value
))
1100 if not DecMatch
and DecDefaultValue
!= None:
1101 Value
= DecDefaultValue
.strip()
1102 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1104 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DEC DEFAULT', "{"))
1105 for Array
in ArrayList
:
1106 FileWrite(File
, '%s' % (Array
))
1108 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DEC DEFAULT', Value
))
1110 self
.PrintStructureInfo(File
, Pcd
.DefaultValues
)
1112 def PrintPcdValue(self
, File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, Flag
= ' '):
1113 if not Pcd
.SkuInfoList
:
1114 Value
= Pcd
.DefaultValue
1115 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1117 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1118 for Array
in ArrayList
:
1119 FileWrite(File
, '%s' % (Array
))
1121 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1123 OverrideValues
= Pcd
.SkuOverrideValues
1125 Keys
= OverrideValues
.keys()
1126 Data
= OverrideValues
[Keys
[0]]
1127 Struct
= Data
.values()[0]
1128 self
.PrintStructureInfo(File
, Struct
)
1129 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1132 SkuList
= sorted(Pcd
.SkuInfoList
.keys())
1134 SkuInfo
= Pcd
.SkuInfoList
[Sku
]
1135 SkuIdName
= SkuInfo
.SkuIdName
1136 if TypeName
in ('DYNHII', 'DEXHII'):
1137 if SkuInfo
.DefaultStoreDict
:
1138 DefaultStoreList
= sorted(SkuInfo
.DefaultStoreDict
.keys())
1139 for DefaultStore
in DefaultStoreList
:
1140 Value
= SkuInfo
.DefaultStoreDict
[DefaultStore
]
1141 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1145 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1146 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1147 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1148 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '{'))
1149 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1150 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', '{'))
1152 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', '{'))
1153 for Array
in ArrayList
:
1154 FileWrite(File
, '%s' % (Array
))
1156 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1157 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1158 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1159 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1160 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1161 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', Value
))
1163 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', Value
))
1166 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1167 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1168 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1169 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '{'))
1170 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1171 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', '{'))
1173 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', '{'))
1174 for Array
in ArrayList
:
1175 FileWrite(File
, '%s' % (Array
))
1177 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1178 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1179 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1180 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1181 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1182 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', Value
))
1184 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', Value
))
1185 FileWrite(File
, '%*s: %s: %s' % (self
.MaxLen
+ 4, SkuInfo
.VariableGuid
, SkuInfo
.VariableName
, SkuInfo
.VariableOffset
))
1187 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1188 Struct
= OverrideValues
[DefaultStore
]
1189 self
.PrintStructureInfo(File
, Struct
)
1190 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1192 Value
= SkuInfo
.DefaultValue
1193 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1198 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', "{"))
1200 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', "{"))
1201 for Array
in ArrayList
:
1202 FileWrite(File
, '%s' % (Array
))
1205 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1207 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1211 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', "{"))
1213 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', "{"))
1214 for Array
in ArrayList
:
1215 FileWrite(File
, '%s' % (Array
))
1218 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1220 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1221 if TypeName
in ('DYNVPD', 'DEXVPD'):
1222 FileWrite(File
, '%*s' % (self
.MaxLen
+ 4, SkuInfo
.VpdOffset
))
1224 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1226 Keys
= OverrideValues
.keys()
1227 Struct
= OverrideValues
[Keys
[0]]
1228 self
.PrintStructureInfo(File
, Struct
)
1229 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1231 def PrintStructureInfo(self
, File
, Struct
):
1232 NewInfo
= collections
.OrderedDict()
1233 for Key
, Value
in Struct
.items():
1234 if Key
not in NewInfo
:
1235 NewInfo
[Key
] = Value
[0]
1238 NewInfo
[Key
] = Value
[0]
1240 for item
in NewInfo
:
1241 FileWrite(File
, ' %-*s = %s' % (self
.MaxLen
+ 4, '.' + item
, NewInfo
[item
]))
1243 def StrtoHex(self
, value
):
1245 value
= hex(int(value
))
1248 if value
.startswith("L\"") and value
.endswith("\""):
1250 for ch
in value
[2:-1]:
1251 valuelist
.append(hex(ord(ch
)))
1252 valuelist
.append('0x00')
1254 elif value
.startswith("\"") and value
.endswith("\""):
1255 return hex(ord(value
[1:-1]))
1256 elif value
.startswith("{") and value
.endswith("}"):
1258 if ',' not in value
:
1260 for ch
in value
[1:-1].split(','):
1262 if ch
.startswith('0x') or ch
.startswith('0X'):
1263 valuelist
.append(ch
)
1266 valuelist
.append(hex(int(ch
.strip())))
1274 # Reports platform and module Prediction information
1276 # This class reports the platform execution order prediction section and
1277 # module load fixed address prediction subsection in the build report file.
1279 class PredictionReport(object):
1281 # Constructor function for class PredictionReport
1283 # This constructor function generates PredictionReport object for the platform.
1285 # @param self: The object pointer
1286 # @param Wa Workspace context information
1288 def __init__(self
, Wa
):
1289 self
._MapFileName
= os
.path
.join(Wa
.BuildDir
, Wa
.Name
+ ".map")
1290 self
._MapFileParsed
= False
1291 self
._EotToolInvoked
= False
1292 self
._FvDir
= Wa
.FvDir
1293 self
._EotDir
= Wa
.BuildDir
1294 self
._FfsEntryPoint
= {}
1296 self
._SourceList
= []
1297 self
.FixedMapDict
= {}
1302 # Collect all platform reference source files and GUID C Name
1304 for Pa
in Wa
.AutoGenObjectList
:
1305 for Module
in Pa
.LibraryAutoGenList
+ Pa
.ModuleAutoGenList
:
1307 # BASE typed modules are EFI agnostic, so we need not scan
1308 # their source code to find PPI/Protocol produce or consume
1311 if Module
.ModuleType
== "BASE":
1314 # Add module referenced source files
1316 self
._SourceList
.append(str(Module
))
1318 for Source
in Module
.SourceFileList
:
1319 if os
.path
.splitext(str(Source
))[1].lower() == ".c":
1320 self
._SourceList
.append(" " + str(Source
))
1321 FindIncludeFiles(Source
.Path
, Module
.IncludePathList
, IncludeList
)
1322 for IncludeFile
in IncludeList
.values():
1323 self
._SourceList
.append(" " + IncludeFile
)
1325 for Guid
in Module
.PpiList
:
1326 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.PpiList
[Guid
])
1327 for Guid
in Module
.ProtocolList
:
1328 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.ProtocolList
[Guid
])
1329 for Guid
in Module
.GuidList
:
1330 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.GuidList
[Guid
])
1332 if Module
.Guid
and not Module
.IsLibrary
:
1333 EntryPoint
= " ".join(Module
.Module
.ModuleEntryPointList
)
1334 if int(str(Module
.AutoGenVersion
), 0) >= 0x00010005:
1335 RealEntryPoint
= "_ModuleEntryPoint"
1337 RealEntryPoint
= EntryPoint
1338 if EntryPoint
== "_ModuleEntryPoint":
1339 CCFlags
= Module
.BuildOption
.get("CC", {}).get("FLAGS", "")
1340 Match
= gGlueLibEntryPoint
.search(CCFlags
)
1342 EntryPoint
= Match
.group(1)
1344 self
._FfsEntryPoint
[Module
.Guid
.upper()] = (EntryPoint
, RealEntryPoint
)
1348 # Collect platform firmware volume list as the input of EOT.
1352 for Fd
in Wa
.FdfProfile
.FdDict
:
1353 for FdRegion
in Wa
.FdfProfile
.FdDict
[Fd
].RegionList
:
1354 if FdRegion
.RegionType
!= "FV":
1356 for FvName
in FdRegion
.RegionDataList
:
1357 if FvName
in self
._FvList
:
1359 self
._FvList
.append(FvName
)
1360 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1361 for Section
in Ffs
.SectionList
:
1363 for FvSection
in Section
.SectionList
:
1364 if FvSection
.FvName
in self
._FvList
:
1366 self
._FvList
.append(FvSection
.FvName
)
1367 except AttributeError:
1372 # Parse platform fixed address map files
1374 # This function parses the platform final fixed address map file to get
1375 # the database of predicted fixed address for module image base, entry point
1378 # @param self: The object pointer
1380 def _ParseMapFile(self
):
1381 if self
._MapFileParsed
:
1383 self
._MapFileParsed
= True
1384 if os
.path
.isfile(self
._MapFileName
):
1386 FileContents
= open(self
._MapFileName
).read()
1387 for Match
in gMapFileItemPattern
.finditer(FileContents
):
1388 AddressType
= Match
.group(1)
1389 BaseAddress
= Match
.group(2)
1390 EntryPoint
= Match
.group(3)
1391 Guid
= Match
.group(4).upper()
1392 List
= self
.FixedMapDict
.setdefault(Guid
, [])
1393 List
.append((AddressType
, BaseAddress
, "*I"))
1394 List
.append((AddressType
, EntryPoint
, "*E"))
1396 EdkLogger
.warn(None, "Cannot open file to read", self
._MapFileName
)
1399 # Invokes EOT tool to get the predicted the execution order.
1401 # This function invokes EOT tool to calculate the predicted dispatch order
1403 # @param self: The object pointer
1405 def _InvokeEotTool(self
):
1406 if self
._EotToolInvoked
:
1409 self
._EotToolInvoked
= True
1411 for FvName
in self
._FvList
:
1412 FvFile
= os
.path
.join(self
._FvDir
, FvName
+ ".Fv")
1413 if os
.path
.isfile(FvFile
):
1414 FvFileList
.append(FvFile
)
1416 if len(FvFileList
) == 0:
1419 # Write source file list and GUID file list to an intermediate file
1420 # as the input for EOT tool and dispatch List as the output file
1423 SourceList
= os
.path
.join(self
._EotDir
, "SourceFile.txt")
1424 GuidList
= os
.path
.join(self
._EotDir
, "GuidList.txt")
1425 DispatchList
= os
.path
.join(self
._EotDir
, "Dispatch.txt")
1427 TempFile
= open(SourceList
, "w+")
1428 for Item
in self
._SourceList
:
1429 FileWrite(TempFile
, Item
)
1431 TempFile
= open(GuidList
, "w+")
1432 for Key
in self
._GuidMap
:
1433 FileWrite(TempFile
, "%s %s" % (Key
, self
._GuidMap
[Key
]))
1437 from Eot
.Eot
import Eot
1440 # Invoke EOT tool and echo its runtime performance
1442 EotStartTime
= time
.time()
1443 Eot(CommandLineOption
=False, SourceFileList
=SourceList
, GuidList
=GuidList
,
1444 FvFileList
=' '.join(FvFileList
), Dispatch
=DispatchList
, IsInit
=True)
1445 EotEndTime
= time
.time()
1446 EotDuration
= time
.strftime("%H:%M:%S", time
.gmtime(int(round(EotEndTime
- EotStartTime
))))
1447 EdkLogger
.quiet("EOT run time: %s\n" % EotDuration
)
1450 # Parse the output of EOT tool
1452 for Line
in open(DispatchList
):
1453 if len(Line
.split()) < 4:
1455 (Guid
, Phase
, FfsName
, FilePath
) = Line
.split()
1456 Symbol
= self
._FfsEntryPoint
.get(Guid
, [FfsName
, ""])[0]
1457 if len(Symbol
) > self
.MaxLen
:
1458 self
.MaxLen
= len(Symbol
)
1459 self
.ItemList
.append((Phase
, Symbol
, FilePath
))
1461 EdkLogger
.quiet("(Python %s on %s\n%s)" % (platform
.python_version(), sys
.platform
, traceback
.format_exc()))
1462 EdkLogger
.warn(None, "Failed to generate execution order prediction report, for some error occurred in executing EOT.")
1466 # Generate platform execution order report
1468 # This function generates the predicted module execution order.
1470 # @param self The object pointer
1471 # @param File The file object for report
1473 def _GenerateExecutionOrderReport(self
, File
):
1474 self
._InvokeEotTool
()
1475 if len(self
.ItemList
) == 0:
1477 FileWrite(File
, gSectionStart
)
1478 FileWrite(File
, "Execution Order Prediction")
1479 FileWrite(File
, "*P PEI phase")
1480 FileWrite(File
, "*D DXE phase")
1481 FileWrite(File
, "*E Module INF entry point name")
1482 FileWrite(File
, "*N Module notification function name")
1484 FileWrite(File
, "Type %-*s %s" % (self
.MaxLen
, "Symbol", "Module INF Path"))
1485 FileWrite(File
, gSectionSep
)
1486 for Item
in self
.ItemList
:
1487 FileWrite(File
, "*%sE %-*s %s" % (Item
[0], self
.MaxLen
, Item
[1], Item
[2]))
1489 FileWrite(File
, gSectionStart
)
1492 # Generate Fixed Address report.
1494 # This function generate the predicted fixed address report for a module
1495 # specified by Guid.
1497 # @param self The object pointer
1498 # @param File The file object for report
1499 # @param Guid The module Guid value.
1500 # @param NotifyList The list of all notify function in a module
1502 def _GenerateFixedAddressReport(self
, File
, Guid
, NotifyList
):
1503 self
._ParseMapFile
()
1504 FixedAddressList
= self
.FixedMapDict
.get(Guid
)
1505 if not FixedAddressList
:
1508 FileWrite(File
, gSubSectionStart
)
1509 FileWrite(File
, "Fixed Address Prediction")
1510 FileWrite(File
, "*I Image Loading Address")
1511 FileWrite(File
, "*E Entry Point Address")
1512 FileWrite(File
, "*N Notification Function Address")
1513 FileWrite(File
, "*F Flash Address")
1514 FileWrite(File
, "*M Memory Address")
1515 FileWrite(File
, "*S SMM RAM Offset")
1516 FileWrite(File
, "TOM Top of Memory")
1518 FileWrite(File
, "Type Address Name")
1519 FileWrite(File
, gSubSectionSep
)
1520 for Item
in FixedAddressList
:
1525 Name
= "(Image Base)"
1526 elif Symbol
== "*E":
1527 Name
= self
._FfsEntryPoint
.get(Guid
, ["", "_ModuleEntryPoint"])[1]
1528 elif Symbol
in NotifyList
:
1536 elif "Memory" in Type
:
1542 Value
= "TOM" + Value
1544 FileWrite(File
, "%s %-16s %s" % (Symbol
, Value
, Name
))
1547 # Generate report for the prediction part
1549 # This function generate the predicted fixed address report for a module or
1550 # predicted module execution order for a platform.
1551 # If the input Guid is None, then, it generates the predicted module execution order;
1552 # otherwise it generated the module fixed loading address for the module specified by
1555 # @param self The object pointer
1556 # @param File The file object for report
1557 # @param Guid The module Guid value.
1559 def GenerateReport(self
, File
, Guid
):
1561 self
._GenerateFixedAddressReport
(File
, Guid
.upper(), [])
1563 self
._GenerateExecutionOrderReport
(File
)
1566 # Reports FD region information
1568 # This class reports the FD subsection in the build report file.
1569 # It collects region information of platform flash device.
1570 # If the region is a firmware volume, it lists the set of modules
1571 # and its space information; otherwise, it only lists its region name,
1572 # base address and size in its sub-section header.
1573 # If there are nesting FVs, the nested FVs will list immediate after
1574 # this FD region subsection
1576 class FdRegionReport(object):
1578 # Discover all the nested FV name list.
1580 # This is an internal worker function to discover the all the nested FV information
1581 # in the parent firmware volume. It uses deep first search algorithm recursively to
1582 # find all the FV list name and append them to the list.
1584 # @param self The object pointer
1585 # @param FvName The name of current firmware file system
1586 # @param Wa Workspace context information
1588 def _DiscoverNestedFvList(self
, FvName
, Wa
):
1589 FvDictKey
=FvName
.upper()
1590 if FvDictKey
in Wa
.FdfProfile
.FvDict
:
1591 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1592 for Section
in Ffs
.SectionList
:
1594 for FvSection
in Section
.SectionList
:
1595 if FvSection
.FvName
in self
.FvList
:
1597 self
._GuidsDb
[Ffs
.NameGuid
.upper()] = FvSection
.FvName
1598 self
.FvList
.append(FvSection
.FvName
)
1599 self
.FvInfo
[FvSection
.FvName
] = ("Nested FV", 0, 0)
1600 self
._DiscoverNestedFvList
(FvSection
.FvName
, Wa
)
1601 except AttributeError:
1605 # Constructor function for class FdRegionReport
1607 # This constructor function generates FdRegionReport object for a specified FdRegion.
1608 # If the FdRegion is a firmware volume, it will recursively find all its nested Firmware
1609 # volume list. This function also collects GUID map in order to dump module identification
1610 # in the final report.
1612 # @param self: The object pointer
1613 # @param FdRegion The current FdRegion object
1614 # @param Wa Workspace context information
1616 def __init__(self
, FdRegion
, Wa
):
1617 self
.Type
= FdRegion
.RegionType
1618 self
.BaseAddress
= FdRegion
.Offset
1619 self
.Size
= FdRegion
.Size
1623 self
._FvDir
= Wa
.FvDir
1626 # If the input FdRegion is not a firmware volume,
1629 if self
.Type
!= "FV":
1633 # Find all nested FVs in the FdRegion
1635 for FvName
in FdRegion
.RegionDataList
:
1636 if FvName
in self
.FvList
:
1638 self
.FvList
.append(FvName
)
1639 self
.FvInfo
[FvName
] = ("Fd Region", self
.BaseAddress
, self
.Size
)
1640 self
._DiscoverNestedFvList
(FvName
, Wa
)
1644 # Collect PCDs declared in DEC files.
1646 for Pa
in Wa
.AutoGenObjectList
:
1647 for Package
in Pa
.PackageList
:
1648 for (TokenCName
, TokenSpaceGuidCName
, DecType
) in Package
.Pcds
:
1649 DecDefaultValue
= Package
.Pcds
[TokenCName
, TokenSpaceGuidCName
, DecType
].DefaultValue
1650 PlatformPcds
[(TokenCName
, TokenSpaceGuidCName
)] = DecDefaultValue
1652 # Collect PCDs defined in DSC file
1654 for Pa
in Wa
.AutoGenObjectList
:
1655 for (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
1656 DscDefaultValue
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)].DefaultValue
1657 PlatformPcds
[(TokenCName
, TokenSpaceGuidCName
)] = DscDefaultValue
1660 # Add PEI and DXE a priori files GUIDs defined in PI specification.
1662 self
._GuidsDb
["1B45CC0A-156A-428A-AF62-49864DA0E6E6"] = "PEI Apriori"
1663 self
._GuidsDb
["FC510EE7-FFDC-11D4-BD41-0080C73C8881"] = "DXE Apriori"
1665 # Add ACPI table storage file
1667 self
._GuidsDb
["7E374E25-8E01-4FEE-87F2-390C23C606CD"] = "ACPI table storage"
1669 for Pa
in Wa
.AutoGenObjectList
:
1670 for ModuleKey
in Pa
.Platform
.Modules
:
1671 M
= Pa
.Platform
.Modules
[ModuleKey
].M
1672 InfPath
= mws
.join(Wa
.WorkspaceDir
, M
.MetaFile
.File
)
1673 self
._GuidsDb
[M
.Guid
.upper()] = "%s (%s)" % (M
.Module
.BaseName
, InfPath
)
1676 # Collect the GUID map in the FV firmware volume
1678 for FvName
in self
.FvList
:
1679 FvDictKey
=FvName
.upper()
1680 if FvDictKey
in Wa
.FdfProfile
.FvDict
:
1681 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1684 # collect GUID map for binary EFI file in FDF file.
1686 Guid
= Ffs
.NameGuid
.upper()
1687 Match
= gPcdGuidPattern
.match(Ffs
.NameGuid
)
1689 PcdTokenspace
= Match
.group(1)
1690 PcdToken
= Match
.group(2)
1691 if (PcdToken
, PcdTokenspace
) in PlatformPcds
:
1692 GuidValue
= PlatformPcds
[(PcdToken
, PcdTokenspace
)]
1693 Guid
= GuidStructureByteArrayToGuidString(GuidValue
).upper()
1694 for Section
in Ffs
.SectionList
:
1696 ModuleSectFile
= mws
.join(Wa
.WorkspaceDir
, Section
.SectFileName
)
1697 self
._GuidsDb
[Guid
] = ModuleSectFile
1698 except AttributeError:
1700 except AttributeError:
1705 # Internal worker function to generate report for the FD region
1707 # This internal worker function to generate report for the FD region.
1708 # It the type is firmware volume, it lists offset and module identification.
1710 # @param self The object pointer
1711 # @param File The file object for report
1712 # @param Title The title for the FD subsection
1713 # @param BaseAddress The base address for the FD region
1714 # @param Size The size of the FD region
1715 # @param FvName The FV name if the FD region is a firmware volume
1717 def _GenerateReport(self
, File
, Title
, Type
, BaseAddress
, Size
=0, FvName
=None):
1718 FileWrite(File
, gSubSectionStart
)
1719 FileWrite(File
, Title
)
1720 FileWrite(File
, "Type: %s" % Type
)
1721 FileWrite(File
, "Base Address: 0x%X" % BaseAddress
)
1723 if self
.Type
== "FV":
1727 FvReportFileName
= os
.path
.join(self
._FvDir
, FvName
+ ".Fv.txt")
1730 # Collect size info in the firmware volume.
1732 FvReport
= open(FvReportFileName
).read()
1733 Match
= gFvTotalSizePattern
.search(FvReport
)
1735 FvTotalSize
= int(Match
.group(1), 16)
1736 Match
= gFvTakenSizePattern
.search(FvReport
)
1738 FvTakenSize
= int(Match
.group(1), 16)
1739 FvFreeSize
= FvTotalSize
- FvTakenSize
1741 # Write size information to the report file.
1743 FileWrite(File
, "Size: 0x%X (%.0fK)" % (FvTotalSize
, FvTotalSize
/ 1024.0))
1744 FileWrite(File
, "Fv Name: %s (%.1f%% Full)" % (FvName
, FvTakenSize
* 100.0 / FvTotalSize
))
1745 FileWrite(File
, "Occupied Size: 0x%X (%.0fK)" % (FvTakenSize
, FvTakenSize
/ 1024.0))
1746 FileWrite(File
, "Free Size: 0x%X (%.0fK)" % (FvFreeSize
, FvFreeSize
/ 1024.0))
1747 FileWrite(File
, "Offset Module")
1748 FileWrite(File
, gSubSectionSep
)
1750 # Write module offset and module identification to the report file.
1753 for Match
in gOffsetGuidPattern
.finditer(FvReport
):
1754 Guid
= Match
.group(2).upper()
1755 OffsetInfo
[Match
.group(1)] = self
._GuidsDb
.get(Guid
, Guid
)
1756 OffsetList
= OffsetInfo
.keys()
1758 for Offset
in OffsetList
:
1759 FileWrite (File
, "%s %s" % (Offset
, OffsetInfo
[Offset
]))
1761 EdkLogger
.warn(None, "Fail to read report file", FvReportFileName
)
1763 FileWrite(File
, "Size: 0x%X (%.0fK)" % (Size
, Size
/ 1024.0))
1764 FileWrite(File
, gSubSectionEnd
)
1767 # Generate report for the FD region
1769 # This function generates report for the FD region.
1771 # @param self The object pointer
1772 # @param File The file object for report
1774 def GenerateReport(self
, File
):
1775 if (len(self
.FvList
) > 0):
1776 for FvItem
in self
.FvList
:
1777 Info
= self
.FvInfo
[FvItem
]
1778 self
._GenerateReport
(File
, Info
[0], "FV", Info
[1], Info
[2], FvItem
)
1780 self
._GenerateReport
(File
, "FD Region", self
.Type
, self
.BaseAddress
, self
.Size
)
1783 # Reports FD information
1785 # This class reports the FD section in the build report file.
1786 # It collects flash device information for a platform.
1788 class FdReport(object):
1790 # Constructor function for class FdReport
1792 # This constructor function generates FdReport object for a specified
1795 # @param self The object pointer
1796 # @param Fd The current Firmware device object
1797 # @param Wa Workspace context information
1799 def __init__(self
, Fd
, Wa
):
1800 self
.FdName
= Fd
.FdUiName
1801 self
.BaseAddress
= Fd
.BaseAddress
1803 self
.FdRegionList
= [FdRegionReport(FdRegion
, Wa
) for FdRegion
in Fd
.RegionList
]
1804 self
.FvPath
= os
.path
.join(Wa
.BuildDir
, "FV")
1805 self
.VpdFilePath
= os
.path
.join(self
.FvPath
, "%s.map" % Wa
.Platform
.VpdToolGuid
)
1806 self
.VPDBaseAddress
= 0
1808 self
.VPDInfoList
= []
1809 for index
, FdRegion
in enumerate(Fd
.RegionList
):
1810 if str(FdRegion
.RegionType
) is 'FILE' and Wa
.Platform
.VpdToolGuid
in str(FdRegion
.RegionDataList
):
1811 self
.VPDBaseAddress
= self
.FdRegionList
[index
].BaseAddress
1812 self
.VPDSize
= self
.FdRegionList
[index
].Size
1815 if os
.path
.isfile(self
.VpdFilePath
):
1816 fd
= open(self
.VpdFilePath
, "r")
1817 Lines
= fd
.readlines()
1820 if len(Line
) == 0 or Line
.startswith("#"):
1823 PcdName
, SkuId
, Offset
, Size
, Value
= Line
.split("#")[0].split("|")
1824 PcdName
, SkuId
, Offset
, Size
, Value
= PcdName
.strip(), SkuId
.strip(), Offset
.strip(), Size
.strip(), Value
.strip()
1825 if Offset
.lower().startswith('0x'):
1826 Offset
= '0x%08X' % (int(Offset
, 16) + self
.VPDBaseAddress
)
1828 Offset
= '0x%08X' % (int(Offset
, 10) + self
.VPDBaseAddress
)
1829 self
.VPDInfoList
.append("%s | %s | %s | %s | %s" % (PcdName
, SkuId
, Offset
, Size
, Value
))
1831 EdkLogger
.error("BuildReport", CODE_ERROR
, "Fail to parse VPD information file %s" % self
.VpdFilePath
)
1835 # Generate report for the firmware device.
1837 # This function generates report for the firmware device.
1839 # @param self The object pointer
1840 # @param File The file object for report
1842 def GenerateReport(self
, File
):
1843 FileWrite(File
, gSectionStart
)
1844 FileWrite(File
, "Firmware Device (FD)")
1845 FileWrite(File
, "FD Name: %s" % self
.FdName
)
1846 FileWrite(File
, "Base Address: %s" % self
.BaseAddress
)
1847 FileWrite(File
, "Size: 0x%X (%.0fK)" % (self
.Size
, self
.Size
/ 1024.0))
1848 if len(self
.FdRegionList
) > 0:
1849 FileWrite(File
, gSectionSep
)
1850 for FdRegionItem
in self
.FdRegionList
:
1851 FdRegionItem
.GenerateReport(File
)
1853 if len(self
.VPDInfoList
) > 0:
1854 FileWrite(File
, gSubSectionStart
)
1855 FileWrite(File
, "FD VPD Region")
1856 FileWrite(File
, "Base Address: 0x%X" % self
.VPDBaseAddress
)
1857 FileWrite(File
, "Size: 0x%X (%.0fK)" % (self
.VPDSize
, self
.VPDSize
/ 1024.0))
1858 FileWrite(File
, gSubSectionSep
)
1859 for item
in self
.VPDInfoList
:
1860 ValueList
= item
.split('|')
1861 Value
= ValueList
[-1].strip()
1862 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1864 ValueList
[-1] = ' {'
1865 FileWrite(File
, '|'.join(ValueList
))
1866 for Array
in ArrayList
:
1867 FileWrite(File
, '%s' % (Array
))
1869 FileWrite(File
, item
)
1870 FileWrite(File
, gSubSectionEnd
)
1871 FileWrite(File
, gSectionEnd
)
1876 # Reports platform information
1878 # This class reports the whole platform information
1880 class PlatformReport(object):
1882 # Constructor function for class PlatformReport
1884 # This constructor function generates PlatformReport object a platform build.
1885 # It generates report for platform summary, flash, global PCDs and detailed
1886 # module information for modules involved in platform build.
1888 # @param self The object pointer
1889 # @param Wa Workspace context information
1890 # @param MaList The list of modules in the platform build
1892 def __init__(self
, Wa
, MaList
, ReportType
):
1893 self
._WorkspaceDir
= Wa
.WorkspaceDir
1894 self
.PlatformName
= Wa
.Name
1895 self
.PlatformDscPath
= Wa
.Platform
1896 self
.Architectures
= " ".join(Wa
.ArchList
)
1897 self
.ToolChain
= Wa
.ToolChain
1898 self
.Target
= Wa
.BuildTarget
1899 self
.OutputPath
= os
.path
.join(Wa
.WorkspaceDir
, Wa
.OutputDir
)
1900 self
.BuildEnvironment
= platform
.platform()
1902 self
.PcdReport
= None
1903 if "PCD" in ReportType
:
1904 self
.PcdReport
= PcdReport(Wa
)
1906 self
.FdReportList
= []
1907 if "FLASH" in ReportType
and Wa
.FdfProfile
and MaList
== None:
1908 for Fd
in Wa
.FdfProfile
.FdDict
:
1909 self
.FdReportList
.append(FdReport(Wa
.FdfProfile
.FdDict
[Fd
], Wa
))
1911 self
.PredictionReport
= None
1912 if "FIXED_ADDRESS" in ReportType
or "EXECUTION_ORDER" in ReportType
:
1913 self
.PredictionReport
= PredictionReport(Wa
)
1915 self
.DepexParser
= None
1916 if "DEPEX" in ReportType
:
1917 self
.DepexParser
= DepexParser(Wa
)
1919 self
.ModuleReportList
= []
1921 self
._IsModuleBuild
= True
1923 self
.ModuleReportList
.append(ModuleReport(Ma
, ReportType
))
1925 self
._IsModuleBuild
= False
1926 for Pa
in Wa
.AutoGenObjectList
:
1927 ModuleAutoGenList
= []
1928 for ModuleKey
in Pa
.Platform
.Modules
:
1929 ModuleAutoGenList
.append(Pa
.Platform
.Modules
[ModuleKey
].M
)
1930 if GlobalData
.gFdfParser
!= None:
1931 if Pa
.Arch
in GlobalData
.gFdfParser
.Profile
.InfDict
:
1932 INFList
= GlobalData
.gFdfParser
.Profile
.InfDict
[Pa
.Arch
]
1933 for InfName
in INFList
:
1934 InfClass
= PathClass(NormPath(InfName
), Wa
.WorkspaceDir
, Pa
.Arch
)
1935 Ma
= ModuleAutoGen(Wa
, InfClass
, Pa
.BuildTarget
, Pa
.ToolChain
, Pa
.Arch
, Wa
.MetaFile
)
1938 if Ma
not in ModuleAutoGenList
:
1939 ModuleAutoGenList
.append(Ma
)
1940 for MGen
in ModuleAutoGenList
:
1941 self
.ModuleReportList
.append(ModuleReport(MGen
, ReportType
))
1946 # Generate report for the whole platform.
1948 # This function generates report for platform information.
1949 # It comprises of platform summary, global PCD, flash and
1950 # module list sections.
1952 # @param self The object pointer
1953 # @param File The file object for report
1954 # @param BuildDuration The total time to build the modules
1955 # @param AutoGenTime The total time of AutoGen Phase
1956 # @param MakeTime The total time of Make Phase
1957 # @param GenFdsTime The total time of GenFds Phase
1958 # @param ReportType The kind of report items in the final report file
1960 def GenerateReport(self
, File
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
, ReportType
):
1961 FileWrite(File
, "Platform Summary")
1962 FileWrite(File
, "Platform Name: %s" % self
.PlatformName
)
1963 FileWrite(File
, "Platform DSC Path: %s" % self
.PlatformDscPath
)
1964 FileWrite(File
, "Architectures: %s" % self
.Architectures
)
1965 FileWrite(File
, "Tool Chain: %s" % self
.ToolChain
)
1966 FileWrite(File
, "Target: %s" % self
.Target
)
1967 if GlobalData
.gSkuids
:
1968 FileWrite(File
, "SKUID: %s" % " ".join(GlobalData
.gSkuids
))
1969 if GlobalData
.gDefaultStores
:
1970 FileWrite(File
, "DefaultStore: %s" % " ".join(GlobalData
.gDefaultStores
))
1971 FileWrite(File
, "Output Path: %s" % self
.OutputPath
)
1972 FileWrite(File
, "Build Environment: %s" % self
.BuildEnvironment
)
1973 FileWrite(File
, "Build Duration: %s" % BuildDuration
)
1975 FileWrite(File
, "AutoGen Duration: %s" % AutoGenTime
)
1977 FileWrite(File
, "Make Duration: %s" % MakeTime
)
1979 FileWrite(File
, "GenFds Duration: %s" % GenFdsTime
)
1980 FileWrite(File
, "Report Content: %s" % ", ".join(ReportType
))
1982 if GlobalData
.MixedPcd
:
1983 FileWrite(File
, gSectionStart
)
1984 FileWrite(File
, "The following PCDs use different access methods:")
1985 FileWrite(File
, gSectionSep
)
1986 for PcdItem
in GlobalData
.MixedPcd
:
1987 FileWrite(File
, "%s.%s" % (str(PcdItem
[1]), str(PcdItem
[0])))
1988 FileWrite(File
, gSectionEnd
)
1990 if not self
._IsModuleBuild
:
1991 if "PCD" in ReportType
:
1992 self
.PcdReport
.GenerateReport(File
, None)
1994 if "FLASH" in ReportType
:
1995 for FdReportListItem
in self
.FdReportList
:
1996 FdReportListItem
.GenerateReport(File
)
1998 for ModuleReportItem
in self
.ModuleReportList
:
1999 ModuleReportItem
.GenerateReport(File
, self
.PcdReport
, self
.PredictionReport
, self
.DepexParser
, ReportType
)
2001 if not self
._IsModuleBuild
:
2002 if "EXECUTION_ORDER" in ReportType
:
2003 self
.PredictionReport
.GenerateReport(File
, None)
2005 ## BuildReport class
2007 # This base class contain the routines to collect data and then
2008 # applies certain format to the output report
2010 class BuildReport(object):
2012 # Constructor function for class BuildReport
2014 # This constructor function generates BuildReport object a platform build.
2015 # It generates report for platform summary, flash, global PCDs and detailed
2016 # module information for modules involved in platform build.
2018 # @param self The object pointer
2019 # @param ReportFile The file name to save report file
2020 # @param ReportType The kind of report items in the final report file
2022 def __init__(self
, ReportFile
, ReportType
):
2023 self
.ReportFile
= ReportFile
2025 self
.ReportList
= []
2026 self
.ReportType
= []
2028 for ReportTypeItem
in ReportType
:
2029 if ReportTypeItem
not in self
.ReportType
:
2030 self
.ReportType
.append(ReportTypeItem
)
2032 self
.ReportType
= ["PCD", "LIBRARY", "BUILD_FLAGS", "DEPEX", "HASH", "FLASH", "FIXED_ADDRESS"]
2034 # Adds platform report to the list
2036 # This function adds a platform report to the final report list.
2038 # @param self The object pointer
2039 # @param Wa Workspace context information
2040 # @param MaList The list of modules in the platform build
2042 def AddPlatformReport(self
, Wa
, MaList
=None):
2044 self
.ReportList
.append((Wa
, MaList
))
2047 # Generates the final report.
2049 # This function generates platform build report. It invokes GenerateReport()
2050 # method for every platform report in the list.
2052 # @param self The object pointer
2053 # @param BuildDuration The total time to build the modules
2054 # @param AutoGenTime The total time of AutoGen phase
2055 # @param MakeTime The total time of Make phase
2056 # @param GenFdsTime The total time of GenFds phase
2058 def GenerateReport(self
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
):
2062 for (Wa
, MaList
) in self
.ReportList
:
2063 PlatformReport(Wa
, MaList
, self
.ReportType
).GenerateReport(File
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
, self
.ReportType
)
2064 Content
= FileLinesSplit(File
.getvalue(), gLineMaxLength
)
2065 SaveFileOnChange(self
.ReportFile
, Content
, True)
2066 EdkLogger
.quiet("Build report can be found at %s" % os
.path
.abspath(self
.ReportFile
))
2068 EdkLogger
.error(None, FILE_WRITE_FAILURE
, ExtraData
=self
.ReportFile
)
2070 EdkLogger
.error("BuildReport", CODE_ERROR
, "Unknown fatal error when generating build report", ExtraData
=self
.ReportFile
, RaiseError
=False)
2071 EdkLogger
.quiet("(Python %s on %s\n%s)" % (platform
.python_version(), sys
.platform
, traceback
.format_exc()))
2074 # This acts like the main() function for the script, unless it is 'import'ed into another script.
2075 if __name__
== '__main__':