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
.append(String
+ gEndOfLine
)
148 def ByteArrayForamt(Value
):
152 if Value
.startswith('{') and Value
.endswith('}') and not Value
.startswith("{CODE("):
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(gEndOfLine
, TAB_LINE_BREAK
).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
.utcfromtimestamp(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
!= b
"":
725 To(Line
.rstrip().decode(encoding
='utf-8', errors
='ignore'))
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 StructPcdDict
= GlobalData
.gStructurePcd
.get(self
.Arch
, collections
.OrderedDict())
784 for Name
, Guid
in StructPcdDict
:
785 if (Name
, Guid
) not in Pa
.Platform
.Pcds
:
786 Pcd
= StructPcdDict
[(Name
, Guid
)]
787 PcdList
= self
.AllPcds
.setdefault(Guid
, {}).setdefault(Pcd
.Type
, [])
788 if Pcd
not in PcdList
and Pcd
not in UnusedPcdFullList
:
789 UnusedPcdFullList
.append(Pcd
)
790 for item
in Pa
.Platform
.Pcds
:
791 Pcd
= Pa
.Platform
.Pcds
[item
]
793 # check the Pcd in FDF file, whether it is used in module first
794 for T
in PCD_TYPE_LIST
:
795 PcdList
= self
.AllPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(T
, [])
801 for package
in Pa
.PackageList
:
802 for T
in PCD_TYPE_LIST
:
803 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, T
) in package
.Pcds
:
806 if not Pcd
.DatumType
:
807 Pcd
.DatumType
= package
.Pcds
[(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, T
)].DatumType
811 if not Pcd
.DatumType
:
813 # Try to remove Hii and Vpd suffix
814 if PcdType
.startswith(TAB_PCDS_DYNAMIC_EX
):
815 PcdType
= TAB_PCDS_DYNAMIC_EX
816 elif PcdType
.startswith(TAB_PCDS_DYNAMIC
):
817 PcdType
= TAB_PCDS_DYNAMIC
818 for package
in Pa
.PackageList
:
819 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, PcdType
) in package
.Pcds
:
820 Pcd
.DatumType
= package
.Pcds
[(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, PcdType
)].DatumType
823 PcdList
= self
.AllPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
824 UnusedPcdList
= self
.UnusedPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
825 if Pcd
in UnusedPcdList
:
826 UnusedPcdList
.remove(Pcd
)
827 if Pcd
not in PcdList
and Pcd
not in UnusedPcdFullList
:
828 UnusedPcdFullList
.append(Pcd
)
829 if len(Pcd
.TokenCName
) > self
.MaxLen
:
830 self
.MaxLen
= len(Pcd
.TokenCName
)
832 if GlobalData
.gConditionalPcds
:
833 for PcdItem
in GlobalData
.gConditionalPcds
:
835 (TokenSpaceGuidCName
, TokenCName
) = PcdItem
.split('.')
836 if (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
837 Pcd
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)]
838 PcdList
= self
.ConditionalPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
839 if Pcd
not in PcdList
:
843 if UnusedPcdFullList
:
844 for Pcd
in UnusedPcdFullList
:
845 if Pcd
.TokenSpaceGuidCName
+ '.' + Pcd
.TokenCName
in GlobalData
.gConditionalPcds
:
847 UnusedPcdList
.append(Pcd
)
849 for Pcd
in UnusedPcdList
:
850 PcdList
= self
.UnusedPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
851 if Pcd
not in PcdList
:
854 for Module
in Pa
.Platform
.Modules
.values():
856 # Collect module override PCDs
858 for ModulePcd
in Module
.M
.ModulePcdList
+ Module
.M
.LibraryPcdList
:
859 TokenCName
= ModulePcd
.TokenCName
860 TokenSpaceGuid
= ModulePcd
.TokenSpaceGuidCName
861 ModuleDefault
= ModulePcd
.DefaultValue
862 ModulePath
= os
.path
.basename(Module
.M
.MetaFile
.File
)
863 self
.ModulePcdOverride
.setdefault((TokenCName
, TokenSpaceGuid
), {})[ModulePath
] = ModuleDefault
867 # Collect PCD DEC default value.
869 self
.DecPcdDefault
= {}
871 for Pa
in Wa
.AutoGenObjectList
:
872 for Package
in Pa
.PackageList
:
873 Guids
= Package
.Guids
874 self
._GuidDict
.update(Guids
)
875 for (TokenCName
, TokenSpaceGuidCName
, DecType
) in Package
.Pcds
:
876 DecDefaultValue
= Package
.Pcds
[TokenCName
, TokenSpaceGuidCName
, DecType
].DefaultValue
877 self
.DecPcdDefault
.setdefault((TokenCName
, TokenSpaceGuidCName
, DecType
), DecDefaultValue
)
879 # Collect PCDs defined in DSC common section
881 self
.DscPcdDefault
= {}
882 for Pa
in Wa
.AutoGenObjectList
:
883 for (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
884 DscDefaultValue
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)].DscDefaultValue
886 self
.DscPcdDefault
[(TokenCName
, TokenSpaceGuidCName
)] = DscDefaultValue
888 def GenerateReport(self
, File
, ModulePcdSet
):
890 if self
.ConditionalPcds
:
891 self
.GenerateReportDetail(File
, ModulePcdSet
, 1)
894 for Token
in self
.UnusedPcds
:
895 TokenDict
= self
.UnusedPcds
[Token
]
896 for Type
in TokenDict
:
903 self
.GenerateReportDetail(File
, ModulePcdSet
, 2)
904 self
.GenerateReportDetail(File
, ModulePcdSet
)
907 # Generate report for PCD information
909 # This function generates report for separate module expression
910 # in a platform build.
912 # @param self The object pointer
913 # @param File The file object for report
914 # @param ModulePcdSet Set of all PCDs referenced by module or None for
915 # platform PCD report
916 # @param ReportySubType 0 means platform/module PCD report, 1 means Conditional
917 # directives section report, 2 means Unused Pcds section report
918 # @param DscOverridePcds Module DSC override PCDs set
920 def GenerateReportDetail(self
, File
, ModulePcdSet
, ReportSubType
= 0):
921 PcdDict
= self
.AllPcds
922 if ReportSubType
== 1:
923 PcdDict
= self
.ConditionalPcds
924 elif ReportSubType
== 2:
925 PcdDict
= self
.UnusedPcds
928 FileWrite(File
, gSectionStart
)
929 if ReportSubType
== 1:
930 FileWrite(File
, "Conditional Directives used by the build system")
931 elif ReportSubType
== 2:
932 FileWrite(File
, "PCDs not used by modules or in conditional directives")
934 FileWrite(File
, "Platform Configuration Database Report")
936 FileWrite(File
, " *B - PCD override in the build option")
937 FileWrite(File
, " *P - Platform scoped PCD override in DSC file")
938 FileWrite(File
, " *F - Platform scoped PCD override in FDF file")
939 if not ReportSubType
:
940 FileWrite(File
, " *M - Module scoped PCD override")
941 FileWrite(File
, gSectionSep
)
943 if not ReportSubType
and ModulePcdSet
:
945 # For module PCD sub-section
947 FileWrite(File
, gSubSectionStart
)
948 FileWrite(File
, TAB_BRG_PCD
)
949 FileWrite(File
, gSubSectionSep
)
953 for Type
in PcdDict
[Key
]:
954 for Pcd
in PcdDict
[Key
][Type
]:
955 AllPcdDict
[Key
][(Pcd
.TokenCName
, Type
)] = Pcd
956 for Key
in sorted(AllPcdDict
):
958 # Group PCD by their token space GUID C Name
961 for PcdTokenCName
, Type
in sorted(AllPcdDict
[Key
]):
963 # Group PCD by their usage type
965 Pcd
= AllPcdDict
[Key
][(PcdTokenCName
, Type
)]
966 TypeName
, DecType
= gPcdTypeMap
.get(Type
, ("", Type
))
968 if GlobalData
.MixedPcd
:
969 for PcdKey
in GlobalData
.MixedPcd
:
970 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
) in GlobalData
.MixedPcd
[PcdKey
]:
971 PcdTokenCName
= PcdKey
[0]
973 if MixedPcdFlag
and not ModulePcdSet
:
976 # Get PCD default value and their override relationship
978 DecDefaultValue
= self
.DecPcdDefault
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, DecType
))
979 DscDefaultValue
= self
.DscPcdDefault
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
))
980 DscDefaultValBak
= DscDefaultValue
982 for (CName
, Guid
, Field
) in self
.FdfPcdSet
:
983 if CName
== PcdTokenCName
and Guid
== Key
:
984 DscDefaultValue
= self
.FdfPcdSet
[(CName
, Guid
, Field
)]
986 if DscDefaultValue
!= DscDefaultValBak
:
988 DscDefaultValue
= ValueExpressionEx(DscDefaultValue
, Pcd
.DatumType
, self
._GuidDict
)(True)
989 except BadExpression
as DscDefaultValue
:
990 EdkLogger
.error('BuildReport', FORMAT_INVALID
, "PCD Value: %s, Type: %s" %(DscDefaultValue
, Pcd
.DatumType
))
992 InfDefaultValue
= None
994 PcdValue
= DecDefaultValue
996 PcdValue
= DscDefaultValue
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
1000 if ModulePcdSet
is not None:
1001 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Type
) not in ModulePcdSet
:
1003 InfDefaultValue
, PcdValue
= ModulePcdSet
[Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Type
]
1004 #The DefaultValue of StructurePcd already be the latest, no need to update.
1005 if not self
.IsStructurePcd(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
):
1006 Pcd
.DefaultValue
= PcdValue
1009 InfDefaultValue
= ValueExpressionEx(InfDefaultValue
, Pcd
.DatumType
, self
._GuidDict
)(True)
1010 except BadExpression
as InfDefaultValue
:
1011 EdkLogger
.error('BuildReport', FORMAT_INVALID
, "PCD Value: %s, Type: %s" % (InfDefaultValue
, Pcd
.DatumType
))
1012 if InfDefaultValue
== "":
1013 InfDefaultValue
= None
1015 BuildOptionMatch
= False
1016 if GlobalData
.BuildOptionPcd
:
1017 for pcd
in GlobalData
.BuildOptionPcd
:
1018 if (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
) == (pcd
[0], pcd
[1]):
1022 #The DefaultValue of StructurePcd already be the latest, no need to update.
1023 if not self
.IsStructurePcd(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
):
1024 Pcd
.DefaultValue
= PcdValue
1025 BuildOptionMatch
= True
1029 if ModulePcdSet
is None:
1031 FileWrite(File
, Key
)
1035 if Pcd
.DatumType
in TAB_PCD_NUMERIC_TYPES
:
1036 if PcdValue
.startswith('0') and not PcdValue
.lower().startswith('0x') and \
1037 len(PcdValue
) > 1 and PcdValue
.lstrip('0'):
1038 PcdValue
= PcdValue
.lstrip('0')
1039 PcdValueNumber
= int(PcdValue
.strip(), 0)
1040 if DecDefaultValue
is None:
1043 if DecDefaultValue
.startswith('0') and not DecDefaultValue
.lower().startswith('0x') and \
1044 len(DecDefaultValue
) > 1 and DecDefaultValue
.lstrip('0'):
1045 DecDefaultValue
= DecDefaultValue
.lstrip('0')
1046 DecDefaultValueNumber
= int(DecDefaultValue
.strip(), 0)
1047 DecMatch
= (DecDefaultValueNumber
== PcdValueNumber
)
1049 if InfDefaultValue
is None:
1052 if InfDefaultValue
.startswith('0') and not InfDefaultValue
.lower().startswith('0x') and \
1053 len(InfDefaultValue
) > 1 and InfDefaultValue
.lstrip('0'):
1054 InfDefaultValue
= InfDefaultValue
.lstrip('0')
1055 InfDefaultValueNumber
= int(InfDefaultValue
.strip(), 0)
1056 InfMatch
= (InfDefaultValueNumber
== PcdValueNumber
)
1058 if DscDefaultValue
is None:
1061 if DscDefaultValue
.startswith('0') and not DscDefaultValue
.lower().startswith('0x') and \
1062 len(DscDefaultValue
) > 1 and DscDefaultValue
.lstrip('0'):
1063 DscDefaultValue
= DscDefaultValue
.lstrip('0')
1064 DscDefaultValueNumber
= int(DscDefaultValue
.strip(), 0)
1065 DscMatch
= (DscDefaultValueNumber
== PcdValueNumber
)
1067 if DecDefaultValue
is None:
1070 DecMatch
= (DecDefaultValue
.strip() == PcdValue
.strip())
1072 if InfDefaultValue
is None:
1075 InfMatch
= (InfDefaultValue
.strip() == PcdValue
.strip())
1077 if DscDefaultValue
is None:
1080 DscMatch
= (DscDefaultValue
.strip() == PcdValue
.strip())
1083 if self
.IsStructurePcd(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
):
1085 if TypeName
in ('DYNVPD', 'DEXVPD'):
1086 SkuInfoList
= Pcd
.SkuInfoList
1087 Pcd
= GlobalData
.gStructurePcd
[self
.Arch
][(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
)]
1088 Pcd
.DatumType
= Pcd
.StructName
1089 if TypeName
in ('DYNVPD', 'DEXVPD'):
1090 Pcd
.SkuInfoList
= SkuInfoList
1091 if Pcd
.PcdValueFromComm
or Pcd
.PcdFieldValueFromComm
:
1092 BuildOptionMatch
= True
1094 elif Pcd
.PcdValueFromFdf
or Pcd
.PcdFieldValueFromFdf
:
1095 DscDefaultValue
= True
1098 elif Pcd
.SkuOverrideValues
:
1100 if Pcd
.DefaultFromDSC
:
1104 for item
in Pcd
.SkuOverrideValues
:
1105 DictLen
+= len(Pcd
.SkuOverrideValues
[item
])
1109 if not Pcd
.SkuInfoList
:
1110 OverrideValues
= Pcd
.SkuOverrideValues
1112 for Data
in OverrideValues
.values():
1113 Struct
= list(Data
.values())
1115 DscOverride
= self
.ParseStruct(Struct
[0])
1118 SkuList
= sorted(Pcd
.SkuInfoList
.keys())
1120 SkuInfo
= Pcd
.SkuInfoList
[Sku
]
1121 if TypeName
in ('DYNHII', 'DEXHII'):
1122 if SkuInfo
.DefaultStoreDict
:
1123 DefaultStoreList
= sorted(SkuInfo
.DefaultStoreDict
.keys())
1124 for DefaultStore
in DefaultStoreList
:
1125 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1126 DscOverride
= self
.ParseStruct(OverrideValues
[DefaultStore
])
1130 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1132 Keys
= list(OverrideValues
.keys())
1133 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[Keys
[0]])
1134 DscOverride
= self
.ParseStruct(OverrideFieldStruct
)
1138 DscDefaultValue
= True
1144 DscDefaultValue
= True
1149 # Report PCD item according to their override relationship
1151 if Pcd
.DatumType
== 'BOOLEAN':
1153 DscDefaultValue
= str(int(DscDefaultValue
, 0))
1155 DecDefaultValue
= str(int(DecDefaultValue
, 0))
1157 InfDefaultValue
= str(int(InfDefaultValue
, 0))
1158 if Pcd
.DefaultValue
:
1159 Pcd
.DefaultValue
= str(int(Pcd
.DefaultValue
, 0))
1161 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, ' ')
1162 elif InfDefaultValue
and InfMatch
:
1163 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*M')
1164 elif BuildOptionMatch
:
1165 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*B')
1167 if DscDefaultValue
and DscMatch
:
1168 if (Pcd
.TokenCName
, Key
, Field
) in self
.FdfPcdSet
:
1169 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*F')
1171 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*P')
1173 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*M')
1175 if ModulePcdSet
is None:
1178 if not TypeName
in ('PATCH', 'FLAG', 'FIXED'):
1180 if not BuildOptionMatch
:
1181 ModuleOverride
= self
.ModulePcdOverride
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
), {})
1182 for ModulePath
in ModuleOverride
:
1183 ModuleDefault
= ModuleOverride
[ModulePath
]
1184 if Pcd
.DatumType
in TAB_PCD_NUMERIC_TYPES
:
1185 if ModuleDefault
.startswith('0') and not ModuleDefault
.lower().startswith('0x') and \
1186 len(ModuleDefault
) > 1 and ModuleDefault
.lstrip('0'):
1187 ModuleDefault
= ModuleDefault
.lstrip('0')
1188 ModulePcdDefaultValueNumber
= int(ModuleDefault
.strip(), 0)
1189 Match
= (ModulePcdDefaultValueNumber
== PcdValueNumber
)
1190 if Pcd
.DatumType
== 'BOOLEAN':
1191 ModuleDefault
= str(ModulePcdDefaultValueNumber
)
1193 Match
= (ModuleDefault
.strip() == PcdValue
.strip())
1196 IsByteArray
, ArrayList
= ByteArrayForamt(ModuleDefault
.strip())
1198 FileWrite(File
, ' *M %-*s = %s' % (self
.MaxLen
+ 15, ModulePath
, '{'))
1199 for Array
in ArrayList
:
1200 FileWrite(File
, Array
)
1202 Value
= ModuleDefault
.strip()
1203 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1204 if Value
.startswith(('0x', '0X')):
1205 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1207 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1208 FileWrite(File
, ' *M %-*s = %s' % (self
.MaxLen
+ 15, ModulePath
, Value
))
1210 if ModulePcdSet
is None:
1211 FileWrite(File
, gSectionEnd
)
1213 if not ReportSubType
and ModulePcdSet
:
1214 FileWrite(File
, gSubSectionEnd
)
1216 def ParseStruct(self
, struct
):
1217 HasDscOverride
= False
1219 for _
, Values
in list(struct
.items()):
1220 for Key
, value
in Values
.items():
1221 if value
[1] and value
[1].endswith('.dsc'):
1222 HasDscOverride
= True
1224 if HasDscOverride
== True:
1226 return HasDscOverride
1228 def PrintPcdDefault(self
, File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
):
1229 if not DscMatch
and DscDefaultValue
is not None:
1230 Value
= DscDefaultValue
.strip()
1231 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1233 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DSC DEFAULT', "{"))
1234 for Array
in ArrayList
:
1235 FileWrite(File
, Array
)
1237 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1238 if Value
.startswith(('0x', '0X')):
1239 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1241 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1242 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DSC DEFAULT', Value
))
1243 if not InfMatch
and InfDefaultValue
is not None:
1244 Value
= InfDefaultValue
.strip()
1245 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1247 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'INF DEFAULT', "{"))
1248 for Array
in ArrayList
:
1249 FileWrite(File
, Array
)
1251 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1252 if Value
.startswith(('0x', '0X')):
1253 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1255 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1256 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'INF DEFAULT', Value
))
1258 if not DecMatch
and DecDefaultValue
is not None:
1259 Value
= DecDefaultValue
.strip()
1260 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1262 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DEC DEFAULT', "{"))
1263 for Array
in ArrayList
:
1264 FileWrite(File
, Array
)
1266 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1267 if Value
.startswith(('0x', '0X')):
1268 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1270 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1271 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DEC DEFAULT', Value
))
1273 for filedvalues
in Pcd
.DefaultValues
.values():
1274 self
.PrintStructureInfo(File
, filedvalues
)
1275 if DecMatch
and IsStructure
:
1276 for filedvalues
in Pcd
.DefaultValues
.values():
1277 self
.PrintStructureInfo(File
, filedvalues
)
1279 def PrintPcdValue(self
, File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, Flag
= ' '):
1280 if not Pcd
.SkuInfoList
:
1281 Value
= Pcd
.DefaultValue
1282 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1284 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1285 for Array
in ArrayList
:
1286 FileWrite(File
, Array
)
1288 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1289 if Value
.startswith('0') and not Value
.lower().startswith('0x') and len(Value
) > 1 and Value
.lstrip('0'):
1290 Value
= Value
.lstrip('0')
1291 if Value
.startswith(('0x', '0X')):
1292 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1294 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1295 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1297 FiledOverrideFlag
= False
1298 OverrideValues
= Pcd
.SkuOverrideValues
1300 for Data
in OverrideValues
.values():
1301 Struct
= list(Data
.values())
1303 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, Struct
[0])
1304 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1305 FiledOverrideFlag
= True
1307 if not FiledOverrideFlag
and (Pcd
.PcdFieldValueFromComm
or Pcd
.PcdFieldValueFromFdf
):
1308 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, {})
1309 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1310 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1313 SkuList
= sorted(Pcd
.SkuInfoList
.keys())
1315 SkuInfo
= Pcd
.SkuInfoList
[Sku
]
1316 SkuIdName
= SkuInfo
.SkuIdName
1317 if TypeName
in ('DYNHII', 'DEXHII'):
1318 if SkuInfo
.DefaultStoreDict
:
1319 DefaultStoreList
= sorted(SkuInfo
.DefaultStoreDict
.keys())
1320 for DefaultStore
in DefaultStoreList
:
1321 Value
= SkuInfo
.DefaultStoreDict
[DefaultStore
]
1322 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1323 if Pcd
.DatumType
== 'BOOLEAN':
1324 Value
= str(int(Value
, 0))
1328 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1329 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1330 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1331 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '{'))
1332 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1333 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', '{'))
1335 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', '{'))
1336 for Array
in ArrayList
:
1337 FileWrite(File
, Array
)
1339 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1340 if Value
.startswith(('0x', '0X')):
1341 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1343 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1344 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1345 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1346 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1347 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1348 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1349 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', Value
))
1351 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', Value
))
1354 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1355 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1356 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1357 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '{'))
1358 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1359 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', '{'))
1361 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', '{'))
1362 for Array
in ArrayList
:
1363 FileWrite(File
, Array
)
1365 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1366 if Value
.startswith(('0x', '0X')):
1367 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1369 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1370 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1371 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1372 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1373 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1374 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1375 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', Value
))
1377 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', Value
))
1378 FileWrite(File
, '%*s: %s: %s' % (self
.MaxLen
+ 4, SkuInfo
.VariableGuid
, SkuInfo
.VariableName
, SkuInfo
.VariableOffset
))
1380 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1381 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[DefaultStore
])
1382 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1383 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1385 Value
= SkuInfo
.DefaultValue
1386 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1387 if Pcd
.DatumType
== 'BOOLEAN':
1388 Value
= str(int(Value
, 0))
1393 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', "{"))
1395 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', "{"))
1396 for Array
in ArrayList
:
1397 FileWrite(File
, Array
)
1399 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1400 if Value
.startswith(('0x', '0X')):
1401 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1403 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1405 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1407 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1411 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', "{"))
1413 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', "{"))
1414 for Array
in ArrayList
:
1415 FileWrite(File
, Array
)
1417 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1418 if Value
.startswith(('0x', '0X')):
1419 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1421 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1423 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1425 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1426 if TypeName
in ('DYNVPD', 'DEXVPD'):
1427 FileWrite(File
, '%*s' % (self
.MaxLen
+ 4, SkuInfo
.VpdOffset
))
1428 VPDPcdItem
= (Pcd
.TokenSpaceGuidCName
+ '.' + PcdTokenCName
, SkuIdName
, SkuInfo
.VpdOffset
, Pcd
.MaxDatumSize
, SkuInfo
.DefaultValue
)
1429 if VPDPcdItem
not in VPDPcdList
:
1430 VPDPcdList
.append(VPDPcdItem
)
1432 FiledOverrideFlag
= False
1433 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1435 Keys
= list(OverrideValues
.keys())
1436 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[Keys
[0]])
1437 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1438 FiledOverrideFlag
= True
1439 if not FiledOverrideFlag
and (Pcd
.PcdFieldValueFromComm
or Pcd
.PcdFieldValueFromFdf
):
1440 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, {})
1441 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1442 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1444 def OverrideFieldValue(self
, Pcd
, OverrideStruct
):
1445 OverrideFieldStruct
= collections
.OrderedDict()
1447 for _
, Values
in OverrideStruct
.items():
1448 for Key
,value
in Values
.items():
1449 if value
[1] and value
[1].endswith('.dsc'):
1450 OverrideFieldStruct
[Key
] = value
1451 if Pcd
.PcdFieldValueFromFdf
:
1452 for Key
, Values
in Pcd
.PcdFieldValueFromFdf
.items():
1453 if Key
in OverrideFieldStruct
and Values
[0] == OverrideFieldStruct
[Key
][0]:
1455 OverrideFieldStruct
[Key
] = Values
1456 if Pcd
.PcdFieldValueFromComm
:
1457 for Key
, Values
in Pcd
.PcdFieldValueFromComm
.items():
1458 if Key
in OverrideFieldStruct
and Values
[0] == OverrideFieldStruct
[Key
][0]:
1460 OverrideFieldStruct
[Key
] = Values
1461 return OverrideFieldStruct
1463 def PrintStructureInfo(self
, File
, Struct
):
1464 for Key
, Value
in sorted(Struct
.items(), key
=lambda x
: x
[0]):
1465 if Value
[1] and 'build command options' in Value
[1]:
1466 FileWrite(File
, ' *B %-*s = %s' % (self
.MaxLen
+ 4, '.' + Key
, Value
[0]))
1467 elif Value
[1] and Value
[1].endswith('.fdf'):
1468 FileWrite(File
, ' *F %-*s = %s' % (self
.MaxLen
+ 4, '.' + Key
, Value
[0]))
1470 FileWrite(File
, ' %-*s = %s' % (self
.MaxLen
+ 4, '.' + Key
, Value
[0]))
1472 def StrtoHex(self
, value
):
1474 value
= hex(int(value
))
1477 if value
.startswith("L\"") and value
.endswith("\""):
1479 for ch
in value
[2:-1]:
1480 valuelist
.append(hex(ord(ch
)))
1481 valuelist
.append('0x00')
1483 elif value
.startswith("\"") and value
.endswith("\""):
1484 return hex(ord(value
[1:-1]))
1485 elif value
.startswith("{") and value
.endswith("}"):
1487 if ',' not in value
:
1489 for ch
in value
[1:-1].split(','):
1491 if ch
.startswith('0x') or ch
.startswith('0X'):
1492 valuelist
.append(ch
)
1495 valuelist
.append(hex(int(ch
.strip())))
1502 def IsStructurePcd(self
, PcdToken
, PcdTokenSpaceGuid
):
1503 if GlobalData
.gStructurePcd
and (self
.Arch
in GlobalData
.gStructurePcd
) and ((PcdToken
, PcdTokenSpaceGuid
) in GlobalData
.gStructurePcd
[self
.Arch
]):
1509 # Reports platform and module Prediction information
1511 # This class reports the platform execution order prediction section and
1512 # module load fixed address prediction subsection in the build report file.
1514 class PredictionReport(object):
1516 # Constructor function for class PredictionReport
1518 # This constructor function generates PredictionReport object for the platform.
1520 # @param self: The object pointer
1521 # @param Wa Workspace context information
1523 def __init__(self
, Wa
):
1524 self
._MapFileName
= os
.path
.join(Wa
.BuildDir
, Wa
.Name
+ ".map")
1525 self
._MapFileParsed
= False
1526 self
._EotToolInvoked
= False
1527 self
._FvDir
= Wa
.FvDir
1528 self
._EotDir
= Wa
.BuildDir
1529 self
._FfsEntryPoint
= {}
1531 self
._SourceList
= []
1532 self
.FixedMapDict
= {}
1537 # Collect all platform reference source files and GUID C Name
1539 for Pa
in Wa
.AutoGenObjectList
:
1540 for Module
in Pa
.LibraryAutoGenList
+ Pa
.ModuleAutoGenList
:
1542 # BASE typed modules are EFI agnostic, so we need not scan
1543 # their source code to find PPI/Protocol produce or consume
1546 if Module
.ModuleType
== SUP_MODULE_BASE
:
1549 # Add module referenced source files
1551 self
._SourceList
.append(str(Module
))
1553 for Source
in Module
.SourceFileList
:
1554 if os
.path
.splitext(str(Source
))[1].lower() == ".c":
1555 self
._SourceList
.append(" " + str(Source
))
1556 FindIncludeFiles(Source
.Path
, Module
.IncludePathList
, IncludeList
)
1557 for IncludeFile
in IncludeList
.values():
1558 self
._SourceList
.append(" " + IncludeFile
)
1560 for Guid
in Module
.PpiList
:
1561 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.PpiList
[Guid
])
1562 for Guid
in Module
.ProtocolList
:
1563 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.ProtocolList
[Guid
])
1564 for Guid
in Module
.GuidList
:
1565 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.GuidList
[Guid
])
1567 if Module
.Guid
and not Module
.IsLibrary
:
1568 EntryPoint
= " ".join(Module
.Module
.ModuleEntryPointList
)
1570 RealEntryPoint
= "_ModuleEntryPoint"
1572 self
._FfsEntryPoint
[Module
.Guid
.upper()] = (EntryPoint
, RealEntryPoint
)
1576 # Collect platform firmware volume list as the input of EOT.
1580 for Fd
in Wa
.FdfProfile
.FdDict
:
1581 for FdRegion
in Wa
.FdfProfile
.FdDict
[Fd
].RegionList
:
1582 if FdRegion
.RegionType
!= BINARY_FILE_TYPE_FV
:
1584 for FvName
in FdRegion
.RegionDataList
:
1585 if FvName
in self
._FvList
:
1587 self
._FvList
.append(FvName
)
1588 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1589 for Section
in Ffs
.SectionList
:
1591 for FvSection
in Section
.SectionList
:
1592 if FvSection
.FvName
in self
._FvList
:
1594 self
._FvList
.append(FvSection
.FvName
)
1595 except AttributeError:
1600 # Parse platform fixed address map files
1602 # This function parses the platform final fixed address map file to get
1603 # the database of predicted fixed address for module image base, entry point
1606 # @param self: The object pointer
1608 def _ParseMapFile(self
):
1609 if self
._MapFileParsed
:
1611 self
._MapFileParsed
= True
1612 if os
.path
.isfile(self
._MapFileName
):
1614 FileContents
= open(self
._MapFileName
).read()
1615 for Match
in gMapFileItemPattern
.finditer(FileContents
):
1616 AddressType
= Match
.group(1)
1617 BaseAddress
= Match
.group(2)
1618 EntryPoint
= Match
.group(3)
1619 Guid
= Match
.group(4).upper()
1620 List
= self
.FixedMapDict
.setdefault(Guid
, [])
1621 List
.append((AddressType
, BaseAddress
, "*I"))
1622 List
.append((AddressType
, EntryPoint
, "*E"))
1624 EdkLogger
.warn(None, "Cannot open file to read", self
._MapFileName
)
1627 # Invokes EOT tool to get the predicted the execution order.
1629 # This function invokes EOT tool to calculate the predicted dispatch order
1631 # @param self: The object pointer
1633 def _InvokeEotTool(self
):
1634 if self
._EotToolInvoked
:
1637 self
._EotToolInvoked
= True
1639 for FvName
in self
._FvList
:
1640 FvFile
= os
.path
.join(self
._FvDir
, FvName
+ ".Fv")
1641 if os
.path
.isfile(FvFile
):
1642 FvFileList
.append(FvFile
)
1644 if len(FvFileList
) == 0:
1647 # Write source file list and GUID file list to an intermediate file
1648 # as the input for EOT tool and dispatch List as the output file
1651 SourceList
= os
.path
.join(self
._EotDir
, "SourceFile.txt")
1652 GuidList
= os
.path
.join(self
._EotDir
, "GuidList.txt")
1653 DispatchList
= os
.path
.join(self
._EotDir
, "Dispatch.txt")
1655 TempFile
= open(SourceList
, "w+")
1656 for Item
in self
._SourceList
:
1657 FileWrite(TempFile
, Item
)
1659 TempFile
= open(GuidList
, "w+")
1660 for Key
in self
._GuidMap
:
1661 FileWrite(TempFile
, "%s %s" % (Key
, self
._GuidMap
[Key
]))
1665 from Eot
.EotMain
import Eot
1668 # Invoke EOT tool and echo its runtime performance
1670 EotStartTime
= time
.time()
1671 Eot(CommandLineOption
=False, SourceFileList
=SourceList
, GuidList
=GuidList
,
1672 FvFileList
=' '.join(FvFileList
), Dispatch
=DispatchList
, IsInit
=True)
1673 EotEndTime
= time
.time()
1674 EotDuration
= time
.strftime("%H:%M:%S", time
.gmtime(int(round(EotEndTime
- EotStartTime
))))
1675 EdkLogger
.quiet("EOT run time: %s\n" % EotDuration
)
1678 # Parse the output of EOT tool
1680 for Line
in open(DispatchList
):
1681 if len(Line
.split()) < 4:
1683 (Guid
, Phase
, FfsName
, FilePath
) = Line
.split()
1684 Symbol
= self
._FfsEntryPoint
.get(Guid
, [FfsName
, ""])[0]
1685 if len(Symbol
) > self
.MaxLen
:
1686 self
.MaxLen
= len(Symbol
)
1687 self
.ItemList
.append((Phase
, Symbol
, FilePath
))
1689 EdkLogger
.quiet("(Python %s on %s\n%s)" % (platform
.python_version(), sys
.platform
, traceback
.format_exc()))
1690 EdkLogger
.warn(None, "Failed to generate execution order prediction report, for some error occurred in executing EOT.")
1694 # Generate platform execution order report
1696 # This function generates the predicted module execution order.
1698 # @param self The object pointer
1699 # @param File The file object for report
1701 def _GenerateExecutionOrderReport(self
, File
):
1702 self
._InvokeEotTool
()
1703 if len(self
.ItemList
) == 0:
1705 FileWrite(File
, gSectionStart
)
1706 FileWrite(File
, "Execution Order Prediction")
1707 FileWrite(File
, "*P PEI phase")
1708 FileWrite(File
, "*D DXE phase")
1709 FileWrite(File
, "*E Module INF entry point name")
1710 FileWrite(File
, "*N Module notification function name")
1712 FileWrite(File
, "Type %-*s %s" % (self
.MaxLen
, "Symbol", "Module INF Path"))
1713 FileWrite(File
, gSectionSep
)
1714 for Item
in self
.ItemList
:
1715 FileWrite(File
, "*%sE %-*s %s" % (Item
[0], self
.MaxLen
, Item
[1], Item
[2]))
1717 FileWrite(File
, gSectionStart
)
1720 # Generate Fixed Address report.
1722 # This function generate the predicted fixed address report for a module
1723 # specified by Guid.
1725 # @param self The object pointer
1726 # @param File The file object for report
1727 # @param Guid The module Guid value.
1728 # @param NotifyList The list of all notify function in a module
1730 def _GenerateFixedAddressReport(self
, File
, Guid
, NotifyList
):
1731 self
._ParseMapFile
()
1732 FixedAddressList
= self
.FixedMapDict
.get(Guid
)
1733 if not FixedAddressList
:
1736 FileWrite(File
, gSubSectionStart
)
1737 FileWrite(File
, "Fixed Address Prediction")
1738 FileWrite(File
, "*I Image Loading Address")
1739 FileWrite(File
, "*E Entry Point Address")
1740 FileWrite(File
, "*N Notification Function Address")
1741 FileWrite(File
, "*F Flash Address")
1742 FileWrite(File
, "*M Memory Address")
1743 FileWrite(File
, "*S SMM RAM Offset")
1744 FileWrite(File
, "TOM Top of Memory")
1746 FileWrite(File
, "Type Address Name")
1747 FileWrite(File
, gSubSectionSep
)
1748 for Item
in FixedAddressList
:
1753 Name
= "(Image Base)"
1754 elif Symbol
== "*E":
1755 Name
= self
._FfsEntryPoint
.get(Guid
, ["", "_ModuleEntryPoint"])[1]
1756 elif Symbol
in NotifyList
:
1764 elif "Memory" in Type
:
1770 Value
= "TOM" + Value
1772 FileWrite(File
, "%s %-16s %s" % (Symbol
, Value
, Name
))
1775 # Generate report for the prediction part
1777 # This function generate the predicted fixed address report for a module or
1778 # predicted module execution order for a platform.
1779 # If the input Guid is None, then, it generates the predicted module execution order;
1780 # otherwise it generated the module fixed loading address for the module specified by
1783 # @param self The object pointer
1784 # @param File The file object for report
1785 # @param Guid The module Guid value.
1787 def GenerateReport(self
, File
, Guid
):
1789 self
._GenerateFixedAddressReport
(File
, Guid
.upper(), [])
1791 self
._GenerateExecutionOrderReport
(File
)
1794 # Reports FD region information
1796 # This class reports the FD subsection in the build report file.
1797 # It collects region information of platform flash device.
1798 # If the region is a firmware volume, it lists the set of modules
1799 # and its space information; otherwise, it only lists its region name,
1800 # base address and size in its sub-section header.
1801 # If there are nesting FVs, the nested FVs will list immediate after
1802 # this FD region subsection
1804 class FdRegionReport(object):
1806 # Discover all the nested FV name list.
1808 # This is an internal worker function to discover the all the nested FV information
1809 # in the parent firmware volume. It uses deep first search algorithm recursively to
1810 # find all the FV list name and append them to the list.
1812 # @param self The object pointer
1813 # @param FvName The name of current firmware file system
1814 # @param Wa Workspace context information
1816 def _DiscoverNestedFvList(self
, FvName
, Wa
):
1817 FvDictKey
=FvName
.upper()
1818 if FvDictKey
in Wa
.FdfProfile
.FvDict
:
1819 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1820 for Section
in Ffs
.SectionList
:
1822 for FvSection
in Section
.SectionList
:
1823 if FvSection
.FvName
in self
.FvList
:
1825 self
._GuidsDb
[Ffs
.NameGuid
.upper()] = FvSection
.FvName
1826 self
.FvList
.append(FvSection
.FvName
)
1827 self
.FvInfo
[FvSection
.FvName
] = ("Nested FV", 0, 0)
1828 self
._DiscoverNestedFvList
(FvSection
.FvName
, Wa
)
1829 except AttributeError:
1833 # Constructor function for class FdRegionReport
1835 # This constructor function generates FdRegionReport object for a specified FdRegion.
1836 # If the FdRegion is a firmware volume, it will recursively find all its nested Firmware
1837 # volume list. This function also collects GUID map in order to dump module identification
1838 # in the final report.
1840 # @param self: The object pointer
1841 # @param FdRegion The current FdRegion object
1842 # @param Wa Workspace context information
1844 def __init__(self
, FdRegion
, Wa
):
1845 self
.Type
= FdRegion
.RegionType
1846 self
.BaseAddress
= FdRegion
.Offset
1847 self
.Size
= FdRegion
.Size
1851 self
._FvDir
= Wa
.FvDir
1852 self
._WorkspaceDir
= Wa
.WorkspaceDir
1855 # If the input FdRegion is not a firmware volume,
1858 if self
.Type
!= BINARY_FILE_TYPE_FV
:
1862 # Find all nested FVs in the FdRegion
1864 for FvName
in FdRegion
.RegionDataList
:
1865 if FvName
in self
.FvList
:
1867 self
.FvList
.append(FvName
)
1868 self
.FvInfo
[FvName
] = ("Fd Region", self
.BaseAddress
, self
.Size
)
1869 self
._DiscoverNestedFvList
(FvName
, Wa
)
1873 # Collect PCDs declared in DEC files.
1875 for Pa
in Wa
.AutoGenObjectList
:
1876 for Package
in Pa
.PackageList
:
1877 for (TokenCName
, TokenSpaceGuidCName
, DecType
) in Package
.Pcds
:
1878 DecDefaultValue
= Package
.Pcds
[TokenCName
, TokenSpaceGuidCName
, DecType
].DefaultValue
1879 PlatformPcds
[(TokenCName
, TokenSpaceGuidCName
)] = DecDefaultValue
1881 # Collect PCDs defined in DSC file
1883 for Pa
in Wa
.AutoGenObjectList
:
1884 for (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
1885 DscDefaultValue
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)].DefaultValue
1886 PlatformPcds
[(TokenCName
, TokenSpaceGuidCName
)] = DscDefaultValue
1889 # Add PEI and DXE a priori files GUIDs defined in PI specification.
1891 self
._GuidsDb
[PEI_APRIORI_GUID
] = "PEI Apriori"
1892 self
._GuidsDb
[DXE_APRIORI_GUID
] = "DXE Apriori"
1894 # Add ACPI table storage file
1896 self
._GuidsDb
["7E374E25-8E01-4FEE-87F2-390C23C606CD"] = "ACPI table storage"
1898 for Pa
in Wa
.AutoGenObjectList
:
1899 for ModuleKey
in Pa
.Platform
.Modules
:
1900 M
= Pa
.Platform
.Modules
[ModuleKey
].M
1901 InfPath
= mws
.join(Wa
.WorkspaceDir
, M
.MetaFile
.File
)
1902 self
._GuidsDb
[M
.Guid
.upper()] = "%s (%s)" % (M
.Module
.BaseName
, InfPath
)
1905 # Collect the GUID map in the FV firmware volume
1907 for FvName
in self
.FvList
:
1908 FvDictKey
=FvName
.upper()
1909 if FvDictKey
in Wa
.FdfProfile
.FvDict
:
1910 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1913 # collect GUID map for binary EFI file in FDF file.
1915 Guid
= Ffs
.NameGuid
.upper()
1916 Match
= gPcdGuidPattern
.match(Ffs
.NameGuid
)
1918 PcdTokenspace
= Match
.group(1)
1919 PcdToken
= Match
.group(2)
1920 if (PcdToken
, PcdTokenspace
) in PlatformPcds
:
1921 GuidValue
= PlatformPcds
[(PcdToken
, PcdTokenspace
)]
1922 Guid
= GuidStructureByteArrayToGuidString(GuidValue
).upper()
1923 for Section
in Ffs
.SectionList
:
1925 ModuleSectFile
= mws
.join(Wa
.WorkspaceDir
, Section
.SectFileName
)
1926 self
._GuidsDb
[Guid
] = ModuleSectFile
1927 except AttributeError:
1929 except AttributeError:
1934 # Internal worker function to generate report for the FD region
1936 # This internal worker function to generate report for the FD region.
1937 # It the type is firmware volume, it lists offset and module identification.
1939 # @param self The object pointer
1940 # @param File The file object for report
1941 # @param Title The title for the FD subsection
1942 # @param BaseAddress The base address for the FD region
1943 # @param Size The size of the FD region
1944 # @param FvName The FV name if the FD region is a firmware volume
1946 def _GenerateReport(self
, File
, Title
, Type
, BaseAddress
, Size
=0, FvName
=None):
1947 FileWrite(File
, gSubSectionStart
)
1948 FileWrite(File
, Title
)
1949 FileWrite(File
, "Type: %s" % Type
)
1950 FileWrite(File
, "Base Address: 0x%X" % BaseAddress
)
1952 if self
.Type
== BINARY_FILE_TYPE_FV
:
1956 if FvName
.upper().endswith('.FV'):
1957 FileExt
= FvName
+ ".txt"
1959 FileExt
= FvName
+ ".Fv.txt"
1961 if not os
.path
.isfile(FileExt
):
1962 FvReportFileName
= mws
.join(self
._WorkspaceDir
, FileExt
)
1963 if not os
.path
.isfile(FvReportFileName
):
1964 FvReportFileName
= os
.path
.join(self
._FvDir
, FileExt
)
1967 # Collect size info in the firmware volume.
1969 FvReport
= open(FvReportFileName
).read()
1970 Match
= gFvTotalSizePattern
.search(FvReport
)
1972 FvTotalSize
= int(Match
.group(1), 16)
1973 Match
= gFvTakenSizePattern
.search(FvReport
)
1975 FvTakenSize
= int(Match
.group(1), 16)
1976 FvFreeSize
= FvTotalSize
- FvTakenSize
1978 # Write size information to the report file.
1980 FileWrite(File
, "Size: 0x%X (%.0fK)" % (FvTotalSize
, FvTotalSize
/ 1024.0))
1981 FileWrite(File
, "Fv Name: %s (%.1f%% Full)" % (FvName
, FvTakenSize
* 100.0 / FvTotalSize
))
1982 FileWrite(File
, "Occupied Size: 0x%X (%.0fK)" % (FvTakenSize
, FvTakenSize
/ 1024.0))
1983 FileWrite(File
, "Free Size: 0x%X (%.0fK)" % (FvFreeSize
, FvFreeSize
/ 1024.0))
1984 FileWrite(File
, "Offset Module")
1985 FileWrite(File
, gSubSectionSep
)
1987 # Write module offset and module identification to the report file.
1990 for Match
in gOffsetGuidPattern
.finditer(FvReport
):
1991 Guid
= Match
.group(2).upper()
1992 OffsetInfo
[Match
.group(1)] = self
._GuidsDb
.get(Guid
, Guid
)
1993 OffsetList
= sorted(OffsetInfo
.keys())
1994 for Offset
in OffsetList
:
1995 FileWrite (File
, "%s %s" % (Offset
, OffsetInfo
[Offset
]))
1997 EdkLogger
.warn(None, "Fail to read report file", FvReportFileName
)
1999 FileWrite(File
, "Size: 0x%X (%.0fK)" % (Size
, Size
/ 1024.0))
2000 FileWrite(File
, gSubSectionEnd
)
2003 # Generate report for the FD region
2005 # This function generates report for the FD region.
2007 # @param self The object pointer
2008 # @param File The file object for report
2010 def GenerateReport(self
, File
):
2011 if (len(self
.FvList
) > 0):
2012 for FvItem
in self
.FvList
:
2013 Info
= self
.FvInfo
[FvItem
]
2014 self
._GenerateReport
(File
, Info
[0], TAB_FV_DIRECTORY
, Info
[1], Info
[2], FvItem
)
2016 self
._GenerateReport
(File
, "FD Region", self
.Type
, self
.BaseAddress
, self
.Size
)
2019 # Reports FD information
2021 # This class reports the FD section in the build report file.
2022 # It collects flash device information for a platform.
2024 class FdReport(object):
2026 # Constructor function for class FdReport
2028 # This constructor function generates FdReport object for a specified
2031 # @param self The object pointer
2032 # @param Fd The current Firmware device object
2033 # @param Wa Workspace context information
2035 def __init__(self
, Fd
, Wa
):
2036 self
.FdName
= Fd
.FdUiName
2037 self
.BaseAddress
= Fd
.BaseAddress
2039 self
.FdRegionList
= [FdRegionReport(FdRegion
, Wa
) for FdRegion
in Fd
.RegionList
]
2040 self
.FvPath
= os
.path
.join(Wa
.BuildDir
, TAB_FV_DIRECTORY
)
2041 self
.VPDBaseAddress
= 0
2043 for index
, FdRegion
in enumerate(Fd
.RegionList
):
2044 if str(FdRegion
.RegionType
) is 'FILE' and Wa
.Platform
.VpdToolGuid
in str(FdRegion
.RegionDataList
):
2045 self
.VPDBaseAddress
= self
.FdRegionList
[index
].BaseAddress
2046 self
.VPDSize
= self
.FdRegionList
[index
].Size
2050 # Generate report for the firmware device.
2052 # This function generates report for the firmware device.
2054 # @param self The object pointer
2055 # @param File The file object for report
2057 def GenerateReport(self
, File
):
2058 FileWrite(File
, gSectionStart
)
2059 FileWrite(File
, "Firmware Device (FD)")
2060 FileWrite(File
, "FD Name: %s" % self
.FdName
)
2061 FileWrite(File
, "Base Address: %s" % self
.BaseAddress
)
2062 FileWrite(File
, "Size: 0x%X (%.0fK)" % (self
.Size
, self
.Size
/ 1024.0))
2063 if len(self
.FdRegionList
) > 0:
2064 FileWrite(File
, gSectionSep
)
2065 for FdRegionItem
in self
.FdRegionList
:
2066 FdRegionItem
.GenerateReport(File
)
2069 VPDPcdList
.sort(key
=lambda x
: int(x
[2], 0))
2070 FileWrite(File
, gSubSectionStart
)
2071 FileWrite(File
, "FD VPD Region")
2072 FileWrite(File
, "Base Address: 0x%X" % self
.VPDBaseAddress
)
2073 FileWrite(File
, "Size: 0x%X (%.0fK)" % (self
.VPDSize
, self
.VPDSize
/ 1024.0))
2074 FileWrite(File
, gSubSectionSep
)
2075 for item
in VPDPcdList
:
2076 # Add BaseAddress for offset
2077 Offset
= '0x%08X' % (int(item
[2], 16) + self
.VPDBaseAddress
)
2078 IsByteArray
, ArrayList
= ByteArrayForamt(item
[-1])
2080 if len(GlobalData
.gSkuids
) == 1 :
2081 Skuinfo
= GlobalData
.gSkuids
[0]
2083 FileWrite(File
, "%s | %s | %s | %s | %s" % (item
[0], Skuinfo
, Offset
, item
[3], '{'))
2084 for Array
in ArrayList
:
2085 FileWrite(File
, Array
)
2087 FileWrite(File
, "%s | %s | %s | %s | %s" % (item
[0], Skuinfo
, Offset
, item
[3], item
[-1]))
2088 FileWrite(File
, gSubSectionEnd
)
2089 FileWrite(File
, gSectionEnd
)
2094 # Reports platform information
2096 # This class reports the whole platform information
2098 class PlatformReport(object):
2100 # Constructor function for class PlatformReport
2102 # This constructor function generates PlatformReport object a platform build.
2103 # It generates report for platform summary, flash, global PCDs and detailed
2104 # module information for modules involved in platform build.
2106 # @param self The object pointer
2107 # @param Wa Workspace context information
2108 # @param MaList The list of modules in the platform build
2110 def __init__(self
, Wa
, MaList
, ReportType
):
2111 self
._WorkspaceDir
= Wa
.WorkspaceDir
2112 self
.PlatformName
= Wa
.Name
2113 self
.PlatformDscPath
= Wa
.Platform
2114 self
.Architectures
= " ".join(Wa
.ArchList
)
2115 self
.ToolChain
= Wa
.ToolChain
2116 self
.Target
= Wa
.BuildTarget
2117 self
.OutputPath
= os
.path
.join(Wa
.WorkspaceDir
, Wa
.OutputDir
)
2118 self
.BuildEnvironment
= platform
.platform()
2120 self
.PcdReport
= None
2121 if "PCD" in ReportType
:
2122 self
.PcdReport
= PcdReport(Wa
)
2124 self
.FdReportList
= []
2125 if "FLASH" in ReportType
and Wa
.FdfProfile
and MaList
is None:
2126 for Fd
in Wa
.FdfProfile
.FdDict
:
2127 self
.FdReportList
.append(FdReport(Wa
.FdfProfile
.FdDict
[Fd
], Wa
))
2129 self
.PredictionReport
= None
2130 if "FIXED_ADDRESS" in ReportType
or "EXECUTION_ORDER" in ReportType
:
2131 self
.PredictionReport
= PredictionReport(Wa
)
2133 self
.DepexParser
= None
2134 if "DEPEX" in ReportType
:
2135 self
.DepexParser
= DepexParser(Wa
)
2137 self
.ModuleReportList
= []
2138 if MaList
is not None:
2139 self
._IsModuleBuild
= True
2141 self
.ModuleReportList
.append(ModuleReport(Ma
, ReportType
))
2143 self
._IsModuleBuild
= False
2144 for Pa
in Wa
.AutoGenObjectList
:
2145 ModuleAutoGenList
= []
2146 for ModuleKey
in Pa
.Platform
.Modules
:
2147 ModuleAutoGenList
.append(Pa
.Platform
.Modules
[ModuleKey
].M
)
2148 if GlobalData
.gFdfParser
is not None:
2149 if Pa
.Arch
in GlobalData
.gFdfParser
.Profile
.InfDict
:
2150 INFList
= GlobalData
.gFdfParser
.Profile
.InfDict
[Pa
.Arch
]
2151 for InfName
in INFList
:
2152 InfClass
= PathClass(NormPath(InfName
), Wa
.WorkspaceDir
, Pa
.Arch
)
2153 Ma
= ModuleAutoGen(Wa
, InfClass
, Pa
.BuildTarget
, Pa
.ToolChain
, Pa
.Arch
, Wa
.MetaFile
)
2156 if Ma
not in ModuleAutoGenList
:
2157 ModuleAutoGenList
.append(Ma
)
2158 for MGen
in ModuleAutoGenList
:
2159 self
.ModuleReportList
.append(ModuleReport(MGen
, ReportType
))
2164 # Generate report for the whole platform.
2166 # This function generates report for platform information.
2167 # It comprises of platform summary, global PCD, flash and
2168 # module list sections.
2170 # @param self The object pointer
2171 # @param File The file object for report
2172 # @param BuildDuration The total time to build the modules
2173 # @param AutoGenTime The total time of AutoGen Phase
2174 # @param MakeTime The total time of Make Phase
2175 # @param GenFdsTime The total time of GenFds Phase
2176 # @param ReportType The kind of report items in the final report file
2178 def GenerateReport(self
, File
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
, ReportType
):
2179 FileWrite(File
, "Platform Summary")
2180 FileWrite(File
, "Platform Name: %s" % self
.PlatformName
)
2181 FileWrite(File
, "Platform DSC Path: %s" % self
.PlatformDscPath
)
2182 FileWrite(File
, "Architectures: %s" % self
.Architectures
)
2183 FileWrite(File
, "Tool Chain: %s" % self
.ToolChain
)
2184 FileWrite(File
, "Target: %s" % self
.Target
)
2185 if GlobalData
.gSkuids
:
2186 FileWrite(File
, "SKUID: %s" % " ".join(GlobalData
.gSkuids
))
2187 if GlobalData
.gDefaultStores
:
2188 FileWrite(File
, "DefaultStore: %s" % " ".join(GlobalData
.gDefaultStores
))
2189 FileWrite(File
, "Output Path: %s" % self
.OutputPath
)
2190 FileWrite(File
, "Build Environment: %s" % self
.BuildEnvironment
)
2191 FileWrite(File
, "Build Duration: %s" % BuildDuration
)
2193 FileWrite(File
, "AutoGen Duration: %s" % AutoGenTime
)
2195 FileWrite(File
, "Make Duration: %s" % MakeTime
)
2197 FileWrite(File
, "GenFds Duration: %s" % GenFdsTime
)
2198 FileWrite(File
, "Report Content: %s" % ", ".join(ReportType
))
2200 if GlobalData
.MixedPcd
:
2201 FileWrite(File
, gSectionStart
)
2202 FileWrite(File
, "The following PCDs use different access methods:")
2203 FileWrite(File
, gSectionSep
)
2204 for PcdItem
in GlobalData
.MixedPcd
:
2205 FileWrite(File
, "%s.%s" % (str(PcdItem
[1]), str(PcdItem
[0])))
2206 FileWrite(File
, gSectionEnd
)
2208 if not self
._IsModuleBuild
:
2209 if "PCD" in ReportType
:
2210 self
.PcdReport
.GenerateReport(File
, None)
2212 if "FLASH" in ReportType
:
2213 for FdReportListItem
in self
.FdReportList
:
2214 FdReportListItem
.GenerateReport(File
)
2216 for ModuleReportItem
in self
.ModuleReportList
:
2217 ModuleReportItem
.GenerateReport(File
, self
.PcdReport
, self
.PredictionReport
, self
.DepexParser
, ReportType
)
2219 if not self
._IsModuleBuild
:
2220 if "EXECUTION_ORDER" in ReportType
:
2221 self
.PredictionReport
.GenerateReport(File
, None)
2223 ## BuildReport class
2225 # This base class contain the routines to collect data and then
2226 # applies certain format to the output report
2228 class BuildReport(object):
2230 # Constructor function for class BuildReport
2232 # This constructor function generates BuildReport object a platform build.
2233 # It generates report for platform summary, flash, global PCDs and detailed
2234 # module information for modules involved in platform build.
2236 # @param self The object pointer
2237 # @param ReportFile The file name to save report file
2238 # @param ReportType The kind of report items in the final report file
2240 def __init__(self
, ReportFile
, ReportType
):
2241 self
.ReportFile
= ReportFile
2243 self
.ReportList
= []
2244 self
.ReportType
= []
2246 for ReportTypeItem
in ReportType
:
2247 if ReportTypeItem
not in self
.ReportType
:
2248 self
.ReportType
.append(ReportTypeItem
)
2250 self
.ReportType
= ["PCD", "LIBRARY", "BUILD_FLAGS", "DEPEX", "HASH", "FLASH", "FIXED_ADDRESS"]
2252 # Adds platform report to the list
2254 # This function adds a platform report to the final report list.
2256 # @param self The object pointer
2257 # @param Wa Workspace context information
2258 # @param MaList The list of modules in the platform build
2260 def AddPlatformReport(self
, Wa
, MaList
=None):
2262 self
.ReportList
.append((Wa
, MaList
))
2265 # Generates the final report.
2267 # This function generates platform build report. It invokes GenerateReport()
2268 # method for every platform report in the list.
2270 # @param self The object pointer
2271 # @param BuildDuration The total time to build the modules
2272 # @param AutoGenTime The total time of AutoGen phase
2273 # @param MakeTime The total time of Make phase
2274 # @param GenFdsTime The total time of GenFds phase
2276 def GenerateReport(self
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
):
2280 for (Wa
, MaList
) in self
.ReportList
:
2281 PlatformReport(Wa
, MaList
, self
.ReportType
).GenerateReport(File
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
, self
.ReportType
)
2282 Content
= FileLinesSplit(''.join(File
), gLineMaxLength
)
2283 SaveFileOnChange(self
.ReportFile
, Content
, False)
2284 EdkLogger
.quiet("Build report can be found at %s" % os
.path
.abspath(self
.ReportFile
))
2286 EdkLogger
.error(None, FILE_WRITE_FAILURE
, ExtraData
=self
.ReportFile
)
2288 EdkLogger
.error("BuildReport", CODE_ERROR
, "Unknown fatal error when generating build report", ExtraData
=self
.ReportFile
, RaiseError
=False)
2289 EdkLogger
.quiet("(Python %s on %s\n%s)" % (platform
.python_version(), sys
.platform
, traceback
.format_exc()))
2291 # This acts like the main() function for the script, unless it is 'import'ed into another script.
2292 if __name__
== '__main__':