2 # Routines for generating build report.
4 # This module contains the functionality to generate build report after
5 # build all target completes successfully.
7 # Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved.<BR>
8 # This program and the accompanying materials
9 # are licensed and made available under the terms and conditions of the BSD License
10 # which accompanies this distribution. The full text of the license may be found at
11 # http://opensource.org/licenses/bsd-license.php
13 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
14 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
19 import Common
.LongFilePathOs
as os
30 from datetime
import datetime
31 from io
import BytesIO
32 from Common
import EdkLogger
33 from Common
.Misc
import SaveFileOnChange
34 from Common
.Misc
import GuidStructureByteArrayToGuidString
35 from Common
.Misc
import GuidStructureStringToGuidString
36 from Common
.BuildToolError
import FILE_WRITE_FAILURE
37 from Common
.BuildToolError
import CODE_ERROR
38 from Common
.BuildToolError
import COMMAND_FAILURE
39 from Common
.BuildToolError
import FORMAT_INVALID
40 from Common
.LongFilePathSupport
import OpenLongFilePath
as open
41 from Common
.MultipleWorkspace
import MultipleWorkspace
as mws
42 import Common
.GlobalData
as GlobalData
43 from AutoGen
.AutoGen
import ModuleAutoGen
44 from Common
.Misc
import PathClass
45 from Common
.StringUtils
import NormPath
46 from Common
.DataType
import *
48 from Common
.Expression
import *
50 ## Pattern to extract contents in EDK DXS files
51 gDxsDependencyPattern
= re
.compile(r
"DEPENDENCY_START(.+)DEPENDENCY_END", re
.DOTALL
)
53 ## Pattern to find total FV total size, occupied size in flash report intermediate file
54 gFvTotalSizePattern
= re
.compile(r
"EFI_FV_TOTAL_SIZE = (0x[0-9a-fA-F]+)")
55 gFvTakenSizePattern
= re
.compile(r
"EFI_FV_TAKEN_SIZE = (0x[0-9a-fA-F]+)")
57 ## Pattern to find module size and time stamp in module summary report intermediate file
58 gModuleSizePattern
= re
.compile(r
"MODULE_SIZE = (\d+)")
59 gTimeStampPattern
= re
.compile(r
"TIME_STAMP = (\d+)")
61 ## Pattern to find GUID value in flash description files
62 gPcdGuidPattern
= re
.compile(r
"PCD\((\w+)[.](\w+)\)")
64 ## Pattern to collect offset, GUID value pair in the flash report intermediate file
65 gOffsetGuidPattern
= re
.compile(r
"(0x[0-9A-Fa-f]+) ([-A-Fa-f0-9]+)")
67 ## Pattern to find module base address and entry point in fixed flash map file
68 gModulePattern
= r
"\n[-\w]+\s*\(([^,]+),\s*BaseAddress=%(Address)s,\s*EntryPoint=%(Address)s\)\s*\(GUID=([-0-9A-Fa-f]+)[^)]*\)"
69 gMapFileItemPattern
= re
.compile(gModulePattern
% {"Address" : "(-?0[xX][0-9A-Fa-f]+)"})
71 ## Pattern to find all module referenced header files in source files
72 gIncludePattern
= re
.compile(r
'#include\s*["<]([^">]+)[">]')
73 gIncludePattern2
= re
.compile(r
"#include\s+EFI_([A-Z_]+)\s*[(]\s*(\w+)\s*[)]")
75 ## Pattern to find the entry point for EDK module using EDKII Glue library
76 gGlueLibEntryPoint
= re
.compile(r
"__EDKII_GLUE_MODULE_ENTRY_POINT__\s*=\s*(\w+)")
78 ## Tags for MaxLength of line in report
81 ## Tags for end of line in report
84 ## Tags for section start, end and separator
85 gSectionStart
= ">" + "=" * (gLineMaxLength
- 2) + "<"
86 gSectionEnd
= "<" + "=" * (gLineMaxLength
- 2) + ">" + "\n"
87 gSectionSep
= "=" * gLineMaxLength
89 ## Tags for subsection start, end and separator
90 gSubSectionStart
= ">" + "-" * (gLineMaxLength
- 2) + "<"
91 gSubSectionEnd
= "<" + "-" * (gLineMaxLength
- 2) + ">"
92 gSubSectionSep
= "-" * gLineMaxLength
95 ## The look up table to map PCD type to pair of report display type and DEC type
97 TAB_PCDS_FIXED_AT_BUILD
: ('FIXED', TAB_PCDS_FIXED_AT_BUILD
),
98 TAB_PCDS_PATCHABLE_IN_MODULE
: ('PATCH', TAB_PCDS_PATCHABLE_IN_MODULE
),
99 TAB_PCDS_FEATURE_FLAG
: ('FLAG', TAB_PCDS_FEATURE_FLAG
),
100 TAB_PCDS_DYNAMIC
: ('DYN', TAB_PCDS_DYNAMIC
),
101 TAB_PCDS_DYNAMIC_HII
: ('DYNHII', TAB_PCDS_DYNAMIC
),
102 TAB_PCDS_DYNAMIC_VPD
: ('DYNVPD', TAB_PCDS_DYNAMIC
),
103 TAB_PCDS_DYNAMIC_EX
: ('DEX', TAB_PCDS_DYNAMIC_EX
),
104 TAB_PCDS_DYNAMIC_EX_HII
: ('DEXHII', TAB_PCDS_DYNAMIC_EX
),
105 TAB_PCDS_DYNAMIC_EX_VPD
: ('DEXVPD', TAB_PCDS_DYNAMIC_EX
),
108 ## The look up table to map module type to driver type
110 SUP_MODULE_SEC
: '0x3 (SECURITY_CORE)',
111 SUP_MODULE_PEI_CORE
: '0x4 (PEI_CORE)',
112 SUP_MODULE_PEIM
: '0x6 (PEIM)',
113 SUP_MODULE_DXE_CORE
: '0x5 (DXE_CORE)',
114 SUP_MODULE_DXE_DRIVER
: '0x7 (DRIVER)',
115 SUP_MODULE_DXE_SAL_DRIVER
: '0x7 (DRIVER)',
116 SUP_MODULE_DXE_SMM_DRIVER
: '0x7 (DRIVER)',
117 SUP_MODULE_DXE_RUNTIME_DRIVER
: '0x7 (DRIVER)',
118 SUP_MODULE_UEFI_DRIVER
: '0x7 (DRIVER)',
119 SUP_MODULE_UEFI_APPLICATION
: '0x9 (APPLICATION)',
120 SUP_MODULE_SMM_CORE
: '0xD (SMM_CORE)',
121 'SMM_DRIVER' : '0xA (SMM)', # Extension of module type to support PI 1.1 SMM drivers
122 SUP_MODULE_MM_STANDALONE
: '0xE (MM_STANDALONE)',
123 SUP_MODULE_MM_CORE_STANDALONE
: '0xF (MM_CORE_STANDALONE)'
126 ## The look up table of the supported opcode in the dependency expression binaries
127 gOpCodeList
= ["BEFORE", "AFTER", "PUSH", "AND", "OR", "NOT", "TRUE", "FALSE", "END", "SOR"]
130 # Writes a string to the file object.
132 # This function writes a string to the file object and a new line is appended
133 # afterwards. It may optionally wraps the string for better readability.
135 # @File The file object to write
136 # @String The string to be written to the file
137 # @Wrapper Indicates whether to wrap the string
139 def FileWrite(File
, String
, Wrapper
=False):
141 String
= textwrap
.fill(String
, 120)
142 File
.write(String
+ gEndOfLine
)
144 def ByteArrayForamt(Value
):
148 if Value
.startswith('{') and Value
.endswith('}'):
150 ValueList
= Value
.split(',')
151 if len(ValueList
) >= SplitNum
:
155 Len
= len(ValueList
)/SplitNum
156 for i
, element
in enumerate(ValueList
):
157 ValueList
[i
] = '0x%02X' % int(element
.strip(), 16)
161 End
= min(SplitNum
*(Id
+1), len(ValueList
))
162 Str
= ','.join(ValueList
[SplitNum
*Id
: End
])
163 if End
== len(ValueList
):
165 ArrayList
.append(Str
)
169 ArrayList
.append(Str
)
172 ArrayList
= [Value
+ '}']
173 return IsByteArray
, ArrayList
176 # Find all the header file that the module source directly includes.
178 # This function scans source code to find all header files the module may
179 # include. This is not accurate but very effective to find all the header
180 # file the module might include with #include statement.
182 # @Source The source file name
183 # @IncludePathList The list of include path to find the source file.
184 # @IncludeFiles The dictionary of current found include files.
186 def FindIncludeFiles(Source
, IncludePathList
, IncludeFiles
):
187 FileContents
= open(Source
).read()
189 # Find header files with pattern #include "XXX.h" or #include <XXX.h>
191 for Match
in gIncludePattern
.finditer(FileContents
):
192 FileName
= Match
.group(1).strip()
193 for Dir
in [os
.path
.dirname(Source
)] + IncludePathList
:
194 FullFileName
= os
.path
.normpath(os
.path
.join(Dir
, FileName
))
195 if os
.path
.exists(FullFileName
):
196 IncludeFiles
[FullFileName
.lower().replace("\\", "/")] = FullFileName
200 # Find header files with pattern like #include EFI_PPI_CONSUMER(XXX)
202 for Match
in gIncludePattern2
.finditer(FileContents
):
204 Type
= Match
.group(1)
205 if "ARCH_PROTOCOL" in Type
:
206 FileName
= "ArchProtocol/%(Key)s/%(Key)s.h" % {"Key" : Key
}
207 elif "PROTOCOL" in Type
:
208 FileName
= "Protocol/%(Key)s/%(Key)s.h" % {"Key" : Key
}
210 FileName
= "Ppi/%(Key)s/%(Key)s.h" % {"Key" : Key
}
211 elif TAB_GUID
in Type
:
212 FileName
= "Guid/%(Key)s/%(Key)s.h" % {"Key" : Key
}
215 for Dir
in IncludePathList
:
216 FullFileName
= os
.path
.normpath(os
.path
.join(Dir
, FileName
))
217 if os
.path
.exists(FullFileName
):
218 IncludeFiles
[FullFileName
.lower().replace("\\", "/")] = FullFileName
221 ## Split each lines in file
223 # This method is used to split the lines in file to make the length of each line
224 # less than MaxLength.
226 # @param Content The content of file
227 # @param MaxLength The Max Length of the line
229 def FileLinesSplit(Content
=None, MaxLength
=None):
230 ContentList
= Content
.split(TAB_LINE_BREAK
)
233 for Line
in ContentList
:
234 while len(Line
.rstrip()) > MaxLength
:
235 LineSpaceIndex
= Line
.rfind(TAB_SPACE_SPLIT
, 0, MaxLength
)
236 LineSlashIndex
= Line
.rfind(TAB_SLASH
, 0, MaxLength
)
237 LineBackSlashIndex
= Line
.rfind(TAB_BACK_SLASH
, 0, MaxLength
)
238 if max(LineSpaceIndex
, LineSlashIndex
, LineBackSlashIndex
) > 0:
239 LineBreakIndex
= max(LineSpaceIndex
, LineSlashIndex
, LineBackSlashIndex
)
241 LineBreakIndex
= MaxLength
242 NewContentList
.append(Line
[:LineBreakIndex
])
243 Line
= Line
[LineBreakIndex
:]
245 NewContentList
.append(Line
)
246 for NewLine
in NewContentList
:
247 NewContent
+= NewLine
+ TAB_LINE_BREAK
249 NewContent
= NewContent
.replace(TAB_LINE_BREAK
, gEndOfLine
).replace('\r\r\n', gEndOfLine
)
255 # Parse binary dependency expression section
257 # This utility class parses the dependency expression section and translate the readable
258 # GUID name and value.
260 class DepexParser(object):
262 # Constructor function for class DepexParser
264 # This constructor function collect GUID values so that the readable
265 # GUID name can be translated.
267 # @param self The object pointer
268 # @param Wa Workspace context information
270 def __init__(self
, Wa
):
272 for Pa
in Wa
.AutoGenObjectList
:
273 for Package
in Pa
.PackageList
:
274 for Protocol
in Package
.Protocols
:
275 GuidValue
= GuidStructureStringToGuidString(Package
.Protocols
[Protocol
])
276 self
._GuidDb
[GuidValue
.upper()] = Protocol
277 for Ppi
in Package
.Ppis
:
278 GuidValue
= GuidStructureStringToGuidString(Package
.Ppis
[Ppi
])
279 self
._GuidDb
[GuidValue
.upper()] = Ppi
280 for Guid
in Package
.Guids
:
281 GuidValue
= GuidStructureStringToGuidString(Package
.Guids
[Guid
])
282 self
._GuidDb
[GuidValue
.upper()] = Guid
283 for Ma
in Pa
.ModuleAutoGenList
:
284 for Pcd
in Ma
.FixedVoidTypePcds
:
285 PcdValue
= Ma
.FixedVoidTypePcds
[Pcd
]
286 if len(PcdValue
.split(',')) == 16:
287 GuidValue
= GuidStructureByteArrayToGuidString(PcdValue
)
288 self
._GuidDb
[GuidValue
.upper()] = Pcd
290 # Parse the binary dependency expression files.
292 # This function parses the binary dependency expression file and translate it
293 # to the instruction list.
295 # @param self The object pointer
296 # @param DepexFileName The file name of binary dependency expression file.
298 def ParseDepexFile(self
, DepexFileName
):
299 DepexFile
= open(DepexFileName
, "rb")
301 OpCode
= DepexFile
.read(1)
303 Statement
= gOpCodeList
[struct
.unpack("B", OpCode
)[0]]
304 if Statement
in ["BEFORE", "AFTER", "PUSH"]:
305 GuidValue
= "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X" % \
306 struct
.unpack(PACK_PATTERN_GUID
, DepexFile
.read(16))
307 GuidString
= self
._GuidDb
.get(GuidValue
, GuidValue
)
308 Statement
= "%s %s" % (Statement
, GuidString
)
309 DepexStatement
.append(Statement
)
310 OpCode
= DepexFile
.read(1)
312 return DepexStatement
315 # Reports library information
317 # This class reports the module library subsection in the build report file.
319 class LibraryReport(object):
321 # Constructor function for class LibraryReport
323 # This constructor function generates LibraryReport object for
326 # @param self The object pointer
327 # @param M Module context information
329 def __init__(self
, M
):
330 self
.LibraryList
= []
331 if int(str(M
.AutoGenVersion
), 0) >= 0x00010005:
332 self
._EdkIIModule
= True
334 self
._EdkIIModule
= False
336 for Lib
in M
.DependentLibraryList
:
337 LibInfPath
= str(Lib
)
338 LibClassList
= Lib
.LibraryClass
[0].LibraryClass
339 LibConstructorList
= Lib
.ConstructorList
340 LibDesstructorList
= Lib
.DestructorList
341 LibDepexList
= Lib
.DepexExpression
[M
.Arch
, M
.ModuleType
]
342 for LibAutoGen
in M
.LibraryAutoGenList
:
343 if LibInfPath
== LibAutoGen
.MetaFile
.Path
:
344 LibTime
= LibAutoGen
.BuildTime
346 self
.LibraryList
.append((LibInfPath
, LibClassList
, LibConstructorList
, LibDesstructorList
, LibDepexList
, LibTime
))
349 # Generate report for module library information
351 # This function generates report for the module library.
352 # If the module is EDKII style one, the additional library class, library
353 # constructor/destructor and dependency expression may also be reported.
355 # @param self The object pointer
356 # @param File The file object for report
358 def GenerateReport(self
, File
):
359 if len(self
.LibraryList
) > 0:
360 FileWrite(File
, gSubSectionStart
)
361 FileWrite(File
, TAB_BRG_LIBRARY
)
362 FileWrite(File
, gSubSectionSep
)
363 for LibraryItem
in self
.LibraryList
:
364 LibInfPath
= LibraryItem
[0]
365 FileWrite(File
, LibInfPath
)
368 # Report library class, library constructor and destructor for
369 # EDKII style module.
371 if self
._EdkIIModule
:
372 LibClass
= LibraryItem
[1]
374 LibConstructor
= " ".join(LibraryItem
[2])
376 EdkIILibInfo
+= " C = " + LibConstructor
377 LibDestructor
= " ".join(LibraryItem
[3])
379 EdkIILibInfo
+= " D = " + LibDestructor
380 LibDepex
= " ".join(LibraryItem
[4])
382 EdkIILibInfo
+= " Depex = " + LibDepex
384 EdkIILibInfo
+= " Time = " + LibraryItem
[5]
386 FileWrite(File
, "{%s: %s}" % (LibClass
, EdkIILibInfo
))
388 FileWrite(File
, "{%s}" % LibClass
)
390 FileWrite(File
, gSubSectionEnd
)
393 # Reports dependency expression information
395 # This class reports the module dependency expression subsection in the build report file.
397 class DepexReport(object):
399 # Constructor function for class DepexReport
401 # This constructor function generates DepexReport object for
402 # a module. If the module source contains the DXS file (usually EDK
403 # style module), it uses the dependency in DXS file; otherwise,
404 # it uses the dependency expression from its own INF [Depex] section
405 # and then merges with the ones from its dependent library INF.
407 # @param self The object pointer
408 # @param M Module context information
410 def __init__(self
, M
):
412 self
._DepexFileName
= os
.path
.join(M
.BuildDir
, "OUTPUT", M
.Module
.BaseName
+ ".depex")
413 ModuleType
= M
.ModuleType
415 ModuleType
= COMPONENT_TO_MODULE_MAP_DICT
.get(M
.ComponentType
, "")
417 if ModuleType
in [SUP_MODULE_SEC
, SUP_MODULE_PEI_CORE
, SUP_MODULE_DXE_CORE
, SUP_MODULE_SMM_CORE
, SUP_MODULE_MM_CORE_STANDALONE
, SUP_MODULE_UEFI_APPLICATION
]:
420 for Source
in M
.SourceFileList
:
421 if os
.path
.splitext(Source
.Path
)[1].lower() == ".dxs":
422 Match
= gDxsDependencyPattern
.search(open(Source
.Path
).read())
424 self
.Depex
= Match
.group(1).strip()
428 self
.Depex
= M
.DepexExpressionDict
.get(M
.ModuleType
, "")
429 self
.ModuleDepex
= " ".join(M
.Module
.DepexExpression
[M
.Arch
, M
.ModuleType
])
430 if not self
.ModuleDepex
:
431 self
.ModuleDepex
= "(None)"
434 for Lib
in M
.DependentLibraryList
:
435 LibDepex
= " ".join(Lib
.DepexExpression
[M
.Arch
, M
.ModuleType
]).strip()
437 LibDepexList
.append("(" + LibDepex
+ ")")
438 self
.LibraryDepex
= " AND ".join(LibDepexList
)
439 if not self
.LibraryDepex
:
440 self
.LibraryDepex
= "(None)"
444 # Generate report for module dependency expression information
446 # This function generates report for the module dependency expression.
448 # @param self The object pointer
449 # @param File The file object for report
450 # @param GlobalDepexParser The platform global Dependency expression parser object
452 def GenerateReport(self
, File
, GlobalDepexParser
):
455 FileWrite(File
, gSubSectionStart
)
456 if os
.path
.isfile(self
._DepexFileName
):
458 DepexStatements
= GlobalDepexParser
.ParseDepexFile(self
._DepexFileName
)
459 FileWrite(File
, "Final Dependency Expression (DEPEX) Instructions")
460 for DepexStatement
in DepexStatements
:
461 FileWrite(File
, " %s" % DepexStatement
)
462 FileWrite(File
, gSubSectionSep
)
464 EdkLogger
.warn(None, "Dependency expression file is corrupted", self
._DepexFileName
)
466 FileWrite(File
, "Dependency Expression (DEPEX) from %s" % self
.Source
)
468 if self
.Source
== "INF":
469 FileWrite(File
, self
.Depex
, True)
470 FileWrite(File
, gSubSectionSep
)
471 FileWrite(File
, "From Module INF: %s" % self
.ModuleDepex
, True)
472 FileWrite(File
, "From Library INF: %s" % self
.LibraryDepex
, True)
474 FileWrite(File
, self
.Depex
)
475 FileWrite(File
, gSubSectionEnd
)
478 # Reports dependency expression information
480 # This class reports the module build flags subsection in the build report file.
482 class BuildFlagsReport(object):
484 # Constructor function for class BuildFlagsReport
486 # This constructor function generates BuildFlagsReport object for
487 # a module. It reports the build tool chain tag and all relevant
488 # build flags to build the module.
490 # @param self The object pointer
491 # @param M Module context information
493 def __init__(self
, M
):
496 # Add build flags according to source file extension so that
497 # irrelevant ones can be filtered out.
499 for Source
in M
.SourceFileList
:
500 Ext
= os
.path
.splitext(Source
.File
)[1].lower()
501 if Ext
in [".c", ".cc", ".cpp"]:
502 BuildOptions
["CC"] = 1
503 elif Ext
in [".s", ".asm"]:
504 BuildOptions
["PP"] = 1
505 BuildOptions
["ASM"] = 1
506 elif Ext
in [".vfr"]:
507 BuildOptions
["VFRPP"] = 1
508 BuildOptions
["VFR"] = 1
509 elif Ext
in [".dxs"]:
510 BuildOptions
["APP"] = 1
511 BuildOptions
["CC"] = 1
512 elif Ext
in [".asl"]:
513 BuildOptions
["ASLPP"] = 1
514 BuildOptions
["ASL"] = 1
515 elif Ext
in [".aslc"]:
516 BuildOptions
["ASLCC"] = 1
517 BuildOptions
["ASLDLINK"] = 1
518 BuildOptions
["CC"] = 1
519 elif Ext
in [".asm16"]:
520 BuildOptions
["ASMLINK"] = 1
521 BuildOptions
["SLINK"] = 1
522 BuildOptions
["DLINK"] = 1
525 # Save module build flags.
527 self
.ToolChainTag
= M
.ToolChain
529 for Tool
in BuildOptions
:
530 self
.BuildFlags
[Tool
+ "_FLAGS"] = M
.BuildOption
.get(Tool
, {}).get("FLAGS", "")
533 # Generate report for module build flags information
535 # This function generates report for the module build flags expression.
537 # @param self The object pointer
538 # @param File The file object for report
540 def GenerateReport(self
, File
):
541 FileWrite(File
, gSubSectionStart
)
542 FileWrite(File
, "Build Flags")
543 FileWrite(File
, "Tool Chain Tag: %s" % self
.ToolChainTag
)
544 for Tool
in self
.BuildFlags
:
545 FileWrite(File
, gSubSectionSep
)
546 FileWrite(File
, "%s = %s" % (Tool
, self
.BuildFlags
[Tool
]), True)
548 FileWrite(File
, gSubSectionEnd
)
552 # Reports individual module information
554 # This class reports the module section in the build report file.
555 # It comprises of module summary, module PCD, library, dependency expression,
556 # build flags sections.
558 class ModuleReport(object):
560 # Constructor function for class ModuleReport
562 # This constructor function generates ModuleReport object for
563 # a separate module in a platform build.
565 # @param self The object pointer
566 # @param M Module context information
567 # @param ReportType The kind of report items in the final report file
569 def __init__(self
, M
, ReportType
):
570 self
.ModuleName
= M
.Module
.BaseName
571 self
.ModuleInfPath
= M
.MetaFile
.File
572 self
.FileGuid
= M
.Guid
574 self
.BuildTimeStamp
= None
578 ModuleType
= M
.ModuleType
580 ModuleType
= COMPONENT_TO_MODULE_MAP_DICT
.get(M
.ComponentType
, "")
582 # If a module complies to PI 1.1, promote Module type to "SMM_DRIVER"
584 if ModuleType
== SUP_MODULE_DXE_SMM_DRIVER
:
585 PiSpec
= M
.Module
.Specification
.get("PI_SPECIFICATION_VERSION", "0x00010000")
586 if int(PiSpec
, 0) >= 0x0001000A:
587 ModuleType
= "SMM_DRIVER"
588 self
.DriverType
= gDriverTypeMap
.get(ModuleType
, "0x2 (FREE_FORM)")
589 self
.UefiSpecVersion
= M
.Module
.Specification
.get("UEFI_SPECIFICATION_VERSION", "")
590 self
.PiSpecVersion
= M
.Module
.Specification
.get("PI_SPECIFICATION_VERSION", "")
591 self
.PciDeviceId
= M
.Module
.Defines
.get("PCI_DEVICE_ID", "")
592 self
.PciVendorId
= M
.Module
.Defines
.get("PCI_VENDOR_ID", "")
593 self
.PciClassCode
= M
.Module
.Defines
.get("PCI_CLASS_CODE", "")
594 self
.BuildTime
= M
.BuildTime
596 self
._BuildDir
= M
.BuildDir
597 self
.ModulePcdSet
= {}
598 if "PCD" in ReportType
:
600 # Collect all module used PCD set: module INF referenced directly or indirectly.
601 # It also saves module INF default values of them in case they exist.
603 for Pcd
in M
.ModulePcdList
+ M
.LibraryPcdList
:
604 self
.ModulePcdSet
.setdefault((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Pcd
.Type
), (Pcd
.InfDefaultValue
, Pcd
.DefaultValue
))
606 self
.LibraryReport
= None
607 if "LIBRARY" in ReportType
:
608 self
.LibraryReport
= LibraryReport(M
)
610 self
.DepexReport
= None
611 if "DEPEX" in ReportType
:
612 self
.DepexReport
= DepexReport(M
)
614 if "BUILD_FLAGS" in ReportType
:
615 self
.BuildFlagsReport
= BuildFlagsReport(M
)
619 # Generate report for module information
621 # This function generates report for separate module expression
622 # in a platform build.
624 # @param self The object pointer
625 # @param File The file object for report
626 # @param GlobalPcdReport The platform global PCD report object
627 # @param GlobalPredictionReport The platform global Prediction report object
628 # @param GlobalDepexParser The platform global Dependency expression parser object
629 # @param ReportType The kind of report items in the final report file
631 def GenerateReport(self
, File
, GlobalPcdReport
, GlobalPredictionReport
, GlobalDepexParser
, ReportType
):
632 FileWrite(File
, gSectionStart
)
634 FwReportFileName
= os
.path
.join(self
._BuildDir
, "DEBUG", self
.ModuleName
+ ".txt")
635 if os
.path
.isfile(FwReportFileName
):
637 FileContents
= open(FwReportFileName
).read()
638 Match
= gModuleSizePattern
.search(FileContents
)
640 self
.Size
= int(Match
.group(1))
642 Match
= gTimeStampPattern
.search(FileContents
)
644 self
.BuildTimeStamp
= datetime
.fromtimestamp(int(Match
.group(1)))
646 EdkLogger
.warn(None, "Fail to read report file", FwReportFileName
)
648 if "HASH" in ReportType
:
649 OutputDir
= os
.path
.join(self
._BuildDir
, "OUTPUT")
650 DefaultEFIfile
= os
.path
.join(OutputDir
, self
.ModuleName
+ ".efi")
651 if os
.path
.isfile(DefaultEFIfile
):
652 Tempfile
= os
.path
.join(OutputDir
, self
.ModuleName
+ "_hash.tmp")
653 # rebase the efi image since its base address may not zero
654 cmd
= ["GenFw", "--rebase", str(0), "-o", Tempfile
, DefaultEFIfile
]
656 PopenObject
= subprocess
.Popen(' '.join(cmd
), stdout
=subprocess
.PIPE
, stderr
=subprocess
.PIPE
, shell
=True)
657 except Exception as X
:
658 EdkLogger
.error("GenFw", COMMAND_FAILURE
, ExtraData
="%s: %s" % (str(X
), cmd
[0]))
659 EndOfProcedure
= threading
.Event()
660 EndOfProcedure
.clear()
661 if PopenObject
.stderr
:
662 StdErrThread
= threading
.Thread(target
=ReadMessage
, args
=(PopenObject
.stderr
, EdkLogger
.quiet
, EndOfProcedure
))
663 StdErrThread
.setName("STDERR-Redirector")
664 StdErrThread
.setDaemon(False)
666 # waiting for program exit
668 if PopenObject
.stderr
:
670 if PopenObject
.returncode
!= 0:
671 EdkLogger
.error("GenFw", COMMAND_FAILURE
, "Failed to generate firmware hash image for %s" % (DefaultEFIfile
))
672 if os
.path
.isfile(Tempfile
):
673 self
.Hash
= hashlib
.sha1()
674 buf
= open(Tempfile
, 'rb').read()
675 if self
.Hash
.update(buf
):
676 self
.Hash
= self
.Hash
.update(buf
)
677 self
.Hash
= self
.Hash
.hexdigest()
680 FileWrite(File
, "Module Summary")
681 FileWrite(File
, "Module Name: %s" % self
.ModuleName
)
682 FileWrite(File
, "Module INF Path: %s" % self
.ModuleInfPath
)
683 FileWrite(File
, "File GUID: %s" % self
.FileGuid
)
685 FileWrite(File
, "Size: 0x%X (%.2fK)" % (self
.Size
, self
.Size
/ 1024.0))
687 FileWrite(File
, "SHA1 HASH: %s *%s" % (self
.Hash
, self
.ModuleName
+ ".efi"))
688 if self
.BuildTimeStamp
:
689 FileWrite(File
, "Build Time Stamp: %s" % self
.BuildTimeStamp
)
691 FileWrite(File
, "Module Build Time: %s" % self
.BuildTime
)
693 FileWrite(File
, "Driver Type: %s" % self
.DriverType
)
694 if self
.UefiSpecVersion
:
695 FileWrite(File
, "UEFI Spec Version: %s" % self
.UefiSpecVersion
)
696 if self
.PiSpecVersion
:
697 FileWrite(File
, "PI Spec Version: %s" % self
.PiSpecVersion
)
699 FileWrite(File
, "PCI Device ID: %s" % self
.PciDeviceId
)
701 FileWrite(File
, "PCI Vendor ID: %s" % self
.PciVendorId
)
702 if self
.PciClassCode
:
703 FileWrite(File
, "PCI Class Code: %s" % self
.PciClassCode
)
705 FileWrite(File
, gSectionSep
)
707 if "PCD" in ReportType
:
708 GlobalPcdReport
.GenerateReport(File
, self
.ModulePcdSet
)
710 if "LIBRARY" in ReportType
:
711 self
.LibraryReport
.GenerateReport(File
)
713 if "DEPEX" in ReportType
:
714 self
.DepexReport
.GenerateReport(File
, GlobalDepexParser
)
716 if "BUILD_FLAGS" in ReportType
:
717 self
.BuildFlagsReport
.GenerateReport(File
)
719 if "FIXED_ADDRESS" in ReportType
and self
.FileGuid
:
720 GlobalPredictionReport
.GenerateReport(File
, self
.FileGuid
)
722 FileWrite(File
, gSectionEnd
)
724 def ReadMessage(From
, To
, ExitFlag
):
726 # read one line a time
727 Line
= From
.readline()
728 # empty string means "end"
729 if Line
is not None and Line
!= "":
737 # Reports platform and module PCD information
739 # This class reports the platform PCD section and module PCD subsection
740 # in the build report file.
742 class PcdReport(object):
744 # Constructor function for class PcdReport
746 # This constructor function generates PcdReport object a platform build.
747 # It collects the whole PCD database from platform DSC files, platform
748 # flash description file and package DEC files.
750 # @param self The object pointer
751 # @param Wa Workspace context information
753 def __init__(self
, Wa
):
756 self
.ConditionalPcds
= {}
760 self
.FdfPcdSet
= Wa
.FdfProfile
.PcdDict
764 self
.DefaultStoreSingle
= True
765 self
.SkuSingle
= True
766 if GlobalData
.gDefaultStores
and len(GlobalData
.gDefaultStores
) > 1:
767 self
.DefaultStoreSingle
= False
768 if GlobalData
.gSkuids
and len(GlobalData
.gSkuids
) > 1:
769 self
.SkuSingle
= False
771 self
.ModulePcdOverride
= {}
772 for Pa
in Wa
.AutoGenObjectList
:
775 # Collect all platform referenced PCDs and grouped them by PCD token space
778 for Pcd
in Pa
.AllPcdList
:
779 PcdList
= self
.AllPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
780 if Pcd
not in PcdList
:
782 if len(Pcd
.TokenCName
) > self
.MaxLen
:
783 self
.MaxLen
= len(Pcd
.TokenCName
)
785 # Collect the PCD defined in DSC/FDF file, but not used in module
787 UnusedPcdFullList
= []
788 for item
in Pa
.Platform
.Pcds
:
789 Pcd
= Pa
.Platform
.Pcds
[item
]
791 # check the Pcd in FDF file, whether it is used in module first
792 for T
in PCD_TYPE_LIST
:
793 PcdList
= self
.AllPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(T
, [])
799 for package
in Pa
.PackageList
:
800 for T
in PCD_TYPE_LIST
:
801 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, T
) in package
.Pcds
:
804 if not Pcd
.DatumType
:
805 Pcd
.DatumType
= package
.Pcds
[(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, T
)].DatumType
809 if not Pcd
.DatumType
:
811 # Try to remove Hii and Vpd suffix
812 if PcdType
.startswith(TAB_PCDS_DYNAMIC_EX
):
813 PcdType
= TAB_PCDS_DYNAMIC_EX
814 elif PcdType
.startswith(TAB_PCDS_DYNAMIC
):
815 PcdType
= TAB_PCDS_DYNAMIC
816 for package
in Pa
.PackageList
:
817 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, PcdType
) in package
.Pcds
:
818 Pcd
.DatumType
= package
.Pcds
[(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, PcdType
)].DatumType
821 PcdList
= self
.AllPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
822 UnusedPcdList
= self
.UnusedPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
823 if Pcd
in UnusedPcdList
:
824 UnusedPcdList
.remove(Pcd
)
825 if Pcd
not in PcdList
and Pcd
not in UnusedPcdFullList
:
826 UnusedPcdFullList
.append(Pcd
)
827 if len(Pcd
.TokenCName
) > self
.MaxLen
:
828 self
.MaxLen
= len(Pcd
.TokenCName
)
830 if GlobalData
.gConditionalPcds
:
831 for PcdItem
in GlobalData
.gConditionalPcds
:
833 (TokenSpaceGuidCName
, TokenCName
) = PcdItem
.split('.')
834 if (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
835 Pcd
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)]
836 PcdList
= self
.ConditionalPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
837 if Pcd
not in PcdList
:
841 if UnusedPcdFullList
:
842 for Pcd
in UnusedPcdFullList
:
843 if Pcd
.TokenSpaceGuidCName
+ '.' + Pcd
.TokenCName
in GlobalData
.gConditionalPcds
:
845 UnusedPcdList
.append(Pcd
)
847 for Pcd
in UnusedPcdList
:
848 PcdList
= self
.UnusedPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
849 if Pcd
not in PcdList
:
852 for Module
in Pa
.Platform
.Modules
.values():
854 # Collect module override PCDs
856 for ModulePcd
in Module
.M
.ModulePcdList
+ Module
.M
.LibraryPcdList
:
857 TokenCName
= ModulePcd
.TokenCName
858 TokenSpaceGuid
= ModulePcd
.TokenSpaceGuidCName
859 ModuleDefault
= ModulePcd
.DefaultValue
860 ModulePath
= os
.path
.basename(Module
.M
.MetaFile
.File
)
861 self
.ModulePcdOverride
.setdefault((TokenCName
, TokenSpaceGuid
), {})[ModulePath
] = ModuleDefault
865 # Collect PCD DEC default value.
867 self
.DecPcdDefault
= {}
869 for Pa
in Wa
.AutoGenObjectList
:
870 for Package
in Pa
.PackageList
:
871 Guids
= Package
.Guids
872 self
._GuidDict
.update(Guids
)
873 for (TokenCName
, TokenSpaceGuidCName
, DecType
) in Package
.Pcds
:
874 DecDefaultValue
= Package
.Pcds
[TokenCName
, TokenSpaceGuidCName
, DecType
].DefaultValue
875 self
.DecPcdDefault
.setdefault((TokenCName
, TokenSpaceGuidCName
, DecType
), DecDefaultValue
)
877 # Collect PCDs defined in DSC common section
879 self
.DscPcdDefault
= {}
880 for Pa
in Wa
.AutoGenObjectList
:
881 for (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
882 DscDefaultValue
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)].DscDefaultValue
884 self
.DscPcdDefault
[(TokenCName
, TokenSpaceGuidCName
)] = DscDefaultValue
886 def GenerateReport(self
, File
, ModulePcdSet
):
888 if self
.ConditionalPcds
:
889 self
.GenerateReportDetail(File
, ModulePcdSet
, 1)
892 for Token
in self
.UnusedPcds
:
893 TokenDict
= self
.UnusedPcds
[Token
]
894 for Type
in TokenDict
:
901 self
.GenerateReportDetail(File
, ModulePcdSet
, 2)
902 self
.GenerateReportDetail(File
, ModulePcdSet
)
905 # Generate report for PCD information
907 # This function generates report for separate module expression
908 # in a platform build.
910 # @param self The object pointer
911 # @param File The file object for report
912 # @param ModulePcdSet Set of all PCDs referenced by module or None for
913 # platform PCD report
914 # @param ReportySubType 0 means platform/module PCD report, 1 means Conditional
915 # directives section report, 2 means Unused Pcds section report
916 # @param DscOverridePcds Module DSC override PCDs set
918 def GenerateReportDetail(self
, File
, ModulePcdSet
, ReportSubType
= 0):
919 PcdDict
= self
.AllPcds
920 if ReportSubType
== 1:
921 PcdDict
= self
.ConditionalPcds
922 elif ReportSubType
== 2:
923 PcdDict
= self
.UnusedPcds
926 FileWrite(File
, gSectionStart
)
927 if ReportSubType
== 1:
928 FileWrite(File
, "Conditional Directives used by the build system")
929 elif ReportSubType
== 2:
930 FileWrite(File
, "PCDs not used by modules or in conditional directives")
932 FileWrite(File
, "Platform Configuration Database Report")
934 FileWrite(File
, " *B - PCD override in the build option")
935 FileWrite(File
, " *P - Platform scoped PCD override in DSC file")
936 FileWrite(File
, " *F - Platform scoped PCD override in FDF file")
937 if not ReportSubType
:
938 FileWrite(File
, " *M - Module scoped PCD override")
939 FileWrite(File
, gSectionSep
)
941 if not ReportSubType
and ModulePcdSet
:
943 # For module PCD sub-section
945 FileWrite(File
, gSubSectionStart
)
946 FileWrite(File
, TAB_BRG_PCD
)
947 FileWrite(File
, gSubSectionSep
)
951 for Type
in PcdDict
[Key
]:
952 for Pcd
in PcdDict
[Key
][Type
]:
953 AllPcdDict
[Key
][(Pcd
.TokenCName
, Type
)] = Pcd
954 for Key
in sorted(AllPcdDict
):
956 # Group PCD by their token space GUID C Name
959 for PcdTokenCName
, Type
in sorted(AllPcdDict
[Key
]):
961 # Group PCD by their usage type
963 Pcd
= AllPcdDict
[Key
][(PcdTokenCName
, Type
)]
964 TypeName
, DecType
= gPcdTypeMap
.get(Type
, ("", Type
))
966 if GlobalData
.MixedPcd
:
967 for PcdKey
in GlobalData
.MixedPcd
:
968 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
) in GlobalData
.MixedPcd
[PcdKey
]:
969 PcdTokenCName
= PcdKey
[0]
971 if MixedPcdFlag
and not ModulePcdSet
:
974 # Get PCD default value and their override relationship
976 DecDefaultValue
= self
.DecPcdDefault
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, DecType
))
977 DscDefaultValue
= self
.DscPcdDefault
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
))
978 DscDefaultValBak
= DscDefaultValue
980 for (CName
, Guid
, Field
) in self
.FdfPcdSet
:
981 if CName
== PcdTokenCName
and Guid
== Key
:
982 DscDefaultValue
= self
.FdfPcdSet
[(CName
, Guid
, Field
)]
984 if DscDefaultValue
!= DscDefaultValBak
:
986 DscDefaultValue
= ValueExpressionEx(DscDefaultValue
, Pcd
.DatumType
, self
._GuidDict
)(True)
987 except BadExpression
as DscDefaultValue
:
988 EdkLogger
.error('BuildReport', FORMAT_INVALID
, "PCD Value: %s, Type: %s" %(DscDefaultValue
, Pcd
.DatumType
))
990 InfDefaultValue
= None
992 PcdValue
= DecDefaultValue
994 PcdValue
= DscDefaultValue
995 #The DefaultValue of StructurePcd already be the latest, no need to update.
996 if not self
.IsStructurePcd(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
):
997 Pcd
.DefaultValue
= PcdValue
998 if ModulePcdSet
is not None:
999 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Type
) not in ModulePcdSet
:
1001 InfDefaultValue
, PcdValue
= ModulePcdSet
[Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Type
]
1002 #The DefaultValue of StructurePcd already be the latest, no need to update.
1003 if not self
.IsStructurePcd(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
):
1004 Pcd
.DefaultValue
= PcdValue
1007 InfDefaultValue
= ValueExpressionEx(InfDefaultValue
, Pcd
.DatumType
, self
._GuidDict
)(True)
1008 except BadExpression
as InfDefaultValue
:
1009 EdkLogger
.error('BuildReport', FORMAT_INVALID
, "PCD Value: %s, Type: %s" % (InfDefaultValue
, Pcd
.DatumType
))
1010 if InfDefaultValue
== "":
1011 InfDefaultValue
= None
1013 BuildOptionMatch
= False
1014 if GlobalData
.BuildOptionPcd
:
1015 for pcd
in GlobalData
.BuildOptionPcd
:
1016 if (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
) == (pcd
[0], pcd
[1]):
1020 #The DefaultValue of StructurePcd already be the latest, no need to update.
1021 if not self
.IsStructurePcd(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
):
1022 Pcd
.DefaultValue
= PcdValue
1023 BuildOptionMatch
= True
1027 if ModulePcdSet
is None:
1029 FileWrite(File
, Key
)
1033 if Pcd
.DatumType
in TAB_PCD_NUMERIC_TYPES
:
1034 PcdValueNumber
= int(PcdValue
.strip(), 0)
1035 if DecDefaultValue
is None:
1038 DecDefaultValueNumber
= int(DecDefaultValue
.strip(), 0)
1039 DecMatch
= (DecDefaultValueNumber
== PcdValueNumber
)
1041 if InfDefaultValue
is None:
1044 InfDefaultValueNumber
= int(InfDefaultValue
.strip(), 0)
1045 InfMatch
= (InfDefaultValueNumber
== PcdValueNumber
)
1047 if DscDefaultValue
is None:
1050 DscDefaultValueNumber
= int(DscDefaultValue
.strip(), 0)
1051 DscMatch
= (DscDefaultValueNumber
== PcdValueNumber
)
1053 if DecDefaultValue
is None:
1056 DecMatch
= (DecDefaultValue
.strip() == PcdValue
.strip())
1058 if InfDefaultValue
is None:
1061 InfMatch
= (InfDefaultValue
.strip() == PcdValue
.strip())
1063 if DscDefaultValue
is None:
1066 DscMatch
= (DscDefaultValue
.strip() == PcdValue
.strip())
1069 if self
.IsStructurePcd(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
):
1071 if TypeName
in ('DYNVPD', 'DEXVPD'):
1072 SkuInfoList
= Pcd
.SkuInfoList
1073 Pcd
= GlobalData
.gStructurePcd
[self
.Arch
][(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
)]
1074 Pcd
.DatumType
= Pcd
.StructName
1075 if TypeName
in ('DYNVPD', 'DEXVPD'):
1076 Pcd
.SkuInfoList
= SkuInfoList
1077 if Pcd
.PcdValueFromComm
or Pcd
.PcdFieldValueFromComm
:
1078 BuildOptionMatch
= True
1080 elif Pcd
.PcdValueFromFdf
or Pcd
.PcdFieldValueFromFdf
:
1081 DscDefaultValue
= True
1084 elif Pcd
.SkuOverrideValues
:
1086 if Pcd
.DefaultFromDSC
:
1090 for item
in Pcd
.SkuOverrideValues
:
1091 DictLen
+= len(Pcd
.SkuOverrideValues
[item
])
1095 if not Pcd
.SkuInfoList
:
1096 OverrideValues
= Pcd
.SkuOverrideValues
1098 for Data
in OverrideValues
.values():
1099 Struct
= list(Data
.values())
1101 DscOverride
= self
.ParseStruct(Struct
[0])
1104 SkuList
= sorted(Pcd
.SkuInfoList
.keys())
1106 SkuInfo
= Pcd
.SkuInfoList
[Sku
]
1107 if TypeName
in ('DYNHII', 'DEXHII'):
1108 if SkuInfo
.DefaultStoreDict
:
1109 DefaultStoreList
= sorted(SkuInfo
.DefaultStoreDict
.keys())
1110 for DefaultStore
in DefaultStoreList
:
1111 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1112 DscOverride
= self
.ParseStruct(OverrideValues
[DefaultStore
])
1116 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1118 Keys
= list(OverrideValues
.keys())
1119 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[Keys
[0]])
1120 DscOverride
= self
.ParseStruct(OverrideFieldStruct
)
1124 DscDefaultValue
= True
1130 DscDefaultValue
= True
1135 # Report PCD item according to their override relationship
1137 if Pcd
.DatumType
== 'BOOLEAN':
1139 DscDefaultValue
= str(int(DscDefaultValue
, 0))
1141 DecDefaultValue
= str(int(DecDefaultValue
, 0))
1143 InfDefaultValue
= str(int(InfDefaultValue
, 0))
1144 if Pcd
.DefaultValue
:
1145 Pcd
.DefaultValue
= str(int(Pcd
.DefaultValue
, 0))
1147 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, ' ')
1148 elif InfDefaultValue
and InfMatch
:
1149 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*M')
1150 elif BuildOptionMatch
:
1151 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*B')
1153 if DscDefaultValue
and DscMatch
:
1154 if (Pcd
.TokenCName
, Key
, Field
) in self
.FdfPcdSet
:
1155 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*F')
1157 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*P')
1159 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*M')
1161 if ModulePcdSet
is None:
1164 if not TypeName
in ('PATCH', 'FLAG', 'FIXED'):
1166 if not BuildOptionMatch
:
1167 ModuleOverride
= self
.ModulePcdOverride
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
), {})
1168 for ModulePath
in ModuleOverride
:
1169 ModuleDefault
= ModuleOverride
[ModulePath
]
1170 if Pcd
.DatumType
in TAB_PCD_NUMERIC_TYPES
:
1171 ModulePcdDefaultValueNumber
= int(ModuleDefault
.strip(), 0)
1172 Match
= (ModulePcdDefaultValueNumber
== PcdValueNumber
)
1173 if Pcd
.DatumType
== 'BOOLEAN':
1174 ModuleDefault
= str(ModulePcdDefaultValueNumber
)
1176 Match
= (ModuleDefault
.strip() == PcdValue
.strip())
1179 IsByteArray
, ArrayList
= ByteArrayForamt(ModuleDefault
.strip())
1181 FileWrite(File
, ' *M %-*s = %s' % (self
.MaxLen
+ 15, ModulePath
, '{'))
1182 for Array
in ArrayList
:
1183 FileWrite(File
, Array
)
1185 Value
= ModuleDefault
.strip()
1186 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1187 if Value
.startswith(('0x', '0X')):
1188 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1190 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1191 FileWrite(File
, ' *M %-*s = %s' % (self
.MaxLen
+ 15, ModulePath
, Value
))
1193 if ModulePcdSet
is None:
1194 FileWrite(File
, gSectionEnd
)
1196 if not ReportSubType
and ModulePcdSet
:
1197 FileWrite(File
, gSubSectionEnd
)
1199 def ParseStruct(self
, struct
):
1200 HasDscOverride
= False
1202 for _
, Values
in struct
.items():
1203 if Values
[1] and Values
[1].endswith('.dsc'):
1204 HasDscOverride
= True
1206 return HasDscOverride
1208 def PrintPcdDefault(self
, File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
):
1209 if not DscMatch
and DscDefaultValue
is not None:
1210 Value
= DscDefaultValue
.strip()
1211 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1213 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DSC DEFAULT', "{"))
1214 for Array
in ArrayList
:
1215 FileWrite(File
, Array
)
1217 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1218 if Value
.startswith(('0x', '0X')):
1219 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1221 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1222 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DSC DEFAULT', Value
))
1223 if not InfMatch
and InfDefaultValue
is not None:
1224 Value
= InfDefaultValue
.strip()
1225 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1227 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'INF DEFAULT', "{"))
1228 for Array
in ArrayList
:
1229 FileWrite(File
, Array
)
1231 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1232 if Value
.startswith(('0x', '0X')):
1233 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1235 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1236 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'INF DEFAULT', Value
))
1238 if not DecMatch
and DecDefaultValue
is not None:
1239 Value
= DecDefaultValue
.strip()
1240 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1242 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DEC DEFAULT', "{"))
1243 for Array
in ArrayList
:
1244 FileWrite(File
, Array
)
1246 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1247 if Value
.startswith(('0x', '0X')):
1248 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1250 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1251 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DEC DEFAULT', Value
))
1253 self
.PrintStructureInfo(File
, Pcd
.DefaultValues
)
1254 if DecMatch
and IsStructure
:
1255 self
.PrintStructureInfo(File
, Pcd
.DefaultValues
)
1257 def PrintPcdValue(self
, File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, Flag
= ' '):
1258 if not Pcd
.SkuInfoList
:
1259 Value
= Pcd
.DefaultValue
1260 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1262 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
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 : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1273 FiledOverrideFlag
= False
1274 OverrideValues
= Pcd
.SkuOverrideValues
1276 for Data
in OverrideValues
.values():
1277 Struct
= list(Data
.values())
1279 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, Struct
[0])
1280 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1281 FiledOverrideFlag
= True
1283 if not FiledOverrideFlag
and (Pcd
.PcdFieldValueFromComm
or Pcd
.PcdFieldValueFromFdf
):
1284 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, {})
1285 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1286 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1289 SkuList
= sorted(Pcd
.SkuInfoList
.keys())
1291 SkuInfo
= Pcd
.SkuInfoList
[Sku
]
1292 SkuIdName
= SkuInfo
.SkuIdName
1293 if TypeName
in ('DYNHII', 'DEXHII'):
1294 if SkuInfo
.DefaultStoreDict
:
1295 DefaultStoreList
= sorted(SkuInfo
.DefaultStoreDict
.keys())
1296 for DefaultStore
in DefaultStoreList
:
1297 Value
= SkuInfo
.DefaultStoreDict
[DefaultStore
]
1298 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1299 if Pcd
.DatumType
== 'BOOLEAN':
1300 Value
= str(int(Value
, 0))
1304 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1305 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1306 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1307 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '{'))
1308 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1309 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', '{'))
1311 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', '{'))
1312 for Array
in ArrayList
:
1313 FileWrite(File
, Array
)
1315 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1316 if Value
.startswith(('0x', '0X')):
1317 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1319 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1320 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1321 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1322 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1323 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1324 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1325 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', Value
))
1327 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', Value
))
1330 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1331 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1332 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1333 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '{'))
1334 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1335 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', '{'))
1337 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', '{'))
1338 for Array
in ArrayList
:
1339 FileWrite(File
, Array
)
1341 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1342 if Value
.startswith(('0x', '0X')):
1343 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1345 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1346 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1347 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1348 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1349 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1350 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1351 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', Value
))
1353 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', Value
))
1354 FileWrite(File
, '%*s: %s: %s' % (self
.MaxLen
+ 4, SkuInfo
.VariableGuid
, SkuInfo
.VariableName
, SkuInfo
.VariableOffset
))
1356 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1357 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[DefaultStore
])
1358 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1359 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1361 Value
= SkuInfo
.DefaultValue
1362 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1363 if Pcd
.DatumType
== 'BOOLEAN':
1364 Value
= str(int(Value
, 0))
1369 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', "{"))
1371 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', "{"))
1372 for Array
in ArrayList
:
1373 FileWrite(File
, Array
)
1375 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1376 if Value
.startswith(('0x', '0X')):
1377 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1379 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1381 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1383 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1387 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', "{"))
1389 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', "{"))
1390 for Array
in ArrayList
:
1391 FileWrite(File
, Array
)
1393 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1394 if Value
.startswith(('0x', '0X')):
1395 Value
= '{} ({:d})'.format(Value
, int(Value
, 0))
1397 Value
= "0x{:X} ({})".format(int(Value
, 0), Value
)
1399 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1401 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1402 if TypeName
in ('DYNVPD', 'DEXVPD'):
1403 FileWrite(File
, '%*s' % (self
.MaxLen
+ 4, SkuInfo
.VpdOffset
))
1405 FiledOverrideFlag
= False
1406 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1408 Keys
= OverrideValues
.keys()
1409 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[Keys
[0]])
1410 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1411 FiledOverrideFlag
= True
1412 if not FiledOverrideFlag
and (Pcd
.PcdFieldValueFromComm
or Pcd
.PcdFieldValueFromFdf
):
1413 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, {})
1414 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1415 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1417 def OverrideFieldValue(self
, Pcd
, OverrideStruct
):
1418 OverrideFieldStruct
= collections
.OrderedDict()
1420 for Key
, Values
in OverrideStruct
.items():
1421 if Values
[1] and Values
[1].endswith('.dsc'):
1422 OverrideFieldStruct
[Key
] = Values
1423 if Pcd
.PcdFieldValueFromFdf
:
1424 for Key
, Values
in Pcd
.PcdFieldValueFromFdf
.items():
1425 if Key
in OverrideFieldStruct
and Values
[0] == OverrideFieldStruct
[Key
][0]:
1427 OverrideFieldStruct
[Key
] = Values
1428 if Pcd
.PcdFieldValueFromComm
:
1429 for Key
, Values
in Pcd
.PcdFieldValueFromComm
.items():
1430 if Key
in OverrideFieldStruct
and Values
[0] == OverrideFieldStruct
[Key
][0]:
1432 OverrideFieldStruct
[Key
] = Values
1433 return OverrideFieldStruct
1435 def PrintStructureInfo(self
, File
, Struct
):
1436 for Key
, Value
in sorted(Struct
.items(), key
=lambda x
: x
[0]):
1437 if Value
[1] and 'build command options' in Value
[1]:
1438 FileWrite(File
, ' *B %-*s = %s' % (self
.MaxLen
+ 4, '.' + Key
, Value
[0]))
1439 elif Value
[1] and Value
[1].endswith('.fdf'):
1440 FileWrite(File
, ' *F %-*s = %s' % (self
.MaxLen
+ 4, '.' + Key
, Value
[0]))
1442 FileWrite(File
, ' %-*s = %s' % (self
.MaxLen
+ 4, '.' + Key
, Value
[0]))
1444 def StrtoHex(self
, value
):
1446 value
= hex(int(value
))
1449 if value
.startswith("L\"") and value
.endswith("\""):
1451 for ch
in value
[2:-1]:
1452 valuelist
.append(hex(ord(ch
)))
1453 valuelist
.append('0x00')
1455 elif value
.startswith("\"") and value
.endswith("\""):
1456 return hex(ord(value
[1:-1]))
1457 elif value
.startswith("{") and value
.endswith("}"):
1459 if ',' not in value
:
1461 for ch
in value
[1:-1].split(','):
1463 if ch
.startswith('0x') or ch
.startswith('0X'):
1464 valuelist
.append(ch
)
1467 valuelist
.append(hex(int(ch
.strip())))
1474 def IsStructurePcd(self
, PcdToken
, PcdTokenSpaceGuid
):
1475 if GlobalData
.gStructurePcd
and (self
.Arch
in GlobalData
.gStructurePcd
) and ((PcdToken
, PcdTokenSpaceGuid
) in GlobalData
.gStructurePcd
[self
.Arch
]):
1481 # Reports platform and module Prediction information
1483 # This class reports the platform execution order prediction section and
1484 # module load fixed address prediction subsection in the build report file.
1486 class PredictionReport(object):
1488 # Constructor function for class PredictionReport
1490 # This constructor function generates PredictionReport object for the platform.
1492 # @param self: The object pointer
1493 # @param Wa Workspace context information
1495 def __init__(self
, Wa
):
1496 self
._MapFileName
= os
.path
.join(Wa
.BuildDir
, Wa
.Name
+ ".map")
1497 self
._MapFileParsed
= False
1498 self
._EotToolInvoked
= False
1499 self
._FvDir
= Wa
.FvDir
1500 self
._EotDir
= Wa
.BuildDir
1501 self
._FfsEntryPoint
= {}
1503 self
._SourceList
= []
1504 self
.FixedMapDict
= {}
1509 # Collect all platform reference source files and GUID C Name
1511 for Pa
in Wa
.AutoGenObjectList
:
1512 for Module
in Pa
.LibraryAutoGenList
+ Pa
.ModuleAutoGenList
:
1514 # BASE typed modules are EFI agnostic, so we need not scan
1515 # their source code to find PPI/Protocol produce or consume
1518 if Module
.ModuleType
== SUP_MODULE_BASE
:
1521 # Add module referenced source files
1523 self
._SourceList
.append(str(Module
))
1525 for Source
in Module
.SourceFileList
:
1526 if os
.path
.splitext(str(Source
))[1].lower() == ".c":
1527 self
._SourceList
.append(" " + str(Source
))
1528 FindIncludeFiles(Source
.Path
, Module
.IncludePathList
, IncludeList
)
1529 for IncludeFile
in IncludeList
.values():
1530 self
._SourceList
.append(" " + IncludeFile
)
1532 for Guid
in Module
.PpiList
:
1533 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.PpiList
[Guid
])
1534 for Guid
in Module
.ProtocolList
:
1535 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.ProtocolList
[Guid
])
1536 for Guid
in Module
.GuidList
:
1537 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.GuidList
[Guid
])
1539 if Module
.Guid
and not Module
.IsLibrary
:
1540 EntryPoint
= " ".join(Module
.Module
.ModuleEntryPointList
)
1541 if int(str(Module
.AutoGenVersion
), 0) >= 0x00010005:
1542 RealEntryPoint
= "_ModuleEntryPoint"
1544 RealEntryPoint
= EntryPoint
1545 if EntryPoint
== "_ModuleEntryPoint":
1546 CCFlags
= Module
.BuildOption
.get("CC", {}).get("FLAGS", "")
1547 Match
= gGlueLibEntryPoint
.search(CCFlags
)
1549 EntryPoint
= Match
.group(1)
1551 self
._FfsEntryPoint
[Module
.Guid
.upper()] = (EntryPoint
, RealEntryPoint
)
1555 # Collect platform firmware volume list as the input of EOT.
1559 for Fd
in Wa
.FdfProfile
.FdDict
:
1560 for FdRegion
in Wa
.FdfProfile
.FdDict
[Fd
].RegionList
:
1561 if FdRegion
.RegionType
!= BINARY_FILE_TYPE_FV
:
1563 for FvName
in FdRegion
.RegionDataList
:
1564 if FvName
in self
._FvList
:
1566 self
._FvList
.append(FvName
)
1567 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1568 for Section
in Ffs
.SectionList
:
1570 for FvSection
in Section
.SectionList
:
1571 if FvSection
.FvName
in self
._FvList
:
1573 self
._FvList
.append(FvSection
.FvName
)
1574 except AttributeError:
1579 # Parse platform fixed address map files
1581 # This function parses the platform final fixed address map file to get
1582 # the database of predicted fixed address for module image base, entry point
1585 # @param self: The object pointer
1587 def _ParseMapFile(self
):
1588 if self
._MapFileParsed
:
1590 self
._MapFileParsed
= True
1591 if os
.path
.isfile(self
._MapFileName
):
1593 FileContents
= open(self
._MapFileName
).read()
1594 for Match
in gMapFileItemPattern
.finditer(FileContents
):
1595 AddressType
= Match
.group(1)
1596 BaseAddress
= Match
.group(2)
1597 EntryPoint
= Match
.group(3)
1598 Guid
= Match
.group(4).upper()
1599 List
= self
.FixedMapDict
.setdefault(Guid
, [])
1600 List
.append((AddressType
, BaseAddress
, "*I"))
1601 List
.append((AddressType
, EntryPoint
, "*E"))
1603 EdkLogger
.warn(None, "Cannot open file to read", self
._MapFileName
)
1606 # Invokes EOT tool to get the predicted the execution order.
1608 # This function invokes EOT tool to calculate the predicted dispatch order
1610 # @param self: The object pointer
1612 def _InvokeEotTool(self
):
1613 if self
._EotToolInvoked
:
1616 self
._EotToolInvoked
= True
1618 for FvName
in self
._FvList
:
1619 FvFile
= os
.path
.join(self
._FvDir
, FvName
+ ".Fv")
1620 if os
.path
.isfile(FvFile
):
1621 FvFileList
.append(FvFile
)
1623 if len(FvFileList
) == 0:
1626 # Write source file list and GUID file list to an intermediate file
1627 # as the input for EOT tool and dispatch List as the output file
1630 SourceList
= os
.path
.join(self
._EotDir
, "SourceFile.txt")
1631 GuidList
= os
.path
.join(self
._EotDir
, "GuidList.txt")
1632 DispatchList
= os
.path
.join(self
._EotDir
, "Dispatch.txt")
1634 TempFile
= open(SourceList
, "w+")
1635 for Item
in self
._SourceList
:
1636 FileWrite(TempFile
, Item
)
1638 TempFile
= open(GuidList
, "w+")
1639 for Key
in self
._GuidMap
:
1640 FileWrite(TempFile
, "%s %s" % (Key
, self
._GuidMap
[Key
]))
1644 from Eot
.EotMain
import Eot
1647 # Invoke EOT tool and echo its runtime performance
1649 EotStartTime
= time
.time()
1650 Eot(CommandLineOption
=False, SourceFileList
=SourceList
, GuidList
=GuidList
,
1651 FvFileList
=' '.join(FvFileList
), Dispatch
=DispatchList
, IsInit
=True)
1652 EotEndTime
= time
.time()
1653 EotDuration
= time
.strftime("%H:%M:%S", time
.gmtime(int(round(EotEndTime
- EotStartTime
))))
1654 EdkLogger
.quiet("EOT run time: %s\n" % EotDuration
)
1657 # Parse the output of EOT tool
1659 for Line
in open(DispatchList
):
1660 if len(Line
.split()) < 4:
1662 (Guid
, Phase
, FfsName
, FilePath
) = Line
.split()
1663 Symbol
= self
._FfsEntryPoint
.get(Guid
, [FfsName
, ""])[0]
1664 if len(Symbol
) > self
.MaxLen
:
1665 self
.MaxLen
= len(Symbol
)
1666 self
.ItemList
.append((Phase
, Symbol
, FilePath
))
1668 EdkLogger
.quiet("(Python %s on %s\n%s)" % (platform
.python_version(), sys
.platform
, traceback
.format_exc()))
1669 EdkLogger
.warn(None, "Failed to generate execution order prediction report, for some error occurred in executing EOT.")
1673 # Generate platform execution order report
1675 # This function generates the predicted module execution order.
1677 # @param self The object pointer
1678 # @param File The file object for report
1680 def _GenerateExecutionOrderReport(self
, File
):
1681 self
._InvokeEotTool
()
1682 if len(self
.ItemList
) == 0:
1684 FileWrite(File
, gSectionStart
)
1685 FileWrite(File
, "Execution Order Prediction")
1686 FileWrite(File
, "*P PEI phase")
1687 FileWrite(File
, "*D DXE phase")
1688 FileWrite(File
, "*E Module INF entry point name")
1689 FileWrite(File
, "*N Module notification function name")
1691 FileWrite(File
, "Type %-*s %s" % (self
.MaxLen
, "Symbol", "Module INF Path"))
1692 FileWrite(File
, gSectionSep
)
1693 for Item
in self
.ItemList
:
1694 FileWrite(File
, "*%sE %-*s %s" % (Item
[0], self
.MaxLen
, Item
[1], Item
[2]))
1696 FileWrite(File
, gSectionStart
)
1699 # Generate Fixed Address report.
1701 # This function generate the predicted fixed address report for a module
1702 # specified by Guid.
1704 # @param self The object pointer
1705 # @param File The file object for report
1706 # @param Guid The module Guid value.
1707 # @param NotifyList The list of all notify function in a module
1709 def _GenerateFixedAddressReport(self
, File
, Guid
, NotifyList
):
1710 self
._ParseMapFile
()
1711 FixedAddressList
= self
.FixedMapDict
.get(Guid
)
1712 if not FixedAddressList
:
1715 FileWrite(File
, gSubSectionStart
)
1716 FileWrite(File
, "Fixed Address Prediction")
1717 FileWrite(File
, "*I Image Loading Address")
1718 FileWrite(File
, "*E Entry Point Address")
1719 FileWrite(File
, "*N Notification Function Address")
1720 FileWrite(File
, "*F Flash Address")
1721 FileWrite(File
, "*M Memory Address")
1722 FileWrite(File
, "*S SMM RAM Offset")
1723 FileWrite(File
, "TOM Top of Memory")
1725 FileWrite(File
, "Type Address Name")
1726 FileWrite(File
, gSubSectionSep
)
1727 for Item
in FixedAddressList
:
1732 Name
= "(Image Base)"
1733 elif Symbol
== "*E":
1734 Name
= self
._FfsEntryPoint
.get(Guid
, ["", "_ModuleEntryPoint"])[1]
1735 elif Symbol
in NotifyList
:
1743 elif "Memory" in Type
:
1749 Value
= "TOM" + Value
1751 FileWrite(File
, "%s %-16s %s" % (Symbol
, Value
, Name
))
1754 # Generate report for the prediction part
1756 # This function generate the predicted fixed address report for a module or
1757 # predicted module execution order for a platform.
1758 # If the input Guid is None, then, it generates the predicted module execution order;
1759 # otherwise it generated the module fixed loading address for the module specified by
1762 # @param self The object pointer
1763 # @param File The file object for report
1764 # @param Guid The module Guid value.
1766 def GenerateReport(self
, File
, Guid
):
1768 self
._GenerateFixedAddressReport
(File
, Guid
.upper(), [])
1770 self
._GenerateExecutionOrderReport
(File
)
1773 # Reports FD region information
1775 # This class reports the FD subsection in the build report file.
1776 # It collects region information of platform flash device.
1777 # If the region is a firmware volume, it lists the set of modules
1778 # and its space information; otherwise, it only lists its region name,
1779 # base address and size in its sub-section header.
1780 # If there are nesting FVs, the nested FVs will list immediate after
1781 # this FD region subsection
1783 class FdRegionReport(object):
1785 # Discover all the nested FV name list.
1787 # This is an internal worker function to discover the all the nested FV information
1788 # in the parent firmware volume. It uses deep first search algorithm recursively to
1789 # find all the FV list name and append them to the list.
1791 # @param self The object pointer
1792 # @param FvName The name of current firmware file system
1793 # @param Wa Workspace context information
1795 def _DiscoverNestedFvList(self
, FvName
, Wa
):
1796 FvDictKey
=FvName
.upper()
1797 if FvDictKey
in Wa
.FdfProfile
.FvDict
:
1798 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1799 for Section
in Ffs
.SectionList
:
1801 for FvSection
in Section
.SectionList
:
1802 if FvSection
.FvName
in self
.FvList
:
1804 self
._GuidsDb
[Ffs
.NameGuid
.upper()] = FvSection
.FvName
1805 self
.FvList
.append(FvSection
.FvName
)
1806 self
.FvInfo
[FvSection
.FvName
] = ("Nested FV", 0, 0)
1807 self
._DiscoverNestedFvList
(FvSection
.FvName
, Wa
)
1808 except AttributeError:
1812 # Constructor function for class FdRegionReport
1814 # This constructor function generates FdRegionReport object for a specified FdRegion.
1815 # If the FdRegion is a firmware volume, it will recursively find all its nested Firmware
1816 # volume list. This function also collects GUID map in order to dump module identification
1817 # in the final report.
1819 # @param self: The object pointer
1820 # @param FdRegion The current FdRegion object
1821 # @param Wa Workspace context information
1823 def __init__(self
, FdRegion
, Wa
):
1824 self
.Type
= FdRegion
.RegionType
1825 self
.BaseAddress
= FdRegion
.Offset
1826 self
.Size
= FdRegion
.Size
1830 self
._FvDir
= Wa
.FvDir
1831 self
._WorkspaceDir
= Wa
.WorkspaceDir
1834 # If the input FdRegion is not a firmware volume,
1837 if self
.Type
!= BINARY_FILE_TYPE_FV
:
1841 # Find all nested FVs in the FdRegion
1843 for FvName
in FdRegion
.RegionDataList
:
1844 if FvName
in self
.FvList
:
1846 self
.FvList
.append(FvName
)
1847 self
.FvInfo
[FvName
] = ("Fd Region", self
.BaseAddress
, self
.Size
)
1848 self
._DiscoverNestedFvList
(FvName
, Wa
)
1852 # Collect PCDs declared in DEC files.
1854 for Pa
in Wa
.AutoGenObjectList
:
1855 for Package
in Pa
.PackageList
:
1856 for (TokenCName
, TokenSpaceGuidCName
, DecType
) in Package
.Pcds
:
1857 DecDefaultValue
= Package
.Pcds
[TokenCName
, TokenSpaceGuidCName
, DecType
].DefaultValue
1858 PlatformPcds
[(TokenCName
, TokenSpaceGuidCName
)] = DecDefaultValue
1860 # Collect PCDs defined in DSC file
1862 for Pa
in Wa
.AutoGenObjectList
:
1863 for (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
1864 DscDefaultValue
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)].DefaultValue
1865 PlatformPcds
[(TokenCName
, TokenSpaceGuidCName
)] = DscDefaultValue
1868 # Add PEI and DXE a priori files GUIDs defined in PI specification.
1870 self
._GuidsDb
["1B45CC0A-156A-428A-AF62-49864DA0E6E6"] = "PEI Apriori"
1871 self
._GuidsDb
["FC510EE7-FFDC-11D4-BD41-0080C73C8881"] = "DXE Apriori"
1873 # Add ACPI table storage file
1875 self
._GuidsDb
["7E374E25-8E01-4FEE-87F2-390C23C606CD"] = "ACPI table storage"
1877 for Pa
in Wa
.AutoGenObjectList
:
1878 for ModuleKey
in Pa
.Platform
.Modules
:
1879 M
= Pa
.Platform
.Modules
[ModuleKey
].M
1880 InfPath
= mws
.join(Wa
.WorkspaceDir
, M
.MetaFile
.File
)
1881 self
._GuidsDb
[M
.Guid
.upper()] = "%s (%s)" % (M
.Module
.BaseName
, InfPath
)
1884 # Collect the GUID map in the FV firmware volume
1886 for FvName
in self
.FvList
:
1887 FvDictKey
=FvName
.upper()
1888 if FvDictKey
in Wa
.FdfProfile
.FvDict
:
1889 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1892 # collect GUID map for binary EFI file in FDF file.
1894 Guid
= Ffs
.NameGuid
.upper()
1895 Match
= gPcdGuidPattern
.match(Ffs
.NameGuid
)
1897 PcdTokenspace
= Match
.group(1)
1898 PcdToken
= Match
.group(2)
1899 if (PcdToken
, PcdTokenspace
) in PlatformPcds
:
1900 GuidValue
= PlatformPcds
[(PcdToken
, PcdTokenspace
)]
1901 Guid
= GuidStructureByteArrayToGuidString(GuidValue
).upper()
1902 for Section
in Ffs
.SectionList
:
1904 ModuleSectFile
= mws
.join(Wa
.WorkspaceDir
, Section
.SectFileName
)
1905 self
._GuidsDb
[Guid
] = ModuleSectFile
1906 except AttributeError:
1908 except AttributeError:
1913 # Internal worker function to generate report for the FD region
1915 # This internal worker function to generate report for the FD region.
1916 # It the type is firmware volume, it lists offset and module identification.
1918 # @param self The object pointer
1919 # @param File The file object for report
1920 # @param Title The title for the FD subsection
1921 # @param BaseAddress The base address for the FD region
1922 # @param Size The size of the FD region
1923 # @param FvName The FV name if the FD region is a firmware volume
1925 def _GenerateReport(self
, File
, Title
, Type
, BaseAddress
, Size
=0, FvName
=None):
1926 FileWrite(File
, gSubSectionStart
)
1927 FileWrite(File
, Title
)
1928 FileWrite(File
, "Type: %s" % Type
)
1929 FileWrite(File
, "Base Address: 0x%X" % BaseAddress
)
1931 if self
.Type
== BINARY_FILE_TYPE_FV
:
1935 if FvName
.upper().endswith('.FV'):
1936 FileExt
= FvName
+ ".txt"
1938 FileExt
= FvName
+ ".Fv.txt"
1940 if not os
.path
.isfile(FileExt
):
1941 FvReportFileName
= mws
.join(self
._WorkspaceDir
, FileExt
)
1942 if not os
.path
.isfile(FvReportFileName
):
1943 FvReportFileName
= os
.path
.join(self
._FvDir
, FileExt
)
1946 # Collect size info in the firmware volume.
1948 FvReport
= open(FvReportFileName
).read()
1949 Match
= gFvTotalSizePattern
.search(FvReport
)
1951 FvTotalSize
= int(Match
.group(1), 16)
1952 Match
= gFvTakenSizePattern
.search(FvReport
)
1954 FvTakenSize
= int(Match
.group(1), 16)
1955 FvFreeSize
= FvTotalSize
- FvTakenSize
1957 # Write size information to the report file.
1959 FileWrite(File
, "Size: 0x%X (%.0fK)" % (FvTotalSize
, FvTotalSize
/ 1024.0))
1960 FileWrite(File
, "Fv Name: %s (%.1f%% Full)" % (FvName
, FvTakenSize
* 100.0 / FvTotalSize
))
1961 FileWrite(File
, "Occupied Size: 0x%X (%.0fK)" % (FvTakenSize
, FvTakenSize
/ 1024.0))
1962 FileWrite(File
, "Free Size: 0x%X (%.0fK)" % (FvFreeSize
, FvFreeSize
/ 1024.0))
1963 FileWrite(File
, "Offset Module")
1964 FileWrite(File
, gSubSectionSep
)
1966 # Write module offset and module identification to the report file.
1969 for Match
in gOffsetGuidPattern
.finditer(FvReport
):
1970 Guid
= Match
.group(2).upper()
1971 OffsetInfo
[Match
.group(1)] = self
._GuidsDb
.get(Guid
, Guid
)
1972 OffsetList
= sorted(OffsetInfo
.keys())
1973 for Offset
in OffsetList
:
1974 FileWrite (File
, "%s %s" % (Offset
, OffsetInfo
[Offset
]))
1976 EdkLogger
.warn(None, "Fail to read report file", FvReportFileName
)
1978 FileWrite(File
, "Size: 0x%X (%.0fK)" % (Size
, Size
/ 1024.0))
1979 FileWrite(File
, gSubSectionEnd
)
1982 # Generate report for the FD region
1984 # This function generates report for the FD region.
1986 # @param self The object pointer
1987 # @param File The file object for report
1989 def GenerateReport(self
, File
):
1990 if (len(self
.FvList
) > 0):
1991 for FvItem
in self
.FvList
:
1992 Info
= self
.FvInfo
[FvItem
]
1993 self
._GenerateReport
(File
, Info
[0], TAB_FV_DIRECTORY
, Info
[1], Info
[2], FvItem
)
1995 self
._GenerateReport
(File
, "FD Region", self
.Type
, self
.BaseAddress
, self
.Size
)
1998 # Reports FD information
2000 # This class reports the FD section in the build report file.
2001 # It collects flash device information for a platform.
2003 class FdReport(object):
2005 # Constructor function for class FdReport
2007 # This constructor function generates FdReport object for a specified
2010 # @param self The object pointer
2011 # @param Fd The current Firmware device object
2012 # @param Wa Workspace context information
2014 def __init__(self
, Fd
, Wa
):
2015 self
.FdName
= Fd
.FdUiName
2016 self
.BaseAddress
= Fd
.BaseAddress
2018 self
.FdRegionList
= [FdRegionReport(FdRegion
, Wa
) for FdRegion
in Fd
.RegionList
]
2019 self
.FvPath
= os
.path
.join(Wa
.BuildDir
, TAB_FV_DIRECTORY
)
2020 self
.VpdFilePath
= os
.path
.join(self
.FvPath
, "%s.map" % Wa
.Platform
.VpdToolGuid
)
2021 self
.VPDBaseAddress
= 0
2023 self
.VPDInfoList
= []
2024 for index
, FdRegion
in enumerate(Fd
.RegionList
):
2025 if str(FdRegion
.RegionType
) is 'FILE' and Wa
.Platform
.VpdToolGuid
in str(FdRegion
.RegionDataList
):
2026 self
.VPDBaseAddress
= self
.FdRegionList
[index
].BaseAddress
2027 self
.VPDSize
= self
.FdRegionList
[index
].Size
2030 if os
.path
.isfile(self
.VpdFilePath
):
2031 fd
= open(self
.VpdFilePath
, "r")
2032 Lines
= fd
.readlines()
2035 if len(Line
) == 0 or Line
.startswith("#"):
2038 PcdName
, SkuId
, Offset
, Size
, Value
= Line
.split("#")[0].split("|")
2039 PcdName
, SkuId
, Offset
, Size
, Value
= PcdName
.strip(), SkuId
.strip(), Offset
.strip(), Size
.strip(), Value
.strip()
2040 if Offset
.lower().startswith('0x'):
2041 Offset
= '0x%08X' % (int(Offset
, 16) + self
.VPDBaseAddress
)
2043 Offset
= '0x%08X' % (int(Offset
, 10) + self
.VPDBaseAddress
)
2044 self
.VPDInfoList
.append("%s | %s | %s | %s | %s" % (PcdName
, SkuId
, Offset
, Size
, Value
))
2046 EdkLogger
.error("BuildReport", CODE_ERROR
, "Fail to parse VPD information file %s" % self
.VpdFilePath
)
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
)
2068 if len(self
.VPDInfoList
) > 0:
2069 FileWrite(File
, gSubSectionStart
)
2070 FileWrite(File
, "FD VPD Region")
2071 FileWrite(File
, "Base Address: 0x%X" % self
.VPDBaseAddress
)
2072 FileWrite(File
, "Size: 0x%X (%.0fK)" % (self
.VPDSize
, self
.VPDSize
/ 1024.0))
2073 FileWrite(File
, gSubSectionSep
)
2074 for item
in self
.VPDInfoList
:
2075 ValueList
= item
.split('|')
2076 Value
= ValueList
[-1].strip()
2077 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
2079 ValueList
[-1] = ' {'
2080 FileWrite(File
, '|'.join(ValueList
))
2081 for Array
in ArrayList
:
2082 FileWrite(File
, Array
)
2084 FileWrite(File
, item
)
2085 FileWrite(File
, gSubSectionEnd
)
2086 FileWrite(File
, gSectionEnd
)
2091 # Reports platform information
2093 # This class reports the whole platform information
2095 class PlatformReport(object):
2097 # Constructor function for class PlatformReport
2099 # This constructor function generates PlatformReport object a platform build.
2100 # It generates report for platform summary, flash, global PCDs and detailed
2101 # module information for modules involved in platform build.
2103 # @param self The object pointer
2104 # @param Wa Workspace context information
2105 # @param MaList The list of modules in the platform build
2107 def __init__(self
, Wa
, MaList
, ReportType
):
2108 self
._WorkspaceDir
= Wa
.WorkspaceDir
2109 self
.PlatformName
= Wa
.Name
2110 self
.PlatformDscPath
= Wa
.Platform
2111 self
.Architectures
= " ".join(Wa
.ArchList
)
2112 self
.ToolChain
= Wa
.ToolChain
2113 self
.Target
= Wa
.BuildTarget
2114 self
.OutputPath
= os
.path
.join(Wa
.WorkspaceDir
, Wa
.OutputDir
)
2115 self
.BuildEnvironment
= platform
.platform()
2117 self
.PcdReport
= None
2118 if "PCD" in ReportType
:
2119 self
.PcdReport
= PcdReport(Wa
)
2121 self
.FdReportList
= []
2122 if "FLASH" in ReportType
and Wa
.FdfProfile
and MaList
is None:
2123 for Fd
in Wa
.FdfProfile
.FdDict
:
2124 self
.FdReportList
.append(FdReport(Wa
.FdfProfile
.FdDict
[Fd
], Wa
))
2126 self
.PredictionReport
= None
2127 if "FIXED_ADDRESS" in ReportType
or "EXECUTION_ORDER" in ReportType
:
2128 self
.PredictionReport
= PredictionReport(Wa
)
2130 self
.DepexParser
= None
2131 if "DEPEX" in ReportType
:
2132 self
.DepexParser
= DepexParser(Wa
)
2134 self
.ModuleReportList
= []
2135 if MaList
is not None:
2136 self
._IsModuleBuild
= True
2138 self
.ModuleReportList
.append(ModuleReport(Ma
, ReportType
))
2140 self
._IsModuleBuild
= False
2141 for Pa
in Wa
.AutoGenObjectList
:
2142 ModuleAutoGenList
= []
2143 for ModuleKey
in Pa
.Platform
.Modules
:
2144 ModuleAutoGenList
.append(Pa
.Platform
.Modules
[ModuleKey
].M
)
2145 if GlobalData
.gFdfParser
is not None:
2146 if Pa
.Arch
in GlobalData
.gFdfParser
.Profile
.InfDict
:
2147 INFList
= GlobalData
.gFdfParser
.Profile
.InfDict
[Pa
.Arch
]
2148 for InfName
in INFList
:
2149 InfClass
= PathClass(NormPath(InfName
), Wa
.WorkspaceDir
, Pa
.Arch
)
2150 Ma
= ModuleAutoGen(Wa
, InfClass
, Pa
.BuildTarget
, Pa
.ToolChain
, Pa
.Arch
, Wa
.MetaFile
)
2153 if Ma
not in ModuleAutoGenList
:
2154 ModuleAutoGenList
.append(Ma
)
2155 for MGen
in ModuleAutoGenList
:
2156 self
.ModuleReportList
.append(ModuleReport(MGen
, ReportType
))
2161 # Generate report for the whole platform.
2163 # This function generates report for platform information.
2164 # It comprises of platform summary, global PCD, flash and
2165 # module list sections.
2167 # @param self The object pointer
2168 # @param File The file object for report
2169 # @param BuildDuration The total time to build the modules
2170 # @param AutoGenTime The total time of AutoGen Phase
2171 # @param MakeTime The total time of Make Phase
2172 # @param GenFdsTime The total time of GenFds Phase
2173 # @param ReportType The kind of report items in the final report file
2175 def GenerateReport(self
, File
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
, ReportType
):
2176 FileWrite(File
, "Platform Summary")
2177 FileWrite(File
, "Platform Name: %s" % self
.PlatformName
)
2178 FileWrite(File
, "Platform DSC Path: %s" % self
.PlatformDscPath
)
2179 FileWrite(File
, "Architectures: %s" % self
.Architectures
)
2180 FileWrite(File
, "Tool Chain: %s" % self
.ToolChain
)
2181 FileWrite(File
, "Target: %s" % self
.Target
)
2182 if GlobalData
.gSkuids
:
2183 FileWrite(File
, "SKUID: %s" % " ".join(GlobalData
.gSkuids
))
2184 if GlobalData
.gDefaultStores
:
2185 FileWrite(File
, "DefaultStore: %s" % " ".join(GlobalData
.gDefaultStores
))
2186 FileWrite(File
, "Output Path: %s" % self
.OutputPath
)
2187 FileWrite(File
, "Build Environment: %s" % self
.BuildEnvironment
)
2188 FileWrite(File
, "Build Duration: %s" % BuildDuration
)
2190 FileWrite(File
, "AutoGen Duration: %s" % AutoGenTime
)
2192 FileWrite(File
, "Make Duration: %s" % MakeTime
)
2194 FileWrite(File
, "GenFds Duration: %s" % GenFdsTime
)
2195 FileWrite(File
, "Report Content: %s" % ", ".join(ReportType
))
2197 if GlobalData
.MixedPcd
:
2198 FileWrite(File
, gSectionStart
)
2199 FileWrite(File
, "The following PCDs use different access methods:")
2200 FileWrite(File
, gSectionSep
)
2201 for PcdItem
in GlobalData
.MixedPcd
:
2202 FileWrite(File
, "%s.%s" % (str(PcdItem
[1]), str(PcdItem
[0])))
2203 FileWrite(File
, gSectionEnd
)
2205 if not self
._IsModuleBuild
:
2206 if "PCD" in ReportType
:
2207 self
.PcdReport
.GenerateReport(File
, None)
2209 if "FLASH" in ReportType
:
2210 for FdReportListItem
in self
.FdReportList
:
2211 FdReportListItem
.GenerateReport(File
)
2213 for ModuleReportItem
in self
.ModuleReportList
:
2214 ModuleReportItem
.GenerateReport(File
, self
.PcdReport
, self
.PredictionReport
, self
.DepexParser
, ReportType
)
2216 if not self
._IsModuleBuild
:
2217 if "EXECUTION_ORDER" in ReportType
:
2218 self
.PredictionReport
.GenerateReport(File
, None)
2220 ## BuildReport class
2222 # This base class contain the routines to collect data and then
2223 # applies certain format to the output report
2225 class BuildReport(object):
2227 # Constructor function for class BuildReport
2229 # This constructor function generates BuildReport object a platform build.
2230 # It generates report for platform summary, flash, global PCDs and detailed
2231 # module information for modules involved in platform build.
2233 # @param self The object pointer
2234 # @param ReportFile The file name to save report file
2235 # @param ReportType The kind of report items in the final report file
2237 def __init__(self
, ReportFile
, ReportType
):
2238 self
.ReportFile
= ReportFile
2240 self
.ReportList
= []
2241 self
.ReportType
= []
2243 for ReportTypeItem
in ReportType
:
2244 if ReportTypeItem
not in self
.ReportType
:
2245 self
.ReportType
.append(ReportTypeItem
)
2247 self
.ReportType
= ["PCD", "LIBRARY", "BUILD_FLAGS", "DEPEX", "HASH", "FLASH", "FIXED_ADDRESS"]
2249 # Adds platform report to the list
2251 # This function adds a platform report to the final report list.
2253 # @param self The object pointer
2254 # @param Wa Workspace context information
2255 # @param MaList The list of modules in the platform build
2257 def AddPlatformReport(self
, Wa
, MaList
=None):
2259 self
.ReportList
.append((Wa
, MaList
))
2262 # Generates the final report.
2264 # This function generates platform build report. It invokes GenerateReport()
2265 # method for every platform report in the list.
2267 # @param self The object pointer
2268 # @param BuildDuration The total time to build the modules
2269 # @param AutoGenTime The total time of AutoGen phase
2270 # @param MakeTime The total time of Make phase
2271 # @param GenFdsTime The total time of GenFds phase
2273 def GenerateReport(self
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
):
2277 for (Wa
, MaList
) in self
.ReportList
:
2278 PlatformReport(Wa
, MaList
, self
.ReportType
).GenerateReport(File
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
, self
.ReportType
)
2279 Content
= FileLinesSplit(File
.getvalue(), gLineMaxLength
)
2280 SaveFileOnChange(self
.ReportFile
, Content
, True)
2281 EdkLogger
.quiet("Build report can be found at %s" % os
.path
.abspath(self
.ReportFile
))
2283 EdkLogger
.error(None, FILE_WRITE_FAILURE
, ExtraData
=self
.ReportFile
)
2285 EdkLogger
.error("BuildReport", CODE_ERROR
, "Unknown fatal error when generating build report", ExtraData
=self
.ReportFile
, RaiseError
=False)
2286 EdkLogger
.quiet("(Python %s on %s\n%s)" % (platform
.python_version(), sys
.platform
, traceback
.format_exc()))
2289 # This acts like the main() function for the script, unless it is 'import'ed into another script.
2290 if __name__
== '__main__':