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 UnusedPcdList
= self
.UnusedPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
823 if Pcd
in UnusedPcdList
:
824 UnusedPcdList
.remove(Pcd
)
825 if Pcd
not in PcdList
and Pcd
not in UnusedPcdFullList
:
826 UnusedPcdFullList
.append(Pcd
)
827 if len(Pcd
.TokenCName
) > self
.MaxLen
:
828 self
.MaxLen
= len(Pcd
.TokenCName
)
830 if GlobalData
.gConditionalPcds
:
831 for PcdItem
in GlobalData
.gConditionalPcds
:
833 (TokenSpaceGuidCName
, TokenCName
) = PcdItem
.split('.')
834 if (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
835 Pcd
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)]
836 PcdList
= self
.ConditionalPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
837 if Pcd
not in PcdList
:
841 if UnusedPcdFullList
:
842 for Pcd
in UnusedPcdFullList
:
843 if Pcd
.TokenSpaceGuidCName
+ '.' + Pcd
.TokenCName
in GlobalData
.gConditionalPcds
:
845 UnusedPcdList
.append(Pcd
)
847 for Pcd
in UnusedPcdList
:
848 PcdList
= self
.UnusedPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
849 if Pcd
not in PcdList
:
852 for Module
in Pa
.Platform
.Modules
.values():
854 # Collect module override PCDs
856 for ModulePcd
in Module
.M
.ModulePcdList
+ Module
.M
.LibraryPcdList
:
857 TokenCName
= ModulePcd
.TokenCName
858 TokenSpaceGuid
= ModulePcd
.TokenSpaceGuidCName
859 ModuleDefault
= ModulePcd
.DefaultValue
860 ModulePath
= os
.path
.basename(Module
.M
.MetaFile
.File
)
861 self
.ModulePcdOverride
.setdefault((TokenCName
, TokenSpaceGuid
), {})[ModulePath
] = ModuleDefault
865 # Collect PCD DEC default value.
867 self
.DecPcdDefault
= {}
869 for Pa
in Wa
.AutoGenObjectList
:
870 for Package
in Pa
.PackageList
:
871 Guids
= Package
.Guids
872 self
._GuidDict
.update(Guids
)
873 for (TokenCName
, TokenSpaceGuidCName
, DecType
) in Package
.Pcds
:
874 DecDefaultValue
= Package
.Pcds
[TokenCName
, TokenSpaceGuidCName
, DecType
].DefaultValue
875 self
.DecPcdDefault
.setdefault((TokenCName
, TokenSpaceGuidCName
, DecType
), DecDefaultValue
)
877 # Collect PCDs defined in DSC common section
879 self
.DscPcdDefault
= {}
880 for Pa
in Wa
.AutoGenObjectList
:
881 for (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
882 DscDefaultValue
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)].DscDefaultValue
884 self
.DscPcdDefault
[(TokenCName
, TokenSpaceGuidCName
)] = DscDefaultValue
886 def GenerateReport(self
, File
, ModulePcdSet
):
888 if self
.ConditionalPcds
:
889 self
.GenerateReportDetail(File
, ModulePcdSet
, 1)
891 self
.GenerateReportDetail(File
, ModulePcdSet
, 2)
892 self
.GenerateReportDetail(File
, ModulePcdSet
)
895 # Generate report for PCD information
897 # This function generates report for separate module expression
898 # in a platform build.
900 # @param self The object pointer
901 # @param File The file object for report
902 # @param ModulePcdSet Set of all PCDs referenced by module or None for
903 # platform PCD report
904 # @param ReportySubType 0 means platform/module PCD report, 1 means Conditional
905 # directives section report, 2 means Unused Pcds section report
906 # @param DscOverridePcds Module DSC override PCDs set
908 def GenerateReportDetail(self
, File
, ModulePcdSet
, ReportSubType
= 0):
909 PcdDict
= self
.AllPcds
910 if ReportSubType
== 1:
911 PcdDict
= self
.ConditionalPcds
912 elif ReportSubType
== 2:
913 PcdDict
= self
.UnusedPcds
916 FileWrite(File
, gSectionStart
)
917 if ReportSubType
== 1:
918 FileWrite(File
, "Conditional Directives used by the build system")
919 elif ReportSubType
== 2:
920 FileWrite(File
, "PCDs not used by modules or in conditional directives")
922 FileWrite(File
, "Platform Configuration Database Report")
924 FileWrite(File
, " *B - PCD override in the build option")
925 FileWrite(File
, " *P - Platform scoped PCD override in DSC file")
926 FileWrite(File
, " *F - Platform scoped PCD override in FDF file")
927 if not ReportSubType
:
928 FileWrite(File
, " *M - Module scoped PCD override")
929 FileWrite(File
, gSectionSep
)
931 if not ReportSubType
and ModulePcdSet
:
933 # For module PCD sub-section
935 FileWrite(File
, gSubSectionStart
)
936 FileWrite(File
, TAB_BRG_PCD
)
937 FileWrite(File
, gSubSectionSep
)
941 for Type
in PcdDict
[Key
]:
942 for Pcd
in PcdDict
[Key
][Type
]:
943 AllPcdDict
[Key
][(Pcd
.TokenCName
, Type
)] = Pcd
944 for Key
in sorted(AllPcdDict
):
946 # Group PCD by their token space GUID C Name
949 for PcdTokenCName
, Type
in sorted(AllPcdDict
[Key
]):
951 # Group PCD by their usage type
953 Pcd
= AllPcdDict
[Key
][(PcdTokenCName
, Type
)]
954 TypeName
, DecType
= gPcdTypeMap
.get(Type
, ("", Type
))
956 if GlobalData
.MixedPcd
:
957 for PcdKey
in GlobalData
.MixedPcd
:
958 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
) in GlobalData
.MixedPcd
[PcdKey
]:
959 PcdTokenCName
= PcdKey
[0]
961 if MixedPcdFlag
and not ModulePcdSet
:
964 # Get PCD default value and their override relationship
966 DecDefaultValue
= self
.DecPcdDefault
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, DecType
))
967 DscDefaultValue
= self
.DscPcdDefault
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
))
968 DscDefaultValBak
= DscDefaultValue
970 for (CName
, Guid
, Field
) in self
.FdfPcdSet
:
971 if CName
== PcdTokenCName
and Guid
== Key
:
972 DscDefaultValue
= self
.FdfPcdSet
[(CName
, Guid
, Field
)]
974 if DscDefaultValue
!= DscDefaultValBak
:
976 DscDefaultValue
= ValueExpressionEx(DscDefaultValue
, Pcd
.DatumType
, self
._GuidDict
)(True)
977 except BadExpression
as DscDefaultValue
:
978 EdkLogger
.error('BuildReport', FORMAT_INVALID
, "PCD Value: %s, Type: %s" %(DscDefaultValue
, Pcd
.DatumType
))
980 InfDefaultValue
= None
982 PcdValue
= DecDefaultValue
984 PcdValue
= DscDefaultValue
985 Pcd
.DefaultValue
= PcdValue
986 if ModulePcdSet
is not None:
987 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Type
) not in ModulePcdSet
:
989 InfDefaultValue
, PcdValue
= ModulePcdSet
[Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Type
]
990 Pcd
.DefaultValue
= PcdValue
993 InfDefaultValue
= ValueExpressionEx(InfDefaultValue
, Pcd
.DatumType
, self
._GuidDict
)(True)
994 except BadExpression
as InfDefaultValue
:
995 EdkLogger
.error('BuildReport', FORMAT_INVALID
, "PCD Value: %s, Type: %s" % (InfDefaultValue
, Pcd
.DatumType
))
996 if InfDefaultValue
== "":
997 InfDefaultValue
= None
999 BuildOptionMatch
= False
1000 if GlobalData
.BuildOptionPcd
:
1001 for pcd
in GlobalData
.BuildOptionPcd
:
1002 if (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
) == (pcd
[0], pcd
[1]):
1006 Pcd
.DefaultValue
= PcdValue
1007 BuildOptionMatch
= True
1011 if ModulePcdSet
is None:
1013 FileWrite(File
, Key
)
1017 if Pcd
.DatumType
in TAB_PCD_NUMERIC_TYPES
:
1018 PcdValueNumber
= int(PcdValue
.strip(), 0)
1019 if DecDefaultValue
is None:
1022 DecDefaultValueNumber
= int(DecDefaultValue
.strip(), 0)
1023 DecMatch
= (DecDefaultValueNumber
== PcdValueNumber
)
1025 if InfDefaultValue
is None:
1028 InfDefaultValueNumber
= int(InfDefaultValue
.strip(), 0)
1029 InfMatch
= (InfDefaultValueNumber
== PcdValueNumber
)
1031 if DscDefaultValue
is None:
1034 DscDefaultValueNumber
= int(DscDefaultValue
.strip(), 0)
1035 DscMatch
= (DscDefaultValueNumber
== PcdValueNumber
)
1037 if DecDefaultValue
is None:
1040 DecMatch
= (DecDefaultValue
.strip() == PcdValue
.strip())
1042 if InfDefaultValue
is None:
1045 InfMatch
= (InfDefaultValue
.strip() == PcdValue
.strip())
1047 if DscDefaultValue
is None:
1050 DscMatch
= (DscDefaultValue
.strip() == PcdValue
.strip())
1053 if GlobalData
.gStructurePcd
and (self
.Arch
in GlobalData
.gStructurePcd
) and ((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
) in GlobalData
.gStructurePcd
[self
.Arch
]):
1055 if TypeName
in ('DYNVPD', 'DEXVPD'):
1056 SkuInfoList
= Pcd
.SkuInfoList
1057 Pcd
= GlobalData
.gStructurePcd
[self
.Arch
][(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
)]
1058 Pcd
.DatumType
= Pcd
.StructName
1059 if TypeName
in ('DYNVPD', 'DEXVPD'):
1060 Pcd
.SkuInfoList
= SkuInfoList
1061 if Pcd
.PcdFieldValueFromComm
:
1062 BuildOptionMatch
= True
1064 elif Pcd
.SkuOverrideValues
:
1066 if not Pcd
.SkuInfoList
:
1067 OverrideValues
= Pcd
.SkuOverrideValues
1069 Keys
= OverrideValues
.keys()
1070 Data
= OverrideValues
[Keys
[0]]
1071 Struct
= Data
.values()[0]
1072 DscOverride
= self
.ParseStruct(Struct
)
1074 SkuList
= sorted(Pcd
.SkuInfoList
.keys())
1076 SkuInfo
= Pcd
.SkuInfoList
[Sku
]
1077 if TypeName
in ('DYNHII', 'DEXHII'):
1078 if SkuInfo
.DefaultStoreDict
:
1079 DefaultStoreList
= sorted(SkuInfo
.DefaultStoreDict
.keys())
1080 for DefaultStore
in DefaultStoreList
:
1081 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1082 DscOverride
= self
.ParseStruct(OverrideValues
[DefaultStore
])
1086 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1088 Keys
= OverrideValues
.keys()
1089 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[Keys
[0]])
1090 DscOverride
= self
.ParseStruct(OverrideFieldStruct
)
1094 DscDefaultValue
= True
1098 DscDefaultValue
= True
1103 # Report PCD item according to their override relationship
1105 if Pcd
.DatumType
== 'BOOLEAN':
1107 DscDefaultValue
= str(int(DscDefaultValue
, 0))
1109 DecDefaultValue
= str(int(DecDefaultValue
, 0))
1111 InfDefaultValue
= str(int(InfDefaultValue
, 0))
1112 if Pcd
.DefaultValue
:
1113 Pcd
.DefaultValue
= str(int(Pcd
.DefaultValue
, 0))
1115 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, ' ')
1116 elif InfDefaultValue
and InfMatch
:
1117 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*M')
1118 elif BuildOptionMatch
:
1119 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*B')
1121 if DscDefaultValue
and DscMatch
:
1122 if (Pcd
.TokenCName
, Key
, Field
) in self
.FdfPcdSet
:
1123 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*F')
1125 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*P')
1127 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*M')
1129 if ModulePcdSet
is None:
1132 if not TypeName
in ('PATCH', 'FLAG', 'FIXED'):
1134 if not BuildOptionMatch
:
1135 ModuleOverride
= self
.ModulePcdOverride
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
), {})
1136 for ModulePath
in ModuleOverride
:
1137 ModuleDefault
= ModuleOverride
[ModulePath
]
1138 if Pcd
.DatumType
in TAB_PCD_NUMERIC_TYPES
:
1139 ModulePcdDefaultValueNumber
= int(ModuleDefault
.strip(), 0)
1140 Match
= (ModulePcdDefaultValueNumber
== PcdValueNumber
)
1141 if Pcd
.DatumType
== 'BOOLEAN':
1142 ModuleDefault
= str(ModulePcdDefaultValueNumber
)
1144 Match
= (ModuleDefault
.strip() == PcdValue
.strip())
1147 IsByteArray
, ArrayList
= ByteArrayForamt(ModuleDefault
.strip())
1149 FileWrite(File
, ' *M %-*s = %s' % (self
.MaxLen
+ 15, ModulePath
, '{'))
1150 for Array
in ArrayList
:
1151 FileWrite(File
, Array
)
1153 Value
= ModuleDefault
.strip()
1154 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1155 if Value
.startswith(('0x', '0X')):
1156 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1158 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1159 FileWrite(File
, ' *M %-*s = %s' % (self
.MaxLen
+ 15, ModulePath
, Value
))
1161 if ModulePcdSet
is None:
1162 FileWrite(File
, gSectionEnd
)
1164 if not ReportSubType
and ModulePcdSet
:
1165 FileWrite(File
, gSubSectionEnd
)
1167 def ParseStruct(self
, struct
):
1168 HasDscOverride
= False
1170 for _
, Values
in struct
.items():
1171 if Values
[1] and Values
[1].endswith('.dsc'):
1172 HasDscOverride
= True
1174 return HasDscOverride
1176 def PrintPcdDefault(self
, File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
):
1177 if not DscMatch
and DscDefaultValue
is not None:
1178 Value
= DscDefaultValue
.strip()
1179 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1181 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DSC 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, 'DSC DEFAULT', Value
))
1191 if not InfMatch
and InfDefaultValue
is not None:
1192 Value
= InfDefaultValue
.strip()
1193 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1195 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'INF DEFAULT', "{"))
1196 for Array
in ArrayList
:
1197 FileWrite(File
, Array
)
1199 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1200 if Value
.startswith(('0x', '0X')):
1201 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1203 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1204 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'INF DEFAULT', Value
))
1206 if not DecMatch
and DecDefaultValue
is not None:
1207 Value
= DecDefaultValue
.strip()
1208 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1210 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DEC DEFAULT', "{"))
1211 for Array
in ArrayList
:
1212 FileWrite(File
, Array
)
1214 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1215 if Value
.startswith(('0x', '0X')):
1216 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1218 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1219 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DEC DEFAULT', Value
))
1221 self
.PrintStructureInfo(File
, Pcd
.DefaultValues
)
1222 if DecMatch
and IsStructure
:
1223 self
.PrintStructureInfo(File
, Pcd
.DefaultValues
)
1225 def PrintPcdValue(self
, File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, Flag
= ' '):
1226 if not Pcd
.SkuInfoList
:
1227 Value
= Pcd
.DefaultValue
1228 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1230 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1231 for Array
in ArrayList
:
1232 FileWrite(File
, Array
)
1234 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1235 if Value
.startswith(('0x', '0X')):
1236 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1238 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1239 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1241 OverrideValues
= Pcd
.SkuOverrideValues
1243 Keys
= OverrideValues
.keys()
1244 Data
= OverrideValues
[Keys
[0]]
1245 Struct
= Data
.values()[0]
1246 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, Struct
)
1247 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1248 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1251 SkuList
= sorted(Pcd
.SkuInfoList
.keys())
1253 SkuInfo
= Pcd
.SkuInfoList
[Sku
]
1254 SkuIdName
= SkuInfo
.SkuIdName
1255 if TypeName
in ('DYNHII', 'DEXHII'):
1256 if SkuInfo
.DefaultStoreDict
:
1257 DefaultStoreList
= sorted(SkuInfo
.DefaultStoreDict
.keys())
1258 for DefaultStore
in DefaultStoreList
:
1259 Value
= SkuInfo
.DefaultStoreDict
[DefaultStore
]
1260 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1261 if Pcd
.DatumType
== 'BOOLEAN':
1262 Value
= str(int(Value
, 0))
1266 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1267 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1268 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1269 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '{'))
1270 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1271 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', '{'))
1273 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', '{'))
1274 for Array
in ArrayList
:
1275 FileWrite(File
, Array
)
1277 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1278 if Value
.startswith(('0x', '0X')):
1279 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1281 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1282 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1283 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1284 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1285 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1286 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1287 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', Value
))
1289 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', Value
))
1292 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1293 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1294 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1295 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '{'))
1296 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1297 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', '{'))
1299 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', '{'))
1300 for Array
in ArrayList
:
1301 FileWrite(File
, Array
)
1303 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1304 if Value
.startswith(('0x', '0X')):
1305 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1307 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1308 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1309 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1310 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1311 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1312 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1313 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', Value
))
1315 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', Value
))
1316 FileWrite(File
, '%*s: %s: %s' % (self
.MaxLen
+ 4, SkuInfo
.VariableGuid
, SkuInfo
.VariableName
, SkuInfo
.VariableOffset
))
1318 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1319 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[DefaultStore
])
1320 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1321 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1323 Value
= SkuInfo
.DefaultValue
1324 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1325 if Pcd
.DatumType
== 'BOOLEAN':
1326 Value
= str(int(Value
, 0))
1331 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', "{"))
1333 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, 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
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1345 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1349 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', "{"))
1351 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', "{"))
1352 for Array
in ArrayList
:
1353 FileWrite(File
, Array
)
1355 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1356 if Value
.startswith(('0x', '0X')):
1357 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1359 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1361 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1363 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1364 if TypeName
in ('DYNVPD', 'DEXVPD'):
1365 FileWrite(File
, '%*s' % (self
.MaxLen
+ 4, SkuInfo
.VpdOffset
))
1367 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1369 Keys
= OverrideValues
.keys()
1370 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[Keys
[0]])
1371 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1372 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1374 def OverrideFieldValue(self
, Pcd
, OverrideStruct
):
1375 OverrideFieldStruct
= collections
.OrderedDict()
1377 for Key
, Values
in OverrideStruct
.items():
1378 if Values
[1] and Values
[1].endswith('.dsc'):
1379 OverrideFieldStruct
[Key
] = Values
1380 if Pcd
.PcdFieldValueFromFdf
:
1381 for Key
, Values
in Pcd
.PcdFieldValueFromFdf
.items():
1382 if Key
in OverrideFieldStruct
and Values
[0] == OverrideFieldStruct
[Key
][0]:
1384 OverrideFieldStruct
[Key
] = Values
1385 if Pcd
.PcdFieldValueFromComm
:
1386 for Key
, Values
in Pcd
.PcdFieldValueFromComm
.items():
1387 if Key
in OverrideFieldStruct
and Values
[0] == OverrideFieldStruct
[Key
][0]:
1389 OverrideFieldStruct
[Key
] = Values
1390 return OverrideFieldStruct
1392 def PrintStructureInfo(self
, File
, Struct
):
1393 for Key
, Value
in sorted(Struct
.items(), key
=lambda x
: x
[0]):
1394 if Value
[1] and 'build command options' in Value
[1]:
1395 FileWrite(File
, ' *B %-*s = %s' % (self
.MaxLen
+ 4, '.' + Key
, Value
[0]))
1396 elif Value
[1] and Value
[1].endswith('.fdf'):
1397 FileWrite(File
, ' *F %-*s = %s' % (self
.MaxLen
+ 4, '.' + Key
, Value
[0]))
1399 FileWrite(File
, ' %-*s = %s' % (self
.MaxLen
+ 4, '.' + Key
, Value
[0]))
1401 def StrtoHex(self
, value
):
1403 value
= hex(int(value
))
1406 if value
.startswith("L\"") and value
.endswith("\""):
1408 for ch
in value
[2:-1]:
1409 valuelist
.append(hex(ord(ch
)))
1410 valuelist
.append('0x00')
1412 elif value
.startswith("\"") and value
.endswith("\""):
1413 return hex(ord(value
[1:-1]))
1414 elif value
.startswith("{") and value
.endswith("}"):
1416 if ',' not in value
:
1418 for ch
in value
[1:-1].split(','):
1420 if ch
.startswith('0x') or ch
.startswith('0X'):
1421 valuelist
.append(ch
)
1424 valuelist
.append(hex(int(ch
.strip())))
1432 # Reports platform and module Prediction information
1434 # This class reports the platform execution order prediction section and
1435 # module load fixed address prediction subsection in the build report file.
1437 class PredictionReport(object):
1439 # Constructor function for class PredictionReport
1441 # This constructor function generates PredictionReport object for the platform.
1443 # @param self: The object pointer
1444 # @param Wa Workspace context information
1446 def __init__(self
, Wa
):
1447 self
._MapFileName
= os
.path
.join(Wa
.BuildDir
, Wa
.Name
+ ".map")
1448 self
._MapFileParsed
= False
1449 self
._EotToolInvoked
= False
1450 self
._FvDir
= Wa
.FvDir
1451 self
._EotDir
= Wa
.BuildDir
1452 self
._FfsEntryPoint
= {}
1454 self
._SourceList
= []
1455 self
.FixedMapDict
= {}
1460 # Collect all platform reference source files and GUID C Name
1462 for Pa
in Wa
.AutoGenObjectList
:
1463 for Module
in Pa
.LibraryAutoGenList
+ Pa
.ModuleAutoGenList
:
1465 # BASE typed modules are EFI agnostic, so we need not scan
1466 # their source code to find PPI/Protocol produce or consume
1469 if Module
.ModuleType
== SUP_MODULE_BASE
:
1472 # Add module referenced source files
1474 self
._SourceList
.append(str(Module
))
1476 for Source
in Module
.SourceFileList
:
1477 if os
.path
.splitext(str(Source
))[1].lower() == ".c":
1478 self
._SourceList
.append(" " + str(Source
))
1479 FindIncludeFiles(Source
.Path
, Module
.IncludePathList
, IncludeList
)
1480 for IncludeFile
in IncludeList
.values():
1481 self
._SourceList
.append(" " + IncludeFile
)
1483 for Guid
in Module
.PpiList
:
1484 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.PpiList
[Guid
])
1485 for Guid
in Module
.ProtocolList
:
1486 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.ProtocolList
[Guid
])
1487 for Guid
in Module
.GuidList
:
1488 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.GuidList
[Guid
])
1490 if Module
.Guid
and not Module
.IsLibrary
:
1491 EntryPoint
= " ".join(Module
.Module
.ModuleEntryPointList
)
1492 if int(str(Module
.AutoGenVersion
), 0) >= 0x00010005:
1493 RealEntryPoint
= "_ModuleEntryPoint"
1495 RealEntryPoint
= EntryPoint
1496 if EntryPoint
== "_ModuleEntryPoint":
1497 CCFlags
= Module
.BuildOption
.get("CC", {}).get("FLAGS", "")
1498 Match
= gGlueLibEntryPoint
.search(CCFlags
)
1500 EntryPoint
= Match
.group(1)
1502 self
._FfsEntryPoint
[Module
.Guid
.upper()] = (EntryPoint
, RealEntryPoint
)
1506 # Collect platform firmware volume list as the input of EOT.
1510 for Fd
in Wa
.FdfProfile
.FdDict
:
1511 for FdRegion
in Wa
.FdfProfile
.FdDict
[Fd
].RegionList
:
1512 if FdRegion
.RegionType
!= BINARY_FILE_TYPE_FV
:
1514 for FvName
in FdRegion
.RegionDataList
:
1515 if FvName
in self
._FvList
:
1517 self
._FvList
.append(FvName
)
1518 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1519 for Section
in Ffs
.SectionList
:
1521 for FvSection
in Section
.SectionList
:
1522 if FvSection
.FvName
in self
._FvList
:
1524 self
._FvList
.append(FvSection
.FvName
)
1525 except AttributeError:
1530 # Parse platform fixed address map files
1532 # This function parses the platform final fixed address map file to get
1533 # the database of predicted fixed address for module image base, entry point
1536 # @param self: The object pointer
1538 def _ParseMapFile(self
):
1539 if self
._MapFileParsed
:
1541 self
._MapFileParsed
= True
1542 if os
.path
.isfile(self
._MapFileName
):
1544 FileContents
= open(self
._MapFileName
).read()
1545 for Match
in gMapFileItemPattern
.finditer(FileContents
):
1546 AddressType
= Match
.group(1)
1547 BaseAddress
= Match
.group(2)
1548 EntryPoint
= Match
.group(3)
1549 Guid
= Match
.group(4).upper()
1550 List
= self
.FixedMapDict
.setdefault(Guid
, [])
1551 List
.append((AddressType
, BaseAddress
, "*I"))
1552 List
.append((AddressType
, EntryPoint
, "*E"))
1554 EdkLogger
.warn(None, "Cannot open file to read", self
._MapFileName
)
1557 # Invokes EOT tool to get the predicted the execution order.
1559 # This function invokes EOT tool to calculate the predicted dispatch order
1561 # @param self: The object pointer
1563 def _InvokeEotTool(self
):
1564 if self
._EotToolInvoked
:
1567 self
._EotToolInvoked
= True
1569 for FvName
in self
._FvList
:
1570 FvFile
= os
.path
.join(self
._FvDir
, FvName
+ ".Fv")
1571 if os
.path
.isfile(FvFile
):
1572 FvFileList
.append(FvFile
)
1574 if len(FvFileList
) == 0:
1577 # Write source file list and GUID file list to an intermediate file
1578 # as the input for EOT tool and dispatch List as the output file
1581 SourceList
= os
.path
.join(self
._EotDir
, "SourceFile.txt")
1582 GuidList
= os
.path
.join(self
._EotDir
, "GuidList.txt")
1583 DispatchList
= os
.path
.join(self
._EotDir
, "Dispatch.txt")
1585 TempFile
= open(SourceList
, "w+")
1586 for Item
in self
._SourceList
:
1587 FileWrite(TempFile
, Item
)
1589 TempFile
= open(GuidList
, "w+")
1590 for Key
in self
._GuidMap
:
1591 FileWrite(TempFile
, "%s %s" % (Key
, self
._GuidMap
[Key
]))
1595 from Eot
.Eot
import Eot
1598 # Invoke EOT tool and echo its runtime performance
1600 EotStartTime
= time
.time()
1601 Eot(CommandLineOption
=False, SourceFileList
=SourceList
, GuidList
=GuidList
,
1602 FvFileList
=' '.join(FvFileList
), Dispatch
=DispatchList
, IsInit
=True)
1603 EotEndTime
= time
.time()
1604 EotDuration
= time
.strftime("%H:%M:%S", time
.gmtime(int(round(EotEndTime
- EotStartTime
))))
1605 EdkLogger
.quiet("EOT run time: %s\n" % EotDuration
)
1608 # Parse the output of EOT tool
1610 for Line
in open(DispatchList
):
1611 if len(Line
.split()) < 4:
1613 (Guid
, Phase
, FfsName
, FilePath
) = Line
.split()
1614 Symbol
= self
._FfsEntryPoint
.get(Guid
, [FfsName
, ""])[0]
1615 if len(Symbol
) > self
.MaxLen
:
1616 self
.MaxLen
= len(Symbol
)
1617 self
.ItemList
.append((Phase
, Symbol
, FilePath
))
1619 EdkLogger
.quiet("(Python %s on %s\n%s)" % (platform
.python_version(), sys
.platform
, traceback
.format_exc()))
1620 EdkLogger
.warn(None, "Failed to generate execution order prediction report, for some error occurred in executing EOT.")
1624 # Generate platform execution order report
1626 # This function generates the predicted module execution order.
1628 # @param self The object pointer
1629 # @param File The file object for report
1631 def _GenerateExecutionOrderReport(self
, File
):
1632 self
._InvokeEotTool
()
1633 if len(self
.ItemList
) == 0:
1635 FileWrite(File
, gSectionStart
)
1636 FileWrite(File
, "Execution Order Prediction")
1637 FileWrite(File
, "*P PEI phase")
1638 FileWrite(File
, "*D DXE phase")
1639 FileWrite(File
, "*E Module INF entry point name")
1640 FileWrite(File
, "*N Module notification function name")
1642 FileWrite(File
, "Type %-*s %s" % (self
.MaxLen
, "Symbol", "Module INF Path"))
1643 FileWrite(File
, gSectionSep
)
1644 for Item
in self
.ItemList
:
1645 FileWrite(File
, "*%sE %-*s %s" % (Item
[0], self
.MaxLen
, Item
[1], Item
[2]))
1647 FileWrite(File
, gSectionStart
)
1650 # Generate Fixed Address report.
1652 # This function generate the predicted fixed address report for a module
1653 # specified by Guid.
1655 # @param self The object pointer
1656 # @param File The file object for report
1657 # @param Guid The module Guid value.
1658 # @param NotifyList The list of all notify function in a module
1660 def _GenerateFixedAddressReport(self
, File
, Guid
, NotifyList
):
1661 self
._ParseMapFile
()
1662 FixedAddressList
= self
.FixedMapDict
.get(Guid
)
1663 if not FixedAddressList
:
1666 FileWrite(File
, gSubSectionStart
)
1667 FileWrite(File
, "Fixed Address Prediction")
1668 FileWrite(File
, "*I Image Loading Address")
1669 FileWrite(File
, "*E Entry Point Address")
1670 FileWrite(File
, "*N Notification Function Address")
1671 FileWrite(File
, "*F Flash Address")
1672 FileWrite(File
, "*M Memory Address")
1673 FileWrite(File
, "*S SMM RAM Offset")
1674 FileWrite(File
, "TOM Top of Memory")
1676 FileWrite(File
, "Type Address Name")
1677 FileWrite(File
, gSubSectionSep
)
1678 for Item
in FixedAddressList
:
1683 Name
= "(Image Base)"
1684 elif Symbol
== "*E":
1685 Name
= self
._FfsEntryPoint
.get(Guid
, ["", "_ModuleEntryPoint"])[1]
1686 elif Symbol
in NotifyList
:
1694 elif "Memory" in Type
:
1700 Value
= "TOM" + Value
1702 FileWrite(File
, "%s %-16s %s" % (Symbol
, Value
, Name
))
1705 # Generate report for the prediction part
1707 # This function generate the predicted fixed address report for a module or
1708 # predicted module execution order for a platform.
1709 # If the input Guid is None, then, it generates the predicted module execution order;
1710 # otherwise it generated the module fixed loading address for the module specified by
1713 # @param self The object pointer
1714 # @param File The file object for report
1715 # @param Guid The module Guid value.
1717 def GenerateReport(self
, File
, Guid
):
1719 self
._GenerateFixedAddressReport
(File
, Guid
.upper(), [])
1721 self
._GenerateExecutionOrderReport
(File
)
1724 # Reports FD region information
1726 # This class reports the FD subsection in the build report file.
1727 # It collects region information of platform flash device.
1728 # If the region is a firmware volume, it lists the set of modules
1729 # and its space information; otherwise, it only lists its region name,
1730 # base address and size in its sub-section header.
1731 # If there are nesting FVs, the nested FVs will list immediate after
1732 # this FD region subsection
1734 class FdRegionReport(object):
1736 # Discover all the nested FV name list.
1738 # This is an internal worker function to discover the all the nested FV information
1739 # in the parent firmware volume. It uses deep first search algorithm recursively to
1740 # find all the FV list name and append them to the list.
1742 # @param self The object pointer
1743 # @param FvName The name of current firmware file system
1744 # @param Wa Workspace context information
1746 def _DiscoverNestedFvList(self
, FvName
, Wa
):
1747 FvDictKey
=FvName
.upper()
1748 if FvDictKey
in Wa
.FdfProfile
.FvDict
:
1749 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1750 for Section
in Ffs
.SectionList
:
1752 for FvSection
in Section
.SectionList
:
1753 if FvSection
.FvName
in self
.FvList
:
1755 self
._GuidsDb
[Ffs
.NameGuid
.upper()] = FvSection
.FvName
1756 self
.FvList
.append(FvSection
.FvName
)
1757 self
.FvInfo
[FvSection
.FvName
] = ("Nested FV", 0, 0)
1758 self
._DiscoverNestedFvList
(FvSection
.FvName
, Wa
)
1759 except AttributeError:
1763 # Constructor function for class FdRegionReport
1765 # This constructor function generates FdRegionReport object for a specified FdRegion.
1766 # If the FdRegion is a firmware volume, it will recursively find all its nested Firmware
1767 # volume list. This function also collects GUID map in order to dump module identification
1768 # in the final report.
1770 # @param self: The object pointer
1771 # @param FdRegion The current FdRegion object
1772 # @param Wa Workspace context information
1774 def __init__(self
, FdRegion
, Wa
):
1775 self
.Type
= FdRegion
.RegionType
1776 self
.BaseAddress
= FdRegion
.Offset
1777 self
.Size
= FdRegion
.Size
1781 self
._FvDir
= Wa
.FvDir
1782 self
._WorkspaceDir
= Wa
.WorkspaceDir
1785 # If the input FdRegion is not a firmware volume,
1788 if self
.Type
!= BINARY_FILE_TYPE_FV
:
1792 # Find all nested FVs in the FdRegion
1794 for FvName
in FdRegion
.RegionDataList
:
1795 if FvName
in self
.FvList
:
1797 self
.FvList
.append(FvName
)
1798 self
.FvInfo
[FvName
] = ("Fd Region", self
.BaseAddress
, self
.Size
)
1799 self
._DiscoverNestedFvList
(FvName
, Wa
)
1803 # Collect PCDs declared in DEC files.
1805 for Pa
in Wa
.AutoGenObjectList
:
1806 for Package
in Pa
.PackageList
:
1807 for (TokenCName
, TokenSpaceGuidCName
, DecType
) in Package
.Pcds
:
1808 DecDefaultValue
= Package
.Pcds
[TokenCName
, TokenSpaceGuidCName
, DecType
].DefaultValue
1809 PlatformPcds
[(TokenCName
, TokenSpaceGuidCName
)] = DecDefaultValue
1811 # Collect PCDs defined in DSC file
1813 for Pa
in Wa
.AutoGenObjectList
:
1814 for (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
1815 DscDefaultValue
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)].DefaultValue
1816 PlatformPcds
[(TokenCName
, TokenSpaceGuidCName
)] = DscDefaultValue
1819 # Add PEI and DXE a priori files GUIDs defined in PI specification.
1821 self
._GuidsDb
["1B45CC0A-156A-428A-AF62-49864DA0E6E6"] = "PEI Apriori"
1822 self
._GuidsDb
["FC510EE7-FFDC-11D4-BD41-0080C73C8881"] = "DXE Apriori"
1824 # Add ACPI table storage file
1826 self
._GuidsDb
["7E374E25-8E01-4FEE-87F2-390C23C606CD"] = "ACPI table storage"
1828 for Pa
in Wa
.AutoGenObjectList
:
1829 for ModuleKey
in Pa
.Platform
.Modules
:
1830 M
= Pa
.Platform
.Modules
[ModuleKey
].M
1831 InfPath
= mws
.join(Wa
.WorkspaceDir
, M
.MetaFile
.File
)
1832 self
._GuidsDb
[M
.Guid
.upper()] = "%s (%s)" % (M
.Module
.BaseName
, InfPath
)
1835 # Collect the GUID map in the FV firmware volume
1837 for FvName
in self
.FvList
:
1838 FvDictKey
=FvName
.upper()
1839 if FvDictKey
in Wa
.FdfProfile
.FvDict
:
1840 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1843 # collect GUID map for binary EFI file in FDF file.
1845 Guid
= Ffs
.NameGuid
.upper()
1846 Match
= gPcdGuidPattern
.match(Ffs
.NameGuid
)
1848 PcdTokenspace
= Match
.group(1)
1849 PcdToken
= Match
.group(2)
1850 if (PcdToken
, PcdTokenspace
) in PlatformPcds
:
1851 GuidValue
= PlatformPcds
[(PcdToken
, PcdTokenspace
)]
1852 Guid
= GuidStructureByteArrayToGuidString(GuidValue
).upper()
1853 for Section
in Ffs
.SectionList
:
1855 ModuleSectFile
= mws
.join(Wa
.WorkspaceDir
, Section
.SectFileName
)
1856 self
._GuidsDb
[Guid
] = ModuleSectFile
1857 except AttributeError:
1859 except AttributeError:
1864 # Internal worker function to generate report for the FD region
1866 # This internal worker function to generate report for the FD region.
1867 # It the type is firmware volume, it lists offset and module identification.
1869 # @param self The object pointer
1870 # @param File The file object for report
1871 # @param Title The title for the FD subsection
1872 # @param BaseAddress The base address for the FD region
1873 # @param Size The size of the FD region
1874 # @param FvName The FV name if the FD region is a firmware volume
1876 def _GenerateReport(self
, File
, Title
, Type
, BaseAddress
, Size
=0, FvName
=None):
1877 FileWrite(File
, gSubSectionStart
)
1878 FileWrite(File
, Title
)
1879 FileWrite(File
, "Type: %s" % Type
)
1880 FileWrite(File
, "Base Address: 0x%X" % BaseAddress
)
1882 if self
.Type
== BINARY_FILE_TYPE_FV
:
1886 if FvName
.upper().endswith('.FV'):
1887 FileExt
= FvName
+ ".txt"
1889 FileExt
= FvName
+ ".Fv.txt"
1891 if not os
.path
.isfile(FileExt
):
1892 FvReportFileName
= mws
.join(self
._WorkspaceDir
, FileExt
)
1893 if not os
.path
.isfile(FvReportFileName
):
1894 FvReportFileName
= os
.path
.join(self
._FvDir
, FileExt
)
1897 # Collect size info in the firmware volume.
1899 FvReport
= open(FvReportFileName
).read()
1900 Match
= gFvTotalSizePattern
.search(FvReport
)
1902 FvTotalSize
= int(Match
.group(1), 16)
1903 Match
= gFvTakenSizePattern
.search(FvReport
)
1905 FvTakenSize
= int(Match
.group(1), 16)
1906 FvFreeSize
= FvTotalSize
- FvTakenSize
1908 # Write size information to the report file.
1910 FileWrite(File
, "Size: 0x%X (%.0fK)" % (FvTotalSize
, FvTotalSize
/ 1024.0))
1911 FileWrite(File
, "Fv Name: %s (%.1f%% Full)" % (FvName
, FvTakenSize
* 100.0 / FvTotalSize
))
1912 FileWrite(File
, "Occupied Size: 0x%X (%.0fK)" % (FvTakenSize
, FvTakenSize
/ 1024.0))
1913 FileWrite(File
, "Free Size: 0x%X (%.0fK)" % (FvFreeSize
, FvFreeSize
/ 1024.0))
1914 FileWrite(File
, "Offset Module")
1915 FileWrite(File
, gSubSectionSep
)
1917 # Write module offset and module identification to the report file.
1920 for Match
in gOffsetGuidPattern
.finditer(FvReport
):
1921 Guid
= Match
.group(2).upper()
1922 OffsetInfo
[Match
.group(1)] = self
._GuidsDb
.get(Guid
, Guid
)
1923 OffsetList
= sorted(OffsetInfo
.keys())
1924 for Offset
in OffsetList
:
1925 FileWrite (File
, "%s %s" % (Offset
, OffsetInfo
[Offset
]))
1927 EdkLogger
.warn(None, "Fail to read report file", FvReportFileName
)
1929 FileWrite(File
, "Size: 0x%X (%.0fK)" % (Size
, Size
/ 1024.0))
1930 FileWrite(File
, gSubSectionEnd
)
1933 # Generate report for the FD region
1935 # This function generates report for the FD region.
1937 # @param self The object pointer
1938 # @param File The file object for report
1940 def GenerateReport(self
, File
):
1941 if (len(self
.FvList
) > 0):
1942 for FvItem
in self
.FvList
:
1943 Info
= self
.FvInfo
[FvItem
]
1944 self
._GenerateReport
(File
, Info
[0], TAB_FV_DIRECTORY
, Info
[1], Info
[2], FvItem
)
1946 self
._GenerateReport
(File
, "FD Region", self
.Type
, self
.BaseAddress
, self
.Size
)
1949 # Reports FD information
1951 # This class reports the FD section in the build report file.
1952 # It collects flash device information for a platform.
1954 class FdReport(object):
1956 # Constructor function for class FdReport
1958 # This constructor function generates FdReport object for a specified
1961 # @param self The object pointer
1962 # @param Fd The current Firmware device object
1963 # @param Wa Workspace context information
1965 def __init__(self
, Fd
, Wa
):
1966 self
.FdName
= Fd
.FdUiName
1967 self
.BaseAddress
= Fd
.BaseAddress
1969 self
.FdRegionList
= [FdRegionReport(FdRegion
, Wa
) for FdRegion
in Fd
.RegionList
]
1970 self
.FvPath
= os
.path
.join(Wa
.BuildDir
, TAB_FV_DIRECTORY
)
1971 self
.VpdFilePath
= os
.path
.join(self
.FvPath
, "%s.map" % Wa
.Platform
.VpdToolGuid
)
1972 self
.VPDBaseAddress
= 0
1974 self
.VPDInfoList
= []
1975 for index
, FdRegion
in enumerate(Fd
.RegionList
):
1976 if str(FdRegion
.RegionType
) is 'FILE' and Wa
.Platform
.VpdToolGuid
in str(FdRegion
.RegionDataList
):
1977 self
.VPDBaseAddress
= self
.FdRegionList
[index
].BaseAddress
1978 self
.VPDSize
= self
.FdRegionList
[index
].Size
1981 if os
.path
.isfile(self
.VpdFilePath
):
1982 fd
= open(self
.VpdFilePath
, "r")
1983 Lines
= fd
.readlines()
1986 if len(Line
) == 0 or Line
.startswith("#"):
1989 PcdName
, SkuId
, Offset
, Size
, Value
= Line
.split("#")[0].split("|")
1990 PcdName
, SkuId
, Offset
, Size
, Value
= PcdName
.strip(), SkuId
.strip(), Offset
.strip(), Size
.strip(), Value
.strip()
1991 if Offset
.lower().startswith('0x'):
1992 Offset
= '0x%08X' % (int(Offset
, 16) + self
.VPDBaseAddress
)
1994 Offset
= '0x%08X' % (int(Offset
, 10) + self
.VPDBaseAddress
)
1995 self
.VPDInfoList
.append("%s | %s | %s | %s | %s" % (PcdName
, SkuId
, Offset
, Size
, Value
))
1997 EdkLogger
.error("BuildReport", CODE_ERROR
, "Fail to parse VPD information file %s" % self
.VpdFilePath
)
2001 # Generate report for the firmware device.
2003 # This function generates report for the firmware device.
2005 # @param self The object pointer
2006 # @param File The file object for report
2008 def GenerateReport(self
, File
):
2009 FileWrite(File
, gSectionStart
)
2010 FileWrite(File
, "Firmware Device (FD)")
2011 FileWrite(File
, "FD Name: %s" % self
.FdName
)
2012 FileWrite(File
, "Base Address: %s" % self
.BaseAddress
)
2013 FileWrite(File
, "Size: 0x%X (%.0fK)" % (self
.Size
, self
.Size
/ 1024.0))
2014 if len(self
.FdRegionList
) > 0:
2015 FileWrite(File
, gSectionSep
)
2016 for FdRegionItem
in self
.FdRegionList
:
2017 FdRegionItem
.GenerateReport(File
)
2019 if len(self
.VPDInfoList
) > 0:
2020 FileWrite(File
, gSubSectionStart
)
2021 FileWrite(File
, "FD VPD Region")
2022 FileWrite(File
, "Base Address: 0x%X" % self
.VPDBaseAddress
)
2023 FileWrite(File
, "Size: 0x%X (%.0fK)" % (self
.VPDSize
, self
.VPDSize
/ 1024.0))
2024 FileWrite(File
, gSubSectionSep
)
2025 for item
in self
.VPDInfoList
:
2026 ValueList
= item
.split('|')
2027 Value
= ValueList
[-1].strip()
2028 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
2030 ValueList
[-1] = ' {'
2031 FileWrite(File
, '|'.join(ValueList
))
2032 for Array
in ArrayList
:
2033 FileWrite(File
, Array
)
2035 FileWrite(File
, item
)
2036 FileWrite(File
, gSubSectionEnd
)
2037 FileWrite(File
, gSectionEnd
)
2042 # Reports platform information
2044 # This class reports the whole platform information
2046 class PlatformReport(object):
2048 # Constructor function for class PlatformReport
2050 # This constructor function generates PlatformReport object a platform build.
2051 # It generates report for platform summary, flash, global PCDs and detailed
2052 # module information for modules involved in platform build.
2054 # @param self The object pointer
2055 # @param Wa Workspace context information
2056 # @param MaList The list of modules in the platform build
2058 def __init__(self
, Wa
, MaList
, ReportType
):
2059 self
._WorkspaceDir
= Wa
.WorkspaceDir
2060 self
.PlatformName
= Wa
.Name
2061 self
.PlatformDscPath
= Wa
.Platform
2062 self
.Architectures
= " ".join(Wa
.ArchList
)
2063 self
.ToolChain
= Wa
.ToolChain
2064 self
.Target
= Wa
.BuildTarget
2065 self
.OutputPath
= os
.path
.join(Wa
.WorkspaceDir
, Wa
.OutputDir
)
2066 self
.BuildEnvironment
= platform
.platform()
2068 self
.PcdReport
= None
2069 if "PCD" in ReportType
:
2070 self
.PcdReport
= PcdReport(Wa
)
2072 self
.FdReportList
= []
2073 if "FLASH" in ReportType
and Wa
.FdfProfile
and MaList
is None:
2074 for Fd
in Wa
.FdfProfile
.FdDict
:
2075 self
.FdReportList
.append(FdReport(Wa
.FdfProfile
.FdDict
[Fd
], Wa
))
2077 self
.PredictionReport
= None
2078 if "FIXED_ADDRESS" in ReportType
or "EXECUTION_ORDER" in ReportType
:
2079 self
.PredictionReport
= PredictionReport(Wa
)
2081 self
.DepexParser
= None
2082 if "DEPEX" in ReportType
:
2083 self
.DepexParser
= DepexParser(Wa
)
2085 self
.ModuleReportList
= []
2086 if MaList
is not None:
2087 self
._IsModuleBuild
= True
2089 self
.ModuleReportList
.append(ModuleReport(Ma
, ReportType
))
2091 self
._IsModuleBuild
= False
2092 for Pa
in Wa
.AutoGenObjectList
:
2093 ModuleAutoGenList
= []
2094 for ModuleKey
in Pa
.Platform
.Modules
:
2095 ModuleAutoGenList
.append(Pa
.Platform
.Modules
[ModuleKey
].M
)
2096 if GlobalData
.gFdfParser
is not None:
2097 if Pa
.Arch
in GlobalData
.gFdfParser
.Profile
.InfDict
:
2098 INFList
= GlobalData
.gFdfParser
.Profile
.InfDict
[Pa
.Arch
]
2099 for InfName
in INFList
:
2100 InfClass
= PathClass(NormPath(InfName
), Wa
.WorkspaceDir
, Pa
.Arch
)
2101 Ma
= ModuleAutoGen(Wa
, InfClass
, Pa
.BuildTarget
, Pa
.ToolChain
, Pa
.Arch
, Wa
.MetaFile
)
2104 if Ma
not in ModuleAutoGenList
:
2105 ModuleAutoGenList
.append(Ma
)
2106 for MGen
in ModuleAutoGenList
:
2107 self
.ModuleReportList
.append(ModuleReport(MGen
, ReportType
))
2112 # Generate report for the whole platform.
2114 # This function generates report for platform information.
2115 # It comprises of platform summary, global PCD, flash and
2116 # module list sections.
2118 # @param self The object pointer
2119 # @param File The file object for report
2120 # @param BuildDuration The total time to build the modules
2121 # @param AutoGenTime The total time of AutoGen Phase
2122 # @param MakeTime The total time of Make Phase
2123 # @param GenFdsTime The total time of GenFds Phase
2124 # @param ReportType The kind of report items in the final report file
2126 def GenerateReport(self
, File
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
, ReportType
):
2127 FileWrite(File
, "Platform Summary")
2128 FileWrite(File
, "Platform Name: %s" % self
.PlatformName
)
2129 FileWrite(File
, "Platform DSC Path: %s" % self
.PlatformDscPath
)
2130 FileWrite(File
, "Architectures: %s" % self
.Architectures
)
2131 FileWrite(File
, "Tool Chain: %s" % self
.ToolChain
)
2132 FileWrite(File
, "Target: %s" % self
.Target
)
2133 if GlobalData
.gSkuids
:
2134 FileWrite(File
, "SKUID: %s" % " ".join(GlobalData
.gSkuids
))
2135 if GlobalData
.gDefaultStores
:
2136 FileWrite(File
, "DefaultStore: %s" % " ".join(GlobalData
.gDefaultStores
))
2137 FileWrite(File
, "Output Path: %s" % self
.OutputPath
)
2138 FileWrite(File
, "Build Environment: %s" % self
.BuildEnvironment
)
2139 FileWrite(File
, "Build Duration: %s" % BuildDuration
)
2141 FileWrite(File
, "AutoGen Duration: %s" % AutoGenTime
)
2143 FileWrite(File
, "Make Duration: %s" % MakeTime
)
2145 FileWrite(File
, "GenFds Duration: %s" % GenFdsTime
)
2146 FileWrite(File
, "Report Content: %s" % ", ".join(ReportType
))
2148 if GlobalData
.MixedPcd
:
2149 FileWrite(File
, gSectionStart
)
2150 FileWrite(File
, "The following PCDs use different access methods:")
2151 FileWrite(File
, gSectionSep
)
2152 for PcdItem
in GlobalData
.MixedPcd
:
2153 FileWrite(File
, "%s.%s" % (str(PcdItem
[1]), str(PcdItem
[0])))
2154 FileWrite(File
, gSectionEnd
)
2156 if not self
._IsModuleBuild
:
2157 if "PCD" in ReportType
:
2158 self
.PcdReport
.GenerateReport(File
, None)
2160 if "FLASH" in ReportType
:
2161 for FdReportListItem
in self
.FdReportList
:
2162 FdReportListItem
.GenerateReport(File
)
2164 for ModuleReportItem
in self
.ModuleReportList
:
2165 ModuleReportItem
.GenerateReport(File
, self
.PcdReport
, self
.PredictionReport
, self
.DepexParser
, ReportType
)
2167 if not self
._IsModuleBuild
:
2168 if "EXECUTION_ORDER" in ReportType
:
2169 self
.PredictionReport
.GenerateReport(File
, None)
2171 ## BuildReport class
2173 # This base class contain the routines to collect data and then
2174 # applies certain format to the output report
2176 class BuildReport(object):
2178 # Constructor function for class BuildReport
2180 # This constructor function generates BuildReport object a platform build.
2181 # It generates report for platform summary, flash, global PCDs and detailed
2182 # module information for modules involved in platform build.
2184 # @param self The object pointer
2185 # @param ReportFile The file name to save report file
2186 # @param ReportType The kind of report items in the final report file
2188 def __init__(self
, ReportFile
, ReportType
):
2189 self
.ReportFile
= ReportFile
2191 self
.ReportList
= []
2192 self
.ReportType
= []
2194 for ReportTypeItem
in ReportType
:
2195 if ReportTypeItem
not in self
.ReportType
:
2196 self
.ReportType
.append(ReportTypeItem
)
2198 self
.ReportType
= ["PCD", "LIBRARY", "BUILD_FLAGS", "DEPEX", "HASH", "FLASH", "FIXED_ADDRESS"]
2200 # Adds platform report to the list
2202 # This function adds a platform report to the final report list.
2204 # @param self The object pointer
2205 # @param Wa Workspace context information
2206 # @param MaList The list of modules in the platform build
2208 def AddPlatformReport(self
, Wa
, MaList
=None):
2210 self
.ReportList
.append((Wa
, MaList
))
2213 # Generates the final report.
2215 # This function generates platform build report. It invokes GenerateReport()
2216 # method for every platform report in the list.
2218 # @param self The object pointer
2219 # @param BuildDuration The total time to build the modules
2220 # @param AutoGenTime The total time of AutoGen phase
2221 # @param MakeTime The total time of Make phase
2222 # @param GenFdsTime The total time of GenFds phase
2224 def GenerateReport(self
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
):
2228 for (Wa
, MaList
) in self
.ReportList
:
2229 PlatformReport(Wa
, MaList
, self
.ReportType
).GenerateReport(File
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
, self
.ReportType
)
2230 Content
= FileLinesSplit(File
.getvalue(), gLineMaxLength
)
2231 SaveFileOnChange(self
.ReportFile
, Content
, True)
2232 EdkLogger
.quiet("Build report can be found at %s" % os
.path
.abspath(self
.ReportFile
))
2234 EdkLogger
.error(None, FILE_WRITE_FAILURE
, ExtraData
=self
.ReportFile
)
2236 EdkLogger
.error("BuildReport", CODE_ERROR
, "Unknown fatal error when generating build report", ExtraData
=self
.ReportFile
, RaiseError
=False)
2237 EdkLogger
.quiet("(Python %s on %s\n%s)" % (platform
.python_version(), sys
.platform
, traceback
.format_exc()))
2240 # This acts like the main() function for the script, unless it is 'import'ed into another script.
2241 if __name__
== '__main__':