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 StringIO
import StringIO
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
285 # Parse the binary dependency expression files.
287 # This function parses the binary dependency expression file and translate it
288 # to the instruction list.
290 # @param self The object pointer
291 # @param DepexFileName The file name of binary dependency expression file.
293 def ParseDepexFile(self
, DepexFileName
):
294 DepexFile
= open(DepexFileName
, "rb")
296 OpCode
= DepexFile
.read(1)
298 Statement
= gOpCodeList
[struct
.unpack("B", OpCode
)[0]]
299 if Statement
in ["BEFORE", "AFTER", "PUSH"]:
300 GuidValue
= "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X" % \
301 struct
.unpack(PACK_PATTERN_GUID
, DepexFile
.read(16))
302 GuidString
= self
._GuidDb
.get(GuidValue
, GuidValue
)
303 Statement
= "%s %s" % (Statement
, GuidString
)
304 DepexStatement
.append(Statement
)
305 OpCode
= DepexFile
.read(1)
307 return DepexStatement
310 # Reports library information
312 # This class reports the module library subsection in the build report file.
314 class LibraryReport(object):
316 # Constructor function for class LibraryReport
318 # This constructor function generates LibraryReport object for
321 # @param self The object pointer
322 # @param M Module context information
324 def __init__(self
, M
):
325 self
.LibraryList
= []
326 if int(str(M
.AutoGenVersion
), 0) >= 0x00010005:
327 self
._EdkIIModule
= True
329 self
._EdkIIModule
= False
331 for Lib
in M
.DependentLibraryList
:
332 LibInfPath
= str(Lib
)
333 LibClassList
= Lib
.LibraryClass
[0].LibraryClass
334 LibConstructorList
= Lib
.ConstructorList
335 LibDesstructorList
= Lib
.DestructorList
336 LibDepexList
= Lib
.DepexExpression
[M
.Arch
, M
.ModuleType
]
337 for LibAutoGen
in M
.LibraryAutoGenList
:
338 if LibInfPath
== LibAutoGen
.MetaFile
.Path
:
339 LibTime
= LibAutoGen
.BuildTime
341 self
.LibraryList
.append((LibInfPath
, LibClassList
, LibConstructorList
, LibDesstructorList
, LibDepexList
, LibTime
))
344 # Generate report for module library information
346 # This function generates report for the module library.
347 # If the module is EDKII style one, the additional library class, library
348 # constructor/destructor and dependency expression may also be reported.
350 # @param self The object pointer
351 # @param File The file object for report
353 def GenerateReport(self
, File
):
354 if len(self
.LibraryList
) > 0:
355 FileWrite(File
, gSubSectionStart
)
356 FileWrite(File
, TAB_BRG_LIBRARY
)
357 FileWrite(File
, gSubSectionSep
)
358 for LibraryItem
in self
.LibraryList
:
359 LibInfPath
= LibraryItem
[0]
360 FileWrite(File
, LibInfPath
)
363 # Report library class, library constructor and destructor for
364 # EDKII style module.
366 if self
._EdkIIModule
:
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
.DepexExpressionList
.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
, "%s" % 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
, "%s" % self
.Depex
)
470 FileWrite(File
, gSubSectionEnd
)
473 # Reports dependency expression information
475 # This class reports the module build flags subsection in the build report file.
477 class BuildFlagsReport(object):
479 # Constructor function for class BuildFlagsReport
481 # This constructor function generates BuildFlagsReport object for
482 # a module. It reports the build tool chain tag and all relevant
483 # build flags to build the module.
485 # @param self The object pointer
486 # @param M Module context information
488 def __init__(self
, M
):
491 # Add build flags according to source file extension so that
492 # irrelevant ones can be filtered out.
494 for Source
in M
.SourceFileList
:
495 Ext
= os
.path
.splitext(Source
.File
)[1].lower()
496 if Ext
in [".c", ".cc", ".cpp"]:
497 BuildOptions
["CC"] = 1
498 elif Ext
in [".s", ".asm"]:
499 BuildOptions
["PP"] = 1
500 BuildOptions
["ASM"] = 1
501 elif Ext
in [".vfr"]:
502 BuildOptions
["VFRPP"] = 1
503 BuildOptions
["VFR"] = 1
504 elif Ext
in [".dxs"]:
505 BuildOptions
["APP"] = 1
506 BuildOptions
["CC"] = 1
507 elif Ext
in [".asl"]:
508 BuildOptions
["ASLPP"] = 1
509 BuildOptions
["ASL"] = 1
510 elif Ext
in [".aslc"]:
511 BuildOptions
["ASLCC"] = 1
512 BuildOptions
["ASLDLINK"] = 1
513 BuildOptions
["CC"] = 1
514 elif Ext
in [".asm16"]:
515 BuildOptions
["ASMLINK"] = 1
516 BuildOptions
["SLINK"] = 1
517 BuildOptions
["DLINK"] = 1
520 # Save module build flags.
522 self
.ToolChainTag
= M
.ToolChain
524 for Tool
in BuildOptions
:
525 self
.BuildFlags
[Tool
+ "_FLAGS"] = M
.BuildOption
.get(Tool
, {}).get("FLAGS", "")
528 # Generate report for module build flags information
530 # This function generates report for the module build flags expression.
532 # @param self The object pointer
533 # @param File The file object for report
535 def GenerateReport(self
, File
):
536 FileWrite(File
, gSubSectionStart
)
537 FileWrite(File
, "Build Flags")
538 FileWrite(File
, "Tool Chain Tag: %s" % self
.ToolChainTag
)
539 for Tool
in self
.BuildFlags
:
540 FileWrite(File
, gSubSectionSep
)
541 FileWrite(File
, "%s = %s" % (Tool
, self
.BuildFlags
[Tool
]), True)
543 FileWrite(File
, gSubSectionEnd
)
547 # Reports individual module information
549 # This class reports the module section in the build report file.
550 # It comprises of module summary, module PCD, library, dependency expression,
551 # build flags sections.
553 class ModuleReport(object):
555 # Constructor function for class ModuleReport
557 # This constructor function generates ModuleReport object for
558 # a separate module in a platform build.
560 # @param self The object pointer
561 # @param M Module context information
562 # @param ReportType The kind of report items in the final report file
564 def __init__(self
, M
, ReportType
):
565 self
.ModuleName
= M
.Module
.BaseName
566 self
.ModuleInfPath
= M
.MetaFile
.File
567 self
.FileGuid
= M
.Guid
569 self
.BuildTimeStamp
= None
573 ModuleType
= M
.ModuleType
575 ModuleType
= COMPONENT_TO_MODULE_MAP_DICT
.get(M
.ComponentType
, "")
577 # If a module complies to PI 1.1, promote Module type to "SMM_DRIVER"
579 if ModuleType
== SUP_MODULE_DXE_SMM_DRIVER
:
580 PiSpec
= M
.Module
.Specification
.get("PI_SPECIFICATION_VERSION", "0x00010000")
581 if int(PiSpec
, 0) >= 0x0001000A:
582 ModuleType
= "SMM_DRIVER"
583 self
.DriverType
= gDriverTypeMap
.get(ModuleType
, "0x2 (FREE_FORM)")
584 self
.UefiSpecVersion
= M
.Module
.Specification
.get("UEFI_SPECIFICATION_VERSION", "")
585 self
.PiSpecVersion
= M
.Module
.Specification
.get("PI_SPECIFICATION_VERSION", "")
586 self
.PciDeviceId
= M
.Module
.Defines
.get("PCI_DEVICE_ID", "")
587 self
.PciVendorId
= M
.Module
.Defines
.get("PCI_VENDOR_ID", "")
588 self
.PciClassCode
= M
.Module
.Defines
.get("PCI_CLASS_CODE", "")
589 self
.BuildTime
= M
.BuildTime
591 self
._BuildDir
= M
.BuildDir
592 self
.ModulePcdSet
= {}
593 if "PCD" in ReportType
:
595 # Collect all module used PCD set: module INF referenced directly or indirectly.
596 # It also saves module INF default values of them in case they exist.
598 for Pcd
in M
.ModulePcdList
+ M
.LibraryPcdList
:
599 self
.ModulePcdSet
.setdefault((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Pcd
.Type
), (Pcd
.InfDefaultValue
, Pcd
.DefaultValue
))
601 self
.LibraryReport
= None
602 if "LIBRARY" in ReportType
:
603 self
.LibraryReport
= LibraryReport(M
)
605 self
.DepexReport
= None
606 if "DEPEX" in ReportType
:
607 self
.DepexReport
= DepexReport(M
)
609 if "BUILD_FLAGS" in ReportType
:
610 self
.BuildFlagsReport
= BuildFlagsReport(M
)
614 # Generate report for module information
616 # This function generates report for separate module expression
617 # in a platform build.
619 # @param self The object pointer
620 # @param File The file object for report
621 # @param GlobalPcdReport The platform global PCD report object
622 # @param GlobalPredictionReport The platform global Prediction report object
623 # @param GlobalDepexParser The platform global Dependency expression parser object
624 # @param ReportType The kind of report items in the final report file
626 def GenerateReport(self
, File
, GlobalPcdReport
, GlobalPredictionReport
, GlobalDepexParser
, ReportType
):
627 FileWrite(File
, gSectionStart
)
629 FwReportFileName
= os
.path
.join(self
._BuildDir
, "DEBUG", self
.ModuleName
+ ".txt")
630 if os
.path
.isfile(FwReportFileName
):
632 FileContents
= open(FwReportFileName
).read()
633 Match
= gModuleSizePattern
.search(FileContents
)
635 self
.Size
= int(Match
.group(1))
637 Match
= gTimeStampPattern
.search(FileContents
)
639 self
.BuildTimeStamp
= datetime
.fromtimestamp(int(Match
.group(1)))
641 EdkLogger
.warn(None, "Fail to read report file", FwReportFileName
)
643 if "HASH" in ReportType
:
644 OutputDir
= os
.path
.join(self
._BuildDir
, "OUTPUT")
645 DefaultEFIfile
= os
.path
.join(OutputDir
, self
.ModuleName
+ ".efi")
646 if os
.path
.isfile(DefaultEFIfile
):
647 Tempfile
= os
.path
.join(OutputDir
, self
.ModuleName
+ "_hash.tmp")
648 # rebase the efi image since its base address may not zero
649 cmd
= ["GenFw", "--rebase", str(0), "-o", Tempfile
, DefaultEFIfile
]
651 PopenObject
= subprocess
.Popen(' '.join(cmd
), stdout
=subprocess
.PIPE
, stderr
=subprocess
.PIPE
, shell
=True)
653 EdkLogger
.error("GenFw", COMMAND_FAILURE
, ExtraData
="%s: %s" % (str(X
), cmd
[0]))
654 EndOfProcedure
= threading
.Event()
655 EndOfProcedure
.clear()
656 if PopenObject
.stderr
:
657 StdErrThread
= threading
.Thread(target
=ReadMessage
, args
=(PopenObject
.stderr
, EdkLogger
.quiet
, EndOfProcedure
))
658 StdErrThread
.setName("STDERR-Redirector")
659 StdErrThread
.setDaemon(False)
661 # waiting for program exit
663 if PopenObject
.stderr
:
665 if PopenObject
.returncode
!= 0:
666 EdkLogger
.error("GenFw", COMMAND_FAILURE
, "Failed to generate firmware hash image for %s" % (DefaultEFIfile
))
667 if os
.path
.isfile(Tempfile
):
668 self
.Hash
= hashlib
.sha1()
669 buf
= open(Tempfile
, 'rb').read()
670 if self
.Hash
.update(buf
):
671 self
.Hash
= self
.Hash
.update(buf
)
672 self
.Hash
= self
.Hash
.hexdigest()
675 FileWrite(File
, "Module Summary")
676 FileWrite(File
, "Module Name: %s" % self
.ModuleName
)
677 FileWrite(File
, "Module INF Path: %s" % self
.ModuleInfPath
)
678 FileWrite(File
, "File GUID: %s" % self
.FileGuid
)
680 FileWrite(File
, "Size: 0x%X (%.2fK)" % (self
.Size
, self
.Size
/ 1024.0))
682 FileWrite(File
, "SHA1 HASH: %s *%s" % (self
.Hash
, self
.ModuleName
+ ".efi"))
683 if self
.BuildTimeStamp
:
684 FileWrite(File
, "Build Time Stamp: %s" % self
.BuildTimeStamp
)
686 FileWrite(File
, "Module Build Time: %s" % self
.BuildTime
)
688 FileWrite(File
, "Driver Type: %s" % self
.DriverType
)
689 if self
.UefiSpecVersion
:
690 FileWrite(File
, "UEFI Spec Version: %s" % self
.UefiSpecVersion
)
691 if self
.PiSpecVersion
:
692 FileWrite(File
, "PI Spec Version: %s" % self
.PiSpecVersion
)
694 FileWrite(File
, "PCI Device ID: %s" % self
.PciDeviceId
)
696 FileWrite(File
, "PCI Vendor ID: %s" % self
.PciVendorId
)
697 if self
.PciClassCode
:
698 FileWrite(File
, "PCI Class Code: %s" % self
.PciClassCode
)
700 FileWrite(File
, gSectionSep
)
702 if "PCD" in ReportType
:
703 GlobalPcdReport
.GenerateReport(File
, self
.ModulePcdSet
)
705 if "LIBRARY" in ReportType
:
706 self
.LibraryReport
.GenerateReport(File
)
708 if "DEPEX" in ReportType
:
709 self
.DepexReport
.GenerateReport(File
, GlobalDepexParser
)
711 if "BUILD_FLAGS" in ReportType
:
712 self
.BuildFlagsReport
.GenerateReport(File
)
714 if "FIXED_ADDRESS" in ReportType
and self
.FileGuid
:
715 GlobalPredictionReport
.GenerateReport(File
, self
.FileGuid
)
717 FileWrite(File
, gSectionEnd
)
719 def ReadMessage(From
, To
, ExitFlag
):
721 # read one line a time
722 Line
= From
.readline()
723 # empty string means "end"
724 if Line
is not None and Line
!= "":
732 # Reports platform and module PCD information
734 # This class reports the platform PCD section and module PCD subsection
735 # in the build report file.
737 class PcdReport(object):
739 # Constructor function for class PcdReport
741 # This constructor function generates PcdReport object a platform build.
742 # It collects the whole PCD database from platform DSC files, platform
743 # flash description file and package DEC files.
745 # @param self The object pointer
746 # @param Wa Workspace context information
748 def __init__(self
, Wa
):
751 self
.ConditionalPcds
= {}
755 self
.FdfPcdSet
= Wa
.FdfProfile
.PcdDict
759 self
.DefaultStoreSingle
= True
760 self
.SkuSingle
= True
761 if GlobalData
.gDefaultStores
and len(GlobalData
.gDefaultStores
) > 1:
762 self
.DefaultStoreSingle
= False
763 if GlobalData
.gSkuids
and len(GlobalData
.gSkuids
) > 1:
764 self
.SkuSingle
= False
766 self
.ModulePcdOverride
= {}
767 for Pa
in Wa
.AutoGenObjectList
:
770 # Collect all platform referenced PCDs and grouped them by PCD token space
773 for Pcd
in Pa
.AllPcdList
:
774 PcdList
= self
.AllPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
775 if Pcd
not in PcdList
:
777 if len(Pcd
.TokenCName
) > self
.MaxLen
:
778 self
.MaxLen
= len(Pcd
.TokenCName
)
780 # Collect the PCD defined in DSC/FDF file, but not used in module
782 UnusedPcdFullList
= []
783 for item
in Pa
.Platform
.Pcds
:
784 Pcd
= Pa
.Platform
.Pcds
[item
]
786 # check the Pcd in FDF file, whether it is used in module first
787 for T
in PCD_TYPE_LIST
:
788 PcdList
= self
.AllPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(T
, [])
794 for package
in Pa
.PackageList
:
795 for T
in PCD_TYPE_LIST
:
796 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, T
) in package
.Pcds
:
799 if not Pcd
.DatumType
:
800 Pcd
.DatumType
= package
.Pcds
[(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, T
)].DatumType
804 if not Pcd
.DatumType
:
806 # Try to remove Hii and Vpd suffix
807 if PcdType
.startswith(TAB_PCDS_DYNAMIC_EX
):
808 PcdType
= TAB_PCDS_DYNAMIC_EX
809 elif PcdType
.startswith(TAB_PCDS_DYNAMIC
):
810 PcdType
= TAB_PCDS_DYNAMIC
811 for package
in Pa
.PackageList
:
812 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, PcdType
) in package
.Pcds
:
813 Pcd
.DatumType
= package
.Pcds
[(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, PcdType
)].DatumType
816 PcdList
= self
.AllPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
817 if Pcd
not in PcdList
and Pcd
not in UnusedPcdFullList
:
818 UnusedPcdFullList
.append(Pcd
)
819 if len(Pcd
.TokenCName
) > self
.MaxLen
:
820 self
.MaxLen
= len(Pcd
.TokenCName
)
822 if GlobalData
.gConditionalPcds
:
823 for PcdItem
in GlobalData
.gConditionalPcds
:
825 (TokenSpaceGuidCName
, TokenCName
) = PcdItem
.split('.')
826 if (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
827 Pcd
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)]
828 PcdList
= self
.ConditionalPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
829 if Pcd
not in PcdList
:
833 if UnusedPcdFullList
:
834 for Pcd
in UnusedPcdFullList
:
835 if Pcd
.TokenSpaceGuidCName
+ '.' + Pcd
.TokenCName
in GlobalData
.gConditionalPcds
:
837 UnusedPcdList
.append(Pcd
)
839 for Pcd
in UnusedPcdList
:
840 PcdList
= self
.UnusedPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
841 if Pcd
not in PcdList
:
844 for Module
in Pa
.Platform
.Modules
.values():
846 # Collect module override PCDs
848 for ModulePcd
in Module
.M
.ModulePcdList
+ Module
.M
.LibraryPcdList
:
849 TokenCName
= ModulePcd
.TokenCName
850 TokenSpaceGuid
= ModulePcd
.TokenSpaceGuidCName
851 ModuleDefault
= ModulePcd
.DefaultValue
852 ModulePath
= os
.path
.basename(Module
.M
.MetaFile
.File
)
853 self
.ModulePcdOverride
.setdefault((TokenCName
, TokenSpaceGuid
), {})[ModulePath
] = ModuleDefault
857 # Collect PCD DEC default value.
859 self
.DecPcdDefault
= {}
861 for Pa
in Wa
.AutoGenObjectList
:
862 for Package
in Pa
.PackageList
:
863 Guids
= Package
.Guids
864 self
._GuidDict
.update(Guids
)
865 for (TokenCName
, TokenSpaceGuidCName
, DecType
) in Package
.Pcds
:
866 DecDefaultValue
= Package
.Pcds
[TokenCName
, TokenSpaceGuidCName
, DecType
].DefaultValue
867 self
.DecPcdDefault
.setdefault((TokenCName
, TokenSpaceGuidCName
, DecType
), DecDefaultValue
)
869 # Collect PCDs defined in DSC common section
871 self
.DscPcdDefault
= {}
872 for Pa
in Wa
.AutoGenObjectList
:
873 for (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
874 DscDefaultValue
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)].DscDefaultValue
876 self
.DscPcdDefault
[(TokenCName
, TokenSpaceGuidCName
)] = DscDefaultValue
878 def GenerateReport(self
, File
, ModulePcdSet
):
880 if self
.ConditionalPcds
:
881 self
.GenerateReportDetail(File
, ModulePcdSet
, 1)
883 self
.GenerateReportDetail(File
, ModulePcdSet
, 2)
884 self
.GenerateReportDetail(File
, ModulePcdSet
)
887 # Generate report for PCD information
889 # This function generates report for separate module expression
890 # in a platform build.
892 # @param self The object pointer
893 # @param File The file object for report
894 # @param ModulePcdSet Set of all PCDs referenced by module or None for
895 # platform PCD report
896 # @param ReportySubType 0 means platform/module PCD report, 1 means Conditional
897 # directives section report, 2 means Unused Pcds section report
898 # @param DscOverridePcds Module DSC override PCDs set
900 def GenerateReportDetail(self
, File
, ModulePcdSet
, ReportSubType
= 0):
901 PcdDict
= self
.AllPcds
902 if ReportSubType
== 1:
903 PcdDict
= self
.ConditionalPcds
904 elif ReportSubType
== 2:
905 PcdDict
= self
.UnusedPcds
908 FileWrite(File
, gSectionStart
)
909 if ReportSubType
== 1:
910 FileWrite(File
, "Conditional Directives used by the build system")
911 elif ReportSubType
== 2:
912 FileWrite(File
, "PCDs not used by modules or in conditional directives")
914 FileWrite(File
, "Platform Configuration Database Report")
916 FileWrite(File
, " *B - PCD override in the build option")
917 FileWrite(File
, " *P - Platform scoped PCD override in DSC file")
918 FileWrite(File
, " *F - Platform scoped PCD override in FDF file")
919 if not ReportSubType
:
920 FileWrite(File
, " *M - Module scoped PCD override")
921 FileWrite(File
, gSectionSep
)
923 if not ReportSubType
and ModulePcdSet
:
925 # For module PCD sub-section
927 FileWrite(File
, gSubSectionStart
)
928 FileWrite(File
, TAB_BRG_PCD
)
929 FileWrite(File
, gSubSectionSep
)
933 for Type
in PcdDict
[Key
]:
934 for Pcd
in PcdDict
[Key
][Type
]:
935 AllPcdDict
[Key
][(Pcd
.TokenCName
, Type
)] = Pcd
936 for Key
in sorted(AllPcdDict
):
938 # Group PCD by their token space GUID C Name
941 for PcdTokenCName
, Type
in sorted(AllPcdDict
[Key
]):
943 # Group PCD by their usage type
945 Pcd
= AllPcdDict
[Key
][(PcdTokenCName
, Type
)]
946 TypeName
, DecType
= gPcdTypeMap
.get(Type
, ("", Type
))
948 if GlobalData
.MixedPcd
:
949 for PcdKey
in GlobalData
.MixedPcd
:
950 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
) in GlobalData
.MixedPcd
[PcdKey
]:
951 PcdTokenCName
= PcdKey
[0]
953 if MixedPcdFlag
and not ModulePcdSet
:
956 # Get PCD default value and their override relationship
958 DecDefaultValue
= self
.DecPcdDefault
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, DecType
))
959 DscDefaultValue
= self
.DscPcdDefault
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
))
960 DscDefaultValBak
= DscDefaultValue
961 DscDefaultValue
= self
.FdfPcdSet
.get((Pcd
.TokenCName
, Key
), DscDefaultValue
)
962 if DscDefaultValue
!= DscDefaultValBak
:
964 DscDefaultValue
= ValueExpressionEx(DscDefaultValue
, Pcd
.DatumType
, self
._GuidDict
)(True)
965 except BadExpression
, DscDefaultValue
:
966 EdkLogger
.error('BuildReport', FORMAT_INVALID
, "PCD Value: %s, Type: %s" %(DscDefaultValue
, Pcd
.DatumType
))
968 InfDefaultValue
= None
970 PcdValue
= DecDefaultValue
972 PcdValue
= DscDefaultValue
973 if ModulePcdSet
is not None:
974 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Type
) not in ModulePcdSet
:
976 InfDefault
, PcdValue
= ModulePcdSet
[Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Type
]
977 Pcd
.DefaultValue
= PcdValue
981 BuildOptionMatch
= False
982 if GlobalData
.BuildOptionPcd
:
983 for pcd
in GlobalData
.BuildOptionPcd
:
984 if (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
) == (pcd
[0], pcd
[1]):
988 Pcd
.DefaultValue
= PcdValue
989 BuildOptionMatch
= True
993 if ModulePcdSet
is None:
999 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1000 PcdValueNumber
= int(PcdValue
.strip(), 0)
1001 if DecDefaultValue
is None:
1004 DecDefaultValueNumber
= int(DecDefaultValue
.strip(), 0)
1005 DecMatch
= (DecDefaultValueNumber
== PcdValueNumber
)
1007 if InfDefaultValue
is None:
1010 InfDefaultValueNumber
= int(InfDefaultValue
.strip(), 0)
1011 InfMatch
= (InfDefaultValueNumber
== PcdValueNumber
)
1013 if DscDefaultValue
is None:
1016 DscDefaultValueNumber
= int(DscDefaultValue
.strip(), 0)
1017 DscMatch
= (DscDefaultValueNumber
== PcdValueNumber
)
1019 if DecDefaultValue
is None:
1022 DecMatch
= (DecDefaultValue
.strip() == PcdValue
.strip())
1024 if InfDefaultValue
is None:
1027 InfMatch
= (InfDefaultValue
.strip() == PcdValue
.strip())
1029 if DscDefaultValue
is None:
1032 DscMatch
= (DscDefaultValue
.strip() == PcdValue
.strip())
1035 if GlobalData
.gStructurePcd
and (self
.Arch
in GlobalData
.gStructurePcd
) and ((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
) in GlobalData
.gStructurePcd
[self
.Arch
]):
1037 if TypeName
in ('DYNVPD', 'DEXVPD'):
1038 SkuInfoList
= Pcd
.SkuInfoList
1039 Pcd
= GlobalData
.gStructurePcd
[self
.Arch
][(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
)]
1040 Pcd
.DatumType
= Pcd
.StructName
1041 if TypeName
in ('DYNVPD', 'DEXVPD'):
1042 Pcd
.SkuInfoList
= SkuInfoList
1043 if Pcd
.PcdFieldValueFromComm
:
1044 BuildOptionMatch
= True
1046 elif Pcd
.SkuOverrideValues
:
1048 if not Pcd
.SkuInfoList
:
1049 OverrideValues
= Pcd
.SkuOverrideValues
1051 Keys
= OverrideValues
.keys()
1052 Data
= OverrideValues
[Keys
[0]]
1053 Struct
= Data
.values()[0]
1054 DscOverride
= self
.ParseStruct(Struct
)
1056 SkuList
= sorted(Pcd
.SkuInfoList
.keys())
1058 SkuInfo
= Pcd
.SkuInfoList
[Sku
]
1059 if TypeName
in ('DYNHII', 'DEXHII'):
1060 if SkuInfo
.DefaultStoreDict
:
1061 DefaultStoreList
= sorted(SkuInfo
.DefaultStoreDict
.keys())
1062 for DefaultStore
in DefaultStoreList
:
1063 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1064 DscOverride
= self
.ParseStruct(OverrideValues
[DefaultStore
])
1068 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1070 Keys
= OverrideValues
.keys()
1071 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[Keys
[0]])
1072 DscOverride
= self
.ParseStruct(OverrideFieldStruct
)
1080 # Report PCD item according to their override relationship
1082 if DecMatch
and InfMatch
:
1083 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, ' ')
1084 elif BuildOptionMatch
:
1085 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*B')
1088 if (Pcd
.TokenCName
, Key
) in self
.FdfPcdSet
:
1089 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*F')
1091 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*P')
1093 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*M')
1095 if ModulePcdSet
is None:
1098 if not TypeName
in ('PATCH', 'FLAG', 'FIXED'):
1100 if not BuildOptionMatch
:
1101 ModuleOverride
= self
.ModulePcdOverride
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
), {})
1102 for ModulePath
in ModuleOverride
:
1103 ModuleDefault
= ModuleOverride
[ModulePath
]
1104 if Pcd
.DatumType
in TAB_PCD_CLEAN_NUMERIC_TYPES
:
1105 ModulePcdDefaultValueNumber
= int(ModuleDefault
.strip(), 0)
1106 Match
= (ModulePcdDefaultValueNumber
== PcdValueNumber
)
1108 Match
= (ModuleDefault
.strip() == PcdValue
.strip())
1111 IsByteArray
, ArrayList
= ByteArrayForamt(ModuleDefault
.strip())
1113 FileWrite(File
, ' *M %-*s = %s' % (self
.MaxLen
+ 15, ModulePath
, '{'))
1114 for Array
in ArrayList
:
1115 FileWrite(File
, '%s' % (Array
))
1117 FileWrite(File
, ' *M %-*s = %s' % (self
.MaxLen
+ 15, ModulePath
, ModuleDefault
.strip()))
1119 if ModulePcdSet
is None:
1120 FileWrite(File
, gSectionEnd
)
1122 if not ReportSubType
and ModulePcdSet
:
1123 FileWrite(File
, gSubSectionEnd
)
1125 def ParseStruct(self
, struct
):
1126 HasDscOverride
= False
1128 for _
, Values
in struct
.items():
1129 if Values
[1] and Values
[1].endswith('.dsc'):
1130 HasDscOverride
= True
1132 return HasDscOverride
1134 def PrintPcdDefault(self
, File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
):
1135 if not DscMatch
and DscDefaultValue
is not None:
1136 Value
= DscDefaultValue
.strip()
1137 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1139 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DSC DEFAULT', "{"))
1140 for Array
in ArrayList
:
1141 FileWrite(File
, '%s' % (Array
))
1143 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DSC DEFAULT', Value
))
1144 if not InfMatch
and InfDefaultValue
is not None:
1145 Value
= InfDefaultValue
.strip()
1146 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1148 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'INF DEFAULT', "{"))
1149 for Array
in ArrayList
:
1150 FileWrite(File
, '%s' % (Array
))
1152 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'INF DEFAULT', Value
))
1154 if not DecMatch
and DecDefaultValue
is not None:
1155 Value
= DecDefaultValue
.strip()
1156 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1158 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DEC DEFAULT', "{"))
1159 for Array
in ArrayList
:
1160 FileWrite(File
, '%s' % (Array
))
1162 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DEC DEFAULT', Value
))
1164 self
.PrintStructureInfo(File
, Pcd
.DefaultValues
)
1165 if DecMatch
and IsStructure
:
1166 self
.PrintStructureInfo(File
, Pcd
.DefaultValues
)
1168 def PrintPcdValue(self
, File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, Flag
= ' '):
1169 if not Pcd
.SkuInfoList
:
1170 Value
= Pcd
.DefaultValue
1171 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1173 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1174 for Array
in ArrayList
:
1175 FileWrite(File
, '%s' % (Array
))
1177 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1179 OverrideValues
= Pcd
.SkuOverrideValues
1181 Keys
= OverrideValues
.keys()
1182 Data
= OverrideValues
[Keys
[0]]
1183 Struct
= Data
.values()[0]
1184 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, Struct
)
1185 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1186 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1189 SkuList
= sorted(Pcd
.SkuInfoList
.keys())
1191 SkuInfo
= Pcd
.SkuInfoList
[Sku
]
1192 SkuIdName
= SkuInfo
.SkuIdName
1193 if TypeName
in ('DYNHII', 'DEXHII'):
1194 if SkuInfo
.DefaultStoreDict
:
1195 DefaultStoreList
= sorted(SkuInfo
.DefaultStoreDict
.keys())
1196 for DefaultStore
in DefaultStoreList
:
1197 Value
= SkuInfo
.DefaultStoreDict
[DefaultStore
]
1198 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1202 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1203 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1204 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1205 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '{'))
1206 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1207 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', '{'))
1209 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', '{'))
1210 for Array
in ArrayList
:
1211 FileWrite(File
, '%s' % (Array
))
1213 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1214 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1215 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1216 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1217 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1218 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', Value
))
1220 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', Value
))
1223 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1224 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1225 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1226 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '{'))
1227 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1228 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', '{'))
1230 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', '{'))
1231 for Array
in ArrayList
:
1232 FileWrite(File
, '%s' % (Array
))
1234 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1235 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1236 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1237 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1238 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1239 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', Value
))
1241 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', Value
))
1242 FileWrite(File
, '%*s: %s: %s' % (self
.MaxLen
+ 4, SkuInfo
.VariableGuid
, SkuInfo
.VariableName
, SkuInfo
.VariableOffset
))
1244 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1245 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[DefaultStore
])
1246 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1247 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1249 Value
= SkuInfo
.DefaultValue
1250 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1255 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', "{"))
1257 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', "{"))
1258 for Array
in ArrayList
:
1259 FileWrite(File
, '%s' % (Array
))
1262 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1264 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1268 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', "{"))
1270 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', "{"))
1271 for Array
in ArrayList
:
1272 FileWrite(File
, '%s' % (Array
))
1275 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1277 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1278 if TypeName
in ('DYNVPD', 'DEXVPD'):
1279 FileWrite(File
, '%*s' % (self
.MaxLen
+ 4, SkuInfo
.VpdOffset
))
1281 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1283 Keys
= OverrideValues
.keys()
1284 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[Keys
[0]])
1285 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1286 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1288 def OverrideFieldValue(self
, Pcd
, OverrideStruct
):
1289 OverrideFieldStruct
= collections
.OrderedDict()
1291 for Key
, Values
in OverrideStruct
.items():
1292 if Values
[1] and Values
[1].endswith('.dsc'):
1293 OverrideFieldStruct
[Key
] = Values
1294 if Pcd
.PcdFieldValueFromComm
:
1295 for Key
, Values
in Pcd
.PcdFieldValueFromComm
.items():
1296 OverrideFieldStruct
[Key
] = Values
1297 return OverrideFieldStruct
1299 def PrintStructureInfo(self
, File
, Struct
):
1300 for Key
, Value
in Struct
.items():
1301 if Value
[1] and 'build command options' in Value
[1]:
1302 FileWrite(File
, ' *B %-*s = %s' % (self
.MaxLen
+ 4, '.' + Key
, Value
[0]))
1304 FileWrite(File
, ' %-*s = %s' % (self
.MaxLen
+ 4, '.' + Key
, Value
[0]))
1306 def StrtoHex(self
, value
):
1308 value
= hex(int(value
))
1311 if value
.startswith("L\"") and value
.endswith("\""):
1313 for ch
in value
[2:-1]:
1314 valuelist
.append(hex(ord(ch
)))
1315 valuelist
.append('0x00')
1317 elif value
.startswith("\"") and value
.endswith("\""):
1318 return hex(ord(value
[1:-1]))
1319 elif value
.startswith("{") and value
.endswith("}"):
1321 if ',' not in value
:
1323 for ch
in value
[1:-1].split(','):
1325 if ch
.startswith('0x') or ch
.startswith('0X'):
1326 valuelist
.append(ch
)
1329 valuelist
.append(hex(int(ch
.strip())))
1337 # Reports platform and module Prediction information
1339 # This class reports the platform execution order prediction section and
1340 # module load fixed address prediction subsection in the build report file.
1342 class PredictionReport(object):
1344 # Constructor function for class PredictionReport
1346 # This constructor function generates PredictionReport object for the platform.
1348 # @param self: The object pointer
1349 # @param Wa Workspace context information
1351 def __init__(self
, Wa
):
1352 self
._MapFileName
= os
.path
.join(Wa
.BuildDir
, Wa
.Name
+ ".map")
1353 self
._MapFileParsed
= False
1354 self
._EotToolInvoked
= False
1355 self
._FvDir
= Wa
.FvDir
1356 self
._EotDir
= Wa
.BuildDir
1357 self
._FfsEntryPoint
= {}
1359 self
._SourceList
= []
1360 self
.FixedMapDict
= {}
1365 # Collect all platform reference source files and GUID C Name
1367 for Pa
in Wa
.AutoGenObjectList
:
1368 for Module
in Pa
.LibraryAutoGenList
+ Pa
.ModuleAutoGenList
:
1370 # BASE typed modules are EFI agnostic, so we need not scan
1371 # their source code to find PPI/Protocol produce or consume
1374 if Module
.ModuleType
== SUP_MODULE_BASE
:
1377 # Add module referenced source files
1379 self
._SourceList
.append(str(Module
))
1381 for Source
in Module
.SourceFileList
:
1382 if os
.path
.splitext(str(Source
))[1].lower() == ".c":
1383 self
._SourceList
.append(" " + str(Source
))
1384 FindIncludeFiles(Source
.Path
, Module
.IncludePathList
, IncludeList
)
1385 for IncludeFile
in IncludeList
.values():
1386 self
._SourceList
.append(" " + IncludeFile
)
1388 for Guid
in Module
.PpiList
:
1389 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.PpiList
[Guid
])
1390 for Guid
in Module
.ProtocolList
:
1391 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.ProtocolList
[Guid
])
1392 for Guid
in Module
.GuidList
:
1393 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.GuidList
[Guid
])
1395 if Module
.Guid
and not Module
.IsLibrary
:
1396 EntryPoint
= " ".join(Module
.Module
.ModuleEntryPointList
)
1397 if int(str(Module
.AutoGenVersion
), 0) >= 0x00010005:
1398 RealEntryPoint
= "_ModuleEntryPoint"
1400 RealEntryPoint
= EntryPoint
1401 if EntryPoint
== "_ModuleEntryPoint":
1402 CCFlags
= Module
.BuildOption
.get("CC", {}).get("FLAGS", "")
1403 Match
= gGlueLibEntryPoint
.search(CCFlags
)
1405 EntryPoint
= Match
.group(1)
1407 self
._FfsEntryPoint
[Module
.Guid
.upper()] = (EntryPoint
, RealEntryPoint
)
1411 # Collect platform firmware volume list as the input of EOT.
1415 for Fd
in Wa
.FdfProfile
.FdDict
:
1416 for FdRegion
in Wa
.FdfProfile
.FdDict
[Fd
].RegionList
:
1417 if FdRegion
.RegionType
!= BINARY_FILE_TYPE_FV
:
1419 for FvName
in FdRegion
.RegionDataList
:
1420 if FvName
in self
._FvList
:
1422 self
._FvList
.append(FvName
)
1423 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1424 for Section
in Ffs
.SectionList
:
1426 for FvSection
in Section
.SectionList
:
1427 if FvSection
.FvName
in self
._FvList
:
1429 self
._FvList
.append(FvSection
.FvName
)
1430 except AttributeError:
1435 # Parse platform fixed address map files
1437 # This function parses the platform final fixed address map file to get
1438 # the database of predicted fixed address for module image base, entry point
1441 # @param self: The object pointer
1443 def _ParseMapFile(self
):
1444 if self
._MapFileParsed
:
1446 self
._MapFileParsed
= True
1447 if os
.path
.isfile(self
._MapFileName
):
1449 FileContents
= open(self
._MapFileName
).read()
1450 for Match
in gMapFileItemPattern
.finditer(FileContents
):
1451 AddressType
= Match
.group(1)
1452 BaseAddress
= Match
.group(2)
1453 EntryPoint
= Match
.group(3)
1454 Guid
= Match
.group(4).upper()
1455 List
= self
.FixedMapDict
.setdefault(Guid
, [])
1456 List
.append((AddressType
, BaseAddress
, "*I"))
1457 List
.append((AddressType
, EntryPoint
, "*E"))
1459 EdkLogger
.warn(None, "Cannot open file to read", self
._MapFileName
)
1462 # Invokes EOT tool to get the predicted the execution order.
1464 # This function invokes EOT tool to calculate the predicted dispatch order
1466 # @param self: The object pointer
1468 def _InvokeEotTool(self
):
1469 if self
._EotToolInvoked
:
1472 self
._EotToolInvoked
= True
1474 for FvName
in self
._FvList
:
1475 FvFile
= os
.path
.join(self
._FvDir
, FvName
+ ".Fv")
1476 if os
.path
.isfile(FvFile
):
1477 FvFileList
.append(FvFile
)
1479 if len(FvFileList
) == 0:
1482 # Write source file list and GUID file list to an intermediate file
1483 # as the input for EOT tool and dispatch List as the output file
1486 SourceList
= os
.path
.join(self
._EotDir
, "SourceFile.txt")
1487 GuidList
= os
.path
.join(self
._EotDir
, "GuidList.txt")
1488 DispatchList
= os
.path
.join(self
._EotDir
, "Dispatch.txt")
1490 TempFile
= open(SourceList
, "w+")
1491 for Item
in self
._SourceList
:
1492 FileWrite(TempFile
, Item
)
1494 TempFile
= open(GuidList
, "w+")
1495 for Key
in self
._GuidMap
:
1496 FileWrite(TempFile
, "%s %s" % (Key
, self
._GuidMap
[Key
]))
1500 from Eot
.Eot
import Eot
1503 # Invoke EOT tool and echo its runtime performance
1505 EotStartTime
= time
.time()
1506 Eot(CommandLineOption
=False, SourceFileList
=SourceList
, GuidList
=GuidList
,
1507 FvFileList
=' '.join(FvFileList
), Dispatch
=DispatchList
, IsInit
=True)
1508 EotEndTime
= time
.time()
1509 EotDuration
= time
.strftime("%H:%M:%S", time
.gmtime(int(round(EotEndTime
- EotStartTime
))))
1510 EdkLogger
.quiet("EOT run time: %s\n" % EotDuration
)
1513 # Parse the output of EOT tool
1515 for Line
in open(DispatchList
):
1516 if len(Line
.split()) < 4:
1518 (Guid
, Phase
, FfsName
, FilePath
) = Line
.split()
1519 Symbol
= self
._FfsEntryPoint
.get(Guid
, [FfsName
, ""])[0]
1520 if len(Symbol
) > self
.MaxLen
:
1521 self
.MaxLen
= len(Symbol
)
1522 self
.ItemList
.append((Phase
, Symbol
, FilePath
))
1524 EdkLogger
.quiet("(Python %s on %s\n%s)" % (platform
.python_version(), sys
.platform
, traceback
.format_exc()))
1525 EdkLogger
.warn(None, "Failed to generate execution order prediction report, for some error occurred in executing EOT.")
1529 # Generate platform execution order report
1531 # This function generates the predicted module execution order.
1533 # @param self The object pointer
1534 # @param File The file object for report
1536 def _GenerateExecutionOrderReport(self
, File
):
1537 self
._InvokeEotTool
()
1538 if len(self
.ItemList
) == 0:
1540 FileWrite(File
, gSectionStart
)
1541 FileWrite(File
, "Execution Order Prediction")
1542 FileWrite(File
, "*P PEI phase")
1543 FileWrite(File
, "*D DXE phase")
1544 FileWrite(File
, "*E Module INF entry point name")
1545 FileWrite(File
, "*N Module notification function name")
1547 FileWrite(File
, "Type %-*s %s" % (self
.MaxLen
, "Symbol", "Module INF Path"))
1548 FileWrite(File
, gSectionSep
)
1549 for Item
in self
.ItemList
:
1550 FileWrite(File
, "*%sE %-*s %s" % (Item
[0], self
.MaxLen
, Item
[1], Item
[2]))
1552 FileWrite(File
, gSectionStart
)
1555 # Generate Fixed Address report.
1557 # This function generate the predicted fixed address report for a module
1558 # specified by Guid.
1560 # @param self The object pointer
1561 # @param File The file object for report
1562 # @param Guid The module Guid value.
1563 # @param NotifyList The list of all notify function in a module
1565 def _GenerateFixedAddressReport(self
, File
, Guid
, NotifyList
):
1566 self
._ParseMapFile
()
1567 FixedAddressList
= self
.FixedMapDict
.get(Guid
)
1568 if not FixedAddressList
:
1571 FileWrite(File
, gSubSectionStart
)
1572 FileWrite(File
, "Fixed Address Prediction")
1573 FileWrite(File
, "*I Image Loading Address")
1574 FileWrite(File
, "*E Entry Point Address")
1575 FileWrite(File
, "*N Notification Function Address")
1576 FileWrite(File
, "*F Flash Address")
1577 FileWrite(File
, "*M Memory Address")
1578 FileWrite(File
, "*S SMM RAM Offset")
1579 FileWrite(File
, "TOM Top of Memory")
1581 FileWrite(File
, "Type Address Name")
1582 FileWrite(File
, gSubSectionSep
)
1583 for Item
in FixedAddressList
:
1588 Name
= "(Image Base)"
1589 elif Symbol
== "*E":
1590 Name
= self
._FfsEntryPoint
.get(Guid
, ["", "_ModuleEntryPoint"])[1]
1591 elif Symbol
in NotifyList
:
1599 elif "Memory" in Type
:
1605 Value
= "TOM" + Value
1607 FileWrite(File
, "%s %-16s %s" % (Symbol
, Value
, Name
))
1610 # Generate report for the prediction part
1612 # This function generate the predicted fixed address report for a module or
1613 # predicted module execution order for a platform.
1614 # If the input Guid is None, then, it generates the predicted module execution order;
1615 # otherwise it generated the module fixed loading address for the module specified by
1618 # @param self The object pointer
1619 # @param File The file object for report
1620 # @param Guid The module Guid value.
1622 def GenerateReport(self
, File
, Guid
):
1624 self
._GenerateFixedAddressReport
(File
, Guid
.upper(), [])
1626 self
._GenerateExecutionOrderReport
(File
)
1629 # Reports FD region information
1631 # This class reports the FD subsection in the build report file.
1632 # It collects region information of platform flash device.
1633 # If the region is a firmware volume, it lists the set of modules
1634 # and its space information; otherwise, it only lists its region name,
1635 # base address and size in its sub-section header.
1636 # If there are nesting FVs, the nested FVs will list immediate after
1637 # this FD region subsection
1639 class FdRegionReport(object):
1641 # Discover all the nested FV name list.
1643 # This is an internal worker function to discover the all the nested FV information
1644 # in the parent firmware volume. It uses deep first search algorithm recursively to
1645 # find all the FV list name and append them to the list.
1647 # @param self The object pointer
1648 # @param FvName The name of current firmware file system
1649 # @param Wa Workspace context information
1651 def _DiscoverNestedFvList(self
, FvName
, Wa
):
1652 FvDictKey
=FvName
.upper()
1653 if FvDictKey
in Wa
.FdfProfile
.FvDict
:
1654 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1655 for Section
in Ffs
.SectionList
:
1657 for FvSection
in Section
.SectionList
:
1658 if FvSection
.FvName
in self
.FvList
:
1660 self
._GuidsDb
[Ffs
.NameGuid
.upper()] = FvSection
.FvName
1661 self
.FvList
.append(FvSection
.FvName
)
1662 self
.FvInfo
[FvSection
.FvName
] = ("Nested FV", 0, 0)
1663 self
._DiscoverNestedFvList
(FvSection
.FvName
, Wa
)
1664 except AttributeError:
1668 # Constructor function for class FdRegionReport
1670 # This constructor function generates FdRegionReport object for a specified FdRegion.
1671 # If the FdRegion is a firmware volume, it will recursively find all its nested Firmware
1672 # volume list. This function also collects GUID map in order to dump module identification
1673 # in the final report.
1675 # @param self: The object pointer
1676 # @param FdRegion The current FdRegion object
1677 # @param Wa Workspace context information
1679 def __init__(self
, FdRegion
, Wa
):
1680 self
.Type
= FdRegion
.RegionType
1681 self
.BaseAddress
= FdRegion
.Offset
1682 self
.Size
= FdRegion
.Size
1686 self
._FvDir
= Wa
.FvDir
1687 self
._WorkspaceDir
= Wa
.WorkspaceDir
1690 # If the input FdRegion is not a firmware volume,
1693 if self
.Type
!= BINARY_FILE_TYPE_FV
:
1697 # Find all nested FVs in the FdRegion
1699 for FvName
in FdRegion
.RegionDataList
:
1700 if FvName
in self
.FvList
:
1702 self
.FvList
.append(FvName
)
1703 self
.FvInfo
[FvName
] = ("Fd Region", self
.BaseAddress
, self
.Size
)
1704 self
._DiscoverNestedFvList
(FvName
, Wa
)
1708 # Collect PCDs declared in DEC files.
1710 for Pa
in Wa
.AutoGenObjectList
:
1711 for Package
in Pa
.PackageList
:
1712 for (TokenCName
, TokenSpaceGuidCName
, DecType
) in Package
.Pcds
:
1713 DecDefaultValue
= Package
.Pcds
[TokenCName
, TokenSpaceGuidCName
, DecType
].DefaultValue
1714 PlatformPcds
[(TokenCName
, TokenSpaceGuidCName
)] = DecDefaultValue
1716 # Collect PCDs defined in DSC file
1718 for Pa
in Wa
.AutoGenObjectList
:
1719 for (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
1720 DscDefaultValue
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)].DefaultValue
1721 PlatformPcds
[(TokenCName
, TokenSpaceGuidCName
)] = DscDefaultValue
1724 # Add PEI and DXE a priori files GUIDs defined in PI specification.
1726 self
._GuidsDb
["1B45CC0A-156A-428A-AF62-49864DA0E6E6"] = "PEI Apriori"
1727 self
._GuidsDb
["FC510EE7-FFDC-11D4-BD41-0080C73C8881"] = "DXE Apriori"
1729 # Add ACPI table storage file
1731 self
._GuidsDb
["7E374E25-8E01-4FEE-87F2-390C23C606CD"] = "ACPI table storage"
1733 for Pa
in Wa
.AutoGenObjectList
:
1734 for ModuleKey
in Pa
.Platform
.Modules
:
1735 M
= Pa
.Platform
.Modules
[ModuleKey
].M
1736 InfPath
= mws
.join(Wa
.WorkspaceDir
, M
.MetaFile
.File
)
1737 self
._GuidsDb
[M
.Guid
.upper()] = "%s (%s)" % (M
.Module
.BaseName
, InfPath
)
1740 # Collect the GUID map in the FV firmware volume
1742 for FvName
in self
.FvList
:
1743 FvDictKey
=FvName
.upper()
1744 if FvDictKey
in Wa
.FdfProfile
.FvDict
:
1745 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1748 # collect GUID map for binary EFI file in FDF file.
1750 Guid
= Ffs
.NameGuid
.upper()
1751 Match
= gPcdGuidPattern
.match(Ffs
.NameGuid
)
1753 PcdTokenspace
= Match
.group(1)
1754 PcdToken
= Match
.group(2)
1755 if (PcdToken
, PcdTokenspace
) in PlatformPcds
:
1756 GuidValue
= PlatformPcds
[(PcdToken
, PcdTokenspace
)]
1757 Guid
= GuidStructureByteArrayToGuidString(GuidValue
).upper()
1758 for Section
in Ffs
.SectionList
:
1760 ModuleSectFile
= mws
.join(Wa
.WorkspaceDir
, Section
.SectFileName
)
1761 self
._GuidsDb
[Guid
] = ModuleSectFile
1762 except AttributeError:
1764 except AttributeError:
1769 # Internal worker function to generate report for the FD region
1771 # This internal worker function to generate report for the FD region.
1772 # It the type is firmware volume, it lists offset and module identification.
1774 # @param self The object pointer
1775 # @param File The file object for report
1776 # @param Title The title for the FD subsection
1777 # @param BaseAddress The base address for the FD region
1778 # @param Size The size of the FD region
1779 # @param FvName The FV name if the FD region is a firmware volume
1781 def _GenerateReport(self
, File
, Title
, Type
, BaseAddress
, Size
=0, FvName
=None):
1782 FileWrite(File
, gSubSectionStart
)
1783 FileWrite(File
, Title
)
1784 FileWrite(File
, "Type: %s" % Type
)
1785 FileWrite(File
, "Base Address: 0x%X" % BaseAddress
)
1787 if self
.Type
== BINARY_FILE_TYPE_FV
:
1791 if FvName
.upper().endswith('.FV'):
1792 FileExt
= FvName
+ ".txt"
1794 FileExt
= FvName
+ ".Fv.txt"
1796 if not os
.path
.isfile(FileExt
):
1797 FvReportFileName
= mws
.join(self
._WorkspaceDir
, FileExt
)
1798 if not os
.path
.isfile(FvReportFileName
):
1799 FvReportFileName
= os
.path
.join(self
._FvDir
, FileExt
)
1802 # Collect size info in the firmware volume.
1804 FvReport
= open(FvReportFileName
).read()
1805 Match
= gFvTotalSizePattern
.search(FvReport
)
1807 FvTotalSize
= int(Match
.group(1), 16)
1808 Match
= gFvTakenSizePattern
.search(FvReport
)
1810 FvTakenSize
= int(Match
.group(1), 16)
1811 FvFreeSize
= FvTotalSize
- FvTakenSize
1813 # Write size information to the report file.
1815 FileWrite(File
, "Size: 0x%X (%.0fK)" % (FvTotalSize
, FvTotalSize
/ 1024.0))
1816 FileWrite(File
, "Fv Name: %s (%.1f%% Full)" % (FvName
, FvTakenSize
* 100.0 / FvTotalSize
))
1817 FileWrite(File
, "Occupied Size: 0x%X (%.0fK)" % (FvTakenSize
, FvTakenSize
/ 1024.0))
1818 FileWrite(File
, "Free Size: 0x%X (%.0fK)" % (FvFreeSize
, FvFreeSize
/ 1024.0))
1819 FileWrite(File
, "Offset Module")
1820 FileWrite(File
, gSubSectionSep
)
1822 # Write module offset and module identification to the report file.
1825 for Match
in gOffsetGuidPattern
.finditer(FvReport
):
1826 Guid
= Match
.group(2).upper()
1827 OffsetInfo
[Match
.group(1)] = self
._GuidsDb
.get(Guid
, Guid
)
1828 OffsetList
= OffsetInfo
.keys()
1830 for Offset
in OffsetList
:
1831 FileWrite (File
, "%s %s" % (Offset
, OffsetInfo
[Offset
]))
1833 EdkLogger
.warn(None, "Fail to read report file", FvReportFileName
)
1835 FileWrite(File
, "Size: 0x%X (%.0fK)" % (Size
, Size
/ 1024.0))
1836 FileWrite(File
, gSubSectionEnd
)
1839 # Generate report for the FD region
1841 # This function generates report for the FD region.
1843 # @param self The object pointer
1844 # @param File The file object for report
1846 def GenerateReport(self
, File
):
1847 if (len(self
.FvList
) > 0):
1848 for FvItem
in self
.FvList
:
1849 Info
= self
.FvInfo
[FvItem
]
1850 self
._GenerateReport
(File
, Info
[0], TAB_FV_DIRECTORY
, Info
[1], Info
[2], FvItem
)
1852 self
._GenerateReport
(File
, "FD Region", self
.Type
, self
.BaseAddress
, self
.Size
)
1855 # Reports FD information
1857 # This class reports the FD section in the build report file.
1858 # It collects flash device information for a platform.
1860 class FdReport(object):
1862 # Constructor function for class FdReport
1864 # This constructor function generates FdReport object for a specified
1867 # @param self The object pointer
1868 # @param Fd The current Firmware device object
1869 # @param Wa Workspace context information
1871 def __init__(self
, Fd
, Wa
):
1872 self
.FdName
= Fd
.FdUiName
1873 self
.BaseAddress
= Fd
.BaseAddress
1875 self
.FdRegionList
= [FdRegionReport(FdRegion
, Wa
) for FdRegion
in Fd
.RegionList
]
1876 self
.FvPath
= os
.path
.join(Wa
.BuildDir
, TAB_FV_DIRECTORY
)
1877 self
.VpdFilePath
= os
.path
.join(self
.FvPath
, "%s.map" % Wa
.Platform
.VpdToolGuid
)
1878 self
.VPDBaseAddress
= 0
1880 self
.VPDInfoList
= []
1881 for index
, FdRegion
in enumerate(Fd
.RegionList
):
1882 if str(FdRegion
.RegionType
) is 'FILE' and Wa
.Platform
.VpdToolGuid
in str(FdRegion
.RegionDataList
):
1883 self
.VPDBaseAddress
= self
.FdRegionList
[index
].BaseAddress
1884 self
.VPDSize
= self
.FdRegionList
[index
].Size
1887 if os
.path
.isfile(self
.VpdFilePath
):
1888 fd
= open(self
.VpdFilePath
, "r")
1889 Lines
= fd
.readlines()
1892 if len(Line
) == 0 or Line
.startswith("#"):
1895 PcdName
, SkuId
, Offset
, Size
, Value
= Line
.split("#")[0].split("|")
1896 PcdName
, SkuId
, Offset
, Size
, Value
= PcdName
.strip(), SkuId
.strip(), Offset
.strip(), Size
.strip(), Value
.strip()
1897 if Offset
.lower().startswith('0x'):
1898 Offset
= '0x%08X' % (int(Offset
, 16) + self
.VPDBaseAddress
)
1900 Offset
= '0x%08X' % (int(Offset
, 10) + self
.VPDBaseAddress
)
1901 self
.VPDInfoList
.append("%s | %s | %s | %s | %s" % (PcdName
, SkuId
, Offset
, Size
, Value
))
1903 EdkLogger
.error("BuildReport", CODE_ERROR
, "Fail to parse VPD information file %s" % self
.VpdFilePath
)
1907 # Generate report for the firmware device.
1909 # This function generates report for the firmware device.
1911 # @param self The object pointer
1912 # @param File The file object for report
1914 def GenerateReport(self
, File
):
1915 FileWrite(File
, gSectionStart
)
1916 FileWrite(File
, "Firmware Device (FD)")
1917 FileWrite(File
, "FD Name: %s" % self
.FdName
)
1918 FileWrite(File
, "Base Address: %s" % self
.BaseAddress
)
1919 FileWrite(File
, "Size: 0x%X (%.0fK)" % (self
.Size
, self
.Size
/ 1024.0))
1920 if len(self
.FdRegionList
) > 0:
1921 FileWrite(File
, gSectionSep
)
1922 for FdRegionItem
in self
.FdRegionList
:
1923 FdRegionItem
.GenerateReport(File
)
1925 if len(self
.VPDInfoList
) > 0:
1926 FileWrite(File
, gSubSectionStart
)
1927 FileWrite(File
, "FD VPD Region")
1928 FileWrite(File
, "Base Address: 0x%X" % self
.VPDBaseAddress
)
1929 FileWrite(File
, "Size: 0x%X (%.0fK)" % (self
.VPDSize
, self
.VPDSize
/ 1024.0))
1930 FileWrite(File
, gSubSectionSep
)
1931 for item
in self
.VPDInfoList
:
1932 ValueList
= item
.split('|')
1933 Value
= ValueList
[-1].strip()
1934 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1936 ValueList
[-1] = ' {'
1937 FileWrite(File
, '|'.join(ValueList
))
1938 for Array
in ArrayList
:
1939 FileWrite(File
, '%s' % (Array
))
1941 FileWrite(File
, item
)
1942 FileWrite(File
, gSubSectionEnd
)
1943 FileWrite(File
, gSectionEnd
)
1948 # Reports platform information
1950 # This class reports the whole platform information
1952 class PlatformReport(object):
1954 # Constructor function for class PlatformReport
1956 # This constructor function generates PlatformReport object a platform build.
1957 # It generates report for platform summary, flash, global PCDs and detailed
1958 # module information for modules involved in platform build.
1960 # @param self The object pointer
1961 # @param Wa Workspace context information
1962 # @param MaList The list of modules in the platform build
1964 def __init__(self
, Wa
, MaList
, ReportType
):
1965 self
._WorkspaceDir
= Wa
.WorkspaceDir
1966 self
.PlatformName
= Wa
.Name
1967 self
.PlatformDscPath
= Wa
.Platform
1968 self
.Architectures
= " ".join(Wa
.ArchList
)
1969 self
.ToolChain
= Wa
.ToolChain
1970 self
.Target
= Wa
.BuildTarget
1971 self
.OutputPath
= os
.path
.join(Wa
.WorkspaceDir
, Wa
.OutputDir
)
1972 self
.BuildEnvironment
= platform
.platform()
1974 self
.PcdReport
= None
1975 if "PCD" in ReportType
:
1976 self
.PcdReport
= PcdReport(Wa
)
1978 self
.FdReportList
= []
1979 if "FLASH" in ReportType
and Wa
.FdfProfile
and MaList
is None:
1980 for Fd
in Wa
.FdfProfile
.FdDict
:
1981 self
.FdReportList
.append(FdReport(Wa
.FdfProfile
.FdDict
[Fd
], Wa
))
1983 self
.PredictionReport
= None
1984 if "FIXED_ADDRESS" in ReportType
or "EXECUTION_ORDER" in ReportType
:
1985 self
.PredictionReport
= PredictionReport(Wa
)
1987 self
.DepexParser
= None
1988 if "DEPEX" in ReportType
:
1989 self
.DepexParser
= DepexParser(Wa
)
1991 self
.ModuleReportList
= []
1992 if MaList
is not None:
1993 self
._IsModuleBuild
= True
1995 self
.ModuleReportList
.append(ModuleReport(Ma
, ReportType
))
1997 self
._IsModuleBuild
= False
1998 for Pa
in Wa
.AutoGenObjectList
:
1999 ModuleAutoGenList
= []
2000 for ModuleKey
in Pa
.Platform
.Modules
:
2001 ModuleAutoGenList
.append(Pa
.Platform
.Modules
[ModuleKey
].M
)
2002 if GlobalData
.gFdfParser
is not None:
2003 if Pa
.Arch
in GlobalData
.gFdfParser
.Profile
.InfDict
:
2004 INFList
= GlobalData
.gFdfParser
.Profile
.InfDict
[Pa
.Arch
]
2005 for InfName
in INFList
:
2006 InfClass
= PathClass(NormPath(InfName
), Wa
.WorkspaceDir
, Pa
.Arch
)
2007 Ma
= ModuleAutoGen(Wa
, InfClass
, Pa
.BuildTarget
, Pa
.ToolChain
, Pa
.Arch
, Wa
.MetaFile
)
2010 if Ma
not in ModuleAutoGenList
:
2011 ModuleAutoGenList
.append(Ma
)
2012 for MGen
in ModuleAutoGenList
:
2013 self
.ModuleReportList
.append(ModuleReport(MGen
, ReportType
))
2018 # Generate report for the whole platform.
2020 # This function generates report for platform information.
2021 # It comprises of platform summary, global PCD, flash and
2022 # module list sections.
2024 # @param self The object pointer
2025 # @param File The file object for report
2026 # @param BuildDuration The total time to build the modules
2027 # @param AutoGenTime The total time of AutoGen Phase
2028 # @param MakeTime The total time of Make Phase
2029 # @param GenFdsTime The total time of GenFds Phase
2030 # @param ReportType The kind of report items in the final report file
2032 def GenerateReport(self
, File
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
, ReportType
):
2033 FileWrite(File
, "Platform Summary")
2034 FileWrite(File
, "Platform Name: %s" % self
.PlatformName
)
2035 FileWrite(File
, "Platform DSC Path: %s" % self
.PlatformDscPath
)
2036 FileWrite(File
, "Architectures: %s" % self
.Architectures
)
2037 FileWrite(File
, "Tool Chain: %s" % self
.ToolChain
)
2038 FileWrite(File
, "Target: %s" % self
.Target
)
2039 if GlobalData
.gSkuids
:
2040 FileWrite(File
, "SKUID: %s" % " ".join(GlobalData
.gSkuids
))
2041 if GlobalData
.gDefaultStores
:
2042 FileWrite(File
, "DefaultStore: %s" % " ".join(GlobalData
.gDefaultStores
))
2043 FileWrite(File
, "Output Path: %s" % self
.OutputPath
)
2044 FileWrite(File
, "Build Environment: %s" % self
.BuildEnvironment
)
2045 FileWrite(File
, "Build Duration: %s" % BuildDuration
)
2047 FileWrite(File
, "AutoGen Duration: %s" % AutoGenTime
)
2049 FileWrite(File
, "Make Duration: %s" % MakeTime
)
2051 FileWrite(File
, "GenFds Duration: %s" % GenFdsTime
)
2052 FileWrite(File
, "Report Content: %s" % ", ".join(ReportType
))
2054 if GlobalData
.MixedPcd
:
2055 FileWrite(File
, gSectionStart
)
2056 FileWrite(File
, "The following PCDs use different access methods:")
2057 FileWrite(File
, gSectionSep
)
2058 for PcdItem
in GlobalData
.MixedPcd
:
2059 FileWrite(File
, "%s.%s" % (str(PcdItem
[1]), str(PcdItem
[0])))
2060 FileWrite(File
, gSectionEnd
)
2062 if not self
._IsModuleBuild
:
2063 if "PCD" in ReportType
:
2064 self
.PcdReport
.GenerateReport(File
, None)
2066 if "FLASH" in ReportType
:
2067 for FdReportListItem
in self
.FdReportList
:
2068 FdReportListItem
.GenerateReport(File
)
2070 for ModuleReportItem
in self
.ModuleReportList
:
2071 ModuleReportItem
.GenerateReport(File
, self
.PcdReport
, self
.PredictionReport
, self
.DepexParser
, ReportType
)
2073 if not self
._IsModuleBuild
:
2074 if "EXECUTION_ORDER" in ReportType
:
2075 self
.PredictionReport
.GenerateReport(File
, None)
2077 ## BuildReport class
2079 # This base class contain the routines to collect data and then
2080 # applies certain format to the output report
2082 class BuildReport(object):
2084 # Constructor function for class BuildReport
2086 # This constructor function generates BuildReport object a platform build.
2087 # It generates report for platform summary, flash, global PCDs and detailed
2088 # module information for modules involved in platform build.
2090 # @param self The object pointer
2091 # @param ReportFile The file name to save report file
2092 # @param ReportType The kind of report items in the final report file
2094 def __init__(self
, ReportFile
, ReportType
):
2095 self
.ReportFile
= ReportFile
2097 self
.ReportList
= []
2098 self
.ReportType
= []
2100 for ReportTypeItem
in ReportType
:
2101 if ReportTypeItem
not in self
.ReportType
:
2102 self
.ReportType
.append(ReportTypeItem
)
2104 self
.ReportType
= ["PCD", "LIBRARY", "BUILD_FLAGS", "DEPEX", "HASH", "FLASH", "FIXED_ADDRESS"]
2106 # Adds platform report to the list
2108 # This function adds a platform report to the final report list.
2110 # @param self The object pointer
2111 # @param Wa Workspace context information
2112 # @param MaList The list of modules in the platform build
2114 def AddPlatformReport(self
, Wa
, MaList
=None):
2116 self
.ReportList
.append((Wa
, MaList
))
2119 # Generates the final report.
2121 # This function generates platform build report. It invokes GenerateReport()
2122 # method for every platform report in the list.
2124 # @param self The object pointer
2125 # @param BuildDuration The total time to build the modules
2126 # @param AutoGenTime The total time of AutoGen phase
2127 # @param MakeTime The total time of Make phase
2128 # @param GenFdsTime The total time of GenFds phase
2130 def GenerateReport(self
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
):
2134 for (Wa
, MaList
) in self
.ReportList
:
2135 PlatformReport(Wa
, MaList
, self
.ReportType
).GenerateReport(File
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
, self
.ReportType
)
2136 Content
= FileLinesSplit(File
.getvalue(), gLineMaxLength
)
2137 SaveFileOnChange(self
.ReportFile
, Content
, True)
2138 EdkLogger
.quiet("Build report can be found at %s" % os
.path
.abspath(self
.ReportFile
))
2140 EdkLogger
.error(None, FILE_WRITE_FAILURE
, ExtraData
=self
.ReportFile
)
2142 EdkLogger
.error("BuildReport", CODE_ERROR
, "Unknown fatal error when generating build report", ExtraData
=self
.ReportFile
, RaiseError
=False)
2143 EdkLogger
.quiet("(Python %s on %s\n%s)" % (platform
.python_version(), sys
.platform
, traceback
.format_exc()))
2146 # This acts like the main() function for the script, unless it is 'import'ed into another script.
2147 if __name__
== '__main__':