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 io
import BytesIO
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
.BuildToolError
import FILE_WRITE_FAILURE
37 from Common
.BuildToolError
import CODE_ERROR
38 from Common
.BuildToolError
import COMMAND_FAILURE
39 from Common
.BuildToolError
import FORMAT_INVALID
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
.StringUtils
import NormPath
46 from Common
.DataType
import *
48 from Common
.Expression
import *
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 TAB_PCDS_FIXED_AT_BUILD
: ('FIXED', TAB_PCDS_FIXED_AT_BUILD
),
98 TAB_PCDS_PATCHABLE_IN_MODULE
: ('PATCH', TAB_PCDS_PATCHABLE_IN_MODULE
),
99 TAB_PCDS_FEATURE_FLAG
: ('FLAG', TAB_PCDS_FEATURE_FLAG
),
100 TAB_PCDS_DYNAMIC
: ('DYN', TAB_PCDS_DYNAMIC
),
101 TAB_PCDS_DYNAMIC_HII
: ('DYNHII', TAB_PCDS_DYNAMIC
),
102 TAB_PCDS_DYNAMIC_VPD
: ('DYNVPD', TAB_PCDS_DYNAMIC
),
103 TAB_PCDS_DYNAMIC_EX
: ('DEX', TAB_PCDS_DYNAMIC_EX
),
104 TAB_PCDS_DYNAMIC_EX_HII
: ('DEXHII', TAB_PCDS_DYNAMIC_EX
),
105 TAB_PCDS_DYNAMIC_EX_VPD
: ('DEXVPD', TAB_PCDS_DYNAMIC_EX
),
108 ## The look up table to map module type to driver type
110 SUP_MODULE_SEC
: '0x3 (SECURITY_CORE)',
111 SUP_MODULE_PEI_CORE
: '0x4 (PEI_CORE)',
112 SUP_MODULE_PEIM
: '0x6 (PEIM)',
113 SUP_MODULE_DXE_CORE
: '0x5 (DXE_CORE)',
114 SUP_MODULE_DXE_DRIVER
: '0x7 (DRIVER)',
115 SUP_MODULE_DXE_SAL_DRIVER
: '0x7 (DRIVER)',
116 SUP_MODULE_DXE_SMM_DRIVER
: '0x7 (DRIVER)',
117 SUP_MODULE_DXE_RUNTIME_DRIVER
: '0x7 (DRIVER)',
118 SUP_MODULE_UEFI_DRIVER
: '0x7 (DRIVER)',
119 SUP_MODULE_UEFI_APPLICATION
: '0x9 (APPLICATION)',
120 SUP_MODULE_SMM_CORE
: '0xD (SMM_CORE)',
121 'SMM_DRIVER' : '0xA (SMM)', # Extension of module type to support PI 1.1 SMM drivers
122 SUP_MODULE_MM_STANDALONE
: '0xE (MM_STANDALONE)',
123 SUP_MODULE_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
}
211 elif TAB_GUID
in Type
:
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
283 for Ma
in Pa
.ModuleAutoGenList
:
284 for Pcd
in Ma
.FixedVoidTypePcds
:
285 PcdValue
= Ma
.FixedVoidTypePcds
[Pcd
]
286 if len(PcdValue
.split(',')) == 16:
287 GuidValue
= GuidStructureByteArrayToGuidString(PcdValue
)
288 self
._GuidDb
[GuidValue
.upper()] = Pcd
290 # Parse the binary dependency expression files.
292 # This function parses the binary dependency expression file and translate it
293 # to the instruction list.
295 # @param self The object pointer
296 # @param DepexFileName The file name of binary dependency expression file.
298 def ParseDepexFile(self
, DepexFileName
):
299 DepexFile
= open(DepexFileName
, "rb")
301 OpCode
= DepexFile
.read(1)
303 Statement
= gOpCodeList
[struct
.unpack("B", OpCode
)[0]]
304 if Statement
in ["BEFORE", "AFTER", "PUSH"]:
305 GuidValue
= "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X" % \
306 struct
.unpack(PACK_PATTERN_GUID
, DepexFile
.read(16))
307 GuidString
= self
._GuidDb
.get(GuidValue
, GuidValue
)
308 Statement
= "%s %s" % (Statement
, GuidString
)
309 DepexStatement
.append(Statement
)
310 OpCode
= DepexFile
.read(1)
312 return DepexStatement
315 # Reports library information
317 # This class reports the module library subsection in the build report file.
319 class LibraryReport(object):
321 # Constructor function for class LibraryReport
323 # This constructor function generates LibraryReport object for
326 # @param self The object pointer
327 # @param M Module context information
329 def __init__(self
, M
):
330 self
.LibraryList
= []
331 if int(str(M
.AutoGenVersion
), 0) >= 0x00010005:
332 self
._EdkIIModule
= True
334 self
._EdkIIModule
= False
336 for Lib
in M
.DependentLibraryList
:
337 LibInfPath
= str(Lib
)
338 LibClassList
= Lib
.LibraryClass
[0].LibraryClass
339 LibConstructorList
= Lib
.ConstructorList
340 LibDesstructorList
= Lib
.DestructorList
341 LibDepexList
= Lib
.DepexExpression
[M
.Arch
, M
.ModuleType
]
342 for LibAutoGen
in M
.LibraryAutoGenList
:
343 if LibInfPath
== LibAutoGen
.MetaFile
.Path
:
344 LibTime
= LibAutoGen
.BuildTime
346 self
.LibraryList
.append((LibInfPath
, LibClassList
, LibConstructorList
, LibDesstructorList
, LibDepexList
, LibTime
))
349 # Generate report for module library information
351 # This function generates report for the module library.
352 # If the module is EDKII style one, the additional library class, library
353 # constructor/destructor and dependency expression may also be reported.
355 # @param self The object pointer
356 # @param File The file object for report
358 def GenerateReport(self
, File
):
359 if len(self
.LibraryList
) > 0:
360 FileWrite(File
, gSubSectionStart
)
361 FileWrite(File
, TAB_BRG_LIBRARY
)
362 FileWrite(File
, gSubSectionSep
)
363 for LibraryItem
in self
.LibraryList
:
364 LibInfPath
= LibraryItem
[0]
365 FileWrite(File
, LibInfPath
)
368 # Report library class, library constructor and destructor for
369 # EDKII style module.
371 if self
._EdkIIModule
:
372 LibClass
= LibraryItem
[1]
374 LibConstructor
= " ".join(LibraryItem
[2])
376 EdkIILibInfo
+= " C = " + LibConstructor
377 LibDestructor
= " ".join(LibraryItem
[3])
379 EdkIILibInfo
+= " D = " + LibDestructor
380 LibDepex
= " ".join(LibraryItem
[4])
382 EdkIILibInfo
+= " Depex = " + LibDepex
384 EdkIILibInfo
+= " Time = " + LibraryItem
[5]
386 FileWrite(File
, "{%s: %s}" % (LibClass
, EdkIILibInfo
))
388 FileWrite(File
, "{%s}" % LibClass
)
390 FileWrite(File
, gSubSectionEnd
)
393 # Reports dependency expression information
395 # This class reports the module dependency expression subsection in the build report file.
397 class DepexReport(object):
399 # Constructor function for class DepexReport
401 # This constructor function generates DepexReport object for
402 # a module. If the module source contains the DXS file (usually EDK
403 # style module), it uses the dependency in DXS file; otherwise,
404 # it uses the dependency expression from its own INF [Depex] section
405 # and then merges with the ones from its dependent library INF.
407 # @param self The object pointer
408 # @param M Module context information
410 def __init__(self
, M
):
412 self
._DepexFileName
= os
.path
.join(M
.BuildDir
, "OUTPUT", M
.Module
.BaseName
+ ".depex")
413 ModuleType
= M
.ModuleType
415 ModuleType
= COMPONENT_TO_MODULE_MAP_DICT
.get(M
.ComponentType
, "")
417 if ModuleType
in [SUP_MODULE_SEC
, SUP_MODULE_PEI_CORE
, SUP_MODULE_DXE_CORE
, SUP_MODULE_SMM_CORE
, SUP_MODULE_MM_CORE_STANDALONE
, SUP_MODULE_UEFI_APPLICATION
]:
420 for Source
in M
.SourceFileList
:
421 if os
.path
.splitext(Source
.Path
)[1].lower() == ".dxs":
422 Match
= gDxsDependencyPattern
.search(open(Source
.Path
).read())
424 self
.Depex
= Match
.group(1).strip()
428 self
.Depex
= M
.DepexExpressionDict
.get(M
.ModuleType
, "")
429 self
.ModuleDepex
= " ".join(M
.Module
.DepexExpression
[M
.Arch
, M
.ModuleType
])
430 if not self
.ModuleDepex
:
431 self
.ModuleDepex
= "(None)"
434 for Lib
in M
.DependentLibraryList
:
435 LibDepex
= " ".join(Lib
.DepexExpression
[M
.Arch
, M
.ModuleType
]).strip()
437 LibDepexList
.append("(" + LibDepex
+ ")")
438 self
.LibraryDepex
= " AND ".join(LibDepexList
)
439 if not self
.LibraryDepex
:
440 self
.LibraryDepex
= "(None)"
444 # Generate report for module dependency expression information
446 # This function generates report for the module dependency expression.
448 # @param self The object pointer
449 # @param File The file object for report
450 # @param GlobalDepexParser The platform global Dependency expression parser object
452 def GenerateReport(self
, File
, GlobalDepexParser
):
455 FileWrite(File
, gSubSectionStart
)
456 if os
.path
.isfile(self
._DepexFileName
):
458 DepexStatements
= GlobalDepexParser
.ParseDepexFile(self
._DepexFileName
)
459 FileWrite(File
, "Final Dependency Expression (DEPEX) Instructions")
460 for DepexStatement
in DepexStatements
:
461 FileWrite(File
, " %s" % DepexStatement
)
462 FileWrite(File
, gSubSectionSep
)
464 EdkLogger
.warn(None, "Dependency expression file is corrupted", self
._DepexFileName
)
466 FileWrite(File
, "Dependency Expression (DEPEX) from %s" % self
.Source
)
468 if self
.Source
== "INF":
469 FileWrite(File
, self
.Depex
, True)
470 FileWrite(File
, gSubSectionSep
)
471 FileWrite(File
, "From Module INF: %s" % self
.ModuleDepex
, True)
472 FileWrite(File
, "From Library INF: %s" % self
.LibraryDepex
, True)
474 FileWrite(File
, self
.Depex
)
475 FileWrite(File
, gSubSectionEnd
)
478 # Reports dependency expression information
480 # This class reports the module build flags subsection in the build report file.
482 class BuildFlagsReport(object):
484 # Constructor function for class BuildFlagsReport
486 # This constructor function generates BuildFlagsReport object for
487 # a module. It reports the build tool chain tag and all relevant
488 # build flags to build the module.
490 # @param self The object pointer
491 # @param M Module context information
493 def __init__(self
, M
):
496 # Add build flags according to source file extension so that
497 # irrelevant ones can be filtered out.
499 for Source
in M
.SourceFileList
:
500 Ext
= os
.path
.splitext(Source
.File
)[1].lower()
501 if Ext
in [".c", ".cc", ".cpp"]:
502 BuildOptions
["CC"] = 1
503 elif Ext
in [".s", ".asm"]:
504 BuildOptions
["PP"] = 1
505 BuildOptions
["ASM"] = 1
506 elif Ext
in [".vfr"]:
507 BuildOptions
["VFRPP"] = 1
508 BuildOptions
["VFR"] = 1
509 elif Ext
in [".dxs"]:
510 BuildOptions
["APP"] = 1
511 BuildOptions
["CC"] = 1
512 elif Ext
in [".asl"]:
513 BuildOptions
["ASLPP"] = 1
514 BuildOptions
["ASL"] = 1
515 elif Ext
in [".aslc"]:
516 BuildOptions
["ASLCC"] = 1
517 BuildOptions
["ASLDLINK"] = 1
518 BuildOptions
["CC"] = 1
519 elif Ext
in [".asm16"]:
520 BuildOptions
["ASMLINK"] = 1
521 BuildOptions
["SLINK"] = 1
522 BuildOptions
["DLINK"] = 1
525 # Save module build flags.
527 self
.ToolChainTag
= M
.ToolChain
529 for Tool
in BuildOptions
:
530 self
.BuildFlags
[Tool
+ "_FLAGS"] = M
.BuildOption
.get(Tool
, {}).get("FLAGS", "")
533 # Generate report for module build flags information
535 # This function generates report for the module build flags expression.
537 # @param self The object pointer
538 # @param File The file object for report
540 def GenerateReport(self
, File
):
541 FileWrite(File
, gSubSectionStart
)
542 FileWrite(File
, "Build Flags")
543 FileWrite(File
, "Tool Chain Tag: %s" % self
.ToolChainTag
)
544 for Tool
in self
.BuildFlags
:
545 FileWrite(File
, gSubSectionSep
)
546 FileWrite(File
, "%s = %s" % (Tool
, self
.BuildFlags
[Tool
]), True)
548 FileWrite(File
, gSubSectionEnd
)
552 # Reports individual module information
554 # This class reports the module section in the build report file.
555 # It comprises of module summary, module PCD, library, dependency expression,
556 # build flags sections.
558 class ModuleReport(object):
560 # Constructor function for class ModuleReport
562 # This constructor function generates ModuleReport object for
563 # a separate module in a platform build.
565 # @param self The object pointer
566 # @param M Module context information
567 # @param ReportType The kind of report items in the final report file
569 def __init__(self
, M
, ReportType
):
570 self
.ModuleName
= M
.Module
.BaseName
571 self
.ModuleInfPath
= M
.MetaFile
.File
572 self
.FileGuid
= M
.Guid
574 self
.BuildTimeStamp
= None
578 ModuleType
= M
.ModuleType
580 ModuleType
= COMPONENT_TO_MODULE_MAP_DICT
.get(M
.ComponentType
, "")
582 # If a module complies to PI 1.1, promote Module type to "SMM_DRIVER"
584 if ModuleType
== SUP_MODULE_DXE_SMM_DRIVER
:
585 PiSpec
= M
.Module
.Specification
.get("PI_SPECIFICATION_VERSION", "0x00010000")
586 if int(PiSpec
, 0) >= 0x0001000A:
587 ModuleType
= "SMM_DRIVER"
588 self
.DriverType
= gDriverTypeMap
.get(ModuleType
, "0x2 (FREE_FORM)")
589 self
.UefiSpecVersion
= M
.Module
.Specification
.get("UEFI_SPECIFICATION_VERSION", "")
590 self
.PiSpecVersion
= M
.Module
.Specification
.get("PI_SPECIFICATION_VERSION", "")
591 self
.PciDeviceId
= M
.Module
.Defines
.get("PCI_DEVICE_ID", "")
592 self
.PciVendorId
= M
.Module
.Defines
.get("PCI_VENDOR_ID", "")
593 self
.PciClassCode
= M
.Module
.Defines
.get("PCI_CLASS_CODE", "")
594 self
.BuildTime
= M
.BuildTime
596 self
._BuildDir
= M
.BuildDir
597 self
.ModulePcdSet
= {}
598 if "PCD" in ReportType
:
600 # Collect all module used PCD set: module INF referenced directly or indirectly.
601 # It also saves module INF default values of them in case they exist.
603 for Pcd
in M
.ModulePcdList
+ M
.LibraryPcdList
:
604 self
.ModulePcdSet
.setdefault((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Pcd
.Type
), (Pcd
.InfDefaultValue
, Pcd
.DefaultValue
))
606 self
.LibraryReport
= None
607 if "LIBRARY" in ReportType
:
608 self
.LibraryReport
= LibraryReport(M
)
610 self
.DepexReport
= None
611 if "DEPEX" in ReportType
:
612 self
.DepexReport
= DepexReport(M
)
614 if "BUILD_FLAGS" in ReportType
:
615 self
.BuildFlagsReport
= BuildFlagsReport(M
)
619 # Generate report for module information
621 # This function generates report for separate module expression
622 # in a platform build.
624 # @param self The object pointer
625 # @param File The file object for report
626 # @param GlobalPcdReport The platform global PCD report object
627 # @param GlobalPredictionReport The platform global Prediction report object
628 # @param GlobalDepexParser The platform global Dependency expression parser object
629 # @param ReportType The kind of report items in the final report file
631 def GenerateReport(self
, File
, GlobalPcdReport
, GlobalPredictionReport
, GlobalDepexParser
, ReportType
):
632 FileWrite(File
, gSectionStart
)
634 FwReportFileName
= os
.path
.join(self
._BuildDir
, "DEBUG", self
.ModuleName
+ ".txt")
635 if os
.path
.isfile(FwReportFileName
):
637 FileContents
= open(FwReportFileName
).read()
638 Match
= gModuleSizePattern
.search(FileContents
)
640 self
.Size
= int(Match
.group(1))
642 Match
= gTimeStampPattern
.search(FileContents
)
644 self
.BuildTimeStamp
= datetime
.fromtimestamp(int(Match
.group(1)))
646 EdkLogger
.warn(None, "Fail to read report file", FwReportFileName
)
648 if "HASH" in ReportType
:
649 OutputDir
= os
.path
.join(self
._BuildDir
, "OUTPUT")
650 DefaultEFIfile
= os
.path
.join(OutputDir
, self
.ModuleName
+ ".efi")
651 if os
.path
.isfile(DefaultEFIfile
):
652 Tempfile
= os
.path
.join(OutputDir
, self
.ModuleName
+ "_hash.tmp")
653 # rebase the efi image since its base address may not zero
654 cmd
= ["GenFw", "--rebase", str(0), "-o", Tempfile
, DefaultEFIfile
]
656 PopenObject
= subprocess
.Popen(' '.join(cmd
), stdout
=subprocess
.PIPE
, stderr
=subprocess
.PIPE
, shell
=True)
657 except Exception as X
:
658 EdkLogger
.error("GenFw", COMMAND_FAILURE
, ExtraData
="%s: %s" % (str(X
), cmd
[0]))
659 EndOfProcedure
= threading
.Event()
660 EndOfProcedure
.clear()
661 if PopenObject
.stderr
:
662 StdErrThread
= threading
.Thread(target
=ReadMessage
, args
=(PopenObject
.stderr
, EdkLogger
.quiet
, EndOfProcedure
))
663 StdErrThread
.setName("STDERR-Redirector")
664 StdErrThread
.setDaemon(False)
666 # waiting for program exit
668 if PopenObject
.stderr
:
670 if PopenObject
.returncode
!= 0:
671 EdkLogger
.error("GenFw", COMMAND_FAILURE
, "Failed to generate firmware hash image for %s" % (DefaultEFIfile
))
672 if os
.path
.isfile(Tempfile
):
673 self
.Hash
= hashlib
.sha1()
674 buf
= open(Tempfile
, 'rb').read()
675 if self
.Hash
.update(buf
):
676 self
.Hash
= self
.Hash
.update(buf
)
677 self
.Hash
= self
.Hash
.hexdigest()
680 FileWrite(File
, "Module Summary")
681 FileWrite(File
, "Module Name: %s" % self
.ModuleName
)
682 FileWrite(File
, "Module INF Path: %s" % self
.ModuleInfPath
)
683 FileWrite(File
, "File GUID: %s" % self
.FileGuid
)
685 FileWrite(File
, "Size: 0x%X (%.2fK)" % (self
.Size
, self
.Size
/ 1024.0))
687 FileWrite(File
, "SHA1 HASH: %s *%s" % (self
.Hash
, self
.ModuleName
+ ".efi"))
688 if self
.BuildTimeStamp
:
689 FileWrite(File
, "Build Time Stamp: %s" % self
.BuildTimeStamp
)
691 FileWrite(File
, "Module Build Time: %s" % self
.BuildTime
)
693 FileWrite(File
, "Driver Type: %s" % self
.DriverType
)
694 if self
.UefiSpecVersion
:
695 FileWrite(File
, "UEFI Spec Version: %s" % self
.UefiSpecVersion
)
696 if self
.PiSpecVersion
:
697 FileWrite(File
, "PI Spec Version: %s" % self
.PiSpecVersion
)
699 FileWrite(File
, "PCI Device ID: %s" % self
.PciDeviceId
)
701 FileWrite(File
, "PCI Vendor ID: %s" % self
.PciVendorId
)
702 if self
.PciClassCode
:
703 FileWrite(File
, "PCI Class Code: %s" % self
.PciClassCode
)
705 FileWrite(File
, gSectionSep
)
707 if "PCD" in ReportType
:
708 GlobalPcdReport
.GenerateReport(File
, self
.ModulePcdSet
)
710 if "LIBRARY" in ReportType
:
711 self
.LibraryReport
.GenerateReport(File
)
713 if "DEPEX" in ReportType
:
714 self
.DepexReport
.GenerateReport(File
, GlobalDepexParser
)
716 if "BUILD_FLAGS" in ReportType
:
717 self
.BuildFlagsReport
.GenerateReport(File
)
719 if "FIXED_ADDRESS" in ReportType
and self
.FileGuid
:
720 GlobalPredictionReport
.GenerateReport(File
, self
.FileGuid
)
722 FileWrite(File
, gSectionEnd
)
724 def ReadMessage(From
, To
, ExitFlag
):
726 # read one line a time
727 Line
= From
.readline()
728 # empty string means "end"
729 if Line
is not None and Line
!= "":
737 # Reports platform and module PCD information
739 # This class reports the platform PCD section and module PCD subsection
740 # in the build report file.
742 class PcdReport(object):
744 # Constructor function for class PcdReport
746 # This constructor function generates PcdReport object a platform build.
747 # It collects the whole PCD database from platform DSC files, platform
748 # flash description file and package DEC files.
750 # @param self The object pointer
751 # @param Wa Workspace context information
753 def __init__(self
, Wa
):
756 self
.ConditionalPcds
= {}
760 self
.FdfPcdSet
= Wa
.FdfProfile
.PcdDict
764 self
.DefaultStoreSingle
= True
765 self
.SkuSingle
= True
766 if GlobalData
.gDefaultStores
and len(GlobalData
.gDefaultStores
) > 1:
767 self
.DefaultStoreSingle
= False
768 if GlobalData
.gSkuids
and len(GlobalData
.gSkuids
) > 1:
769 self
.SkuSingle
= False
771 self
.ModulePcdOverride
= {}
772 for Pa
in Wa
.AutoGenObjectList
:
775 # Collect all platform referenced PCDs and grouped them by PCD token space
778 for Pcd
in Pa
.AllPcdList
:
779 PcdList
= self
.AllPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
780 if Pcd
not in PcdList
:
782 if len(Pcd
.TokenCName
) > self
.MaxLen
:
783 self
.MaxLen
= len(Pcd
.TokenCName
)
785 # Collect the PCD defined in DSC/FDF file, but not used in module
787 UnusedPcdFullList
= []
788 for item
in Pa
.Platform
.Pcds
:
789 Pcd
= Pa
.Platform
.Pcds
[item
]
791 # check the Pcd in FDF file, whether it is used in module first
792 for T
in PCD_TYPE_LIST
:
793 PcdList
= self
.AllPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(T
, [])
799 for package
in Pa
.PackageList
:
800 for T
in PCD_TYPE_LIST
:
801 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, T
) in package
.Pcds
:
804 if not Pcd
.DatumType
:
805 Pcd
.DatumType
= package
.Pcds
[(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, T
)].DatumType
809 if not Pcd
.DatumType
:
811 # Try to remove Hii and Vpd suffix
812 if PcdType
.startswith(TAB_PCDS_DYNAMIC_EX
):
813 PcdType
= TAB_PCDS_DYNAMIC_EX
814 elif PcdType
.startswith(TAB_PCDS_DYNAMIC
):
815 PcdType
= TAB_PCDS_DYNAMIC
816 for package
in Pa
.PackageList
:
817 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, PcdType
) in package
.Pcds
:
818 Pcd
.DatumType
= package
.Pcds
[(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, PcdType
)].DatumType
821 PcdList
= self
.AllPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
822 if Pcd
not in PcdList
and Pcd
not in UnusedPcdFullList
:
823 UnusedPcdFullList
.append(Pcd
)
824 if len(Pcd
.TokenCName
) > self
.MaxLen
:
825 self
.MaxLen
= len(Pcd
.TokenCName
)
827 if GlobalData
.gConditionalPcds
:
828 for PcdItem
in GlobalData
.gConditionalPcds
:
830 (TokenSpaceGuidCName
, TokenCName
) = PcdItem
.split('.')
831 if (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
832 Pcd
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)]
833 PcdList
= self
.ConditionalPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
834 if Pcd
not in PcdList
:
838 if UnusedPcdFullList
:
839 for Pcd
in UnusedPcdFullList
:
840 if Pcd
.TokenSpaceGuidCName
+ '.' + Pcd
.TokenCName
in GlobalData
.gConditionalPcds
:
842 UnusedPcdList
.append(Pcd
)
844 for Pcd
in UnusedPcdList
:
845 PcdList
= self
.UnusedPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
846 if Pcd
not in PcdList
:
849 for Module
in Pa
.Platform
.Modules
.values():
851 # Collect module override PCDs
853 for ModulePcd
in Module
.M
.ModulePcdList
+ Module
.M
.LibraryPcdList
:
854 TokenCName
= ModulePcd
.TokenCName
855 TokenSpaceGuid
= ModulePcd
.TokenSpaceGuidCName
856 ModuleDefault
= ModulePcd
.DefaultValue
857 ModulePath
= os
.path
.basename(Module
.M
.MetaFile
.File
)
858 self
.ModulePcdOverride
.setdefault((TokenCName
, TokenSpaceGuid
), {})[ModulePath
] = ModuleDefault
862 # Collect PCD DEC default value.
864 self
.DecPcdDefault
= {}
866 for Pa
in Wa
.AutoGenObjectList
:
867 for Package
in Pa
.PackageList
:
868 Guids
= Package
.Guids
869 self
._GuidDict
.update(Guids
)
870 for (TokenCName
, TokenSpaceGuidCName
, DecType
) in Package
.Pcds
:
871 DecDefaultValue
= Package
.Pcds
[TokenCName
, TokenSpaceGuidCName
, DecType
].DefaultValue
872 self
.DecPcdDefault
.setdefault((TokenCName
, TokenSpaceGuidCName
, DecType
), DecDefaultValue
)
874 # Collect PCDs defined in DSC common section
876 self
.DscPcdDefault
= {}
877 for Pa
in Wa
.AutoGenObjectList
:
878 for (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
879 DscDefaultValue
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)].DscDefaultValue
881 self
.DscPcdDefault
[(TokenCName
, TokenSpaceGuidCName
)] = DscDefaultValue
883 def GenerateReport(self
, File
, ModulePcdSet
):
885 if self
.ConditionalPcds
:
886 self
.GenerateReportDetail(File
, ModulePcdSet
, 1)
888 self
.GenerateReportDetail(File
, ModulePcdSet
, 2)
889 self
.GenerateReportDetail(File
, ModulePcdSet
)
892 # Generate report for PCD information
894 # This function generates report for separate module expression
895 # in a platform build.
897 # @param self The object pointer
898 # @param File The file object for report
899 # @param ModulePcdSet Set of all PCDs referenced by module or None for
900 # platform PCD report
901 # @param ReportySubType 0 means platform/module PCD report, 1 means Conditional
902 # directives section report, 2 means Unused Pcds section report
903 # @param DscOverridePcds Module DSC override PCDs set
905 def GenerateReportDetail(self
, File
, ModulePcdSet
, ReportSubType
= 0):
906 PcdDict
= self
.AllPcds
907 if ReportSubType
== 1:
908 PcdDict
= self
.ConditionalPcds
909 elif ReportSubType
== 2:
910 PcdDict
= self
.UnusedPcds
913 FileWrite(File
, gSectionStart
)
914 if ReportSubType
== 1:
915 FileWrite(File
, "Conditional Directives used by the build system")
916 elif ReportSubType
== 2:
917 FileWrite(File
, "PCDs not used by modules or in conditional directives")
919 FileWrite(File
, "Platform Configuration Database Report")
921 FileWrite(File
, " *B - PCD override in the build option")
922 FileWrite(File
, " *P - Platform scoped PCD override in DSC file")
923 FileWrite(File
, " *F - Platform scoped PCD override in FDF file")
924 if not ReportSubType
:
925 FileWrite(File
, " *M - Module scoped PCD override")
926 FileWrite(File
, gSectionSep
)
928 if not ReportSubType
and ModulePcdSet
:
930 # For module PCD sub-section
932 FileWrite(File
, gSubSectionStart
)
933 FileWrite(File
, TAB_BRG_PCD
)
934 FileWrite(File
, gSubSectionSep
)
938 for Type
in PcdDict
[Key
]:
939 for Pcd
in PcdDict
[Key
][Type
]:
940 AllPcdDict
[Key
][(Pcd
.TokenCName
, Type
)] = Pcd
941 for Key
in sorted(AllPcdDict
):
943 # Group PCD by their token space GUID C Name
946 for PcdTokenCName
, Type
in sorted(AllPcdDict
[Key
]):
948 # Group PCD by their usage type
950 Pcd
= AllPcdDict
[Key
][(PcdTokenCName
, Type
)]
951 TypeName
, DecType
= gPcdTypeMap
.get(Type
, ("", Type
))
953 if GlobalData
.MixedPcd
:
954 for PcdKey
in GlobalData
.MixedPcd
:
955 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
) in GlobalData
.MixedPcd
[PcdKey
]:
956 PcdTokenCName
= PcdKey
[0]
958 if MixedPcdFlag
and not ModulePcdSet
:
961 # Get PCD default value and their override relationship
963 DecDefaultValue
= self
.DecPcdDefault
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, DecType
))
964 DscDefaultValue
= self
.DscPcdDefault
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
))
965 DscDefaultValBak
= DscDefaultValue
967 for (CName
, Guid
, Field
) in self
.FdfPcdSet
:
968 if CName
== PcdTokenCName
and Guid
== Key
:
969 DscDefaultValue
= self
.FdfPcdSet
[(CName
, Guid
, Field
)]
971 if DscDefaultValue
!= DscDefaultValBak
:
973 DscDefaultValue
= ValueExpressionEx(DscDefaultValue
, Pcd
.DatumType
, self
._GuidDict
)(True)
974 except BadExpression
as DscDefaultValue
:
975 EdkLogger
.error('BuildReport', FORMAT_INVALID
, "PCD Value: %s, Type: %s" %(DscDefaultValue
, Pcd
.DatumType
))
977 InfDefaultValue
= None
979 PcdValue
= DecDefaultValue
981 PcdValue
= DscDefaultValue
982 Pcd
.DefaultValue
= PcdValue
983 if ModulePcdSet
is not None:
984 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Type
) not in ModulePcdSet
:
986 InfDefaultValue
, PcdValue
= ModulePcdSet
[Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Type
]
987 Pcd
.DefaultValue
= PcdValue
990 InfDefaultValue
= ValueExpressionEx(InfDefaultValue
, Pcd
.DatumType
, self
._GuidDict
)(True)
991 except BadExpression
as InfDefaultValue
:
992 EdkLogger
.error('BuildReport', FORMAT_INVALID
, "PCD Value: %s, Type: %s" % (InfDefaultValue
, Pcd
.DatumType
))
993 if InfDefaultValue
== "":
994 InfDefaultValue
= None
996 BuildOptionMatch
= False
997 if GlobalData
.BuildOptionPcd
:
998 for pcd
in GlobalData
.BuildOptionPcd
:
999 if (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
) == (pcd
[0], pcd
[1]):
1003 Pcd
.DefaultValue
= PcdValue
1004 BuildOptionMatch
= True
1008 if ModulePcdSet
is None:
1010 FileWrite(File
, Key
)
1014 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1015 PcdValueNumber
= int(PcdValue
.strip(), 0)
1016 if DecDefaultValue
is None:
1019 DecDefaultValueNumber
= int(DecDefaultValue
.strip(), 0)
1020 DecMatch
= (DecDefaultValueNumber
== PcdValueNumber
)
1022 if InfDefaultValue
is None:
1025 InfDefaultValueNumber
= int(InfDefaultValue
.strip(), 0)
1026 InfMatch
= (InfDefaultValueNumber
== PcdValueNumber
)
1028 if DscDefaultValue
is None:
1031 DscDefaultValueNumber
= int(DscDefaultValue
.strip(), 0)
1032 DscMatch
= (DscDefaultValueNumber
== PcdValueNumber
)
1034 if DecDefaultValue
is None:
1037 DecMatch
= (DecDefaultValue
.strip() == PcdValue
.strip())
1039 if InfDefaultValue
is None:
1042 InfMatch
= (InfDefaultValue
.strip() == PcdValue
.strip())
1044 if DscDefaultValue
is None:
1047 DscMatch
= (DscDefaultValue
.strip() == PcdValue
.strip())
1050 if GlobalData
.gStructurePcd
and (self
.Arch
in GlobalData
.gStructurePcd
) and ((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
) in GlobalData
.gStructurePcd
[self
.Arch
]):
1052 if TypeName
in ('DYNVPD', 'DEXVPD'):
1053 SkuInfoList
= Pcd
.SkuInfoList
1054 Pcd
= GlobalData
.gStructurePcd
[self
.Arch
][(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
)]
1055 Pcd
.DatumType
= Pcd
.StructName
1056 if TypeName
in ('DYNVPD', 'DEXVPD'):
1057 Pcd
.SkuInfoList
= SkuInfoList
1058 if Pcd
.PcdFieldValueFromComm
:
1059 BuildOptionMatch
= True
1061 elif Pcd
.SkuOverrideValues
:
1063 if not Pcd
.SkuInfoList
:
1064 OverrideValues
= Pcd
.SkuOverrideValues
1066 Keys
= OverrideValues
.keys()
1067 Data
= OverrideValues
[Keys
[0]]
1068 Struct
= Data
.values()[0]
1069 DscOverride
= self
.ParseStruct(Struct
)
1071 SkuList
= sorted(Pcd
.SkuInfoList
.keys())
1073 SkuInfo
= Pcd
.SkuInfoList
[Sku
]
1074 if TypeName
in ('DYNHII', 'DEXHII'):
1075 if SkuInfo
.DefaultStoreDict
:
1076 DefaultStoreList
= sorted(SkuInfo
.DefaultStoreDict
.keys())
1077 for DefaultStore
in DefaultStoreList
:
1078 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1079 DscOverride
= self
.ParseStruct(OverrideValues
[DefaultStore
])
1083 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1085 Keys
= OverrideValues
.keys()
1086 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[Keys
[0]])
1087 DscOverride
= self
.ParseStruct(OverrideFieldStruct
)
1091 DscDefaultValue
= True
1095 DscDefaultValue
= True
1100 # Report PCD item according to their override relationship
1103 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, ' ')
1104 elif InfDefaultValue
and InfMatch
:
1105 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*M')
1106 elif BuildOptionMatch
:
1107 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*B')
1109 if DscDefaultValue
and DscMatch
:
1110 if (Pcd
.TokenCName
, Key
, Field
) in self
.FdfPcdSet
:
1111 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*F')
1113 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*P')
1115 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*M')
1117 if ModulePcdSet
is None:
1120 if not TypeName
in ('PATCH', 'FLAG', 'FIXED'):
1122 if not BuildOptionMatch
:
1123 ModuleOverride
= self
.ModulePcdOverride
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
), {})
1124 for ModulePath
in ModuleOverride
:
1125 ModuleDefault
= ModuleOverride
[ModulePath
]
1126 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1127 ModulePcdDefaultValueNumber
= int(ModuleDefault
.strip(), 0)
1128 Match
= (ModulePcdDefaultValueNumber
== PcdValueNumber
)
1130 Match
= (ModuleDefault
.strip() == PcdValue
.strip())
1133 IsByteArray
, ArrayList
= ByteArrayForamt(ModuleDefault
.strip())
1135 FileWrite(File
, ' *M %-*s = %s' % (self
.MaxLen
+ 15, ModulePath
, '{'))
1136 for Array
in ArrayList
:
1137 FileWrite(File
, Array
)
1139 Value
= ModuleDefault
.strip()
1140 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1141 if Value
.startswith(('0x', '0X')):
1142 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1144 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1145 FileWrite(File
, ' *M %-*s = %s' % (self
.MaxLen
+ 15, ModulePath
, Value
))
1147 if ModulePcdSet
is None:
1148 FileWrite(File
, gSectionEnd
)
1150 if not ReportSubType
and ModulePcdSet
:
1151 FileWrite(File
, gSubSectionEnd
)
1153 def ParseStruct(self
, struct
):
1154 HasDscOverride
= False
1156 for _
, Values
in struct
.items():
1157 if Values
[1] and Values
[1].endswith('.dsc'):
1158 HasDscOverride
= True
1160 return HasDscOverride
1162 def PrintPcdDefault(self
, File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
):
1163 if not DscMatch
and DscDefaultValue
is not None:
1164 Value
= DscDefaultValue
.strip()
1165 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1167 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DSC DEFAULT', "{"))
1168 for Array
in ArrayList
:
1169 FileWrite(File
, Array
)
1171 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1172 if Value
.startswith(('0x', '0X')):
1173 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1175 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1176 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DSC DEFAULT', Value
))
1177 if not InfMatch
and InfDefaultValue
is not None:
1178 Value
= InfDefaultValue
.strip()
1179 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1181 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'INF DEFAULT', "{"))
1182 for Array
in ArrayList
:
1183 FileWrite(File
, Array
)
1185 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1186 if Value
.startswith(('0x', '0X')):
1187 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1189 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1190 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'INF DEFAULT', Value
))
1192 if not DecMatch
and DecDefaultValue
is not None:
1193 Value
= DecDefaultValue
.strip()
1194 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1196 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DEC DEFAULT', "{"))
1197 for Array
in ArrayList
:
1198 FileWrite(File
, Array
)
1200 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1201 if Value
.startswith(('0x', '0X')):
1202 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1204 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1205 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DEC DEFAULT', Value
))
1207 self
.PrintStructureInfo(File
, Pcd
.DefaultValues
)
1208 if DecMatch
and IsStructure
:
1209 self
.PrintStructureInfo(File
, Pcd
.DefaultValues
)
1211 def PrintPcdValue(self
, File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, Flag
= ' '):
1212 if not Pcd
.SkuInfoList
:
1213 Value
= Pcd
.DefaultValue
1214 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1216 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1217 for Array
in ArrayList
:
1218 FileWrite(File
, Array
)
1220 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1221 if Value
.startswith(('0x', '0X')):
1222 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1224 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1225 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1227 OverrideValues
= Pcd
.SkuOverrideValues
1229 Keys
= OverrideValues
.keys()
1230 Data
= OverrideValues
[Keys
[0]]
1231 Struct
= Data
.values()[0]
1232 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, Struct
)
1233 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1234 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1237 SkuList
= sorted(Pcd
.SkuInfoList
.keys())
1239 SkuInfo
= Pcd
.SkuInfoList
[Sku
]
1240 SkuIdName
= SkuInfo
.SkuIdName
1241 if TypeName
in ('DYNHII', 'DEXHII'):
1242 if SkuInfo
.DefaultStoreDict
:
1243 DefaultStoreList
= sorted(SkuInfo
.DefaultStoreDict
.keys())
1244 for DefaultStore
in DefaultStoreList
:
1245 Value
= SkuInfo
.DefaultStoreDict
[DefaultStore
]
1246 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1250 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1251 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1252 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1253 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '{'))
1254 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1255 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', '{'))
1257 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', '{'))
1258 for Array
in ArrayList
:
1259 FileWrite(File
, Array
)
1261 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1262 if Value
.startswith(('0x', '0X')):
1263 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1265 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1266 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1267 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1268 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1269 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1270 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1271 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', Value
))
1273 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', Value
))
1276 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1277 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1278 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1279 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '{'))
1280 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1281 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', '{'))
1283 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', '{'))
1284 for Array
in ArrayList
:
1285 FileWrite(File
, Array
)
1287 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1288 if Value
.startswith(('0x', '0X')):
1289 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1291 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1292 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1293 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1294 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1295 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1296 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1297 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', Value
))
1299 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', Value
))
1300 FileWrite(File
, '%*s: %s: %s' % (self
.MaxLen
+ 4, SkuInfo
.VariableGuid
, SkuInfo
.VariableName
, SkuInfo
.VariableOffset
))
1302 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1303 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[DefaultStore
])
1304 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1305 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1307 Value
= SkuInfo
.DefaultValue
1308 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1313 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', "{"))
1315 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', "{"))
1316 for Array
in ArrayList
:
1317 FileWrite(File
, Array
)
1319 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1320 if Value
.startswith(('0x', '0X')):
1321 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1323 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1325 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1327 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1331 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', "{"))
1333 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', "{"))
1334 for Array
in ArrayList
:
1335 FileWrite(File
, Array
)
1337 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1338 if Value
.startswith(('0x', '0X')):
1339 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1341 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1343 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1345 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1346 if TypeName
in ('DYNVPD', 'DEXVPD'):
1347 FileWrite(File
, '%*s' % (self
.MaxLen
+ 4, SkuInfo
.VpdOffset
))
1349 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1351 Keys
= OverrideValues
.keys()
1352 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[Keys
[0]])
1353 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1354 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1356 def OverrideFieldValue(self
, Pcd
, OverrideStruct
):
1357 OverrideFieldStruct
= collections
.OrderedDict()
1359 for Key
, Values
in OverrideStruct
.items():
1360 if Values
[1] and Values
[1].endswith('.dsc'):
1361 OverrideFieldStruct
[Key
] = Values
1362 if Pcd
.PcdFieldValueFromFdf
:
1363 for Key
, Values
in Pcd
.PcdFieldValueFromFdf
.items():
1364 if Key
in OverrideFieldStruct
and Values
[0] == OverrideFieldStruct
[Key
][0]:
1366 OverrideFieldStruct
[Key
] = Values
1367 if Pcd
.PcdFieldValueFromComm
:
1368 for Key
, Values
in Pcd
.PcdFieldValueFromComm
.items():
1369 if Key
in OverrideFieldStruct
and Values
[0] == OverrideFieldStruct
[Key
][0]:
1371 OverrideFieldStruct
[Key
] = Values
1372 return OverrideFieldStruct
1374 def PrintStructureInfo(self
, File
, Struct
):
1375 for Key
, Value
in sorted(Struct
.items(), key
=lambda x
: x
[0]):
1376 if Value
[1] and 'build command options' in Value
[1]:
1377 FileWrite(File
, ' *B %-*s = %s' % (self
.MaxLen
+ 4, '.' + Key
, Value
[0]))
1378 elif Value
[1] and Value
[1].endswith('.fdf'):
1379 FileWrite(File
, ' *F %-*s = %s' % (self
.MaxLen
+ 4, '.' + Key
, Value
[0]))
1381 FileWrite(File
, ' %-*s = %s' % (self
.MaxLen
+ 4, '.' + Key
, Value
[0]))
1383 def StrtoHex(self
, value
):
1385 value
= hex(int(value
))
1388 if value
.startswith("L\"") and value
.endswith("\""):
1390 for ch
in value
[2:-1]:
1391 valuelist
.append(hex(ord(ch
)))
1392 valuelist
.append('0x00')
1394 elif value
.startswith("\"") and value
.endswith("\""):
1395 return hex(ord(value
[1:-1]))
1396 elif value
.startswith("{") and value
.endswith("}"):
1398 if ',' not in value
:
1400 for ch
in value
[1:-1].split(','):
1402 if ch
.startswith('0x') or ch
.startswith('0X'):
1403 valuelist
.append(ch
)
1406 valuelist
.append(hex(int(ch
.strip())))
1414 # Reports platform and module Prediction information
1416 # This class reports the platform execution order prediction section and
1417 # module load fixed address prediction subsection in the build report file.
1419 class PredictionReport(object):
1421 # Constructor function for class PredictionReport
1423 # This constructor function generates PredictionReport object for the platform.
1425 # @param self: The object pointer
1426 # @param Wa Workspace context information
1428 def __init__(self
, Wa
):
1429 self
._MapFileName
= os
.path
.join(Wa
.BuildDir
, Wa
.Name
+ ".map")
1430 self
._MapFileParsed
= False
1431 self
._EotToolInvoked
= False
1432 self
._FvDir
= Wa
.FvDir
1433 self
._EotDir
= Wa
.BuildDir
1434 self
._FfsEntryPoint
= {}
1436 self
._SourceList
= []
1437 self
.FixedMapDict
= {}
1442 # Collect all platform reference source files and GUID C Name
1444 for Pa
in Wa
.AutoGenObjectList
:
1445 for Module
in Pa
.LibraryAutoGenList
+ Pa
.ModuleAutoGenList
:
1447 # BASE typed modules are EFI agnostic, so we need not scan
1448 # their source code to find PPI/Protocol produce or consume
1451 if Module
.ModuleType
== SUP_MODULE_BASE
:
1454 # Add module referenced source files
1456 self
._SourceList
.append(str(Module
))
1458 for Source
in Module
.SourceFileList
:
1459 if os
.path
.splitext(str(Source
))[1].lower() == ".c":
1460 self
._SourceList
.append(" " + str(Source
))
1461 FindIncludeFiles(Source
.Path
, Module
.IncludePathList
, IncludeList
)
1462 for IncludeFile
in IncludeList
.values():
1463 self
._SourceList
.append(" " + IncludeFile
)
1465 for Guid
in Module
.PpiList
:
1466 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.PpiList
[Guid
])
1467 for Guid
in Module
.ProtocolList
:
1468 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.ProtocolList
[Guid
])
1469 for Guid
in Module
.GuidList
:
1470 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.GuidList
[Guid
])
1472 if Module
.Guid
and not Module
.IsLibrary
:
1473 EntryPoint
= " ".join(Module
.Module
.ModuleEntryPointList
)
1474 if int(str(Module
.AutoGenVersion
), 0) >= 0x00010005:
1475 RealEntryPoint
= "_ModuleEntryPoint"
1477 RealEntryPoint
= EntryPoint
1478 if EntryPoint
== "_ModuleEntryPoint":
1479 CCFlags
= Module
.BuildOption
.get("CC", {}).get("FLAGS", "")
1480 Match
= gGlueLibEntryPoint
.search(CCFlags
)
1482 EntryPoint
= Match
.group(1)
1484 self
._FfsEntryPoint
[Module
.Guid
.upper()] = (EntryPoint
, RealEntryPoint
)
1488 # Collect platform firmware volume list as the input of EOT.
1492 for Fd
in Wa
.FdfProfile
.FdDict
:
1493 for FdRegion
in Wa
.FdfProfile
.FdDict
[Fd
].RegionList
:
1494 if FdRegion
.RegionType
!= BINARY_FILE_TYPE_FV
:
1496 for FvName
in FdRegion
.RegionDataList
:
1497 if FvName
in self
._FvList
:
1499 self
._FvList
.append(FvName
)
1500 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1501 for Section
in Ffs
.SectionList
:
1503 for FvSection
in Section
.SectionList
:
1504 if FvSection
.FvName
in self
._FvList
:
1506 self
._FvList
.append(FvSection
.FvName
)
1507 except AttributeError:
1512 # Parse platform fixed address map files
1514 # This function parses the platform final fixed address map file to get
1515 # the database of predicted fixed address for module image base, entry point
1518 # @param self: The object pointer
1520 def _ParseMapFile(self
):
1521 if self
._MapFileParsed
:
1523 self
._MapFileParsed
= True
1524 if os
.path
.isfile(self
._MapFileName
):
1526 FileContents
= open(self
._MapFileName
).read()
1527 for Match
in gMapFileItemPattern
.finditer(FileContents
):
1528 AddressType
= Match
.group(1)
1529 BaseAddress
= Match
.group(2)
1530 EntryPoint
= Match
.group(3)
1531 Guid
= Match
.group(4).upper()
1532 List
= self
.FixedMapDict
.setdefault(Guid
, [])
1533 List
.append((AddressType
, BaseAddress
, "*I"))
1534 List
.append((AddressType
, EntryPoint
, "*E"))
1536 EdkLogger
.warn(None, "Cannot open file to read", self
._MapFileName
)
1539 # Invokes EOT tool to get the predicted the execution order.
1541 # This function invokes EOT tool to calculate the predicted dispatch order
1543 # @param self: The object pointer
1545 def _InvokeEotTool(self
):
1546 if self
._EotToolInvoked
:
1549 self
._EotToolInvoked
= True
1551 for FvName
in self
._FvList
:
1552 FvFile
= os
.path
.join(self
._FvDir
, FvName
+ ".Fv")
1553 if os
.path
.isfile(FvFile
):
1554 FvFileList
.append(FvFile
)
1556 if len(FvFileList
) == 0:
1559 # Write source file list and GUID file list to an intermediate file
1560 # as the input for EOT tool and dispatch List as the output file
1563 SourceList
= os
.path
.join(self
._EotDir
, "SourceFile.txt")
1564 GuidList
= os
.path
.join(self
._EotDir
, "GuidList.txt")
1565 DispatchList
= os
.path
.join(self
._EotDir
, "Dispatch.txt")
1567 TempFile
= open(SourceList
, "w+")
1568 for Item
in self
._SourceList
:
1569 FileWrite(TempFile
, Item
)
1571 TempFile
= open(GuidList
, "w+")
1572 for Key
in self
._GuidMap
:
1573 FileWrite(TempFile
, "%s %s" % (Key
, self
._GuidMap
[Key
]))
1577 from Eot
.Eot
import Eot
1580 # Invoke EOT tool and echo its runtime performance
1582 EotStartTime
= time
.time()
1583 Eot(CommandLineOption
=False, SourceFileList
=SourceList
, GuidList
=GuidList
,
1584 FvFileList
=' '.join(FvFileList
), Dispatch
=DispatchList
, IsInit
=True)
1585 EotEndTime
= time
.time()
1586 EotDuration
= time
.strftime("%H:%M:%S", time
.gmtime(int(round(EotEndTime
- EotStartTime
))))
1587 EdkLogger
.quiet("EOT run time: %s\n" % EotDuration
)
1590 # Parse the output of EOT tool
1592 for Line
in open(DispatchList
):
1593 if len(Line
.split()) < 4:
1595 (Guid
, Phase
, FfsName
, FilePath
) = Line
.split()
1596 Symbol
= self
._FfsEntryPoint
.get(Guid
, [FfsName
, ""])[0]
1597 if len(Symbol
) > self
.MaxLen
:
1598 self
.MaxLen
= len(Symbol
)
1599 self
.ItemList
.append((Phase
, Symbol
, FilePath
))
1601 EdkLogger
.quiet("(Python %s on %s\n%s)" % (platform
.python_version(), sys
.platform
, traceback
.format_exc()))
1602 EdkLogger
.warn(None, "Failed to generate execution order prediction report, for some error occurred in executing EOT.")
1606 # Generate platform execution order report
1608 # This function generates the predicted module execution order.
1610 # @param self The object pointer
1611 # @param File The file object for report
1613 def _GenerateExecutionOrderReport(self
, File
):
1614 self
._InvokeEotTool
()
1615 if len(self
.ItemList
) == 0:
1617 FileWrite(File
, gSectionStart
)
1618 FileWrite(File
, "Execution Order Prediction")
1619 FileWrite(File
, "*P PEI phase")
1620 FileWrite(File
, "*D DXE phase")
1621 FileWrite(File
, "*E Module INF entry point name")
1622 FileWrite(File
, "*N Module notification function name")
1624 FileWrite(File
, "Type %-*s %s" % (self
.MaxLen
, "Symbol", "Module INF Path"))
1625 FileWrite(File
, gSectionSep
)
1626 for Item
in self
.ItemList
:
1627 FileWrite(File
, "*%sE %-*s %s" % (Item
[0], self
.MaxLen
, Item
[1], Item
[2]))
1629 FileWrite(File
, gSectionStart
)
1632 # Generate Fixed Address report.
1634 # This function generate the predicted fixed address report for a module
1635 # specified by Guid.
1637 # @param self The object pointer
1638 # @param File The file object for report
1639 # @param Guid The module Guid value.
1640 # @param NotifyList The list of all notify function in a module
1642 def _GenerateFixedAddressReport(self
, File
, Guid
, NotifyList
):
1643 self
._ParseMapFile
()
1644 FixedAddressList
= self
.FixedMapDict
.get(Guid
)
1645 if not FixedAddressList
:
1648 FileWrite(File
, gSubSectionStart
)
1649 FileWrite(File
, "Fixed Address Prediction")
1650 FileWrite(File
, "*I Image Loading Address")
1651 FileWrite(File
, "*E Entry Point Address")
1652 FileWrite(File
, "*N Notification Function Address")
1653 FileWrite(File
, "*F Flash Address")
1654 FileWrite(File
, "*M Memory Address")
1655 FileWrite(File
, "*S SMM RAM Offset")
1656 FileWrite(File
, "TOM Top of Memory")
1658 FileWrite(File
, "Type Address Name")
1659 FileWrite(File
, gSubSectionSep
)
1660 for Item
in FixedAddressList
:
1665 Name
= "(Image Base)"
1666 elif Symbol
== "*E":
1667 Name
= self
._FfsEntryPoint
.get(Guid
, ["", "_ModuleEntryPoint"])[1]
1668 elif Symbol
in NotifyList
:
1676 elif "Memory" in Type
:
1682 Value
= "TOM" + Value
1684 FileWrite(File
, "%s %-16s %s" % (Symbol
, Value
, Name
))
1687 # Generate report for the prediction part
1689 # This function generate the predicted fixed address report for a module or
1690 # predicted module execution order for a platform.
1691 # If the input Guid is None, then, it generates the predicted module execution order;
1692 # otherwise it generated the module fixed loading address for the module specified by
1695 # @param self The object pointer
1696 # @param File The file object for report
1697 # @param Guid The module Guid value.
1699 def GenerateReport(self
, File
, Guid
):
1701 self
._GenerateFixedAddressReport
(File
, Guid
.upper(), [])
1703 self
._GenerateExecutionOrderReport
(File
)
1706 # Reports FD region information
1708 # This class reports the FD subsection in the build report file.
1709 # It collects region information of platform flash device.
1710 # If the region is a firmware volume, it lists the set of modules
1711 # and its space information; otherwise, it only lists its region name,
1712 # base address and size in its sub-section header.
1713 # If there are nesting FVs, the nested FVs will list immediate after
1714 # this FD region subsection
1716 class FdRegionReport(object):
1718 # Discover all the nested FV name list.
1720 # This is an internal worker function to discover the all the nested FV information
1721 # in the parent firmware volume. It uses deep first search algorithm recursively to
1722 # find all the FV list name and append them to the list.
1724 # @param self The object pointer
1725 # @param FvName The name of current firmware file system
1726 # @param Wa Workspace context information
1728 def _DiscoverNestedFvList(self
, FvName
, Wa
):
1729 FvDictKey
=FvName
.upper()
1730 if FvDictKey
in Wa
.FdfProfile
.FvDict
:
1731 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1732 for Section
in Ffs
.SectionList
:
1734 for FvSection
in Section
.SectionList
:
1735 if FvSection
.FvName
in self
.FvList
:
1737 self
._GuidsDb
[Ffs
.NameGuid
.upper()] = FvSection
.FvName
1738 self
.FvList
.append(FvSection
.FvName
)
1739 self
.FvInfo
[FvSection
.FvName
] = ("Nested FV", 0, 0)
1740 self
._DiscoverNestedFvList
(FvSection
.FvName
, Wa
)
1741 except AttributeError:
1745 # Constructor function for class FdRegionReport
1747 # This constructor function generates FdRegionReport object for a specified FdRegion.
1748 # If the FdRegion is a firmware volume, it will recursively find all its nested Firmware
1749 # volume list. This function also collects GUID map in order to dump module identification
1750 # in the final report.
1752 # @param self: The object pointer
1753 # @param FdRegion The current FdRegion object
1754 # @param Wa Workspace context information
1756 def __init__(self
, FdRegion
, Wa
):
1757 self
.Type
= FdRegion
.RegionType
1758 self
.BaseAddress
= FdRegion
.Offset
1759 self
.Size
= FdRegion
.Size
1763 self
._FvDir
= Wa
.FvDir
1764 self
._WorkspaceDir
= Wa
.WorkspaceDir
1767 # If the input FdRegion is not a firmware volume,
1770 if self
.Type
!= BINARY_FILE_TYPE_FV
:
1774 # Find all nested FVs in the FdRegion
1776 for FvName
in FdRegion
.RegionDataList
:
1777 if FvName
in self
.FvList
:
1779 self
.FvList
.append(FvName
)
1780 self
.FvInfo
[FvName
] = ("Fd Region", self
.BaseAddress
, self
.Size
)
1781 self
._DiscoverNestedFvList
(FvName
, Wa
)
1785 # Collect PCDs declared in DEC files.
1787 for Pa
in Wa
.AutoGenObjectList
:
1788 for Package
in Pa
.PackageList
:
1789 for (TokenCName
, TokenSpaceGuidCName
, DecType
) in Package
.Pcds
:
1790 DecDefaultValue
= Package
.Pcds
[TokenCName
, TokenSpaceGuidCName
, DecType
].DefaultValue
1791 PlatformPcds
[(TokenCName
, TokenSpaceGuidCName
)] = DecDefaultValue
1793 # Collect PCDs defined in DSC file
1795 for Pa
in Wa
.AutoGenObjectList
:
1796 for (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
1797 DscDefaultValue
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)].DefaultValue
1798 PlatformPcds
[(TokenCName
, TokenSpaceGuidCName
)] = DscDefaultValue
1801 # Add PEI and DXE a priori files GUIDs defined in PI specification.
1803 self
._GuidsDb
["1B45CC0A-156A-428A-AF62-49864DA0E6E6"] = "PEI Apriori"
1804 self
._GuidsDb
["FC510EE7-FFDC-11D4-BD41-0080C73C8881"] = "DXE Apriori"
1806 # Add ACPI table storage file
1808 self
._GuidsDb
["7E374E25-8E01-4FEE-87F2-390C23C606CD"] = "ACPI table storage"
1810 for Pa
in Wa
.AutoGenObjectList
:
1811 for ModuleKey
in Pa
.Platform
.Modules
:
1812 M
= Pa
.Platform
.Modules
[ModuleKey
].M
1813 InfPath
= mws
.join(Wa
.WorkspaceDir
, M
.MetaFile
.File
)
1814 self
._GuidsDb
[M
.Guid
.upper()] = "%s (%s)" % (M
.Module
.BaseName
, InfPath
)
1817 # Collect the GUID map in the FV firmware volume
1819 for FvName
in self
.FvList
:
1820 FvDictKey
=FvName
.upper()
1821 if FvDictKey
in Wa
.FdfProfile
.FvDict
:
1822 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1825 # collect GUID map for binary EFI file in FDF file.
1827 Guid
= Ffs
.NameGuid
.upper()
1828 Match
= gPcdGuidPattern
.match(Ffs
.NameGuid
)
1830 PcdTokenspace
= Match
.group(1)
1831 PcdToken
= Match
.group(2)
1832 if (PcdToken
, PcdTokenspace
) in PlatformPcds
:
1833 GuidValue
= PlatformPcds
[(PcdToken
, PcdTokenspace
)]
1834 Guid
= GuidStructureByteArrayToGuidString(GuidValue
).upper()
1835 for Section
in Ffs
.SectionList
:
1837 ModuleSectFile
= mws
.join(Wa
.WorkspaceDir
, Section
.SectFileName
)
1838 self
._GuidsDb
[Guid
] = ModuleSectFile
1839 except AttributeError:
1841 except AttributeError:
1846 # Internal worker function to generate report for the FD region
1848 # This internal worker function to generate report for the FD region.
1849 # It the type is firmware volume, it lists offset and module identification.
1851 # @param self The object pointer
1852 # @param File The file object for report
1853 # @param Title The title for the FD subsection
1854 # @param BaseAddress The base address for the FD region
1855 # @param Size The size of the FD region
1856 # @param FvName The FV name if the FD region is a firmware volume
1858 def _GenerateReport(self
, File
, Title
, Type
, BaseAddress
, Size
=0, FvName
=None):
1859 FileWrite(File
, gSubSectionStart
)
1860 FileWrite(File
, Title
)
1861 FileWrite(File
, "Type: %s" % Type
)
1862 FileWrite(File
, "Base Address: 0x%X" % BaseAddress
)
1864 if self
.Type
== BINARY_FILE_TYPE_FV
:
1868 if FvName
.upper().endswith('.FV'):
1869 FileExt
= FvName
+ ".txt"
1871 FileExt
= FvName
+ ".Fv.txt"
1873 if not os
.path
.isfile(FileExt
):
1874 FvReportFileName
= mws
.join(self
._WorkspaceDir
, FileExt
)
1875 if not os
.path
.isfile(FvReportFileName
):
1876 FvReportFileName
= os
.path
.join(self
._FvDir
, FileExt
)
1879 # Collect size info in the firmware volume.
1881 FvReport
= open(FvReportFileName
).read()
1882 Match
= gFvTotalSizePattern
.search(FvReport
)
1884 FvTotalSize
= int(Match
.group(1), 16)
1885 Match
= gFvTakenSizePattern
.search(FvReport
)
1887 FvTakenSize
= int(Match
.group(1), 16)
1888 FvFreeSize
= FvTotalSize
- FvTakenSize
1890 # Write size information to the report file.
1892 FileWrite(File
, "Size: 0x%X (%.0fK)" % (FvTotalSize
, FvTotalSize
/ 1024.0))
1893 FileWrite(File
, "Fv Name: %s (%.1f%% Full)" % (FvName
, FvTakenSize
* 100.0 / FvTotalSize
))
1894 FileWrite(File
, "Occupied Size: 0x%X (%.0fK)" % (FvTakenSize
, FvTakenSize
/ 1024.0))
1895 FileWrite(File
, "Free Size: 0x%X (%.0fK)" % (FvFreeSize
, FvFreeSize
/ 1024.0))
1896 FileWrite(File
, "Offset Module")
1897 FileWrite(File
, gSubSectionSep
)
1899 # Write module offset and module identification to the report file.
1902 for Match
in gOffsetGuidPattern
.finditer(FvReport
):
1903 Guid
= Match
.group(2).upper()
1904 OffsetInfo
[Match
.group(1)] = self
._GuidsDb
.get(Guid
, Guid
)
1905 OffsetList
= sorted(OffsetInfo
.keys())
1906 for Offset
in OffsetList
:
1907 FileWrite (File
, "%s %s" % (Offset
, OffsetInfo
[Offset
]))
1909 EdkLogger
.warn(None, "Fail to read report file", FvReportFileName
)
1911 FileWrite(File
, "Size: 0x%X (%.0fK)" % (Size
, Size
/ 1024.0))
1912 FileWrite(File
, gSubSectionEnd
)
1915 # Generate report for the FD region
1917 # This function generates report for the FD region.
1919 # @param self The object pointer
1920 # @param File The file object for report
1922 def GenerateReport(self
, File
):
1923 if (len(self
.FvList
) > 0):
1924 for FvItem
in self
.FvList
:
1925 Info
= self
.FvInfo
[FvItem
]
1926 self
._GenerateReport
(File
, Info
[0], TAB_FV_DIRECTORY
, Info
[1], Info
[2], FvItem
)
1928 self
._GenerateReport
(File
, "FD Region", self
.Type
, self
.BaseAddress
, self
.Size
)
1931 # Reports FD information
1933 # This class reports the FD section in the build report file.
1934 # It collects flash device information for a platform.
1936 class FdReport(object):
1938 # Constructor function for class FdReport
1940 # This constructor function generates FdReport object for a specified
1943 # @param self The object pointer
1944 # @param Fd The current Firmware device object
1945 # @param Wa Workspace context information
1947 def __init__(self
, Fd
, Wa
):
1948 self
.FdName
= Fd
.FdUiName
1949 self
.BaseAddress
= Fd
.BaseAddress
1951 self
.FdRegionList
= [FdRegionReport(FdRegion
, Wa
) for FdRegion
in Fd
.RegionList
]
1952 self
.FvPath
= os
.path
.join(Wa
.BuildDir
, TAB_FV_DIRECTORY
)
1953 self
.VpdFilePath
= os
.path
.join(self
.FvPath
, "%s.map" % Wa
.Platform
.VpdToolGuid
)
1954 self
.VPDBaseAddress
= 0
1956 self
.VPDInfoList
= []
1957 for index
, FdRegion
in enumerate(Fd
.RegionList
):
1958 if str(FdRegion
.RegionType
) is 'FILE' and Wa
.Platform
.VpdToolGuid
in str(FdRegion
.RegionDataList
):
1959 self
.VPDBaseAddress
= self
.FdRegionList
[index
].BaseAddress
1960 self
.VPDSize
= self
.FdRegionList
[index
].Size
1963 if os
.path
.isfile(self
.VpdFilePath
):
1964 fd
= open(self
.VpdFilePath
, "r")
1965 Lines
= fd
.readlines()
1968 if len(Line
) == 0 or Line
.startswith("#"):
1971 PcdName
, SkuId
, Offset
, Size
, Value
= Line
.split("#")[0].split("|")
1972 PcdName
, SkuId
, Offset
, Size
, Value
= PcdName
.strip(), SkuId
.strip(), Offset
.strip(), Size
.strip(), Value
.strip()
1973 if Offset
.lower().startswith('0x'):
1974 Offset
= '0x%08X' % (int(Offset
, 16) + self
.VPDBaseAddress
)
1976 Offset
= '0x%08X' % (int(Offset
, 10) + self
.VPDBaseAddress
)
1977 self
.VPDInfoList
.append("%s | %s | %s | %s | %s" % (PcdName
, SkuId
, Offset
, Size
, Value
))
1979 EdkLogger
.error("BuildReport", CODE_ERROR
, "Fail to parse VPD information file %s" % self
.VpdFilePath
)
1983 # Generate report for the firmware device.
1985 # This function generates report for the firmware device.
1987 # @param self The object pointer
1988 # @param File The file object for report
1990 def GenerateReport(self
, File
):
1991 FileWrite(File
, gSectionStart
)
1992 FileWrite(File
, "Firmware Device (FD)")
1993 FileWrite(File
, "FD Name: %s" % self
.FdName
)
1994 FileWrite(File
, "Base Address: %s" % self
.BaseAddress
)
1995 FileWrite(File
, "Size: 0x%X (%.0fK)" % (self
.Size
, self
.Size
/ 1024.0))
1996 if len(self
.FdRegionList
) > 0:
1997 FileWrite(File
, gSectionSep
)
1998 for FdRegionItem
in self
.FdRegionList
:
1999 FdRegionItem
.GenerateReport(File
)
2001 if len(self
.VPDInfoList
) > 0:
2002 FileWrite(File
, gSubSectionStart
)
2003 FileWrite(File
, "FD VPD Region")
2004 FileWrite(File
, "Base Address: 0x%X" % self
.VPDBaseAddress
)
2005 FileWrite(File
, "Size: 0x%X (%.0fK)" % (self
.VPDSize
, self
.VPDSize
/ 1024.0))
2006 FileWrite(File
, gSubSectionSep
)
2007 for item
in self
.VPDInfoList
:
2008 ValueList
= item
.split('|')
2009 Value
= ValueList
[-1].strip()
2010 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
2012 ValueList
[-1] = ' {'
2013 FileWrite(File
, '|'.join(ValueList
))
2014 for Array
in ArrayList
:
2015 FileWrite(File
, Array
)
2017 FileWrite(File
, item
)
2018 FileWrite(File
, gSubSectionEnd
)
2019 FileWrite(File
, gSectionEnd
)
2024 # Reports platform information
2026 # This class reports the whole platform information
2028 class PlatformReport(object):
2030 # Constructor function for class PlatformReport
2032 # This constructor function generates PlatformReport object a platform build.
2033 # It generates report for platform summary, flash, global PCDs and detailed
2034 # module information for modules involved in platform build.
2036 # @param self The object pointer
2037 # @param Wa Workspace context information
2038 # @param MaList The list of modules in the platform build
2040 def __init__(self
, Wa
, MaList
, ReportType
):
2041 self
._WorkspaceDir
= Wa
.WorkspaceDir
2042 self
.PlatformName
= Wa
.Name
2043 self
.PlatformDscPath
= Wa
.Platform
2044 self
.Architectures
= " ".join(Wa
.ArchList
)
2045 self
.ToolChain
= Wa
.ToolChain
2046 self
.Target
= Wa
.BuildTarget
2047 self
.OutputPath
= os
.path
.join(Wa
.WorkspaceDir
, Wa
.OutputDir
)
2048 self
.BuildEnvironment
= platform
.platform()
2050 self
.PcdReport
= None
2051 if "PCD" in ReportType
:
2052 self
.PcdReport
= PcdReport(Wa
)
2054 self
.FdReportList
= []
2055 if "FLASH" in ReportType
and Wa
.FdfProfile
and MaList
is None:
2056 for Fd
in Wa
.FdfProfile
.FdDict
:
2057 self
.FdReportList
.append(FdReport(Wa
.FdfProfile
.FdDict
[Fd
], Wa
))
2059 self
.PredictionReport
= None
2060 if "FIXED_ADDRESS" in ReportType
or "EXECUTION_ORDER" in ReportType
:
2061 self
.PredictionReport
= PredictionReport(Wa
)
2063 self
.DepexParser
= None
2064 if "DEPEX" in ReportType
:
2065 self
.DepexParser
= DepexParser(Wa
)
2067 self
.ModuleReportList
= []
2068 if MaList
is not None:
2069 self
._IsModuleBuild
= True
2071 self
.ModuleReportList
.append(ModuleReport(Ma
, ReportType
))
2073 self
._IsModuleBuild
= False
2074 for Pa
in Wa
.AutoGenObjectList
:
2075 ModuleAutoGenList
= []
2076 for ModuleKey
in Pa
.Platform
.Modules
:
2077 ModuleAutoGenList
.append(Pa
.Platform
.Modules
[ModuleKey
].M
)
2078 if GlobalData
.gFdfParser
is not None:
2079 if Pa
.Arch
in GlobalData
.gFdfParser
.Profile
.InfDict
:
2080 INFList
= GlobalData
.gFdfParser
.Profile
.InfDict
[Pa
.Arch
]
2081 for InfName
in INFList
:
2082 InfClass
= PathClass(NormPath(InfName
), Wa
.WorkspaceDir
, Pa
.Arch
)
2083 Ma
= ModuleAutoGen(Wa
, InfClass
, Pa
.BuildTarget
, Pa
.ToolChain
, Pa
.Arch
, Wa
.MetaFile
)
2086 if Ma
not in ModuleAutoGenList
:
2087 ModuleAutoGenList
.append(Ma
)
2088 for MGen
in ModuleAutoGenList
:
2089 self
.ModuleReportList
.append(ModuleReport(MGen
, ReportType
))
2094 # Generate report for the whole platform.
2096 # This function generates report for platform information.
2097 # It comprises of platform summary, global PCD, flash and
2098 # module list sections.
2100 # @param self The object pointer
2101 # @param File The file object for report
2102 # @param BuildDuration The total time to build the modules
2103 # @param AutoGenTime The total time of AutoGen Phase
2104 # @param MakeTime The total time of Make Phase
2105 # @param GenFdsTime The total time of GenFds Phase
2106 # @param ReportType The kind of report items in the final report file
2108 def GenerateReport(self
, File
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
, ReportType
):
2109 FileWrite(File
, "Platform Summary")
2110 FileWrite(File
, "Platform Name: %s" % self
.PlatformName
)
2111 FileWrite(File
, "Platform DSC Path: %s" % self
.PlatformDscPath
)
2112 FileWrite(File
, "Architectures: %s" % self
.Architectures
)
2113 FileWrite(File
, "Tool Chain: %s" % self
.ToolChain
)
2114 FileWrite(File
, "Target: %s" % self
.Target
)
2115 if GlobalData
.gSkuids
:
2116 FileWrite(File
, "SKUID: %s" % " ".join(GlobalData
.gSkuids
))
2117 if GlobalData
.gDefaultStores
:
2118 FileWrite(File
, "DefaultStore: %s" % " ".join(GlobalData
.gDefaultStores
))
2119 FileWrite(File
, "Output Path: %s" % self
.OutputPath
)
2120 FileWrite(File
, "Build Environment: %s" % self
.BuildEnvironment
)
2121 FileWrite(File
, "Build Duration: %s" % BuildDuration
)
2123 FileWrite(File
, "AutoGen Duration: %s" % AutoGenTime
)
2125 FileWrite(File
, "Make Duration: %s" % MakeTime
)
2127 FileWrite(File
, "GenFds Duration: %s" % GenFdsTime
)
2128 FileWrite(File
, "Report Content: %s" % ", ".join(ReportType
))
2130 if GlobalData
.MixedPcd
:
2131 FileWrite(File
, gSectionStart
)
2132 FileWrite(File
, "The following PCDs use different access methods:")
2133 FileWrite(File
, gSectionSep
)
2134 for PcdItem
in GlobalData
.MixedPcd
:
2135 FileWrite(File
, "%s.%s" % (str(PcdItem
[1]), str(PcdItem
[0])))
2136 FileWrite(File
, gSectionEnd
)
2138 if not self
._IsModuleBuild
:
2139 if "PCD" in ReportType
:
2140 self
.PcdReport
.GenerateReport(File
, None)
2142 if "FLASH" in ReportType
:
2143 for FdReportListItem
in self
.FdReportList
:
2144 FdReportListItem
.GenerateReport(File
)
2146 for ModuleReportItem
in self
.ModuleReportList
:
2147 ModuleReportItem
.GenerateReport(File
, self
.PcdReport
, self
.PredictionReport
, self
.DepexParser
, ReportType
)
2149 if not self
._IsModuleBuild
:
2150 if "EXECUTION_ORDER" in ReportType
:
2151 self
.PredictionReport
.GenerateReport(File
, None)
2153 ## BuildReport class
2155 # This base class contain the routines to collect data and then
2156 # applies certain format to the output report
2158 class BuildReport(object):
2160 # Constructor function for class BuildReport
2162 # This constructor function generates BuildReport object a platform build.
2163 # It generates report for platform summary, flash, global PCDs and detailed
2164 # module information for modules involved in platform build.
2166 # @param self The object pointer
2167 # @param ReportFile The file name to save report file
2168 # @param ReportType The kind of report items in the final report file
2170 def __init__(self
, ReportFile
, ReportType
):
2171 self
.ReportFile
= ReportFile
2173 self
.ReportList
= []
2174 self
.ReportType
= []
2176 for ReportTypeItem
in ReportType
:
2177 if ReportTypeItem
not in self
.ReportType
:
2178 self
.ReportType
.append(ReportTypeItem
)
2180 self
.ReportType
= ["PCD", "LIBRARY", "BUILD_FLAGS", "DEPEX", "HASH", "FLASH", "FIXED_ADDRESS"]
2182 # Adds platform report to the list
2184 # This function adds a platform report to the final report list.
2186 # @param self The object pointer
2187 # @param Wa Workspace context information
2188 # @param MaList The list of modules in the platform build
2190 def AddPlatformReport(self
, Wa
, MaList
=None):
2192 self
.ReportList
.append((Wa
, MaList
))
2195 # Generates the final report.
2197 # This function generates platform build report. It invokes GenerateReport()
2198 # method for every platform report in the list.
2200 # @param self The object pointer
2201 # @param BuildDuration The total time to build the modules
2202 # @param AutoGenTime The total time of AutoGen phase
2203 # @param MakeTime The total time of Make phase
2204 # @param GenFdsTime The total time of GenFds phase
2206 def GenerateReport(self
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
):
2210 for (Wa
, MaList
) in self
.ReportList
:
2211 PlatformReport(Wa
, MaList
, self
.ReportType
).GenerateReport(File
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
, self
.ReportType
)
2212 Content
= FileLinesSplit(File
.getvalue(), gLineMaxLength
)
2213 SaveFileOnChange(self
.ReportFile
, Content
, True)
2214 EdkLogger
.quiet("Build report can be found at %s" % os
.path
.abspath(self
.ReportFile
))
2216 EdkLogger
.error(None, FILE_WRITE_FAILURE
, ExtraData
=self
.ReportFile
)
2218 EdkLogger
.error("BuildReport", CODE_ERROR
, "Unknown fatal error when generating build report", ExtraData
=self
.ReportFile
, RaiseError
=False)
2219 EdkLogger
.quiet("(Python %s on %s\n%s)" % (platform
.python_version(), sys
.platform
, traceback
.format_exc()))
2222 # This acts like the main() function for the script, unless it is 'import'ed into another script.
2223 if __name__
== '__main__':