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 *
49 from GenFds
.AprioriSection
import DXE_APRIORI_GUID
, PEI_APRIORI_GUID
51 ## Pattern to extract contents in EDK DXS files
52 gDxsDependencyPattern
= re
.compile(r
"DEPENDENCY_START(.+)DEPENDENCY_END", re
.DOTALL
)
54 ## Pattern to find total FV total size, occupied size in flash report intermediate file
55 gFvTotalSizePattern
= re
.compile(r
"EFI_FV_TOTAL_SIZE = (0x[0-9a-fA-F]+)")
56 gFvTakenSizePattern
= re
.compile(r
"EFI_FV_TAKEN_SIZE = (0x[0-9a-fA-F]+)")
58 ## Pattern to find module size and time stamp in module summary report intermediate file
59 gModuleSizePattern
= re
.compile(r
"MODULE_SIZE = (\d+)")
60 gTimeStampPattern
= re
.compile(r
"TIME_STAMP = (\d+)")
62 ## Pattern to find GUID value in flash description files
63 gPcdGuidPattern
= re
.compile(r
"PCD\((\w+)[.](\w+)\)")
65 ## Pattern to collect offset, GUID value pair in the flash report intermediate file
66 gOffsetGuidPattern
= re
.compile(r
"(0x[0-9A-Fa-f]+) ([-A-Fa-f0-9]+)")
68 ## Pattern to find module base address and entry point in fixed flash map file
69 gModulePattern
= r
"\n[-\w]+\s*\(([^,]+),\s*BaseAddress=%(Address)s,\s*EntryPoint=%(Address)s\)\s*\(GUID=([-0-9A-Fa-f]+)[^)]*\)"
70 gMapFileItemPattern
= re
.compile(gModulePattern
% {"Address" : "(-?0[xX][0-9A-Fa-f]+)"})
72 ## Pattern to find all module referenced header files in source files
73 gIncludePattern
= re
.compile(r
'#include\s*["<]([^">]+)[">]')
74 gIncludePattern2
= re
.compile(r
"#include\s+EFI_([A-Z_]+)\s*[(]\s*(\w+)\s*[)]")
76 ## Pattern to find the entry point for EDK module using EDKII Glue library
77 gGlueLibEntryPoint
= re
.compile(r
"__EDKII_GLUE_MODULE_ENTRY_POINT__\s*=\s*(\w+)")
79 ## Tags for MaxLength of line in report
82 ## Tags for end of line in report
85 ## Tags for section start, end and separator
86 gSectionStart
= ">" + "=" * (gLineMaxLength
- 2) + "<"
87 gSectionEnd
= "<" + "=" * (gLineMaxLength
- 2) + ">" + "\n"
88 gSectionSep
= "=" * gLineMaxLength
90 ## Tags for subsection start, end and separator
91 gSubSectionStart
= ">" + "-" * (gLineMaxLength
- 2) + "<"
92 gSubSectionEnd
= "<" + "-" * (gLineMaxLength
- 2) + ">"
93 gSubSectionSep
= "-" * gLineMaxLength
96 ## The look up table to map PCD type to pair of report display type and DEC type
98 TAB_PCDS_FIXED_AT_BUILD
: ('FIXED', TAB_PCDS_FIXED_AT_BUILD
),
99 TAB_PCDS_PATCHABLE_IN_MODULE
: ('PATCH', TAB_PCDS_PATCHABLE_IN_MODULE
),
100 TAB_PCDS_FEATURE_FLAG
: ('FLAG', TAB_PCDS_FEATURE_FLAG
),
101 TAB_PCDS_DYNAMIC
: ('DYN', TAB_PCDS_DYNAMIC
),
102 TAB_PCDS_DYNAMIC_HII
: ('DYNHII', TAB_PCDS_DYNAMIC
),
103 TAB_PCDS_DYNAMIC_VPD
: ('DYNVPD', TAB_PCDS_DYNAMIC
),
104 TAB_PCDS_DYNAMIC_EX
: ('DEX', TAB_PCDS_DYNAMIC_EX
),
105 TAB_PCDS_DYNAMIC_EX_HII
: ('DEXHII', TAB_PCDS_DYNAMIC_EX
),
106 TAB_PCDS_DYNAMIC_EX_VPD
: ('DEXVPD', TAB_PCDS_DYNAMIC_EX
),
109 ## The look up table to map module type to driver type
111 SUP_MODULE_SEC
: '0x3 (SECURITY_CORE)',
112 SUP_MODULE_PEI_CORE
: '0x4 (PEI_CORE)',
113 SUP_MODULE_PEIM
: '0x6 (PEIM)',
114 SUP_MODULE_DXE_CORE
: '0x5 (DXE_CORE)',
115 SUP_MODULE_DXE_DRIVER
: '0x7 (DRIVER)',
116 SUP_MODULE_DXE_SAL_DRIVER
: '0x7 (DRIVER)',
117 SUP_MODULE_DXE_SMM_DRIVER
: '0x7 (DRIVER)',
118 SUP_MODULE_DXE_RUNTIME_DRIVER
: '0x7 (DRIVER)',
119 SUP_MODULE_UEFI_DRIVER
: '0x7 (DRIVER)',
120 SUP_MODULE_UEFI_APPLICATION
: '0x9 (APPLICATION)',
121 SUP_MODULE_SMM_CORE
: '0xD (SMM_CORE)',
122 'SMM_DRIVER' : '0xA (SMM)', # Extension of module type to support PI 1.1 SMM drivers
123 SUP_MODULE_MM_STANDALONE
: '0xE (MM_STANDALONE)',
124 SUP_MODULE_MM_CORE_STANDALONE
: '0xF (MM_CORE_STANDALONE)'
127 ## The look up table of the supported opcode in the dependency expression binaries
128 gOpCodeList
= ["BEFORE", "AFTER", "PUSH", "AND", "OR", "NOT", "TRUE", "FALSE", "END", "SOR"]
134 # Writes a string to the file object.
136 # This function writes a string to the file object and a new line is appended
137 # afterwards. It may optionally wraps the string for better readability.
139 # @File The file object to write
140 # @String The string to be written to the file
141 # @Wrapper Indicates whether to wrap the string
143 def FileWrite(File
, String
, Wrapper
=False):
145 String
= textwrap
.fill(String
, 120)
146 File
.write(String
+ gEndOfLine
)
148 def ByteArrayForamt(Value
):
152 if Value
.startswith('{') and Value
.endswith('}'):
154 ValueList
= Value
.split(',')
155 if len(ValueList
) >= SplitNum
:
159 Len
= len(ValueList
)/SplitNum
160 for i
, element
in enumerate(ValueList
):
161 ValueList
[i
] = '0x%02X' % int(element
.strip(), 16)
165 End
= min(SplitNum
*(Id
+1), len(ValueList
))
166 Str
= ','.join(ValueList
[SplitNum
*Id
: End
])
167 if End
== len(ValueList
):
169 ArrayList
.append(Str
)
173 ArrayList
.append(Str
)
176 ArrayList
= [Value
+ '}']
177 return IsByteArray
, ArrayList
180 # Find all the header file that the module source directly includes.
182 # This function scans source code to find all header files the module may
183 # include. This is not accurate but very effective to find all the header
184 # file the module might include with #include statement.
186 # @Source The source file name
187 # @IncludePathList The list of include path to find the source file.
188 # @IncludeFiles The dictionary of current found include files.
190 def FindIncludeFiles(Source
, IncludePathList
, IncludeFiles
):
191 FileContents
= open(Source
).read()
193 # Find header files with pattern #include "XXX.h" or #include <XXX.h>
195 for Match
in gIncludePattern
.finditer(FileContents
):
196 FileName
= Match
.group(1).strip()
197 for Dir
in [os
.path
.dirname(Source
)] + IncludePathList
:
198 FullFileName
= os
.path
.normpath(os
.path
.join(Dir
, FileName
))
199 if os
.path
.exists(FullFileName
):
200 IncludeFiles
[FullFileName
.lower().replace("\\", "/")] = FullFileName
204 # Find header files with pattern like #include EFI_PPI_CONSUMER(XXX)
206 for Match
in gIncludePattern2
.finditer(FileContents
):
208 Type
= Match
.group(1)
209 if "ARCH_PROTOCOL" in Type
:
210 FileName
= "ArchProtocol/%(Key)s/%(Key)s.h" % {"Key" : Key
}
211 elif "PROTOCOL" in Type
:
212 FileName
= "Protocol/%(Key)s/%(Key)s.h" % {"Key" : Key
}
214 FileName
= "Ppi/%(Key)s/%(Key)s.h" % {"Key" : Key
}
215 elif TAB_GUID
in Type
:
216 FileName
= "Guid/%(Key)s/%(Key)s.h" % {"Key" : Key
}
219 for Dir
in IncludePathList
:
220 FullFileName
= os
.path
.normpath(os
.path
.join(Dir
, FileName
))
221 if os
.path
.exists(FullFileName
):
222 IncludeFiles
[FullFileName
.lower().replace("\\", "/")] = FullFileName
225 ## Split each lines in file
227 # This method is used to split the lines in file to make the length of each line
228 # less than MaxLength.
230 # @param Content The content of file
231 # @param MaxLength The Max Length of the line
233 def FileLinesSplit(Content
=None, MaxLength
=None):
234 ContentList
= Content
.split(TAB_LINE_BREAK
)
237 for Line
in ContentList
:
238 while len(Line
.rstrip()) > MaxLength
:
239 LineSpaceIndex
= Line
.rfind(TAB_SPACE_SPLIT
, 0, MaxLength
)
240 LineSlashIndex
= Line
.rfind(TAB_SLASH
, 0, MaxLength
)
241 LineBackSlashIndex
= Line
.rfind(TAB_BACK_SLASH
, 0, MaxLength
)
242 if max(LineSpaceIndex
, LineSlashIndex
, LineBackSlashIndex
) > 0:
243 LineBreakIndex
= max(LineSpaceIndex
, LineSlashIndex
, LineBackSlashIndex
)
245 LineBreakIndex
= MaxLength
246 NewContentList
.append(Line
[:LineBreakIndex
])
247 Line
= Line
[LineBreakIndex
:]
249 NewContentList
.append(Line
)
250 for NewLine
in NewContentList
:
251 NewContent
+= NewLine
+ TAB_LINE_BREAK
253 NewContent
= NewContent
.replace(TAB_LINE_BREAK
, gEndOfLine
).replace('\r\r\n', gEndOfLine
)
259 # Parse binary dependency expression section
261 # This utility class parses the dependency expression section and translate the readable
262 # GUID name and value.
264 class DepexParser(object):
266 # Constructor function for class DepexParser
268 # This constructor function collect GUID values so that the readable
269 # GUID name can be translated.
271 # @param self The object pointer
272 # @param Wa Workspace context information
274 def __init__(self
, Wa
):
276 for Pa
in Wa
.AutoGenObjectList
:
277 for Package
in Pa
.PackageList
:
278 for Protocol
in Package
.Protocols
:
279 GuidValue
= GuidStructureStringToGuidString(Package
.Protocols
[Protocol
])
280 self
._GuidDb
[GuidValue
.upper()] = Protocol
281 for Ppi
in Package
.Ppis
:
282 GuidValue
= GuidStructureStringToGuidString(Package
.Ppis
[Ppi
])
283 self
._GuidDb
[GuidValue
.upper()] = Ppi
284 for Guid
in Package
.Guids
:
285 GuidValue
= GuidStructureStringToGuidString(Package
.Guids
[Guid
])
286 self
._GuidDb
[GuidValue
.upper()] = Guid
287 for Ma
in Pa
.ModuleAutoGenList
:
288 for Pcd
in Ma
.FixedVoidTypePcds
:
289 PcdValue
= Ma
.FixedVoidTypePcds
[Pcd
]
290 if len(PcdValue
.split(',')) == 16:
291 GuidValue
= GuidStructureByteArrayToGuidString(PcdValue
)
292 self
._GuidDb
[GuidValue
.upper()] = Pcd
294 # Parse the binary dependency expression files.
296 # This function parses the binary dependency expression file and translate it
297 # to the instruction list.
299 # @param self The object pointer
300 # @param DepexFileName The file name of binary dependency expression file.
302 def ParseDepexFile(self
, DepexFileName
):
303 DepexFile
= open(DepexFileName
, "rb")
305 OpCode
= DepexFile
.read(1)
307 Statement
= gOpCodeList
[struct
.unpack("B", OpCode
)[0]]
308 if Statement
in ["BEFORE", "AFTER", "PUSH"]:
309 GuidValue
= "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X" % \
310 struct
.unpack(PACK_PATTERN_GUID
, DepexFile
.read(16))
311 GuidString
= self
._GuidDb
.get(GuidValue
, GuidValue
)
312 Statement
= "%s %s" % (Statement
, GuidString
)
313 DepexStatement
.append(Statement
)
314 OpCode
= DepexFile
.read(1)
316 return DepexStatement
319 # Reports library information
321 # This class reports the module library subsection in the build report file.
323 class LibraryReport(object):
325 # Constructor function for class LibraryReport
327 # This constructor function generates LibraryReport object for
330 # @param self The object pointer
331 # @param M Module context information
333 def __init__(self
, M
):
334 self
.LibraryList
= []
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
)
367 LibClass
= LibraryItem
[1]
369 LibConstructor
= " ".join(LibraryItem
[2])
371 EdkIILibInfo
+= " C = " + LibConstructor
372 LibDestructor
= " ".join(LibraryItem
[3])
374 EdkIILibInfo
+= " D = " + LibDestructor
375 LibDepex
= " ".join(LibraryItem
[4])
377 EdkIILibInfo
+= " Depex = " + LibDepex
379 EdkIILibInfo
+= " Time = " + LibraryItem
[5]
381 FileWrite(File
, "{%s: %s}" % (LibClass
, EdkIILibInfo
))
383 FileWrite(File
, "{%s}" % LibClass
)
385 FileWrite(File
, gSubSectionEnd
)
388 # Reports dependency expression information
390 # This class reports the module dependency expression subsection in the build report file.
392 class DepexReport(object):
394 # Constructor function for class DepexReport
396 # This constructor function generates DepexReport object for
397 # a module. If the module source contains the DXS file (usually EDK
398 # style module), it uses the dependency in DXS file; otherwise,
399 # it uses the dependency expression from its own INF [Depex] section
400 # and then merges with the ones from its dependent library INF.
402 # @param self The object pointer
403 # @param M Module context information
405 def __init__(self
, M
):
407 self
._DepexFileName
= os
.path
.join(M
.BuildDir
, "OUTPUT", M
.Module
.BaseName
+ ".depex")
408 ModuleType
= M
.ModuleType
410 ModuleType
= COMPONENT_TO_MODULE_MAP_DICT
.get(M
.ComponentType
, "")
412 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
]:
415 for Source
in M
.SourceFileList
:
416 if os
.path
.splitext(Source
.Path
)[1].lower() == ".dxs":
417 Match
= gDxsDependencyPattern
.search(open(Source
.Path
).read())
419 self
.Depex
= Match
.group(1).strip()
423 self
.Depex
= M
.DepexExpressionDict
.get(M
.ModuleType
, "")
424 self
.ModuleDepex
= " ".join(M
.Module
.DepexExpression
[M
.Arch
, M
.ModuleType
])
425 if not self
.ModuleDepex
:
426 self
.ModuleDepex
= "(None)"
429 for Lib
in M
.DependentLibraryList
:
430 LibDepex
= " ".join(Lib
.DepexExpression
[M
.Arch
, M
.ModuleType
]).strip()
432 LibDepexList
.append("(" + LibDepex
+ ")")
433 self
.LibraryDepex
= " AND ".join(LibDepexList
)
434 if not self
.LibraryDepex
:
435 self
.LibraryDepex
= "(None)"
439 # Generate report for module dependency expression information
441 # This function generates report for the module dependency expression.
443 # @param self The object pointer
444 # @param File The file object for report
445 # @param GlobalDepexParser The platform global Dependency expression parser object
447 def GenerateReport(self
, File
, GlobalDepexParser
):
450 FileWrite(File
, gSubSectionStart
)
451 if os
.path
.isfile(self
._DepexFileName
):
453 DepexStatements
= GlobalDepexParser
.ParseDepexFile(self
._DepexFileName
)
454 FileWrite(File
, "Final Dependency Expression (DEPEX) Instructions")
455 for DepexStatement
in DepexStatements
:
456 FileWrite(File
, " %s" % DepexStatement
)
457 FileWrite(File
, gSubSectionSep
)
459 EdkLogger
.warn(None, "Dependency expression file is corrupted", self
._DepexFileName
)
461 FileWrite(File
, "Dependency Expression (DEPEX) from %s" % self
.Source
)
463 if self
.Source
== "INF":
464 FileWrite(File
, self
.Depex
, True)
465 FileWrite(File
, gSubSectionSep
)
466 FileWrite(File
, "From Module INF: %s" % self
.ModuleDepex
, True)
467 FileWrite(File
, "From Library INF: %s" % self
.LibraryDepex
, True)
469 FileWrite(File
, self
.Depex
)
470 FileWrite(File
, gSubSectionEnd
)
473 # Reports dependency expression information
475 # This class reports the module build flags subsection in the build report file.
477 class BuildFlagsReport(object):
479 # Constructor function for class BuildFlagsReport
481 # This constructor function generates BuildFlagsReport object for
482 # a module. It reports the build tool chain tag and all relevant
483 # build flags to build the module.
485 # @param self The object pointer
486 # @param M Module context information
488 def __init__(self
, M
):
491 # Add build flags according to source file extension so that
492 # irrelevant ones can be filtered out.
494 for Source
in M
.SourceFileList
:
495 Ext
= os
.path
.splitext(Source
.File
)[1].lower()
496 if Ext
in [".c", ".cc", ".cpp"]:
497 BuildOptions
["CC"] = 1
498 elif Ext
in [".s", ".asm"]:
499 BuildOptions
["PP"] = 1
500 BuildOptions
["ASM"] = 1
501 elif Ext
in [".vfr"]:
502 BuildOptions
["VFRPP"] = 1
503 BuildOptions
["VFR"] = 1
504 elif Ext
in [".dxs"]:
505 BuildOptions
["APP"] = 1
506 BuildOptions
["CC"] = 1
507 elif Ext
in [".asl"]:
508 BuildOptions
["ASLPP"] = 1
509 BuildOptions
["ASL"] = 1
510 elif Ext
in [".aslc"]:
511 BuildOptions
["ASLCC"] = 1
512 BuildOptions
["ASLDLINK"] = 1
513 BuildOptions
["CC"] = 1
514 elif Ext
in [".asm16"]:
515 BuildOptions
["ASMLINK"] = 1
516 BuildOptions
["SLINK"] = 1
517 BuildOptions
["DLINK"] = 1
520 # Save module build flags.
522 self
.ToolChainTag
= M
.ToolChain
524 for Tool
in BuildOptions
:
525 self
.BuildFlags
[Tool
+ "_FLAGS"] = M
.BuildOption
.get(Tool
, {}).get("FLAGS", "")
528 # Generate report for module build flags information
530 # This function generates report for the module build flags expression.
532 # @param self The object pointer
533 # @param File The file object for report
535 def GenerateReport(self
, File
):
536 FileWrite(File
, gSubSectionStart
)
537 FileWrite(File
, "Build Flags")
538 FileWrite(File
, "Tool Chain Tag: %s" % self
.ToolChainTag
)
539 for Tool
in self
.BuildFlags
:
540 FileWrite(File
, gSubSectionSep
)
541 FileWrite(File
, "%s = %s" % (Tool
, self
.BuildFlags
[Tool
]), True)
543 FileWrite(File
, gSubSectionEnd
)
547 # Reports individual module information
549 # This class reports the module section in the build report file.
550 # It comprises of module summary, module PCD, library, dependency expression,
551 # build flags sections.
553 class ModuleReport(object):
555 # Constructor function for class ModuleReport
557 # This constructor function generates ModuleReport object for
558 # a separate module in a platform build.
560 # @param self The object pointer
561 # @param M Module context information
562 # @param ReportType The kind of report items in the final report file
564 def __init__(self
, M
, ReportType
):
565 self
.ModuleName
= M
.Module
.BaseName
566 self
.ModuleInfPath
= M
.MetaFile
.File
567 self
.FileGuid
= M
.Guid
569 self
.BuildTimeStamp
= None
573 ModuleType
= M
.ModuleType
575 ModuleType
= COMPONENT_TO_MODULE_MAP_DICT
.get(M
.ComponentType
, "")
577 # If a module complies to PI 1.1, promote Module type to "SMM_DRIVER"
579 if ModuleType
== SUP_MODULE_DXE_SMM_DRIVER
:
580 PiSpec
= M
.Module
.Specification
.get("PI_SPECIFICATION_VERSION", "0x00010000")
581 if int(PiSpec
, 0) >= 0x0001000A:
582 ModuleType
= "SMM_DRIVER"
583 self
.DriverType
= gDriverTypeMap
.get(ModuleType
, "0x2 (FREE_FORM)")
584 self
.UefiSpecVersion
= M
.Module
.Specification
.get("UEFI_SPECIFICATION_VERSION", "")
585 self
.PiSpecVersion
= M
.Module
.Specification
.get("PI_SPECIFICATION_VERSION", "")
586 self
.PciDeviceId
= M
.Module
.Defines
.get("PCI_DEVICE_ID", "")
587 self
.PciVendorId
= M
.Module
.Defines
.get("PCI_VENDOR_ID", "")
588 self
.PciClassCode
= M
.Module
.Defines
.get("PCI_CLASS_CODE", "")
589 self
.BuildTime
= M
.BuildTime
591 self
._BuildDir
= M
.BuildDir
592 self
.ModulePcdSet
= {}
593 if "PCD" in ReportType
:
595 # Collect all module used PCD set: module INF referenced directly or indirectly.
596 # It also saves module INF default values of them in case they exist.
598 for Pcd
in M
.ModulePcdList
+ M
.LibraryPcdList
:
599 self
.ModulePcdSet
.setdefault((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Pcd
.Type
), (Pcd
.InfDefaultValue
, Pcd
.DefaultValue
))
601 self
.LibraryReport
= None
602 if "LIBRARY" in ReportType
:
603 self
.LibraryReport
= LibraryReport(M
)
605 self
.DepexReport
= None
606 if "DEPEX" in ReportType
:
607 self
.DepexReport
= DepexReport(M
)
609 if "BUILD_FLAGS" in ReportType
:
610 self
.BuildFlagsReport
= BuildFlagsReport(M
)
614 # Generate report for module information
616 # This function generates report for separate module expression
617 # in a platform build.
619 # @param self The object pointer
620 # @param File The file object for report
621 # @param GlobalPcdReport The platform global PCD report object
622 # @param GlobalPredictionReport The platform global Prediction report object
623 # @param GlobalDepexParser The platform global Dependency expression parser object
624 # @param ReportType The kind of report items in the final report file
626 def GenerateReport(self
, File
, GlobalPcdReport
, GlobalPredictionReport
, GlobalDepexParser
, ReportType
):
627 FileWrite(File
, gSectionStart
)
629 FwReportFileName
= os
.path
.join(self
._BuildDir
, "DEBUG", self
.ModuleName
+ ".txt")
630 if os
.path
.isfile(FwReportFileName
):
632 FileContents
= open(FwReportFileName
).read()
633 Match
= gModuleSizePattern
.search(FileContents
)
635 self
.Size
= int(Match
.group(1))
637 Match
= gTimeStampPattern
.search(FileContents
)
639 self
.BuildTimeStamp
= datetime
.fromtimestamp(int(Match
.group(1)))
641 EdkLogger
.warn(None, "Fail to read report file", FwReportFileName
)
643 if "HASH" in ReportType
:
644 OutputDir
= os
.path
.join(self
._BuildDir
, "OUTPUT")
645 DefaultEFIfile
= os
.path
.join(OutputDir
, self
.ModuleName
+ ".efi")
646 if os
.path
.isfile(DefaultEFIfile
):
647 Tempfile
= os
.path
.join(OutputDir
, self
.ModuleName
+ "_hash.tmp")
648 # rebase the efi image since its base address may not zero
649 cmd
= ["GenFw", "--rebase", str(0), "-o", Tempfile
, DefaultEFIfile
]
651 PopenObject
= subprocess
.Popen(' '.join(cmd
), stdout
=subprocess
.PIPE
, stderr
=subprocess
.PIPE
, shell
=True)
652 except Exception as X
:
653 EdkLogger
.error("GenFw", COMMAND_FAILURE
, ExtraData
="%s: %s" % (str(X
), cmd
[0]))
654 EndOfProcedure
= threading
.Event()
655 EndOfProcedure
.clear()
656 if PopenObject
.stderr
:
657 StdErrThread
= threading
.Thread(target
=ReadMessage
, args
=(PopenObject
.stderr
, EdkLogger
.quiet
, EndOfProcedure
))
658 StdErrThread
.setName("STDERR-Redirector")
659 StdErrThread
.setDaemon(False)
661 # waiting for program exit
663 if PopenObject
.stderr
:
665 if PopenObject
.returncode
!= 0:
666 EdkLogger
.error("GenFw", COMMAND_FAILURE
, "Failed to generate firmware hash image for %s" % (DefaultEFIfile
))
667 if os
.path
.isfile(Tempfile
):
668 self
.Hash
= hashlib
.sha1()
669 buf
= open(Tempfile
, 'rb').read()
670 if self
.Hash
.update(buf
):
671 self
.Hash
= self
.Hash
.update(buf
)
672 self
.Hash
= self
.Hash
.hexdigest()
675 FileWrite(File
, "Module Summary")
676 FileWrite(File
, "Module Name: %s" % self
.ModuleName
)
677 FileWrite(File
, "Module INF Path: %s" % self
.ModuleInfPath
)
678 FileWrite(File
, "File GUID: %s" % self
.FileGuid
)
680 FileWrite(File
, "Size: 0x%X (%.2fK)" % (self
.Size
, self
.Size
/ 1024.0))
682 FileWrite(File
, "SHA1 HASH: %s *%s" % (self
.Hash
, self
.ModuleName
+ ".efi"))
683 if self
.BuildTimeStamp
:
684 FileWrite(File
, "Build Time Stamp: %s" % self
.BuildTimeStamp
)
686 FileWrite(File
, "Module Build Time: %s" % self
.BuildTime
)
688 FileWrite(File
, "Driver Type: %s" % self
.DriverType
)
689 if self
.UefiSpecVersion
:
690 FileWrite(File
, "UEFI Spec Version: %s" % self
.UefiSpecVersion
)
691 if self
.PiSpecVersion
:
692 FileWrite(File
, "PI Spec Version: %s" % self
.PiSpecVersion
)
694 FileWrite(File
, "PCI Device ID: %s" % self
.PciDeviceId
)
696 FileWrite(File
, "PCI Vendor ID: %s" % self
.PciVendorId
)
697 if self
.PciClassCode
:
698 FileWrite(File
, "PCI Class Code: %s" % self
.PciClassCode
)
700 FileWrite(File
, gSectionSep
)
702 if "PCD" in ReportType
:
703 GlobalPcdReport
.GenerateReport(File
, self
.ModulePcdSet
)
705 if "LIBRARY" in ReportType
:
706 self
.LibraryReport
.GenerateReport(File
)
708 if "DEPEX" in ReportType
:
709 self
.DepexReport
.GenerateReport(File
, GlobalDepexParser
)
711 if "BUILD_FLAGS" in ReportType
:
712 self
.BuildFlagsReport
.GenerateReport(File
)
714 if "FIXED_ADDRESS" in ReportType
and self
.FileGuid
:
715 GlobalPredictionReport
.GenerateReport(File
, self
.FileGuid
)
717 FileWrite(File
, gSectionEnd
)
719 def ReadMessage(From
, To
, ExitFlag
):
721 # read one line a time
722 Line
= From
.readline()
723 # empty string means "end"
724 if Line
is not None and Line
!= "":
732 # Reports platform and module PCD information
734 # This class reports the platform PCD section and module PCD subsection
735 # in the build report file.
737 class PcdReport(object):
739 # Constructor function for class PcdReport
741 # This constructor function generates PcdReport object a platform build.
742 # It collects the whole PCD database from platform DSC files, platform
743 # flash description file and package DEC files.
745 # @param self The object pointer
746 # @param Wa Workspace context information
748 def __init__(self
, Wa
):
751 self
.ConditionalPcds
= {}
755 self
.FdfPcdSet
= Wa
.FdfProfile
.PcdDict
759 self
.DefaultStoreSingle
= True
760 self
.SkuSingle
= True
761 if GlobalData
.gDefaultStores
and len(GlobalData
.gDefaultStores
) > 1:
762 self
.DefaultStoreSingle
= False
763 if GlobalData
.gSkuids
and len(GlobalData
.gSkuids
) > 1:
764 self
.SkuSingle
= False
766 self
.ModulePcdOverride
= {}
767 for Pa
in Wa
.AutoGenObjectList
:
770 # Collect all platform referenced PCDs and grouped them by PCD token space
773 for Pcd
in Pa
.AllPcdList
:
774 PcdList
= self
.AllPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
775 if Pcd
not in PcdList
:
777 if len(Pcd
.TokenCName
) > self
.MaxLen
:
778 self
.MaxLen
= len(Pcd
.TokenCName
)
780 # Collect the PCD defined in DSC/FDF file, but not used in module
782 UnusedPcdFullList
= []
783 for item
in Pa
.Platform
.Pcds
:
784 Pcd
= Pa
.Platform
.Pcds
[item
]
786 # check the Pcd in FDF file, whether it is used in module first
787 for T
in PCD_TYPE_LIST
:
788 PcdList
= self
.AllPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(T
, [])
794 for package
in Pa
.PackageList
:
795 for T
in PCD_TYPE_LIST
:
796 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, T
) in package
.Pcds
:
799 if not Pcd
.DatumType
:
800 Pcd
.DatumType
= package
.Pcds
[(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, T
)].DatumType
804 if not Pcd
.DatumType
:
806 # Try to remove Hii and Vpd suffix
807 if PcdType
.startswith(TAB_PCDS_DYNAMIC_EX
):
808 PcdType
= TAB_PCDS_DYNAMIC_EX
809 elif PcdType
.startswith(TAB_PCDS_DYNAMIC
):
810 PcdType
= TAB_PCDS_DYNAMIC
811 for package
in Pa
.PackageList
:
812 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, PcdType
) in package
.Pcds
:
813 Pcd
.DatumType
= package
.Pcds
[(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, PcdType
)].DatumType
816 PcdList
= self
.AllPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
817 UnusedPcdList
= self
.UnusedPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
818 if Pcd
in UnusedPcdList
:
819 UnusedPcdList
.remove(Pcd
)
820 if Pcd
not in PcdList
and Pcd
not in UnusedPcdFullList
:
821 UnusedPcdFullList
.append(Pcd
)
822 if len(Pcd
.TokenCName
) > self
.MaxLen
:
823 self
.MaxLen
= len(Pcd
.TokenCName
)
825 if GlobalData
.gConditionalPcds
:
826 for PcdItem
in GlobalData
.gConditionalPcds
:
828 (TokenSpaceGuidCName
, TokenCName
) = PcdItem
.split('.')
829 if (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
830 Pcd
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)]
831 PcdList
= self
.ConditionalPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
832 if Pcd
not in PcdList
:
836 if UnusedPcdFullList
:
837 for Pcd
in UnusedPcdFullList
:
838 if Pcd
.TokenSpaceGuidCName
+ '.' + Pcd
.TokenCName
in GlobalData
.gConditionalPcds
:
840 UnusedPcdList
.append(Pcd
)
842 for Pcd
in UnusedPcdList
:
843 PcdList
= self
.UnusedPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
844 if Pcd
not in PcdList
:
847 for Module
in Pa
.Platform
.Modules
.values():
849 # Collect module override PCDs
851 for ModulePcd
in Module
.M
.ModulePcdList
+ Module
.M
.LibraryPcdList
:
852 TokenCName
= ModulePcd
.TokenCName
853 TokenSpaceGuid
= ModulePcd
.TokenSpaceGuidCName
854 ModuleDefault
= ModulePcd
.DefaultValue
855 ModulePath
= os
.path
.basename(Module
.M
.MetaFile
.File
)
856 self
.ModulePcdOverride
.setdefault((TokenCName
, TokenSpaceGuid
), {})[ModulePath
] = ModuleDefault
860 # Collect PCD DEC default value.
862 self
.DecPcdDefault
= {}
864 for Pa
in Wa
.AutoGenObjectList
:
865 for Package
in Pa
.PackageList
:
866 Guids
= Package
.Guids
867 self
._GuidDict
.update(Guids
)
868 for (TokenCName
, TokenSpaceGuidCName
, DecType
) in Package
.Pcds
:
869 DecDefaultValue
= Package
.Pcds
[TokenCName
, TokenSpaceGuidCName
, DecType
].DefaultValue
870 self
.DecPcdDefault
.setdefault((TokenCName
, TokenSpaceGuidCName
, DecType
), DecDefaultValue
)
872 # Collect PCDs defined in DSC common section
874 self
.DscPcdDefault
= {}
875 for Pa
in Wa
.AutoGenObjectList
:
876 for (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
877 DscDefaultValue
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)].DscDefaultValue
879 self
.DscPcdDefault
[(TokenCName
, TokenSpaceGuidCName
)] = DscDefaultValue
881 def GenerateReport(self
, File
, ModulePcdSet
):
883 if self
.ConditionalPcds
:
884 self
.GenerateReportDetail(File
, ModulePcdSet
, 1)
887 for Token
in self
.UnusedPcds
:
888 TokenDict
= self
.UnusedPcds
[Token
]
889 for Type
in TokenDict
:
896 self
.GenerateReportDetail(File
, ModulePcdSet
, 2)
897 self
.GenerateReportDetail(File
, ModulePcdSet
)
900 # Generate report for PCD information
902 # This function generates report for separate module expression
903 # in a platform build.
905 # @param self The object pointer
906 # @param File The file object for report
907 # @param ModulePcdSet Set of all PCDs referenced by module or None for
908 # platform PCD report
909 # @param ReportySubType 0 means platform/module PCD report, 1 means Conditional
910 # directives section report, 2 means Unused Pcds section report
911 # @param DscOverridePcds Module DSC override PCDs set
913 def GenerateReportDetail(self
, File
, ModulePcdSet
, ReportSubType
= 0):
914 PcdDict
= self
.AllPcds
915 if ReportSubType
== 1:
916 PcdDict
= self
.ConditionalPcds
917 elif ReportSubType
== 2:
918 PcdDict
= self
.UnusedPcds
921 FileWrite(File
, gSectionStart
)
922 if ReportSubType
== 1:
923 FileWrite(File
, "Conditional Directives used by the build system")
924 elif ReportSubType
== 2:
925 FileWrite(File
, "PCDs not used by modules or in conditional directives")
927 FileWrite(File
, "Platform Configuration Database Report")
929 FileWrite(File
, " *B - PCD override in the build option")
930 FileWrite(File
, " *P - Platform scoped PCD override in DSC file")
931 FileWrite(File
, " *F - Platform scoped PCD override in FDF file")
932 if not ReportSubType
:
933 FileWrite(File
, " *M - Module scoped PCD override")
934 FileWrite(File
, gSectionSep
)
936 if not ReportSubType
and ModulePcdSet
:
938 # For module PCD sub-section
940 FileWrite(File
, gSubSectionStart
)
941 FileWrite(File
, TAB_BRG_PCD
)
942 FileWrite(File
, gSubSectionSep
)
946 for Type
in PcdDict
[Key
]:
947 for Pcd
in PcdDict
[Key
][Type
]:
948 AllPcdDict
[Key
][(Pcd
.TokenCName
, Type
)] = Pcd
949 for Key
in sorted(AllPcdDict
):
951 # Group PCD by their token space GUID C Name
954 for PcdTokenCName
, Type
in sorted(AllPcdDict
[Key
]):
956 # Group PCD by their usage type
958 Pcd
= AllPcdDict
[Key
][(PcdTokenCName
, Type
)]
959 TypeName
, DecType
= gPcdTypeMap
.get(Type
, ("", Type
))
961 if GlobalData
.MixedPcd
:
962 for PcdKey
in GlobalData
.MixedPcd
:
963 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
) in GlobalData
.MixedPcd
[PcdKey
]:
964 PcdTokenCName
= PcdKey
[0]
966 if MixedPcdFlag
and not ModulePcdSet
:
969 # Get PCD default value and their override relationship
971 DecDefaultValue
= self
.DecPcdDefault
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, DecType
))
972 DscDefaultValue
= self
.DscPcdDefault
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
))
973 DscDefaultValBak
= DscDefaultValue
975 for (CName
, Guid
, Field
) in self
.FdfPcdSet
:
976 if CName
== PcdTokenCName
and Guid
== Key
:
977 DscDefaultValue
= self
.FdfPcdSet
[(CName
, Guid
, Field
)]
979 if DscDefaultValue
!= DscDefaultValBak
:
981 DscDefaultValue
= ValueExpressionEx(DscDefaultValue
, Pcd
.DatumType
, self
._GuidDict
)(True)
982 except BadExpression
as DscDefaultValue
:
983 EdkLogger
.error('BuildReport', FORMAT_INVALID
, "PCD Value: %s, Type: %s" %(DscDefaultValue
, Pcd
.DatumType
))
985 InfDefaultValue
= None
987 PcdValue
= DecDefaultValue
989 PcdValue
= DscDefaultValue
990 #The DefaultValue of StructurePcd already be the latest, no need to update.
991 if not self
.IsStructurePcd(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
):
992 Pcd
.DefaultValue
= PcdValue
993 if ModulePcdSet
is not None:
994 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Type
) not in ModulePcdSet
:
996 InfDefaultValue
, PcdValue
= ModulePcdSet
[Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Type
]
997 #The DefaultValue of StructurePcd already be the latest, no need to update.
998 if not self
.IsStructurePcd(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
):
999 Pcd
.DefaultValue
= PcdValue
1002 InfDefaultValue
= ValueExpressionEx(InfDefaultValue
, Pcd
.DatumType
, self
._GuidDict
)(True)
1003 except BadExpression
as InfDefaultValue
:
1004 EdkLogger
.error('BuildReport', FORMAT_INVALID
, "PCD Value: %s, Type: %s" % (InfDefaultValue
, Pcd
.DatumType
))
1005 if InfDefaultValue
== "":
1006 InfDefaultValue
= None
1008 BuildOptionMatch
= False
1009 if GlobalData
.BuildOptionPcd
:
1010 for pcd
in GlobalData
.BuildOptionPcd
:
1011 if (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
) == (pcd
[0], pcd
[1]):
1015 #The DefaultValue of StructurePcd already be the latest, no need to update.
1016 if not self
.IsStructurePcd(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
):
1017 Pcd
.DefaultValue
= PcdValue
1018 BuildOptionMatch
= True
1022 if ModulePcdSet
is None:
1024 FileWrite(File
, Key
)
1028 if Pcd
.DatumType
in TAB_PCD_NUMERIC_TYPES
:
1029 PcdValueNumber
= int(PcdValue
.strip(), 0)
1030 if DecDefaultValue
is None:
1033 DecDefaultValueNumber
= int(DecDefaultValue
.strip(), 0)
1034 DecMatch
= (DecDefaultValueNumber
== PcdValueNumber
)
1036 if InfDefaultValue
is None:
1039 InfDefaultValueNumber
= int(InfDefaultValue
.strip(), 0)
1040 InfMatch
= (InfDefaultValueNumber
== PcdValueNumber
)
1042 if DscDefaultValue
is None:
1045 DscDefaultValueNumber
= int(DscDefaultValue
.strip(), 0)
1046 DscMatch
= (DscDefaultValueNumber
== PcdValueNumber
)
1048 if DecDefaultValue
is None:
1051 DecMatch
= (DecDefaultValue
.strip() == PcdValue
.strip())
1053 if InfDefaultValue
is None:
1056 InfMatch
= (InfDefaultValue
.strip() == PcdValue
.strip())
1058 if DscDefaultValue
is None:
1061 DscMatch
= (DscDefaultValue
.strip() == PcdValue
.strip())
1064 if self
.IsStructurePcd(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
):
1066 if TypeName
in ('DYNVPD', 'DEXVPD'):
1067 SkuInfoList
= Pcd
.SkuInfoList
1068 Pcd
= GlobalData
.gStructurePcd
[self
.Arch
][(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
)]
1069 Pcd
.DatumType
= Pcd
.StructName
1070 if TypeName
in ('DYNVPD', 'DEXVPD'):
1071 Pcd
.SkuInfoList
= SkuInfoList
1072 if Pcd
.PcdValueFromComm
or Pcd
.PcdFieldValueFromComm
:
1073 BuildOptionMatch
= True
1075 elif Pcd
.PcdValueFromFdf
or Pcd
.PcdFieldValueFromFdf
:
1076 DscDefaultValue
= True
1079 elif Pcd
.SkuOverrideValues
:
1081 if Pcd
.DefaultFromDSC
:
1085 for item
in Pcd
.SkuOverrideValues
:
1086 DictLen
+= len(Pcd
.SkuOverrideValues
[item
])
1090 if not Pcd
.SkuInfoList
:
1091 OverrideValues
= Pcd
.SkuOverrideValues
1093 for Data
in OverrideValues
.values():
1094 Struct
= list(Data
.values())
1096 DscOverride
= self
.ParseStruct(Struct
[0])
1099 SkuList
= sorted(Pcd
.SkuInfoList
.keys())
1101 SkuInfo
= Pcd
.SkuInfoList
[Sku
]
1102 if TypeName
in ('DYNHII', 'DEXHII'):
1103 if SkuInfo
.DefaultStoreDict
:
1104 DefaultStoreList
= sorted(SkuInfo
.DefaultStoreDict
.keys())
1105 for DefaultStore
in DefaultStoreList
:
1106 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1107 DscOverride
= self
.ParseStruct(OverrideValues
[DefaultStore
])
1111 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1113 Keys
= list(OverrideValues
.keys())
1114 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[Keys
[0]])
1115 DscOverride
= self
.ParseStruct(OverrideFieldStruct
)
1119 DscDefaultValue
= True
1125 DscDefaultValue
= True
1130 # Report PCD item according to their override relationship
1132 if Pcd
.DatumType
== 'BOOLEAN':
1134 DscDefaultValue
= str(int(DscDefaultValue
, 0))
1136 DecDefaultValue
= str(int(DecDefaultValue
, 0))
1138 InfDefaultValue
= str(int(InfDefaultValue
, 0))
1139 if Pcd
.DefaultValue
:
1140 Pcd
.DefaultValue
= str(int(Pcd
.DefaultValue
, 0))
1142 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, ' ')
1143 elif InfDefaultValue
and InfMatch
:
1144 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*M')
1145 elif BuildOptionMatch
:
1146 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*B')
1148 if DscDefaultValue
and DscMatch
:
1149 if (Pcd
.TokenCName
, Key
, Field
) in self
.FdfPcdSet
:
1150 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*F')
1152 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*P')
1154 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*M')
1156 if ModulePcdSet
is None:
1159 if not TypeName
in ('PATCH', 'FLAG', 'FIXED'):
1161 if not BuildOptionMatch
:
1162 ModuleOverride
= self
.ModulePcdOverride
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
), {})
1163 for ModulePath
in ModuleOverride
:
1164 ModuleDefault
= ModuleOverride
[ModulePath
]
1165 if Pcd
.DatumType
in TAB_PCD_NUMERIC_TYPES
:
1166 ModulePcdDefaultValueNumber
= int(ModuleDefault
.strip(), 0)
1167 Match
= (ModulePcdDefaultValueNumber
== PcdValueNumber
)
1168 if Pcd
.DatumType
== 'BOOLEAN':
1169 ModuleDefault
= str(ModulePcdDefaultValueNumber
)
1171 Match
= (ModuleDefault
.strip() == PcdValue
.strip())
1174 IsByteArray
, ArrayList
= ByteArrayForamt(ModuleDefault
.strip())
1176 FileWrite(File
, ' *M %-*s = %s' % (self
.MaxLen
+ 15, ModulePath
, '{'))
1177 for Array
in ArrayList
:
1178 FileWrite(File
, Array
)
1180 Value
= ModuleDefault
.strip()
1181 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1182 if Value
.startswith(('0x', '0X')):
1183 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1185 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1186 FileWrite(File
, ' *M %-*s = %s' % (self
.MaxLen
+ 15, ModulePath
, Value
))
1188 if ModulePcdSet
is None:
1189 FileWrite(File
, gSectionEnd
)
1191 if not ReportSubType
and ModulePcdSet
:
1192 FileWrite(File
, gSubSectionEnd
)
1194 def ParseStruct(self
, struct
):
1195 HasDscOverride
= False
1197 for _
, Values
in struct
.items():
1198 if Values
[1] and Values
[1].endswith('.dsc'):
1199 HasDscOverride
= True
1201 return HasDscOverride
1203 def PrintPcdDefault(self
, File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
):
1204 if not DscMatch
and DscDefaultValue
is not None:
1205 Value
= DscDefaultValue
.strip()
1206 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1208 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DSC DEFAULT', "{"))
1209 for Array
in ArrayList
:
1210 FileWrite(File
, Array
)
1212 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1213 if Value
.startswith(('0x', '0X')):
1214 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1216 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1217 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DSC DEFAULT', Value
))
1218 if not InfMatch
and InfDefaultValue
is not None:
1219 Value
= InfDefaultValue
.strip()
1220 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1222 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'INF DEFAULT', "{"))
1223 for Array
in ArrayList
:
1224 FileWrite(File
, Array
)
1226 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1227 if Value
.startswith(('0x', '0X')):
1228 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1230 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1231 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'INF DEFAULT', Value
))
1233 if not DecMatch
and DecDefaultValue
is not None:
1234 Value
= DecDefaultValue
.strip()
1235 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1237 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DEC DEFAULT', "{"))
1238 for Array
in ArrayList
:
1239 FileWrite(File
, Array
)
1241 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1242 if Value
.startswith(('0x', '0X')):
1243 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1245 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1246 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DEC DEFAULT', Value
))
1248 self
.PrintStructureInfo(File
, Pcd
.DefaultValues
)
1249 if DecMatch
and IsStructure
:
1250 self
.PrintStructureInfo(File
, Pcd
.DefaultValues
)
1252 def PrintPcdValue(self
, File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, Flag
= ' '):
1253 if not Pcd
.SkuInfoList
:
1254 Value
= Pcd
.DefaultValue
1255 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1257 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
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 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1268 FiledOverrideFlag
= False
1269 OverrideValues
= Pcd
.SkuOverrideValues
1271 for Data
in OverrideValues
.values():
1272 Struct
= list(Data
.values())
1274 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, Struct
[0])
1275 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1276 FiledOverrideFlag
= True
1278 if not FiledOverrideFlag
and (Pcd
.PcdFieldValueFromComm
or Pcd
.PcdFieldValueFromFdf
):
1279 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, {})
1280 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1281 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1284 SkuList
= sorted(Pcd
.SkuInfoList
.keys())
1286 SkuInfo
= Pcd
.SkuInfoList
[Sku
]
1287 SkuIdName
= SkuInfo
.SkuIdName
1288 if TypeName
in ('DYNHII', 'DEXHII'):
1289 if SkuInfo
.DefaultStoreDict
:
1290 DefaultStoreList
= sorted(SkuInfo
.DefaultStoreDict
.keys())
1291 for DefaultStore
in DefaultStoreList
:
1292 Value
= SkuInfo
.DefaultStoreDict
[DefaultStore
]
1293 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1294 if Pcd
.DatumType
== 'BOOLEAN':
1295 Value
= str(int(Value
, 0))
1299 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1300 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1301 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1302 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '{'))
1303 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1304 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', '{'))
1306 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', '{'))
1307 for Array
in ArrayList
:
1308 FileWrite(File
, Array
)
1310 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1311 if Value
.startswith(('0x', '0X')):
1312 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1314 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1315 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1316 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1317 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1318 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1319 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1320 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', Value
))
1322 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', Value
))
1325 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1326 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1327 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1328 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '{'))
1329 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1330 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', '{'))
1332 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', '{'))
1333 for Array
in ArrayList
:
1334 FileWrite(File
, Array
)
1336 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1337 if Value
.startswith(('0x', '0X')):
1338 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1340 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1341 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1342 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1343 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1344 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1345 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1346 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', Value
))
1348 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', Value
))
1349 FileWrite(File
, '%*s: %s: %s' % (self
.MaxLen
+ 4, SkuInfo
.VariableGuid
, SkuInfo
.VariableName
, SkuInfo
.VariableOffset
))
1351 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1352 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[DefaultStore
])
1353 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1354 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1356 Value
= SkuInfo
.DefaultValue
1357 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1358 if Pcd
.DatumType
== 'BOOLEAN':
1359 Value
= str(int(Value
, 0))
1364 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', "{"))
1366 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', "{"))
1367 for Array
in ArrayList
:
1368 FileWrite(File
, Array
)
1370 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1371 if Value
.startswith(('0x', '0X')):
1372 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1374 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1376 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1378 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1382 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', "{"))
1384 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', "{"))
1385 for Array
in ArrayList
:
1386 FileWrite(File
, Array
)
1388 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1389 if Value
.startswith(('0x', '0X')):
1390 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1392 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1394 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1396 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1397 if TypeName
in ('DYNVPD', 'DEXVPD'):
1398 FileWrite(File
, '%*s' % (self
.MaxLen
+ 4, SkuInfo
.VpdOffset
))
1399 VPDPcdItem
= (Pcd
.TokenSpaceGuidCName
+ '.' + PcdTokenCName
, SkuIdName
, SkuInfo
.VpdOffset
, Pcd
.MaxDatumSize
, SkuInfo
.DefaultValue
)
1400 if VPDPcdItem
not in VPDPcdList
:
1401 VPDPcdList
.append(VPDPcdItem
)
1403 FiledOverrideFlag
= False
1404 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1406 Keys
= OverrideValues
.keys()
1407 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[Keys
[0]])
1408 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1409 FiledOverrideFlag
= True
1410 if not FiledOverrideFlag
and (Pcd
.PcdFieldValueFromComm
or Pcd
.PcdFieldValueFromFdf
):
1411 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, {})
1412 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1413 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1415 def OverrideFieldValue(self
, Pcd
, OverrideStruct
):
1416 OverrideFieldStruct
= collections
.OrderedDict()
1418 for _
, Values
in OverrideStruct
.items():
1419 for Key
,value
in Values
.items():
1420 if value
[1] and value
[1].endswith('.dsc'):
1421 OverrideFieldStruct
[Key
] = value
1422 if Pcd
.PcdFieldValueFromFdf
:
1423 for Key
, Values
in Pcd
.PcdFieldValueFromFdf
.items():
1424 if Key
in OverrideFieldStruct
and Values
[0] == OverrideFieldStruct
[Key
][0]:
1426 OverrideFieldStruct
[Key
] = Values
1427 if Pcd
.PcdFieldValueFromComm
:
1428 for Key
, Values
in Pcd
.PcdFieldValueFromComm
.items():
1429 if Key
in OverrideFieldStruct
and Values
[0] == OverrideFieldStruct
[Key
][0]:
1431 OverrideFieldStruct
[Key
] = Values
1432 return OverrideFieldStruct
1434 def PrintStructureInfo(self
, File
, Struct
):
1435 for Key
, Value
in sorted(Struct
.items(), key
=lambda x
: x
[0]):
1436 if Value
[1] and 'build command options' in Value
[1]:
1437 FileWrite(File
, ' *B %-*s = %s' % (self
.MaxLen
+ 4, '.' + Key
, Value
[0]))
1438 elif Value
[1] and Value
[1].endswith('.fdf'):
1439 FileWrite(File
, ' *F %-*s = %s' % (self
.MaxLen
+ 4, '.' + Key
, Value
[0]))
1441 FileWrite(File
, ' %-*s = %s' % (self
.MaxLen
+ 4, '.' + Key
, Value
[0]))
1443 def StrtoHex(self
, value
):
1445 value
= hex(int(value
))
1448 if value
.startswith("L\"") and value
.endswith("\""):
1450 for ch
in value
[2:-1]:
1451 valuelist
.append(hex(ord(ch
)))
1452 valuelist
.append('0x00')
1454 elif value
.startswith("\"") and value
.endswith("\""):
1455 return hex(ord(value
[1:-1]))
1456 elif value
.startswith("{") and value
.endswith("}"):
1458 if ',' not in value
:
1460 for ch
in value
[1:-1].split(','):
1462 if ch
.startswith('0x') or ch
.startswith('0X'):
1463 valuelist
.append(ch
)
1466 valuelist
.append(hex(int(ch
.strip())))
1473 def IsStructurePcd(self
, PcdToken
, PcdTokenSpaceGuid
):
1474 if GlobalData
.gStructurePcd
and (self
.Arch
in GlobalData
.gStructurePcd
) and ((PcdToken
, PcdTokenSpaceGuid
) in GlobalData
.gStructurePcd
[self
.Arch
]):
1480 # Reports platform and module Prediction information
1482 # This class reports the platform execution order prediction section and
1483 # module load fixed address prediction subsection in the build report file.
1485 class PredictionReport(object):
1487 # Constructor function for class PredictionReport
1489 # This constructor function generates PredictionReport object for the platform.
1491 # @param self: The object pointer
1492 # @param Wa Workspace context information
1494 def __init__(self
, Wa
):
1495 self
._MapFileName
= os
.path
.join(Wa
.BuildDir
, Wa
.Name
+ ".map")
1496 self
._MapFileParsed
= False
1497 self
._EotToolInvoked
= False
1498 self
._FvDir
= Wa
.FvDir
1499 self
._EotDir
= Wa
.BuildDir
1500 self
._FfsEntryPoint
= {}
1502 self
._SourceList
= []
1503 self
.FixedMapDict
= {}
1508 # Collect all platform reference source files and GUID C Name
1510 for Pa
in Wa
.AutoGenObjectList
:
1511 for Module
in Pa
.LibraryAutoGenList
+ Pa
.ModuleAutoGenList
:
1513 # BASE typed modules are EFI agnostic, so we need not scan
1514 # their source code to find PPI/Protocol produce or consume
1517 if Module
.ModuleType
== SUP_MODULE_BASE
:
1520 # Add module referenced source files
1522 self
._SourceList
.append(str(Module
))
1524 for Source
in Module
.SourceFileList
:
1525 if os
.path
.splitext(str(Source
))[1].lower() == ".c":
1526 self
._SourceList
.append(" " + str(Source
))
1527 FindIncludeFiles(Source
.Path
, Module
.IncludePathList
, IncludeList
)
1528 for IncludeFile
in IncludeList
.values():
1529 self
._SourceList
.append(" " + IncludeFile
)
1531 for Guid
in Module
.PpiList
:
1532 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.PpiList
[Guid
])
1533 for Guid
in Module
.ProtocolList
:
1534 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.ProtocolList
[Guid
])
1535 for Guid
in Module
.GuidList
:
1536 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.GuidList
[Guid
])
1538 if Module
.Guid
and not Module
.IsLibrary
:
1539 EntryPoint
= " ".join(Module
.Module
.ModuleEntryPointList
)
1541 RealEntryPoint
= "_ModuleEntryPoint"
1543 self
._FfsEntryPoint
[Module
.Guid
.upper()] = (EntryPoint
, RealEntryPoint
)
1547 # Collect platform firmware volume list as the input of EOT.
1551 for Fd
in Wa
.FdfProfile
.FdDict
:
1552 for FdRegion
in Wa
.FdfProfile
.FdDict
[Fd
].RegionList
:
1553 if FdRegion
.RegionType
!= BINARY_FILE_TYPE_FV
:
1555 for FvName
in FdRegion
.RegionDataList
:
1556 if FvName
in self
._FvList
:
1558 self
._FvList
.append(FvName
)
1559 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1560 for Section
in Ffs
.SectionList
:
1562 for FvSection
in Section
.SectionList
:
1563 if FvSection
.FvName
in self
._FvList
:
1565 self
._FvList
.append(FvSection
.FvName
)
1566 except AttributeError:
1571 # Parse platform fixed address map files
1573 # This function parses the platform final fixed address map file to get
1574 # the database of predicted fixed address for module image base, entry point
1577 # @param self: The object pointer
1579 def _ParseMapFile(self
):
1580 if self
._MapFileParsed
:
1582 self
._MapFileParsed
= True
1583 if os
.path
.isfile(self
._MapFileName
):
1585 FileContents
= open(self
._MapFileName
).read()
1586 for Match
in gMapFileItemPattern
.finditer(FileContents
):
1587 AddressType
= Match
.group(1)
1588 BaseAddress
= Match
.group(2)
1589 EntryPoint
= Match
.group(3)
1590 Guid
= Match
.group(4).upper()
1591 List
= self
.FixedMapDict
.setdefault(Guid
, [])
1592 List
.append((AddressType
, BaseAddress
, "*I"))
1593 List
.append((AddressType
, EntryPoint
, "*E"))
1595 EdkLogger
.warn(None, "Cannot open file to read", self
._MapFileName
)
1598 # Invokes EOT tool to get the predicted the execution order.
1600 # This function invokes EOT tool to calculate the predicted dispatch order
1602 # @param self: The object pointer
1604 def _InvokeEotTool(self
):
1605 if self
._EotToolInvoked
:
1608 self
._EotToolInvoked
= True
1610 for FvName
in self
._FvList
:
1611 FvFile
= os
.path
.join(self
._FvDir
, FvName
+ ".Fv")
1612 if os
.path
.isfile(FvFile
):
1613 FvFileList
.append(FvFile
)
1615 if len(FvFileList
) == 0:
1618 # Write source file list and GUID file list to an intermediate file
1619 # as the input for EOT tool and dispatch List as the output file
1622 SourceList
= os
.path
.join(self
._EotDir
, "SourceFile.txt")
1623 GuidList
= os
.path
.join(self
._EotDir
, "GuidList.txt")
1624 DispatchList
= os
.path
.join(self
._EotDir
, "Dispatch.txt")
1626 TempFile
= open(SourceList
, "w+")
1627 for Item
in self
._SourceList
:
1628 FileWrite(TempFile
, Item
)
1630 TempFile
= open(GuidList
, "w+")
1631 for Key
in self
._GuidMap
:
1632 FileWrite(TempFile
, "%s %s" % (Key
, self
._GuidMap
[Key
]))
1636 from Eot
.EotMain
import Eot
1639 # Invoke EOT tool and echo its runtime performance
1641 EotStartTime
= time
.time()
1642 Eot(CommandLineOption
=False, SourceFileList
=SourceList
, GuidList
=GuidList
,
1643 FvFileList
=' '.join(FvFileList
), Dispatch
=DispatchList
, IsInit
=True)
1644 EotEndTime
= time
.time()
1645 EotDuration
= time
.strftime("%H:%M:%S", time
.gmtime(int(round(EotEndTime
- EotStartTime
))))
1646 EdkLogger
.quiet("EOT run time: %s\n" % EotDuration
)
1649 # Parse the output of EOT tool
1651 for Line
in open(DispatchList
):
1652 if len(Line
.split()) < 4:
1654 (Guid
, Phase
, FfsName
, FilePath
) = Line
.split()
1655 Symbol
= self
._FfsEntryPoint
.get(Guid
, [FfsName
, ""])[0]
1656 if len(Symbol
) > self
.MaxLen
:
1657 self
.MaxLen
= len(Symbol
)
1658 self
.ItemList
.append((Phase
, Symbol
, FilePath
))
1660 EdkLogger
.quiet("(Python %s on %s\n%s)" % (platform
.python_version(), sys
.platform
, traceback
.format_exc()))
1661 EdkLogger
.warn(None, "Failed to generate execution order prediction report, for some error occurred in executing EOT.")
1665 # Generate platform execution order report
1667 # This function generates the predicted module execution order.
1669 # @param self The object pointer
1670 # @param File The file object for report
1672 def _GenerateExecutionOrderReport(self
, File
):
1673 self
._InvokeEotTool
()
1674 if len(self
.ItemList
) == 0:
1676 FileWrite(File
, gSectionStart
)
1677 FileWrite(File
, "Execution Order Prediction")
1678 FileWrite(File
, "*P PEI phase")
1679 FileWrite(File
, "*D DXE phase")
1680 FileWrite(File
, "*E Module INF entry point name")
1681 FileWrite(File
, "*N Module notification function name")
1683 FileWrite(File
, "Type %-*s %s" % (self
.MaxLen
, "Symbol", "Module INF Path"))
1684 FileWrite(File
, gSectionSep
)
1685 for Item
in self
.ItemList
:
1686 FileWrite(File
, "*%sE %-*s %s" % (Item
[0], self
.MaxLen
, Item
[1], Item
[2]))
1688 FileWrite(File
, gSectionStart
)
1691 # Generate Fixed Address report.
1693 # This function generate the predicted fixed address report for a module
1694 # specified by Guid.
1696 # @param self The object pointer
1697 # @param File The file object for report
1698 # @param Guid The module Guid value.
1699 # @param NotifyList The list of all notify function in a module
1701 def _GenerateFixedAddressReport(self
, File
, Guid
, NotifyList
):
1702 self
._ParseMapFile
()
1703 FixedAddressList
= self
.FixedMapDict
.get(Guid
)
1704 if not FixedAddressList
:
1707 FileWrite(File
, gSubSectionStart
)
1708 FileWrite(File
, "Fixed Address Prediction")
1709 FileWrite(File
, "*I Image Loading Address")
1710 FileWrite(File
, "*E Entry Point Address")
1711 FileWrite(File
, "*N Notification Function Address")
1712 FileWrite(File
, "*F Flash Address")
1713 FileWrite(File
, "*M Memory Address")
1714 FileWrite(File
, "*S SMM RAM Offset")
1715 FileWrite(File
, "TOM Top of Memory")
1717 FileWrite(File
, "Type Address Name")
1718 FileWrite(File
, gSubSectionSep
)
1719 for Item
in FixedAddressList
:
1724 Name
= "(Image Base)"
1725 elif Symbol
== "*E":
1726 Name
= self
._FfsEntryPoint
.get(Guid
, ["", "_ModuleEntryPoint"])[1]
1727 elif Symbol
in NotifyList
:
1735 elif "Memory" in Type
:
1741 Value
= "TOM" + Value
1743 FileWrite(File
, "%s %-16s %s" % (Symbol
, Value
, Name
))
1746 # Generate report for the prediction part
1748 # This function generate the predicted fixed address report for a module or
1749 # predicted module execution order for a platform.
1750 # If the input Guid is None, then, it generates the predicted module execution order;
1751 # otherwise it generated the module fixed loading address for the module specified by
1754 # @param self The object pointer
1755 # @param File The file object for report
1756 # @param Guid The module Guid value.
1758 def GenerateReport(self
, File
, Guid
):
1760 self
._GenerateFixedAddressReport
(File
, Guid
.upper(), [])
1762 self
._GenerateExecutionOrderReport
(File
)
1765 # Reports FD region information
1767 # This class reports the FD subsection in the build report file.
1768 # It collects region information of platform flash device.
1769 # If the region is a firmware volume, it lists the set of modules
1770 # and its space information; otherwise, it only lists its region name,
1771 # base address and size in its sub-section header.
1772 # If there are nesting FVs, the nested FVs will list immediate after
1773 # this FD region subsection
1775 class FdRegionReport(object):
1777 # Discover all the nested FV name list.
1779 # This is an internal worker function to discover the all the nested FV information
1780 # in the parent firmware volume. It uses deep first search algorithm recursively to
1781 # find all the FV list name and append them to the list.
1783 # @param self The object pointer
1784 # @param FvName The name of current firmware file system
1785 # @param Wa Workspace context information
1787 def _DiscoverNestedFvList(self
, FvName
, Wa
):
1788 FvDictKey
=FvName
.upper()
1789 if FvDictKey
in Wa
.FdfProfile
.FvDict
:
1790 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1791 for Section
in Ffs
.SectionList
:
1793 for FvSection
in Section
.SectionList
:
1794 if FvSection
.FvName
in self
.FvList
:
1796 self
._GuidsDb
[Ffs
.NameGuid
.upper()] = FvSection
.FvName
1797 self
.FvList
.append(FvSection
.FvName
)
1798 self
.FvInfo
[FvSection
.FvName
] = ("Nested FV", 0, 0)
1799 self
._DiscoverNestedFvList
(FvSection
.FvName
, Wa
)
1800 except AttributeError:
1804 # Constructor function for class FdRegionReport
1806 # This constructor function generates FdRegionReport object for a specified FdRegion.
1807 # If the FdRegion is a firmware volume, it will recursively find all its nested Firmware
1808 # volume list. This function also collects GUID map in order to dump module identification
1809 # in the final report.
1811 # @param self: The object pointer
1812 # @param FdRegion The current FdRegion object
1813 # @param Wa Workspace context information
1815 def __init__(self
, FdRegion
, Wa
):
1816 self
.Type
= FdRegion
.RegionType
1817 self
.BaseAddress
= FdRegion
.Offset
1818 self
.Size
= FdRegion
.Size
1822 self
._FvDir
= Wa
.FvDir
1823 self
._WorkspaceDir
= Wa
.WorkspaceDir
1826 # If the input FdRegion is not a firmware volume,
1829 if self
.Type
!= BINARY_FILE_TYPE_FV
:
1833 # Find all nested FVs in the FdRegion
1835 for FvName
in FdRegion
.RegionDataList
:
1836 if FvName
in self
.FvList
:
1838 self
.FvList
.append(FvName
)
1839 self
.FvInfo
[FvName
] = ("Fd Region", self
.BaseAddress
, self
.Size
)
1840 self
._DiscoverNestedFvList
(FvName
, Wa
)
1844 # Collect PCDs declared in DEC files.
1846 for Pa
in Wa
.AutoGenObjectList
:
1847 for Package
in Pa
.PackageList
:
1848 for (TokenCName
, TokenSpaceGuidCName
, DecType
) in Package
.Pcds
:
1849 DecDefaultValue
= Package
.Pcds
[TokenCName
, TokenSpaceGuidCName
, DecType
].DefaultValue
1850 PlatformPcds
[(TokenCName
, TokenSpaceGuidCName
)] = DecDefaultValue
1852 # Collect PCDs defined in DSC file
1854 for Pa
in Wa
.AutoGenObjectList
:
1855 for (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
1856 DscDefaultValue
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)].DefaultValue
1857 PlatformPcds
[(TokenCName
, TokenSpaceGuidCName
)] = DscDefaultValue
1860 # Add PEI and DXE a priori files GUIDs defined in PI specification.
1862 self
._GuidsDb
[PEI_APRIORI_GUID
] = "PEI Apriori"
1863 self
._GuidsDb
[DXE_APRIORI_GUID
] = "DXE Apriori"
1865 # Add ACPI table storage file
1867 self
._GuidsDb
["7E374E25-8E01-4FEE-87F2-390C23C606CD"] = "ACPI table storage"
1869 for Pa
in Wa
.AutoGenObjectList
:
1870 for ModuleKey
in Pa
.Platform
.Modules
:
1871 M
= Pa
.Platform
.Modules
[ModuleKey
].M
1872 InfPath
= mws
.join(Wa
.WorkspaceDir
, M
.MetaFile
.File
)
1873 self
._GuidsDb
[M
.Guid
.upper()] = "%s (%s)" % (M
.Module
.BaseName
, InfPath
)
1876 # Collect the GUID map in the FV firmware volume
1878 for FvName
in self
.FvList
:
1879 FvDictKey
=FvName
.upper()
1880 if FvDictKey
in Wa
.FdfProfile
.FvDict
:
1881 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1884 # collect GUID map for binary EFI file in FDF file.
1886 Guid
= Ffs
.NameGuid
.upper()
1887 Match
= gPcdGuidPattern
.match(Ffs
.NameGuid
)
1889 PcdTokenspace
= Match
.group(1)
1890 PcdToken
= Match
.group(2)
1891 if (PcdToken
, PcdTokenspace
) in PlatformPcds
:
1892 GuidValue
= PlatformPcds
[(PcdToken
, PcdTokenspace
)]
1893 Guid
= GuidStructureByteArrayToGuidString(GuidValue
).upper()
1894 for Section
in Ffs
.SectionList
:
1896 ModuleSectFile
= mws
.join(Wa
.WorkspaceDir
, Section
.SectFileName
)
1897 self
._GuidsDb
[Guid
] = ModuleSectFile
1898 except AttributeError:
1900 except AttributeError:
1905 # Internal worker function to generate report for the FD region
1907 # This internal worker function to generate report for the FD region.
1908 # It the type is firmware volume, it lists offset and module identification.
1910 # @param self The object pointer
1911 # @param File The file object for report
1912 # @param Title The title for the FD subsection
1913 # @param BaseAddress The base address for the FD region
1914 # @param Size The size of the FD region
1915 # @param FvName The FV name if the FD region is a firmware volume
1917 def _GenerateReport(self
, File
, Title
, Type
, BaseAddress
, Size
=0, FvName
=None):
1918 FileWrite(File
, gSubSectionStart
)
1919 FileWrite(File
, Title
)
1920 FileWrite(File
, "Type: %s" % Type
)
1921 FileWrite(File
, "Base Address: 0x%X" % BaseAddress
)
1923 if self
.Type
== BINARY_FILE_TYPE_FV
:
1927 if FvName
.upper().endswith('.FV'):
1928 FileExt
= FvName
+ ".txt"
1930 FileExt
= FvName
+ ".Fv.txt"
1932 if not os
.path
.isfile(FileExt
):
1933 FvReportFileName
= mws
.join(self
._WorkspaceDir
, FileExt
)
1934 if not os
.path
.isfile(FvReportFileName
):
1935 FvReportFileName
= os
.path
.join(self
._FvDir
, FileExt
)
1938 # Collect size info in the firmware volume.
1940 FvReport
= open(FvReportFileName
).read()
1941 Match
= gFvTotalSizePattern
.search(FvReport
)
1943 FvTotalSize
= int(Match
.group(1), 16)
1944 Match
= gFvTakenSizePattern
.search(FvReport
)
1946 FvTakenSize
= int(Match
.group(1), 16)
1947 FvFreeSize
= FvTotalSize
- FvTakenSize
1949 # Write size information to the report file.
1951 FileWrite(File
, "Size: 0x%X (%.0fK)" % (FvTotalSize
, FvTotalSize
/ 1024.0))
1952 FileWrite(File
, "Fv Name: %s (%.1f%% Full)" % (FvName
, FvTakenSize
* 100.0 / FvTotalSize
))
1953 FileWrite(File
, "Occupied Size: 0x%X (%.0fK)" % (FvTakenSize
, FvTakenSize
/ 1024.0))
1954 FileWrite(File
, "Free Size: 0x%X (%.0fK)" % (FvFreeSize
, FvFreeSize
/ 1024.0))
1955 FileWrite(File
, "Offset Module")
1956 FileWrite(File
, gSubSectionSep
)
1958 # Write module offset and module identification to the report file.
1961 for Match
in gOffsetGuidPattern
.finditer(FvReport
):
1962 Guid
= Match
.group(2).upper()
1963 OffsetInfo
[Match
.group(1)] = self
._GuidsDb
.get(Guid
, Guid
)
1964 OffsetList
= sorted(OffsetInfo
.keys())
1965 for Offset
in OffsetList
:
1966 FileWrite (File
, "%s %s" % (Offset
, OffsetInfo
[Offset
]))
1968 EdkLogger
.warn(None, "Fail to read report file", FvReportFileName
)
1970 FileWrite(File
, "Size: 0x%X (%.0fK)" % (Size
, Size
/ 1024.0))
1971 FileWrite(File
, gSubSectionEnd
)
1974 # Generate report for the FD region
1976 # This function generates report for the FD region.
1978 # @param self The object pointer
1979 # @param File The file object for report
1981 def GenerateReport(self
, File
):
1982 if (len(self
.FvList
) > 0):
1983 for FvItem
in self
.FvList
:
1984 Info
= self
.FvInfo
[FvItem
]
1985 self
._GenerateReport
(File
, Info
[0], TAB_FV_DIRECTORY
, Info
[1], Info
[2], FvItem
)
1987 self
._GenerateReport
(File
, "FD Region", self
.Type
, self
.BaseAddress
, self
.Size
)
1990 # Reports FD information
1992 # This class reports the FD section in the build report file.
1993 # It collects flash device information for a platform.
1995 class FdReport(object):
1997 # Constructor function for class FdReport
1999 # This constructor function generates FdReport object for a specified
2002 # @param self The object pointer
2003 # @param Fd The current Firmware device object
2004 # @param Wa Workspace context information
2006 def __init__(self
, Fd
, Wa
):
2007 self
.FdName
= Fd
.FdUiName
2008 self
.BaseAddress
= Fd
.BaseAddress
2010 self
.FdRegionList
= [FdRegionReport(FdRegion
, Wa
) for FdRegion
in Fd
.RegionList
]
2011 self
.FvPath
= os
.path
.join(Wa
.BuildDir
, TAB_FV_DIRECTORY
)
2012 self
.VPDBaseAddress
= 0
2014 for index
, FdRegion
in enumerate(Fd
.RegionList
):
2015 if str(FdRegion
.RegionType
) is 'FILE' and Wa
.Platform
.VpdToolGuid
in str(FdRegion
.RegionDataList
):
2016 self
.VPDBaseAddress
= self
.FdRegionList
[index
].BaseAddress
2017 self
.VPDSize
= self
.FdRegionList
[index
].Size
2021 # Generate report for the firmware device.
2023 # This function generates report for the firmware device.
2025 # @param self The object pointer
2026 # @param File The file object for report
2028 def GenerateReport(self
, File
):
2029 FileWrite(File
, gSectionStart
)
2030 FileWrite(File
, "Firmware Device (FD)")
2031 FileWrite(File
, "FD Name: %s" % self
.FdName
)
2032 FileWrite(File
, "Base Address: %s" % self
.BaseAddress
)
2033 FileWrite(File
, "Size: 0x%X (%.0fK)" % (self
.Size
, self
.Size
/ 1024.0))
2034 if len(self
.FdRegionList
) > 0:
2035 FileWrite(File
, gSectionSep
)
2036 for FdRegionItem
in self
.FdRegionList
:
2037 FdRegionItem
.GenerateReport(File
)
2040 VPDPcdList
.sort(key
=lambda x
: int(x
[2], 0))
2041 FileWrite(File
, gSubSectionStart
)
2042 FileWrite(File
, "FD VPD Region")
2043 FileWrite(File
, "Base Address: 0x%X" % self
.VPDBaseAddress
)
2044 FileWrite(File
, "Size: 0x%X (%.0fK)" % (self
.VPDSize
, self
.VPDSize
/ 1024.0))
2045 FileWrite(File
, gSubSectionSep
)
2046 for item
in VPDPcdList
:
2047 # Add BaseAddress for offset
2048 Offset
= '0x%08X' % (int(item
[2], 16) + self
.VPDBaseAddress
)
2049 IsByteArray
, ArrayList
= ByteArrayForamt(item
[-1])
2051 if len(GlobalData
.gSkuids
) == 1 :
2052 Skuinfo
= GlobalData
.gSkuids
[0]
2054 FileWrite(File
, "%s | %s | %s | %s | %s" % (item
[0], Skuinfo
, Offset
, item
[3], '{'))
2055 for Array
in ArrayList
:
2056 FileWrite(File
, Array
)
2058 FileWrite(File
, "%s | %s | %s | %s | %s" % (item
[0], Skuinfo
, Offset
, item
[3], item
[-1]))
2059 FileWrite(File
, gSubSectionEnd
)
2060 FileWrite(File
, gSectionEnd
)
2065 # Reports platform information
2067 # This class reports the whole platform information
2069 class PlatformReport(object):
2071 # Constructor function for class PlatformReport
2073 # This constructor function generates PlatformReport object a platform build.
2074 # It generates report for platform summary, flash, global PCDs and detailed
2075 # module information for modules involved in platform build.
2077 # @param self The object pointer
2078 # @param Wa Workspace context information
2079 # @param MaList The list of modules in the platform build
2081 def __init__(self
, Wa
, MaList
, ReportType
):
2082 self
._WorkspaceDir
= Wa
.WorkspaceDir
2083 self
.PlatformName
= Wa
.Name
2084 self
.PlatformDscPath
= Wa
.Platform
2085 self
.Architectures
= " ".join(Wa
.ArchList
)
2086 self
.ToolChain
= Wa
.ToolChain
2087 self
.Target
= Wa
.BuildTarget
2088 self
.OutputPath
= os
.path
.join(Wa
.WorkspaceDir
, Wa
.OutputDir
)
2089 self
.BuildEnvironment
= platform
.platform()
2091 self
.PcdReport
= None
2092 if "PCD" in ReportType
:
2093 self
.PcdReport
= PcdReport(Wa
)
2095 self
.FdReportList
= []
2096 if "FLASH" in ReportType
and Wa
.FdfProfile
and MaList
is None:
2097 for Fd
in Wa
.FdfProfile
.FdDict
:
2098 self
.FdReportList
.append(FdReport(Wa
.FdfProfile
.FdDict
[Fd
], Wa
))
2100 self
.PredictionReport
= None
2101 if "FIXED_ADDRESS" in ReportType
or "EXECUTION_ORDER" in ReportType
:
2102 self
.PredictionReport
= PredictionReport(Wa
)
2104 self
.DepexParser
= None
2105 if "DEPEX" in ReportType
:
2106 self
.DepexParser
= DepexParser(Wa
)
2108 self
.ModuleReportList
= []
2109 if MaList
is not None:
2110 self
._IsModuleBuild
= True
2112 self
.ModuleReportList
.append(ModuleReport(Ma
, ReportType
))
2114 self
._IsModuleBuild
= False
2115 for Pa
in Wa
.AutoGenObjectList
:
2116 ModuleAutoGenList
= []
2117 for ModuleKey
in Pa
.Platform
.Modules
:
2118 ModuleAutoGenList
.append(Pa
.Platform
.Modules
[ModuleKey
].M
)
2119 if GlobalData
.gFdfParser
is not None:
2120 if Pa
.Arch
in GlobalData
.gFdfParser
.Profile
.InfDict
:
2121 INFList
= GlobalData
.gFdfParser
.Profile
.InfDict
[Pa
.Arch
]
2122 for InfName
in INFList
:
2123 InfClass
= PathClass(NormPath(InfName
), Wa
.WorkspaceDir
, Pa
.Arch
)
2124 Ma
= ModuleAutoGen(Wa
, InfClass
, Pa
.BuildTarget
, Pa
.ToolChain
, Pa
.Arch
, Wa
.MetaFile
)
2127 if Ma
not in ModuleAutoGenList
:
2128 ModuleAutoGenList
.append(Ma
)
2129 for MGen
in ModuleAutoGenList
:
2130 self
.ModuleReportList
.append(ModuleReport(MGen
, ReportType
))
2135 # Generate report for the whole platform.
2137 # This function generates report for platform information.
2138 # It comprises of platform summary, global PCD, flash and
2139 # module list sections.
2141 # @param self The object pointer
2142 # @param File The file object for report
2143 # @param BuildDuration The total time to build the modules
2144 # @param AutoGenTime The total time of AutoGen Phase
2145 # @param MakeTime The total time of Make Phase
2146 # @param GenFdsTime The total time of GenFds Phase
2147 # @param ReportType The kind of report items in the final report file
2149 def GenerateReport(self
, File
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
, ReportType
):
2150 FileWrite(File
, "Platform Summary")
2151 FileWrite(File
, "Platform Name: %s" % self
.PlatformName
)
2152 FileWrite(File
, "Platform DSC Path: %s" % self
.PlatformDscPath
)
2153 FileWrite(File
, "Architectures: %s" % self
.Architectures
)
2154 FileWrite(File
, "Tool Chain: %s" % self
.ToolChain
)
2155 FileWrite(File
, "Target: %s" % self
.Target
)
2156 if GlobalData
.gSkuids
:
2157 FileWrite(File
, "SKUID: %s" % " ".join(GlobalData
.gSkuids
))
2158 if GlobalData
.gDefaultStores
:
2159 FileWrite(File
, "DefaultStore: %s" % " ".join(GlobalData
.gDefaultStores
))
2160 FileWrite(File
, "Output Path: %s" % self
.OutputPath
)
2161 FileWrite(File
, "Build Environment: %s" % self
.BuildEnvironment
)
2162 FileWrite(File
, "Build Duration: %s" % BuildDuration
)
2164 FileWrite(File
, "AutoGen Duration: %s" % AutoGenTime
)
2166 FileWrite(File
, "Make Duration: %s" % MakeTime
)
2168 FileWrite(File
, "GenFds Duration: %s" % GenFdsTime
)
2169 FileWrite(File
, "Report Content: %s" % ", ".join(ReportType
))
2171 if GlobalData
.MixedPcd
:
2172 FileWrite(File
, gSectionStart
)
2173 FileWrite(File
, "The following PCDs use different access methods:")
2174 FileWrite(File
, gSectionSep
)
2175 for PcdItem
in GlobalData
.MixedPcd
:
2176 FileWrite(File
, "%s.%s" % (str(PcdItem
[1]), str(PcdItem
[0])))
2177 FileWrite(File
, gSectionEnd
)
2179 if not self
._IsModuleBuild
:
2180 if "PCD" in ReportType
:
2181 self
.PcdReport
.GenerateReport(File
, None)
2183 if "FLASH" in ReportType
:
2184 for FdReportListItem
in self
.FdReportList
:
2185 FdReportListItem
.GenerateReport(File
)
2187 for ModuleReportItem
in self
.ModuleReportList
:
2188 ModuleReportItem
.GenerateReport(File
, self
.PcdReport
, self
.PredictionReport
, self
.DepexParser
, ReportType
)
2190 if not self
._IsModuleBuild
:
2191 if "EXECUTION_ORDER" in ReportType
:
2192 self
.PredictionReport
.GenerateReport(File
, None)
2194 ## BuildReport class
2196 # This base class contain the routines to collect data and then
2197 # applies certain format to the output report
2199 class BuildReport(object):
2201 # Constructor function for class BuildReport
2203 # This constructor function generates BuildReport object a platform build.
2204 # It generates report for platform summary, flash, global PCDs and detailed
2205 # module information for modules involved in platform build.
2207 # @param self The object pointer
2208 # @param ReportFile The file name to save report file
2209 # @param ReportType The kind of report items in the final report file
2211 def __init__(self
, ReportFile
, ReportType
):
2212 self
.ReportFile
= ReportFile
2214 self
.ReportList
= []
2215 self
.ReportType
= []
2217 for ReportTypeItem
in ReportType
:
2218 if ReportTypeItem
not in self
.ReportType
:
2219 self
.ReportType
.append(ReportTypeItem
)
2221 self
.ReportType
= ["PCD", "LIBRARY", "BUILD_FLAGS", "DEPEX", "HASH", "FLASH", "FIXED_ADDRESS"]
2223 # Adds platform report to the list
2225 # This function adds a platform report to the final report list.
2227 # @param self The object pointer
2228 # @param Wa Workspace context information
2229 # @param MaList The list of modules in the platform build
2231 def AddPlatformReport(self
, Wa
, MaList
=None):
2233 self
.ReportList
.append((Wa
, MaList
))
2236 # Generates the final report.
2238 # This function generates platform build report. It invokes GenerateReport()
2239 # method for every platform report in the list.
2241 # @param self The object pointer
2242 # @param BuildDuration The total time to build the modules
2243 # @param AutoGenTime The total time of AutoGen phase
2244 # @param MakeTime The total time of Make phase
2245 # @param GenFdsTime The total time of GenFds phase
2247 def GenerateReport(self
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
):
2251 for (Wa
, MaList
) in self
.ReportList
:
2252 PlatformReport(Wa
, MaList
, self
.ReportType
).GenerateReport(File
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
, self
.ReportType
)
2253 Content
= FileLinesSplit(File
.getvalue(), gLineMaxLength
)
2254 SaveFileOnChange(self
.ReportFile
, Content
, True)
2255 EdkLogger
.quiet("Build report can be found at %s" % os
.path
.abspath(self
.ReportFile
))
2257 EdkLogger
.error(None, FILE_WRITE_FAILURE
, ExtraData
=self
.ReportFile
)
2259 EdkLogger
.error("BuildReport", CODE_ERROR
, "Unknown fatal error when generating build report", ExtraData
=self
.ReportFile
, RaiseError
=False)
2260 EdkLogger
.quiet("(Python %s on %s\n%s)" % (platform
.python_version(), sys
.platform
, traceback
.format_exc()))
2263 # This acts like the main() function for the script, unless it is 'import'ed into another script.
2264 if __name__
== '__main__':