BaseTools: Replace StandardError with Expression
[mirror_edk2.git] / BaseTools / Source / Python / build / BuildReport.py
1 ## @file
2 # Routines for generating build report.
3 #
4 # This module contains the functionality to generate build report after
5 # build all target completes successfully.
6 #
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
12 #
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.
15 #
16
17 ## Import Modules
18 #
19 import Common.LongFilePathOs as os
20 import re
21 import platform
22 import textwrap
23 import traceback
24 import sys
25 import time
26 import struct
27 import hashlib
28 import subprocess
29 import threading
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 *
47 import collections
48 from Common.Expression import *
49
50 ## Pattern to extract contents in EDK DXS files
51 gDxsDependencyPattern = re.compile(r"DEPENDENCY_START(.+)DEPENDENCY_END", re.DOTALL)
52
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]+)")
56
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+)")
60
61 ## Pattern to find GUID value in flash description files
62 gPcdGuidPattern = re.compile(r"PCD\((\w+)[.](\w+)\)")
63
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]+)")
66
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]+)"})
70
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*[)]")
74
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+)")
77
78 ## Tags for MaxLength of line in report
79 gLineMaxLength = 120
80
81 ## Tags for end of line in report
82 gEndOfLine = "\r\n"
83
84 ## Tags for section start, end and separator
85 gSectionStart = ">" + "=" * (gLineMaxLength - 2) + "<"
86 gSectionEnd = "<" + "=" * (gLineMaxLength - 2) + ">" + "\n"
87 gSectionSep = "=" * gLineMaxLength
88
89 ## Tags for subsection start, end and separator
90 gSubSectionStart = ">" + "-" * (gLineMaxLength - 2) + "<"
91 gSubSectionEnd = "<" + "-" * (gLineMaxLength - 2) + ">"
92 gSubSectionSep = "-" * gLineMaxLength
93
94
95 ## The look up table to map PCD type to pair of report display type and DEC type
96 gPcdTypeMap = {
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),
106 }
107
108 ## The look up table to map module type to driver type
109 gDriverTypeMap = {
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)'
124 }
125
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"]
128
129 ##
130 # Writes a string to the file object.
131 #
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.
134 #
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
138 #
139 def FileWrite(File, String, Wrapper=False):
140 if Wrapper:
141 String = textwrap.fill(String, 120)
142 File.write(String + gEndOfLine)
143
144 def ByteArrayForamt(Value):
145 IsByteArray = False
146 SplitNum = 16
147 ArrayList = []
148 if Value.startswith('{') and Value.endswith('}'):
149 Value = Value[1:-1]
150 ValueList = Value.split(',')
151 if len(ValueList) >= SplitNum:
152 IsByteArray = True
153 if IsByteArray:
154 if ValueList:
155 Len = len(ValueList)/SplitNum
156 for i, element in enumerate(ValueList):
157 ValueList[i] = '0x%02X' % int(element.strip(), 16)
158 if Len:
159 Id = 0
160 while (Id <= Len):
161 End = min(SplitNum*(Id+1), len(ValueList))
162 Str = ','.join(ValueList[SplitNum*Id : End])
163 if End == len(ValueList):
164 Str += '}'
165 ArrayList.append(Str)
166 break
167 else:
168 Str += ','
169 ArrayList.append(Str)
170 Id += 1
171 else:
172 ArrayList = [Value + '}']
173 return IsByteArray, ArrayList
174
175 ##
176 # Find all the header file that the module source directly includes.
177 #
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.
181 #
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.
185 #
186 def FindIncludeFiles(Source, IncludePathList, IncludeFiles):
187 FileContents = open(Source).read()
188 #
189 # Find header files with pattern #include "XXX.h" or #include <XXX.h>
190 #
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
197 break
198
199 #
200 # Find header files with pattern like #include EFI_PPI_CONSUMER(XXX)
201 #
202 for Match in gIncludePattern2.finditer(FileContents):
203 Key = Match.group(2)
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}
209 elif "PPI" in Type:
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}
213 else:
214 continue
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
219 break
220
221 ## Split each lines in file
222 #
223 # This method is used to split the lines in file to make the length of each line
224 # less than MaxLength.
225 #
226 # @param Content The content of file
227 # @param MaxLength The Max Length of the line
228 #
229 def FileLinesSplit(Content=None, MaxLength=None):
230 ContentList = Content.split(TAB_LINE_BREAK)
231 NewContent = ''
232 NewContentList = []
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)
240 else:
241 LineBreakIndex = MaxLength
242 NewContentList.append(Line[:LineBreakIndex])
243 Line = Line[LineBreakIndex:]
244 if Line:
245 NewContentList.append(Line)
246 for NewLine in NewContentList:
247 NewContent += NewLine + TAB_LINE_BREAK
248
249 NewContent = NewContent.replace(TAB_LINE_BREAK, gEndOfLine).replace('\r\r\n', gEndOfLine)
250 return NewContent
251
252
253
254 ##
255 # Parse binary dependency expression section
256 #
257 # This utility class parses the dependency expression section and translate the readable
258 # GUID name and value.
259 #
260 class DepexParser(object):
261 ##
262 # Constructor function for class DepexParser
263 #
264 # This constructor function collect GUID values so that the readable
265 # GUID name can be translated.
266 #
267 # @param self The object pointer
268 # @param Wa Workspace context information
269 #
270 def __init__(self, Wa):
271 self._GuidDb = {}
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
284 ##
285 # Parse the binary dependency expression files.
286 #
287 # This function parses the binary dependency expression file and translate it
288 # to the instruction list.
289 #
290 # @param self The object pointer
291 # @param DepexFileName The file name of binary dependency expression file.
292 #
293 def ParseDepexFile(self, DepexFileName):
294 DepexFile = open(DepexFileName, "rb")
295 DepexStatement = []
296 OpCode = DepexFile.read(1)
297 while OpCode:
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)
306
307 return DepexStatement
308
309 ##
310 # Reports library information
311 #
312 # This class reports the module library subsection in the build report file.
313 #
314 class LibraryReport(object):
315 ##
316 # Constructor function for class LibraryReport
317 #
318 # This constructor function generates LibraryReport object for
319 # a module.
320 #
321 # @param self The object pointer
322 # @param M Module context information
323 #
324 def __init__(self, M):
325 self.LibraryList = []
326 if int(str(M.AutoGenVersion), 0) >= 0x00010005:
327 self._EdkIIModule = True
328 else:
329 self._EdkIIModule = False
330
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
340 break
341 self.LibraryList.append((LibInfPath, LibClassList, LibConstructorList, LibDesstructorList, LibDepexList, LibTime))
342
343 ##
344 # Generate report for module library information
345 #
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.
349 #
350 # @param self The object pointer
351 # @param File The file object for report
352 #
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)
361
362 #
363 # Report library class, library constructor and destructor for
364 # EDKII style module.
365 #
366 if self._EdkIIModule:
367 LibClass = LibraryItem[1]
368 EdkIILibInfo = ""
369 LibConstructor = " ".join(LibraryItem[2])
370 if LibConstructor:
371 EdkIILibInfo += " C = " + LibConstructor
372 LibDestructor = " ".join(LibraryItem[3])
373 if LibDestructor:
374 EdkIILibInfo += " D = " + LibDestructor
375 LibDepex = " ".join(LibraryItem[4])
376 if LibDepex:
377 EdkIILibInfo += " Depex = " + LibDepex
378 if LibraryItem[5]:
379 EdkIILibInfo += " Time = " + LibraryItem[5]
380 if EdkIILibInfo:
381 FileWrite(File, "{%s: %s}" % (LibClass, EdkIILibInfo))
382 else:
383 FileWrite(File, "{%s}" % LibClass)
384
385 FileWrite(File, gSubSectionEnd)
386
387 ##
388 # Reports dependency expression information
389 #
390 # This class reports the module dependency expression subsection in the build report file.
391 #
392 class DepexReport(object):
393 ##
394 # Constructor function for class DepexReport
395 #
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.
401 #
402 # @param self The object pointer
403 # @param M Module context information
404 #
405 def __init__(self, M):
406 self.Depex = ""
407 self._DepexFileName = os.path.join(M.BuildDir, "OUTPUT", M.Module.BaseName + ".depex")
408 ModuleType = M.ModuleType
409 if not ModuleType:
410 ModuleType = COMPONENT_TO_MODULE_MAP_DICT.get(M.ComponentType, "")
411
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]:
413 return
414
415 for Source in M.SourceFileList:
416 if os.path.splitext(Source.Path)[1].lower() == ".dxs":
417 Match = gDxsDependencyPattern.search(open(Source.Path).read())
418 if Match:
419 self.Depex = Match.group(1).strip()
420 self.Source = "DXS"
421 break
422 else:
423 self.Depex = M.DepexExpressionDict.get(M.ModuleType, "")
424 self.ModuleDepex = " ".join(M.Module.DepexExpression[M.Arch, M.ModuleType])
425 if not self.ModuleDepex:
426 self.ModuleDepex = "(None)"
427
428 LibDepexList = []
429 for Lib in M.DependentLibraryList:
430 LibDepex = " ".join(Lib.DepexExpression[M.Arch, M.ModuleType]).strip()
431 if LibDepex != "":
432 LibDepexList.append("(" + LibDepex + ")")
433 self.LibraryDepex = " AND ".join(LibDepexList)
434 if not self.LibraryDepex:
435 self.LibraryDepex = "(None)"
436 self.Source = "INF"
437
438 ##
439 # Generate report for module dependency expression information
440 #
441 # This function generates report for the module dependency expression.
442 #
443 # @param self The object pointer
444 # @param File The file object for report
445 # @param GlobalDepexParser The platform global Dependency expression parser object
446 #
447 def GenerateReport(self, File, GlobalDepexParser):
448 if not self.Depex:
449 return
450 FileWrite(File, gSubSectionStart)
451 if os.path.isfile(self._DepexFileName):
452 try:
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)
458 except:
459 EdkLogger.warn(None, "Dependency expression file is corrupted", self._DepexFileName)
460
461 FileWrite(File, "Dependency Expression (DEPEX) from %s" % self.Source)
462
463 if self.Source == "INF":
464 FileWrite(File, self.Depex, True)
465 FileWrite(File, gSubSectionSep)
466 FileWrite(File, "From Module INF: %s" % self.ModuleDepex, True)
467 FileWrite(File, "From Library INF: %s" % self.LibraryDepex, True)
468 else:
469 FileWrite(File, self.Depex)
470 FileWrite(File, gSubSectionEnd)
471
472 ##
473 # Reports dependency expression information
474 #
475 # This class reports the module build flags subsection in the build report file.
476 #
477 class BuildFlagsReport(object):
478 ##
479 # Constructor function for class BuildFlagsReport
480 #
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.
484 #
485 # @param self The object pointer
486 # @param M Module context information
487 #
488 def __init__(self, M):
489 BuildOptions = {}
490 #
491 # Add build flags according to source file extension so that
492 # irrelevant ones can be filtered out.
493 #
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
518
519 #
520 # Save module build flags.
521 #
522 self.ToolChainTag = M.ToolChain
523 self.BuildFlags = {}
524 for Tool in BuildOptions:
525 self.BuildFlags[Tool + "_FLAGS"] = M.BuildOption.get(Tool, {}).get("FLAGS", "")
526
527 ##
528 # Generate report for module build flags information
529 #
530 # This function generates report for the module build flags expression.
531 #
532 # @param self The object pointer
533 # @param File The file object for report
534 #
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)
542
543 FileWrite(File, gSubSectionEnd)
544
545
546 ##
547 # Reports individual module information
548 #
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.
552 #
553 class ModuleReport(object):
554 ##
555 # Constructor function for class ModuleReport
556 #
557 # This constructor function generates ModuleReport object for
558 # a separate module in a platform build.
559 #
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
563 #
564 def __init__(self, M, ReportType):
565 self.ModuleName = M.Module.BaseName
566 self.ModuleInfPath = M.MetaFile.File
567 self.FileGuid = M.Guid
568 self.Size = 0
569 self.BuildTimeStamp = None
570 self.Hash = 0
571 self.DriverType = ""
572 if not M.IsLibrary:
573 ModuleType = M.ModuleType
574 if not ModuleType:
575 ModuleType = COMPONENT_TO_MODULE_MAP_DICT.get(M.ComponentType, "")
576 #
577 # If a module complies to PI 1.1, promote Module type to "SMM_DRIVER"
578 #
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
590
591 self._BuildDir = M.BuildDir
592 self.ModulePcdSet = {}
593 if "PCD" in ReportType:
594 #
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.
597 #
598 for Pcd in M.ModulePcdList + M.LibraryPcdList:
599 self.ModulePcdSet.setdefault((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Type), (Pcd.InfDefaultValue, Pcd.DefaultValue))
600
601 self.LibraryReport = None
602 if "LIBRARY" in ReportType:
603 self.LibraryReport = LibraryReport(M)
604
605 self.DepexReport = None
606 if "DEPEX" in ReportType:
607 self.DepexReport = DepexReport(M)
608
609 if "BUILD_FLAGS" in ReportType:
610 self.BuildFlagsReport = BuildFlagsReport(M)
611
612
613 ##
614 # Generate report for module information
615 #
616 # This function generates report for separate module expression
617 # in a platform build.
618 #
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
625 #
626 def GenerateReport(self, File, GlobalPcdReport, GlobalPredictionReport, GlobalDepexParser, ReportType):
627 FileWrite(File, gSectionStart)
628
629 FwReportFileName = os.path.join(self._BuildDir, "DEBUG", self.ModuleName + ".txt")
630 if os.path.isfile(FwReportFileName):
631 try:
632 FileContents = open(FwReportFileName).read()
633 Match = gModuleSizePattern.search(FileContents)
634 if Match:
635 self.Size = int(Match.group(1))
636
637 Match = gTimeStampPattern.search(FileContents)
638 if Match:
639 self.BuildTimeStamp = datetime.fromtimestamp(int(Match.group(1)))
640 except IOError:
641 EdkLogger.warn(None, "Fail to read report file", FwReportFileName)
642
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]
650 try:
651 PopenObject = subprocess.Popen(' '.join(cmd), stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
652 except Exception as X:
653 EdkLogger.error("GenFw", COMMAND_FAILURE, ExtraData="%s: %s" % (str(X), cmd[0]))
654 EndOfProcedure = threading.Event()
655 EndOfProcedure.clear()
656 if PopenObject.stderr:
657 StdErrThread = threading.Thread(target=ReadMessage, args=(PopenObject.stderr, EdkLogger.quiet, EndOfProcedure))
658 StdErrThread.setName("STDERR-Redirector")
659 StdErrThread.setDaemon(False)
660 StdErrThread.start()
661 # waiting for program exit
662 PopenObject.wait()
663 if PopenObject.stderr:
664 StdErrThread.join()
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()
673 os.remove(Tempfile)
674
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)
679 if self.Size:
680 FileWrite(File, "Size: 0x%X (%.2fK)" % (self.Size, self.Size / 1024.0))
681 if self.Hash:
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)
685 if self.BuildTime:
686 FileWrite(File, "Module Build Time: %s" % self.BuildTime)
687 if self.DriverType:
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)
693 if self.PciDeviceId:
694 FileWrite(File, "PCI Device ID: %s" % self.PciDeviceId)
695 if self.PciVendorId:
696 FileWrite(File, "PCI Vendor ID: %s" % self.PciVendorId)
697 if self.PciClassCode:
698 FileWrite(File, "PCI Class Code: %s" % self.PciClassCode)
699
700 FileWrite(File, gSectionSep)
701
702 if "PCD" in ReportType:
703 GlobalPcdReport.GenerateReport(File, self.ModulePcdSet)
704
705 if "LIBRARY" in ReportType:
706 self.LibraryReport.GenerateReport(File)
707
708 if "DEPEX" in ReportType:
709 self.DepexReport.GenerateReport(File, GlobalDepexParser)
710
711 if "BUILD_FLAGS" in ReportType:
712 self.BuildFlagsReport.GenerateReport(File)
713
714 if "FIXED_ADDRESS" in ReportType and self.FileGuid:
715 GlobalPredictionReport.GenerateReport(File, self.FileGuid)
716
717 FileWrite(File, gSectionEnd)
718
719 def ReadMessage(From, To, ExitFlag):
720 while True:
721 # read one line a time
722 Line = From.readline()
723 # empty string means "end"
724 if Line is not None and Line != "":
725 To(Line.rstrip())
726 else:
727 break
728 if ExitFlag.isSet():
729 break
730
731 ##
732 # Reports platform and module PCD information
733 #
734 # This class reports the platform PCD section and module PCD subsection
735 # in the build report file.
736 #
737 class PcdReport(object):
738 ##
739 # Constructor function for class PcdReport
740 #
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.
744 #
745 # @param self The object pointer
746 # @param Wa Workspace context information
747 #
748 def __init__(self, Wa):
749 self.AllPcds = {}
750 self.UnusedPcds = {}
751 self.ConditionalPcds = {}
752 self.MaxLen = 0
753 self.Arch = None
754 if Wa.FdfProfile:
755 self.FdfPcdSet = Wa.FdfProfile.PcdDict
756 else:
757 self.FdfPcdSet = {}
758
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
765
766 self.ModulePcdOverride = {}
767 for Pa in Wa.AutoGenObjectList:
768 self.Arch = Pa.Arch
769 #
770 # Collect all platform referenced PCDs and grouped them by PCD token space
771 # GUID C Names
772 #
773 for Pcd in Pa.AllPcdList:
774 PcdList = self.AllPcds.setdefault(Pcd.TokenSpaceGuidCName, {}).setdefault(Pcd.Type, [])
775 if Pcd not in PcdList:
776 PcdList.append(Pcd)
777 if len(Pcd.TokenCName) > self.MaxLen:
778 self.MaxLen = len(Pcd.TokenCName)
779 #
780 # Collect the PCD defined in DSC/FDF file, but not used in module
781 #
782 UnusedPcdFullList = []
783 for item in Pa.Platform.Pcds:
784 Pcd = Pa.Platform.Pcds[item]
785 if not Pcd.Type:
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, [])
789 if Pcd in PcdList:
790 Pcd.Type = T
791 break
792 if not Pcd.Type:
793 PcdTypeFlag = False
794 for package in Pa.PackageList:
795 for T in PCD_TYPE_LIST:
796 if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, T) in package.Pcds:
797 Pcd.Type = T
798 PcdTypeFlag = True
799 if not Pcd.DatumType:
800 Pcd.DatumType = package.Pcds[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName, T)].DatumType
801 break
802 if PcdTypeFlag:
803 break
804 if not Pcd.DatumType:
805 PcdType = Pcd.Type
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
814 break
815
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)
821
822 if GlobalData.gConditionalPcds:
823 for PcdItem in GlobalData.gConditionalPcds:
824 if '.' in PcdItem:
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:
830 PcdList.append(Pcd)
831
832 UnusedPcdList = []
833 if UnusedPcdFullList:
834 for Pcd in UnusedPcdFullList:
835 if Pcd.TokenSpaceGuidCName + '.' + Pcd.TokenCName in GlobalData.gConditionalPcds:
836 continue
837 UnusedPcdList.append(Pcd)
838
839 for Pcd in UnusedPcdList:
840 PcdList = self.UnusedPcds.setdefault(Pcd.TokenSpaceGuidCName, {}).setdefault(Pcd.Type, [])
841 if Pcd not in PcdList:
842 PcdList.append(Pcd)
843
844 for Module in Pa.Platform.Modules.values():
845 #
846 # Collect module override PCDs
847 #
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
854
855
856 #
857 # Collect PCD DEC default value.
858 #
859 self.DecPcdDefault = {}
860 self._GuidDict = {}
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)
868 #
869 # Collect PCDs defined in DSC common section
870 #
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
875 if DscDefaultValue:
876 self.DscPcdDefault[(TokenCName, TokenSpaceGuidCName)] = DscDefaultValue
877
878 def GenerateReport(self, File, ModulePcdSet):
879 if not ModulePcdSet:
880 if self.ConditionalPcds:
881 self.GenerateReportDetail(File, ModulePcdSet, 1)
882 if self.UnusedPcds:
883 self.GenerateReportDetail(File, ModulePcdSet, 2)
884 self.GenerateReportDetail(File, ModulePcdSet)
885
886 ##
887 # Generate report for PCD information
888 #
889 # This function generates report for separate module expression
890 # in a platform build.
891 #
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
899 #
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
906
907 if not ModulePcdSet:
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")
913 else:
914 FileWrite(File, "Platform Configuration Database Report")
915
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)
922 else:
923 if not ReportSubType and ModulePcdSet:
924 #
925 # For module PCD sub-section
926 #
927 FileWrite(File, gSubSectionStart)
928 FileWrite(File, TAB_BRG_PCD)
929 FileWrite(File, gSubSectionSep)
930 AllPcdDict = {}
931 for Key in PcdDict:
932 AllPcdDict[Key] = {}
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):
937 #
938 # Group PCD by their token space GUID C Name
939 #
940 First = True
941 for PcdTokenCName, Type in sorted(AllPcdDict[Key]):
942 #
943 # Group PCD by their usage type
944 #
945 Pcd = AllPcdDict[Key][(PcdTokenCName, Type)]
946 TypeName, DecType = gPcdTypeMap.get(Type, ("", Type))
947 MixedPcdFlag = False
948 if GlobalData.MixedPcd:
949 for PcdKey in GlobalData.MixedPcd:
950 if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdKey]:
951 PcdTokenCName = PcdKey[0]
952 MixedPcdFlag = True
953 if MixedPcdFlag and not ModulePcdSet:
954 continue
955 #
956 # Get PCD default value and their override relationship
957 #
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:
963 try:
964 DscDefaultValue = ValueExpressionEx(DscDefaultValue, Pcd.DatumType, self._GuidDict)(True)
965 except BadExpression as DscDefaultValue:
966 EdkLogger.error('BuildReport', FORMAT_INVALID, "PCD Value: %s, Type: %s" %(DscDefaultValue, Pcd.DatumType))
967
968 InfDefaultValue = None
969
970 PcdValue = DecDefaultValue
971 if DscDefaultValue:
972 PcdValue = DscDefaultValue
973 if ModulePcdSet is not None:
974 if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Type) not in ModulePcdSet:
975 continue
976 InfDefault, PcdValue = ModulePcdSet[Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Type]
977 Pcd.DefaultValue = PcdValue
978 if InfDefault == "":
979 InfDefault = None
980
981 BuildOptionMatch = False
982 if GlobalData.BuildOptionPcd:
983 for pcd in GlobalData.BuildOptionPcd:
984 if (Pcd.TokenSpaceGuidCName, Pcd.TokenCName) == (pcd[0], pcd[1]):
985 if pcd[2]:
986 continue
987 PcdValue = pcd[3]
988 Pcd.DefaultValue = PcdValue
989 BuildOptionMatch = True
990 break
991
992 if First:
993 if ModulePcdSet is None:
994 FileWrite(File, "")
995 FileWrite(File, Key)
996 First = False
997
998
999 if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:
1000 PcdValueNumber = int(PcdValue.strip(), 0)
1001 if DecDefaultValue is None:
1002 DecMatch = True
1003 else:
1004 DecDefaultValueNumber = int(DecDefaultValue.strip(), 0)
1005 DecMatch = (DecDefaultValueNumber == PcdValueNumber)
1006
1007 if InfDefaultValue is None:
1008 InfMatch = True
1009 else:
1010 InfDefaultValueNumber = int(InfDefaultValue.strip(), 0)
1011 InfMatch = (InfDefaultValueNumber == PcdValueNumber)
1012
1013 if DscDefaultValue is None:
1014 DscMatch = True
1015 else:
1016 DscDefaultValueNumber = int(DscDefaultValue.strip(), 0)
1017 DscMatch = (DscDefaultValueNumber == PcdValueNumber)
1018 else:
1019 if DecDefaultValue is None:
1020 DecMatch = True
1021 else:
1022 DecMatch = (DecDefaultValue.strip() == PcdValue.strip())
1023
1024 if InfDefaultValue is None:
1025 InfMatch = True
1026 else:
1027 InfMatch = (InfDefaultValue.strip() == PcdValue.strip())
1028
1029 if DscDefaultValue is None:
1030 DscMatch = True
1031 else:
1032 DscMatch = (DscDefaultValue.strip() == PcdValue.strip())
1033
1034 IsStructure = False
1035 if GlobalData.gStructurePcd and (self.Arch in GlobalData.gStructurePcd) and ((Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.gStructurePcd[self.Arch]):
1036 IsStructure = True
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
1045 DecMatch = False
1046 elif Pcd.SkuOverrideValues:
1047 DscOverride = False
1048 if not Pcd.SkuInfoList:
1049 OverrideValues = Pcd.SkuOverrideValues
1050 if OverrideValues:
1051 Keys = OverrideValues.keys()
1052 Data = OverrideValues[Keys[0]]
1053 Struct = Data.values()[0]
1054 DscOverride = self.ParseStruct(Struct)
1055 else:
1056 SkuList = sorted(Pcd.SkuInfoList.keys())
1057 for Sku in SkuList:
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])
1065 if DscOverride:
1066 break
1067 else:
1068 OverrideValues = Pcd.SkuOverrideValues[Sku]
1069 if OverrideValues:
1070 Keys = OverrideValues.keys()
1071 OverrideFieldStruct = self.OverrideFieldValue(Pcd, OverrideValues[Keys[0]])
1072 DscOverride = self.ParseStruct(OverrideFieldStruct)
1073 if DscOverride:
1074 break
1075 if DscOverride:
1076 DscMatch = True
1077 DecMatch = False
1078
1079 #
1080 # Report PCD item according to their override relationship
1081 #
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')
1086 else:
1087 if DscMatch:
1088 if (Pcd.TokenCName, Key) in self.FdfPcdSet:
1089 self.PrintPcdValue(File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValBak, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, '*F')
1090 else:
1091 self.PrintPcdValue(File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValBak, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, '*P')
1092 else:
1093 self.PrintPcdValue(File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValBak, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, '*M')
1094
1095 if ModulePcdSet is None:
1096 if IsStructure:
1097 continue
1098 if not TypeName in ('PATCH', 'FLAG', 'FIXED'):
1099 continue
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)
1107 else:
1108 Match = (ModuleDefault.strip() == PcdValue.strip())
1109 if Match:
1110 continue
1111 IsByteArray, ArrayList = ByteArrayForamt(ModuleDefault.strip())
1112 if IsByteArray:
1113 FileWrite(File, ' *M %-*s = %s' % (self.MaxLen + 15, ModulePath, '{'))
1114 for Array in ArrayList:
1115 FileWrite(File, Array)
1116 else:
1117 FileWrite(File, ' *M %-*s = %s' % (self.MaxLen + 15, ModulePath, ModuleDefault.strip()))
1118
1119 if ModulePcdSet is None:
1120 FileWrite(File, gSectionEnd)
1121 else:
1122 if not ReportSubType and ModulePcdSet:
1123 FileWrite(File, gSubSectionEnd)
1124
1125 def ParseStruct(self, struct):
1126 HasDscOverride = False
1127 if struct:
1128 for _, Values in struct.items():
1129 if Values[1] and Values[1].endswith('.dsc'):
1130 HasDscOverride = True
1131 break
1132 return HasDscOverride
1133
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)
1138 if IsByteArray:
1139 FileWrite(File, ' %*s = %s' % (self.MaxLen + 19, 'DSC DEFAULT', "{"))
1140 for Array in ArrayList:
1141 FileWrite(File, Array)
1142 else:
1143 if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:
1144 if Value.startswith(('0x', '0X')):
1145 Value = '{} ({:d})'.format(Value, int(Value, 0))
1146 else:
1147 Value = "0x{:X} ({})".format(int(Value, 0), Value)
1148 FileWrite(File, ' %*s = %s' % (self.MaxLen + 19, 'DSC DEFAULT', Value))
1149 if not InfMatch and InfDefaultValue is not None:
1150 Value = InfDefaultValue.strip()
1151 IsByteArray, ArrayList = ByteArrayForamt(Value)
1152 if IsByteArray:
1153 FileWrite(File, ' %*s = %s' % (self.MaxLen + 19, 'INF DEFAULT', "{"))
1154 for Array in ArrayList:
1155 FileWrite(File, Array)
1156 else:
1157 if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:
1158 if Value.startswith(('0x', '0X')):
1159 Value = '{} ({:d})'.format(Value, int(Value, 0))
1160 else:
1161 Value = "0x{:X} ({})".format(int(Value, 0), Value)
1162 FileWrite(File, ' %*s = %s' % (self.MaxLen + 19, 'INF DEFAULT', Value))
1163
1164 if not DecMatch and DecDefaultValue is not None:
1165 Value = DecDefaultValue.strip()
1166 IsByteArray, ArrayList = ByteArrayForamt(Value)
1167 if IsByteArray:
1168 FileWrite(File, ' %*s = %s' % (self.MaxLen + 19, 'DEC DEFAULT', "{"))
1169 for Array in ArrayList:
1170 FileWrite(File, Array)
1171 else:
1172 if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:
1173 if Value.startswith(('0x', '0X')):
1174 Value = '{} ({:d})'.format(Value, int(Value, 0))
1175 else:
1176 Value = "0x{:X} ({})".format(int(Value, 0), Value)
1177 FileWrite(File, ' %*s = %s' % (self.MaxLen + 19, 'DEC DEFAULT', Value))
1178 if IsStructure:
1179 self.PrintStructureInfo(File, Pcd.DefaultValues)
1180 if DecMatch and IsStructure:
1181 self.PrintStructureInfo(File, Pcd.DefaultValues)
1182
1183 def PrintPcdValue(self, File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValue, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, Flag = ' '):
1184 if not Pcd.SkuInfoList:
1185 Value = Pcd.DefaultValue
1186 IsByteArray, ArrayList = ByteArrayForamt(Value)
1187 if IsByteArray:
1188 FileWrite(File, ' %-*s : %6s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '{'))
1189 for Array in ArrayList:
1190 FileWrite(File, Array)
1191 else:
1192 if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:
1193 if Value.startswith(('0x','0X')):
1194 Value = '{} ({:d})'.format(Value, int(Value, 0))
1195 else:
1196 Value = "0x{:X} ({})".format(int(Value, 0), Value)
1197 FileWrite(File, ' %-*s : %6s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', Value))
1198 if IsStructure:
1199 OverrideValues = Pcd.SkuOverrideValues
1200 if OverrideValues:
1201 Keys = OverrideValues.keys()
1202 Data = OverrideValues[Keys[0]]
1203 Struct = Data.values()[0]
1204 OverrideFieldStruct = self.OverrideFieldValue(Pcd, Struct)
1205 self.PrintStructureInfo(File, OverrideFieldStruct)
1206 self.PrintPcdDefault(File, Pcd, IsStructure, DscMatch, DscDefaultValue, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue)
1207 else:
1208 FirstPrint = True
1209 SkuList = sorted(Pcd.SkuInfoList.keys())
1210 for Sku in SkuList:
1211 SkuInfo = Pcd.SkuInfoList[Sku]
1212 SkuIdName = SkuInfo.SkuIdName
1213 if TypeName in ('DYNHII', 'DEXHII'):
1214 if SkuInfo.DefaultStoreDict:
1215 DefaultStoreList = sorted(SkuInfo.DefaultStoreDict.keys())
1216 for DefaultStore in DefaultStoreList:
1217 Value = SkuInfo.DefaultStoreDict[DefaultStore]
1218 IsByteArray, ArrayList = ByteArrayForamt(Value)
1219 if FirstPrint:
1220 FirstPrint = False
1221 if IsByteArray:
1222 if self.DefaultStoreSingle and self.SkuSingle:
1223 FileWrite(File, ' %-*s : %6s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '{'))
1224 elif self.DefaultStoreSingle and not self.SkuSingle:
1225 FileWrite(File, ' %-*s : %6s %10s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', '{'))
1226 elif not self.DefaultStoreSingle and self.SkuSingle:
1227 FileWrite(File, ' %-*s : %6s %10s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '(' + DefaultStore + ')', '{'))
1228 else:
1229 FileWrite(File, ' %-*s : %6s %10s %10s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', '(' + DefaultStore + ')', '{'))
1230 for Array in ArrayList:
1231 FileWrite(File, Array)
1232 else:
1233 if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:
1234 if Value.startswith(('0x', '0X')):
1235 Value = '{} ({:d})'.format(Value, int(Value, 0))
1236 else:
1237 Value = "0x{:X} ({})".format(int(Value, 0), Value)
1238 if self.DefaultStoreSingle and self.SkuSingle:
1239 FileWrite(File, ' %-*s : %6s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', Value))
1240 elif self.DefaultStoreSingle and not self.SkuSingle:
1241 FileWrite(File, ' %-*s : %6s %10s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', Value))
1242 elif not self.DefaultStoreSingle and self.SkuSingle:
1243 FileWrite(File, ' %-*s : %6s %10s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '(' + DefaultStore + ')', Value))
1244 else:
1245 FileWrite(File, ' %-*s : %6s %10s %10s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', '(' + DefaultStore + ')', Value))
1246 else:
1247 if IsByteArray:
1248 if self.DefaultStoreSingle and self.SkuSingle:
1249 FileWrite(File, ' %-*s : %6s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', '{'))
1250 elif self.DefaultStoreSingle and not self.SkuSingle:
1251 FileWrite(File, ' %-*s : %6s %10s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', '{'))
1252 elif not self.DefaultStoreSingle and self.SkuSingle:
1253 FileWrite(File, ' %-*s : %6s %10s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', '(' + DefaultStore + ')', '{'))
1254 else:
1255 FileWrite(File, ' %-*s : %6s %10s %10s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', '(' + DefaultStore + ')', '{'))
1256 for Array in ArrayList:
1257 FileWrite(File, Array)
1258 else:
1259 if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:
1260 if Value.startswith(('0x', '0X')):
1261 Value = '{} ({:d})'.format(Value, int(Value, 0))
1262 else:
1263 Value = "0x{:X} ({})".format(int(Value, 0), Value)
1264 if self.DefaultStoreSingle and self.SkuSingle:
1265 FileWrite(File, ' %-*s : %6s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', Value))
1266 elif self.DefaultStoreSingle and not self.SkuSingle:
1267 FileWrite(File, ' %-*s : %6s %10s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', Value))
1268 elif not self.DefaultStoreSingle and self.SkuSingle:
1269 FileWrite(File, ' %-*s : %6s %10s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', '(' + DefaultStore + ')', Value))
1270 else:
1271 FileWrite(File, ' %-*s : %6s %10s %10s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', '(' + DefaultStore + ')', Value))
1272 FileWrite(File, '%*s: %s: %s' % (self.MaxLen + 4, SkuInfo.VariableGuid, SkuInfo.VariableName, SkuInfo.VariableOffset))
1273 if IsStructure:
1274 OverrideValues = Pcd.SkuOverrideValues[Sku]
1275 OverrideFieldStruct = self.OverrideFieldValue(Pcd, OverrideValues[DefaultStore])
1276 self.PrintStructureInfo(File, OverrideFieldStruct)
1277 self.PrintPcdDefault(File, Pcd, IsStructure, DscMatch, DscDefaultValue, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue)
1278 else:
1279 Value = SkuInfo.DefaultValue
1280 IsByteArray, ArrayList = ByteArrayForamt(Value)
1281 if FirstPrint:
1282 FirstPrint = False
1283 if IsByteArray:
1284 if self.SkuSingle:
1285 FileWrite(File, ' %-*s : %6s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', "{"))
1286 else:
1287 FileWrite(File, ' %-*s : %6s %10s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', "{"))
1288 for Array in ArrayList:
1289 FileWrite(File, Array)
1290 else:
1291 if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:
1292 if Value.startswith(('0x', '0X')):
1293 Value = '{} ({:d})'.format(Value, int(Value, 0))
1294 else:
1295 Value = "0x{:X} ({})".format(int(Value, 0), Value)
1296 if self.SkuSingle:
1297 FileWrite(File, ' %-*s : %6s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', Value))
1298 else:
1299 FileWrite(File, ' %-*s : %6s %10s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', Value))
1300 else:
1301 if IsByteArray:
1302 if self.SkuSingle:
1303 FileWrite(File, ' %-*s : %6s %10s = %s' % (self.MaxLen, ' ' , TypeName, '(' + Pcd.DatumType + ')', "{"))
1304 else:
1305 FileWrite(File, ' %-*s : %6s %10s %10s = %s' % (self.MaxLen, ' ' , TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', "{"))
1306 for Array in ArrayList:
1307 FileWrite(File, Array)
1308 else:
1309 if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:
1310 if Value.startswith(('0x', '0X')):
1311 Value = '{} ({:d})'.format(Value, int(Value, 0))
1312 else:
1313 Value = "0x{:X} ({})".format(int(Value, 0), Value)
1314 if self.SkuSingle:
1315 FileWrite(File, ' %-*s : %6s %10s = %s' % (self.MaxLen, ' ' , TypeName, '(' + Pcd.DatumType + ')', Value))
1316 else:
1317 FileWrite(File, ' %-*s : %6s %10s %10s = %s' % (self.MaxLen, ' ' , TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', Value))
1318 if TypeName in ('DYNVPD', 'DEXVPD'):
1319 FileWrite(File, '%*s' % (self.MaxLen + 4, SkuInfo.VpdOffset))
1320 if IsStructure:
1321 OverrideValues = Pcd.SkuOverrideValues[Sku]
1322 if OverrideValues:
1323 Keys = OverrideValues.keys()
1324 OverrideFieldStruct = self.OverrideFieldValue(Pcd, OverrideValues[Keys[0]])
1325 self.PrintStructureInfo(File, OverrideFieldStruct)
1326 self.PrintPcdDefault(File, Pcd, IsStructure, DscMatch, DscDefaultValue, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue)
1327
1328 def OverrideFieldValue(self, Pcd, OverrideStruct):
1329 OverrideFieldStruct = collections.OrderedDict()
1330 if OverrideStruct:
1331 for Key, Values in OverrideStruct.items():
1332 if Values[1] and Values[1].endswith('.dsc'):
1333 OverrideFieldStruct[Key] = Values
1334 if Pcd.PcdFieldValueFromComm:
1335 for Key, Values in Pcd.PcdFieldValueFromComm.items():
1336 OverrideFieldStruct[Key] = Values
1337 return OverrideFieldStruct
1338
1339 def PrintStructureInfo(self, File, Struct):
1340 for Key, Value in Struct.items():
1341 if Value[1] and 'build command options' in Value[1]:
1342 FileWrite(File, ' *B %-*s = %s' % (self.MaxLen + 4, '.' + Key, Value[0]))
1343 else:
1344 FileWrite(File, ' %-*s = %s' % (self.MaxLen + 4, '.' + Key, Value[0]))
1345
1346 def StrtoHex(self, value):
1347 try:
1348 value = hex(int(value))
1349 return value
1350 except:
1351 if value.startswith("L\"") and value.endswith("\""):
1352 valuelist = []
1353 for ch in value[2:-1]:
1354 valuelist.append(hex(ord(ch)))
1355 valuelist.append('0x00')
1356 return valuelist
1357 elif value.startswith("\"") and value.endswith("\""):
1358 return hex(ord(value[1:-1]))
1359 elif value.startswith("{") and value.endswith("}"):
1360 valuelist = []
1361 if ',' not in value:
1362 return value[1:-1]
1363 for ch in value[1:-1].split(','):
1364 ch = ch.strip()
1365 if ch.startswith('0x') or ch.startswith('0X'):
1366 valuelist.append(ch)
1367 continue
1368 try:
1369 valuelist.append(hex(int(ch.strip())))
1370 except:
1371 pass
1372 return valuelist
1373 else:
1374 return value
1375
1376 ##
1377 # Reports platform and module Prediction information
1378 #
1379 # This class reports the platform execution order prediction section and
1380 # module load fixed address prediction subsection in the build report file.
1381 #
1382 class PredictionReport(object):
1383 ##
1384 # Constructor function for class PredictionReport
1385 #
1386 # This constructor function generates PredictionReport object for the platform.
1387 #
1388 # @param self: The object pointer
1389 # @param Wa Workspace context information
1390 #
1391 def __init__(self, Wa):
1392 self._MapFileName = os.path.join(Wa.BuildDir, Wa.Name + ".map")
1393 self._MapFileParsed = False
1394 self._EotToolInvoked = False
1395 self._FvDir = Wa.FvDir
1396 self._EotDir = Wa.BuildDir
1397 self._FfsEntryPoint = {}
1398 self._GuidMap = {}
1399 self._SourceList = []
1400 self.FixedMapDict = {}
1401 self.ItemList = []
1402 self.MaxLen = 0
1403
1404 #
1405 # Collect all platform reference source files and GUID C Name
1406 #
1407 for Pa in Wa.AutoGenObjectList:
1408 for Module in Pa.LibraryAutoGenList + Pa.ModuleAutoGenList:
1409 #
1410 # BASE typed modules are EFI agnostic, so we need not scan
1411 # their source code to find PPI/Protocol produce or consume
1412 # information.
1413 #
1414 if Module.ModuleType == SUP_MODULE_BASE:
1415 continue
1416 #
1417 # Add module referenced source files
1418 #
1419 self._SourceList.append(str(Module))
1420 IncludeList = {}
1421 for Source in Module.SourceFileList:
1422 if os.path.splitext(str(Source))[1].lower() == ".c":
1423 self._SourceList.append(" " + str(Source))
1424 FindIncludeFiles(Source.Path, Module.IncludePathList, IncludeList)
1425 for IncludeFile in IncludeList.values():
1426 self._SourceList.append(" " + IncludeFile)
1427
1428 for Guid in Module.PpiList:
1429 self._GuidMap[Guid] = GuidStructureStringToGuidString(Module.PpiList[Guid])
1430 for Guid in Module.ProtocolList:
1431 self._GuidMap[Guid] = GuidStructureStringToGuidString(Module.ProtocolList[Guid])
1432 for Guid in Module.GuidList:
1433 self._GuidMap[Guid] = GuidStructureStringToGuidString(Module.GuidList[Guid])
1434
1435 if Module.Guid and not Module.IsLibrary:
1436 EntryPoint = " ".join(Module.Module.ModuleEntryPointList)
1437 if int(str(Module.AutoGenVersion), 0) >= 0x00010005:
1438 RealEntryPoint = "_ModuleEntryPoint"
1439 else:
1440 RealEntryPoint = EntryPoint
1441 if EntryPoint == "_ModuleEntryPoint":
1442 CCFlags = Module.BuildOption.get("CC", {}).get("FLAGS", "")
1443 Match = gGlueLibEntryPoint.search(CCFlags)
1444 if Match:
1445 EntryPoint = Match.group(1)
1446
1447 self._FfsEntryPoint[Module.Guid.upper()] = (EntryPoint, RealEntryPoint)
1448
1449
1450 #
1451 # Collect platform firmware volume list as the input of EOT.
1452 #
1453 self._FvList = []
1454 if Wa.FdfProfile:
1455 for Fd in Wa.FdfProfile.FdDict:
1456 for FdRegion in Wa.FdfProfile.FdDict[Fd].RegionList:
1457 if FdRegion.RegionType != BINARY_FILE_TYPE_FV:
1458 continue
1459 for FvName in FdRegion.RegionDataList:
1460 if FvName in self._FvList:
1461 continue
1462 self._FvList.append(FvName)
1463 for Ffs in Wa.FdfProfile.FvDict[FvName.upper()].FfsList:
1464 for Section in Ffs.SectionList:
1465 try:
1466 for FvSection in Section.SectionList:
1467 if FvSection.FvName in self._FvList:
1468 continue
1469 self._FvList.append(FvSection.FvName)
1470 except AttributeError:
1471 pass
1472
1473
1474 ##
1475 # Parse platform fixed address map files
1476 #
1477 # This function parses the platform final fixed address map file to get
1478 # the database of predicted fixed address for module image base, entry point
1479 # etc.
1480 #
1481 # @param self: The object pointer
1482 #
1483 def _ParseMapFile(self):
1484 if self._MapFileParsed:
1485 return
1486 self._MapFileParsed = True
1487 if os.path.isfile(self._MapFileName):
1488 try:
1489 FileContents = open(self._MapFileName).read()
1490 for Match in gMapFileItemPattern.finditer(FileContents):
1491 AddressType = Match.group(1)
1492 BaseAddress = Match.group(2)
1493 EntryPoint = Match.group(3)
1494 Guid = Match.group(4).upper()
1495 List = self.FixedMapDict.setdefault(Guid, [])
1496 List.append((AddressType, BaseAddress, "*I"))
1497 List.append((AddressType, EntryPoint, "*E"))
1498 except:
1499 EdkLogger.warn(None, "Cannot open file to read", self._MapFileName)
1500
1501 ##
1502 # Invokes EOT tool to get the predicted the execution order.
1503 #
1504 # This function invokes EOT tool to calculate the predicted dispatch order
1505 #
1506 # @param self: The object pointer
1507 #
1508 def _InvokeEotTool(self):
1509 if self._EotToolInvoked:
1510 return
1511
1512 self._EotToolInvoked = True
1513 FvFileList = []
1514 for FvName in self._FvList:
1515 FvFile = os.path.join(self._FvDir, FvName + ".Fv")
1516 if os.path.isfile(FvFile):
1517 FvFileList.append(FvFile)
1518
1519 if len(FvFileList) == 0:
1520 return
1521 #
1522 # Write source file list and GUID file list to an intermediate file
1523 # as the input for EOT tool and dispatch List as the output file
1524 # from EOT tool.
1525 #
1526 SourceList = os.path.join(self._EotDir, "SourceFile.txt")
1527 GuidList = os.path.join(self._EotDir, "GuidList.txt")
1528 DispatchList = os.path.join(self._EotDir, "Dispatch.txt")
1529
1530 TempFile = open(SourceList, "w+")
1531 for Item in self._SourceList:
1532 FileWrite(TempFile, Item)
1533 TempFile.close()
1534 TempFile = open(GuidList, "w+")
1535 for Key in self._GuidMap:
1536 FileWrite(TempFile, "%s %s" % (Key, self._GuidMap[Key]))
1537 TempFile.close()
1538
1539 try:
1540 from Eot.Eot import Eot
1541
1542 #
1543 # Invoke EOT tool and echo its runtime performance
1544 #
1545 EotStartTime = time.time()
1546 Eot(CommandLineOption=False, SourceFileList=SourceList, GuidList=GuidList,
1547 FvFileList=' '.join(FvFileList), Dispatch=DispatchList, IsInit=True)
1548 EotEndTime = time.time()
1549 EotDuration = time.strftime("%H:%M:%S", time.gmtime(int(round(EotEndTime - EotStartTime))))
1550 EdkLogger.quiet("EOT run time: %s\n" % EotDuration)
1551
1552 #
1553 # Parse the output of EOT tool
1554 #
1555 for Line in open(DispatchList):
1556 if len(Line.split()) < 4:
1557 continue
1558 (Guid, Phase, FfsName, FilePath) = Line.split()
1559 Symbol = self._FfsEntryPoint.get(Guid, [FfsName, ""])[0]
1560 if len(Symbol) > self.MaxLen:
1561 self.MaxLen = len(Symbol)
1562 self.ItemList.append((Phase, Symbol, FilePath))
1563 except:
1564 EdkLogger.quiet("(Python %s on %s\n%s)" % (platform.python_version(), sys.platform, traceback.format_exc()))
1565 EdkLogger.warn(None, "Failed to generate execution order prediction report, for some error occurred in executing EOT.")
1566
1567
1568 ##
1569 # Generate platform execution order report
1570 #
1571 # This function generates the predicted module execution order.
1572 #
1573 # @param self The object pointer
1574 # @param File The file object for report
1575 #
1576 def _GenerateExecutionOrderReport(self, File):
1577 self._InvokeEotTool()
1578 if len(self.ItemList) == 0:
1579 return
1580 FileWrite(File, gSectionStart)
1581 FileWrite(File, "Execution Order Prediction")
1582 FileWrite(File, "*P PEI phase")
1583 FileWrite(File, "*D DXE phase")
1584 FileWrite(File, "*E Module INF entry point name")
1585 FileWrite(File, "*N Module notification function name")
1586
1587 FileWrite(File, "Type %-*s %s" % (self.MaxLen, "Symbol", "Module INF Path"))
1588 FileWrite(File, gSectionSep)
1589 for Item in self.ItemList:
1590 FileWrite(File, "*%sE %-*s %s" % (Item[0], self.MaxLen, Item[1], Item[2]))
1591
1592 FileWrite(File, gSectionStart)
1593
1594 ##
1595 # Generate Fixed Address report.
1596 #
1597 # This function generate the predicted fixed address report for a module
1598 # specified by Guid.
1599 #
1600 # @param self The object pointer
1601 # @param File The file object for report
1602 # @param Guid The module Guid value.
1603 # @param NotifyList The list of all notify function in a module
1604 #
1605 def _GenerateFixedAddressReport(self, File, Guid, NotifyList):
1606 self._ParseMapFile()
1607 FixedAddressList = self.FixedMapDict.get(Guid)
1608 if not FixedAddressList:
1609 return
1610
1611 FileWrite(File, gSubSectionStart)
1612 FileWrite(File, "Fixed Address Prediction")
1613 FileWrite(File, "*I Image Loading Address")
1614 FileWrite(File, "*E Entry Point Address")
1615 FileWrite(File, "*N Notification Function Address")
1616 FileWrite(File, "*F Flash Address")
1617 FileWrite(File, "*M Memory Address")
1618 FileWrite(File, "*S SMM RAM Offset")
1619 FileWrite(File, "TOM Top of Memory")
1620
1621 FileWrite(File, "Type Address Name")
1622 FileWrite(File, gSubSectionSep)
1623 for Item in FixedAddressList:
1624 Type = Item[0]
1625 Value = Item[1]
1626 Symbol = Item[2]
1627 if Symbol == "*I":
1628 Name = "(Image Base)"
1629 elif Symbol == "*E":
1630 Name = self._FfsEntryPoint.get(Guid, ["", "_ModuleEntryPoint"])[1]
1631 elif Symbol in NotifyList:
1632 Name = Symbol
1633 Symbol = "*N"
1634 else:
1635 continue
1636
1637 if "Flash" in Type:
1638 Symbol += "F"
1639 elif "Memory" in Type:
1640 Symbol += "M"
1641 else:
1642 Symbol += "S"
1643
1644 if Value[0] == "-":
1645 Value = "TOM" + Value
1646
1647 FileWrite(File, "%s %-16s %s" % (Symbol, Value, Name))
1648
1649 ##
1650 # Generate report for the prediction part
1651 #
1652 # This function generate the predicted fixed address report for a module or
1653 # predicted module execution order for a platform.
1654 # If the input Guid is None, then, it generates the predicted module execution order;
1655 # otherwise it generated the module fixed loading address for the module specified by
1656 # Guid.
1657 #
1658 # @param self The object pointer
1659 # @param File The file object for report
1660 # @param Guid The module Guid value.
1661 #
1662 def GenerateReport(self, File, Guid):
1663 if Guid:
1664 self._GenerateFixedAddressReport(File, Guid.upper(), [])
1665 else:
1666 self._GenerateExecutionOrderReport(File)
1667
1668 ##
1669 # Reports FD region information
1670 #
1671 # This class reports the FD subsection in the build report file.
1672 # It collects region information of platform flash device.
1673 # If the region is a firmware volume, it lists the set of modules
1674 # and its space information; otherwise, it only lists its region name,
1675 # base address and size in its sub-section header.
1676 # If there are nesting FVs, the nested FVs will list immediate after
1677 # this FD region subsection
1678 #
1679 class FdRegionReport(object):
1680 ##
1681 # Discover all the nested FV name list.
1682 #
1683 # This is an internal worker function to discover the all the nested FV information
1684 # in the parent firmware volume. It uses deep first search algorithm recursively to
1685 # find all the FV list name and append them to the list.
1686 #
1687 # @param self The object pointer
1688 # @param FvName The name of current firmware file system
1689 # @param Wa Workspace context information
1690 #
1691 def _DiscoverNestedFvList(self, FvName, Wa):
1692 FvDictKey=FvName.upper()
1693 if FvDictKey in Wa.FdfProfile.FvDict:
1694 for Ffs in Wa.FdfProfile.FvDict[FvName.upper()].FfsList:
1695 for Section in Ffs.SectionList:
1696 try:
1697 for FvSection in Section.SectionList:
1698 if FvSection.FvName in self.FvList:
1699 continue
1700 self._GuidsDb[Ffs.NameGuid.upper()] = FvSection.FvName
1701 self.FvList.append(FvSection.FvName)
1702 self.FvInfo[FvSection.FvName] = ("Nested FV", 0, 0)
1703 self._DiscoverNestedFvList(FvSection.FvName, Wa)
1704 except AttributeError:
1705 pass
1706
1707 ##
1708 # Constructor function for class FdRegionReport
1709 #
1710 # This constructor function generates FdRegionReport object for a specified FdRegion.
1711 # If the FdRegion is a firmware volume, it will recursively find all its nested Firmware
1712 # volume list. This function also collects GUID map in order to dump module identification
1713 # in the final report.
1714 #
1715 # @param self: The object pointer
1716 # @param FdRegion The current FdRegion object
1717 # @param Wa Workspace context information
1718 #
1719 def __init__(self, FdRegion, Wa):
1720 self.Type = FdRegion.RegionType
1721 self.BaseAddress = FdRegion.Offset
1722 self.Size = FdRegion.Size
1723 self.FvList = []
1724 self.FvInfo = {}
1725 self._GuidsDb = {}
1726 self._FvDir = Wa.FvDir
1727 self._WorkspaceDir = Wa.WorkspaceDir
1728
1729 #
1730 # If the input FdRegion is not a firmware volume,
1731 # we are done.
1732 #
1733 if self.Type != BINARY_FILE_TYPE_FV:
1734 return
1735
1736 #
1737 # Find all nested FVs in the FdRegion
1738 #
1739 for FvName in FdRegion.RegionDataList:
1740 if FvName in self.FvList:
1741 continue
1742 self.FvList.append(FvName)
1743 self.FvInfo[FvName] = ("Fd Region", self.BaseAddress, self.Size)
1744 self._DiscoverNestedFvList(FvName, Wa)
1745
1746 PlatformPcds = {}
1747 #
1748 # Collect PCDs declared in DEC files.
1749 #
1750 for Pa in Wa.AutoGenObjectList:
1751 for Package in Pa.PackageList:
1752 for (TokenCName, TokenSpaceGuidCName, DecType) in Package.Pcds:
1753 DecDefaultValue = Package.Pcds[TokenCName, TokenSpaceGuidCName, DecType].DefaultValue
1754 PlatformPcds[(TokenCName, TokenSpaceGuidCName)] = DecDefaultValue
1755 #
1756 # Collect PCDs defined in DSC file
1757 #
1758 for Pa in Wa.AutoGenObjectList:
1759 for (TokenCName, TokenSpaceGuidCName) in Pa.Platform.Pcds:
1760 DscDefaultValue = Pa.Platform.Pcds[(TokenCName, TokenSpaceGuidCName)].DefaultValue
1761 PlatformPcds[(TokenCName, TokenSpaceGuidCName)] = DscDefaultValue
1762
1763 #
1764 # Add PEI and DXE a priori files GUIDs defined in PI specification.
1765 #
1766 self._GuidsDb["1B45CC0A-156A-428A-AF62-49864DA0E6E6"] = "PEI Apriori"
1767 self._GuidsDb["FC510EE7-FFDC-11D4-BD41-0080C73C8881"] = "DXE Apriori"
1768 #
1769 # Add ACPI table storage file
1770 #
1771 self._GuidsDb["7E374E25-8E01-4FEE-87F2-390C23C606CD"] = "ACPI table storage"
1772
1773 for Pa in Wa.AutoGenObjectList:
1774 for ModuleKey in Pa.Platform.Modules:
1775 M = Pa.Platform.Modules[ModuleKey].M
1776 InfPath = mws.join(Wa.WorkspaceDir, M.MetaFile.File)
1777 self._GuidsDb[M.Guid.upper()] = "%s (%s)" % (M.Module.BaseName, InfPath)
1778
1779 #
1780 # Collect the GUID map in the FV firmware volume
1781 #
1782 for FvName in self.FvList:
1783 FvDictKey=FvName.upper()
1784 if FvDictKey in Wa.FdfProfile.FvDict:
1785 for Ffs in Wa.FdfProfile.FvDict[FvName.upper()].FfsList:
1786 try:
1787 #
1788 # collect GUID map for binary EFI file in FDF file.
1789 #
1790 Guid = Ffs.NameGuid.upper()
1791 Match = gPcdGuidPattern.match(Ffs.NameGuid)
1792 if Match:
1793 PcdTokenspace = Match.group(1)
1794 PcdToken = Match.group(2)
1795 if (PcdToken, PcdTokenspace) in PlatformPcds:
1796 GuidValue = PlatformPcds[(PcdToken, PcdTokenspace)]
1797 Guid = GuidStructureByteArrayToGuidString(GuidValue).upper()
1798 for Section in Ffs.SectionList:
1799 try:
1800 ModuleSectFile = mws.join(Wa.WorkspaceDir, Section.SectFileName)
1801 self._GuidsDb[Guid] = ModuleSectFile
1802 except AttributeError:
1803 pass
1804 except AttributeError:
1805 pass
1806
1807
1808 ##
1809 # Internal worker function to generate report for the FD region
1810 #
1811 # This internal worker function to generate report for the FD region.
1812 # It the type is firmware volume, it lists offset and module identification.
1813 #
1814 # @param self The object pointer
1815 # @param File The file object for report
1816 # @param Title The title for the FD subsection
1817 # @param BaseAddress The base address for the FD region
1818 # @param Size The size of the FD region
1819 # @param FvName The FV name if the FD region is a firmware volume
1820 #
1821 def _GenerateReport(self, File, Title, Type, BaseAddress, Size=0, FvName=None):
1822 FileWrite(File, gSubSectionStart)
1823 FileWrite(File, Title)
1824 FileWrite(File, "Type: %s" % Type)
1825 FileWrite(File, "Base Address: 0x%X" % BaseAddress)
1826
1827 if self.Type == BINARY_FILE_TYPE_FV:
1828 FvTotalSize = 0
1829 FvTakenSize = 0
1830 FvFreeSize = 0
1831 if FvName.upper().endswith('.FV'):
1832 FileExt = FvName + ".txt"
1833 else:
1834 FileExt = FvName + ".Fv.txt"
1835
1836 if not os.path.isfile(FileExt):
1837 FvReportFileName = mws.join(self._WorkspaceDir, FileExt)
1838 if not os.path.isfile(FvReportFileName):
1839 FvReportFileName = os.path.join(self._FvDir, FileExt)
1840 try:
1841 #
1842 # Collect size info in the firmware volume.
1843 #
1844 FvReport = open(FvReportFileName).read()
1845 Match = gFvTotalSizePattern.search(FvReport)
1846 if Match:
1847 FvTotalSize = int(Match.group(1), 16)
1848 Match = gFvTakenSizePattern.search(FvReport)
1849 if Match:
1850 FvTakenSize = int(Match.group(1), 16)
1851 FvFreeSize = FvTotalSize - FvTakenSize
1852 #
1853 # Write size information to the report file.
1854 #
1855 FileWrite(File, "Size: 0x%X (%.0fK)" % (FvTotalSize, FvTotalSize / 1024.0))
1856 FileWrite(File, "Fv Name: %s (%.1f%% Full)" % (FvName, FvTakenSize * 100.0 / FvTotalSize))
1857 FileWrite(File, "Occupied Size: 0x%X (%.0fK)" % (FvTakenSize, FvTakenSize / 1024.0))
1858 FileWrite(File, "Free Size: 0x%X (%.0fK)" % (FvFreeSize, FvFreeSize / 1024.0))
1859 FileWrite(File, "Offset Module")
1860 FileWrite(File, gSubSectionSep)
1861 #
1862 # Write module offset and module identification to the report file.
1863 #
1864 OffsetInfo = {}
1865 for Match in gOffsetGuidPattern.finditer(FvReport):
1866 Guid = Match.group(2).upper()
1867 OffsetInfo[Match.group(1)] = self._GuidsDb.get(Guid, Guid)
1868 OffsetList = OffsetInfo.keys()
1869 OffsetList.sort()
1870 for Offset in OffsetList:
1871 FileWrite (File, "%s %s" % (Offset, OffsetInfo[Offset]))
1872 except IOError:
1873 EdkLogger.warn(None, "Fail to read report file", FvReportFileName)
1874 else:
1875 FileWrite(File, "Size: 0x%X (%.0fK)" % (Size, Size / 1024.0))
1876 FileWrite(File, gSubSectionEnd)
1877
1878 ##
1879 # Generate report for the FD region
1880 #
1881 # This function generates report for the FD region.
1882 #
1883 # @param self The object pointer
1884 # @param File The file object for report
1885 #
1886 def GenerateReport(self, File):
1887 if (len(self.FvList) > 0):
1888 for FvItem in self.FvList:
1889 Info = self.FvInfo[FvItem]
1890 self._GenerateReport(File, Info[0], TAB_FV_DIRECTORY, Info[1], Info[2], FvItem)
1891 else:
1892 self._GenerateReport(File, "FD Region", self.Type, self.BaseAddress, self.Size)
1893
1894 ##
1895 # Reports FD information
1896 #
1897 # This class reports the FD section in the build report file.
1898 # It collects flash device information for a platform.
1899 #
1900 class FdReport(object):
1901 ##
1902 # Constructor function for class FdReport
1903 #
1904 # This constructor function generates FdReport object for a specified
1905 # firmware device.
1906 #
1907 # @param self The object pointer
1908 # @param Fd The current Firmware device object
1909 # @param Wa Workspace context information
1910 #
1911 def __init__(self, Fd, Wa):
1912 self.FdName = Fd.FdUiName
1913 self.BaseAddress = Fd.BaseAddress
1914 self.Size = Fd.Size
1915 self.FdRegionList = [FdRegionReport(FdRegion, Wa) for FdRegion in Fd.RegionList]
1916 self.FvPath = os.path.join(Wa.BuildDir, TAB_FV_DIRECTORY)
1917 self.VpdFilePath = os.path.join(self.FvPath, "%s.map" % Wa.Platform.VpdToolGuid)
1918 self.VPDBaseAddress = 0
1919 self.VPDSize = 0
1920 self.VPDInfoList = []
1921 for index, FdRegion in enumerate(Fd.RegionList):
1922 if str(FdRegion.RegionType) is 'FILE' and Wa.Platform.VpdToolGuid in str(FdRegion.RegionDataList):
1923 self.VPDBaseAddress = self.FdRegionList[index].BaseAddress
1924 self.VPDSize = self.FdRegionList[index].Size
1925 break
1926
1927 if os.path.isfile(self.VpdFilePath):
1928 fd = open(self.VpdFilePath, "r")
1929 Lines = fd.readlines()
1930 for Line in Lines:
1931 Line = Line.strip()
1932 if len(Line) == 0 or Line.startswith("#"):
1933 continue
1934 try:
1935 PcdName, SkuId, Offset, Size, Value = Line.split("#")[0].split("|")
1936 PcdName, SkuId, Offset, Size, Value = PcdName.strip(), SkuId.strip(), Offset.strip(), Size.strip(), Value.strip()
1937 if Offset.lower().startswith('0x'):
1938 Offset = '0x%08X' % (int(Offset, 16) + self.VPDBaseAddress)
1939 else:
1940 Offset = '0x%08X' % (int(Offset, 10) + self.VPDBaseAddress)
1941 self.VPDInfoList.append("%s | %s | %s | %s | %s" % (PcdName, SkuId, Offset, Size, Value))
1942 except:
1943 EdkLogger.error("BuildReport", CODE_ERROR, "Fail to parse VPD information file %s" % self.VpdFilePath)
1944 fd.close()
1945
1946 ##
1947 # Generate report for the firmware device.
1948 #
1949 # This function generates report for the firmware device.
1950 #
1951 # @param self The object pointer
1952 # @param File The file object for report
1953 #
1954 def GenerateReport(self, File):
1955 FileWrite(File, gSectionStart)
1956 FileWrite(File, "Firmware Device (FD)")
1957 FileWrite(File, "FD Name: %s" % self.FdName)
1958 FileWrite(File, "Base Address: %s" % self.BaseAddress)
1959 FileWrite(File, "Size: 0x%X (%.0fK)" % (self.Size, self.Size / 1024.0))
1960 if len(self.FdRegionList) > 0:
1961 FileWrite(File, gSectionSep)
1962 for FdRegionItem in self.FdRegionList:
1963 FdRegionItem.GenerateReport(File)
1964
1965 if len(self.VPDInfoList) > 0:
1966 FileWrite(File, gSubSectionStart)
1967 FileWrite(File, "FD VPD Region")
1968 FileWrite(File, "Base Address: 0x%X" % self.VPDBaseAddress)
1969 FileWrite(File, "Size: 0x%X (%.0fK)" % (self.VPDSize, self.VPDSize / 1024.0))
1970 FileWrite(File, gSubSectionSep)
1971 for item in self.VPDInfoList:
1972 ValueList = item.split('|')
1973 Value = ValueList[-1].strip()
1974 IsByteArray, ArrayList = ByteArrayForamt(Value)
1975 if IsByteArray:
1976 ValueList[-1] = ' {'
1977 FileWrite(File, '|'.join(ValueList))
1978 for Array in ArrayList:
1979 FileWrite(File, Array)
1980 else:
1981 FileWrite(File, item)
1982 FileWrite(File, gSubSectionEnd)
1983 FileWrite(File, gSectionEnd)
1984
1985
1986
1987 ##
1988 # Reports platform information
1989 #
1990 # This class reports the whole platform information
1991 #
1992 class PlatformReport(object):
1993 ##
1994 # Constructor function for class PlatformReport
1995 #
1996 # This constructor function generates PlatformReport object a platform build.
1997 # It generates report for platform summary, flash, global PCDs and detailed
1998 # module information for modules involved in platform build.
1999 #
2000 # @param self The object pointer
2001 # @param Wa Workspace context information
2002 # @param MaList The list of modules in the platform build
2003 #
2004 def __init__(self, Wa, MaList, ReportType):
2005 self._WorkspaceDir = Wa.WorkspaceDir
2006 self.PlatformName = Wa.Name
2007 self.PlatformDscPath = Wa.Platform
2008 self.Architectures = " ".join(Wa.ArchList)
2009 self.ToolChain = Wa.ToolChain
2010 self.Target = Wa.BuildTarget
2011 self.OutputPath = os.path.join(Wa.WorkspaceDir, Wa.OutputDir)
2012 self.BuildEnvironment = platform.platform()
2013
2014 self.PcdReport = None
2015 if "PCD" in ReportType:
2016 self.PcdReport = PcdReport(Wa)
2017
2018 self.FdReportList = []
2019 if "FLASH" in ReportType and Wa.FdfProfile and MaList is None:
2020 for Fd in Wa.FdfProfile.FdDict:
2021 self.FdReportList.append(FdReport(Wa.FdfProfile.FdDict[Fd], Wa))
2022
2023 self.PredictionReport = None
2024 if "FIXED_ADDRESS" in ReportType or "EXECUTION_ORDER" in ReportType:
2025 self.PredictionReport = PredictionReport(Wa)
2026
2027 self.DepexParser = None
2028 if "DEPEX" in ReportType:
2029 self.DepexParser = DepexParser(Wa)
2030
2031 self.ModuleReportList = []
2032 if MaList is not None:
2033 self._IsModuleBuild = True
2034 for Ma in MaList:
2035 self.ModuleReportList.append(ModuleReport(Ma, ReportType))
2036 else:
2037 self._IsModuleBuild = False
2038 for Pa in Wa.AutoGenObjectList:
2039 ModuleAutoGenList = []
2040 for ModuleKey in Pa.Platform.Modules:
2041 ModuleAutoGenList.append(Pa.Platform.Modules[ModuleKey].M)
2042 if GlobalData.gFdfParser is not None:
2043 if Pa.Arch in GlobalData.gFdfParser.Profile.InfDict:
2044 INFList = GlobalData.gFdfParser.Profile.InfDict[Pa.Arch]
2045 for InfName in INFList:
2046 InfClass = PathClass(NormPath(InfName), Wa.WorkspaceDir, Pa.Arch)
2047 Ma = ModuleAutoGen(Wa, InfClass, Pa.BuildTarget, Pa.ToolChain, Pa.Arch, Wa.MetaFile)
2048 if Ma is None:
2049 continue
2050 if Ma not in ModuleAutoGenList:
2051 ModuleAutoGenList.append(Ma)
2052 for MGen in ModuleAutoGenList:
2053 self.ModuleReportList.append(ModuleReport(MGen, ReportType))
2054
2055
2056
2057 ##
2058 # Generate report for the whole platform.
2059 #
2060 # This function generates report for platform information.
2061 # It comprises of platform summary, global PCD, flash and
2062 # module list sections.
2063 #
2064 # @param self The object pointer
2065 # @param File The file object for report
2066 # @param BuildDuration The total time to build the modules
2067 # @param AutoGenTime The total time of AutoGen Phase
2068 # @param MakeTime The total time of Make Phase
2069 # @param GenFdsTime The total time of GenFds Phase
2070 # @param ReportType The kind of report items in the final report file
2071 #
2072 def GenerateReport(self, File, BuildDuration, AutoGenTime, MakeTime, GenFdsTime, ReportType):
2073 FileWrite(File, "Platform Summary")
2074 FileWrite(File, "Platform Name: %s" % self.PlatformName)
2075 FileWrite(File, "Platform DSC Path: %s" % self.PlatformDscPath)
2076 FileWrite(File, "Architectures: %s" % self.Architectures)
2077 FileWrite(File, "Tool Chain: %s" % self.ToolChain)
2078 FileWrite(File, "Target: %s" % self.Target)
2079 if GlobalData.gSkuids:
2080 FileWrite(File, "SKUID: %s" % " ".join(GlobalData.gSkuids))
2081 if GlobalData.gDefaultStores:
2082 FileWrite(File, "DefaultStore: %s" % " ".join(GlobalData.gDefaultStores))
2083 FileWrite(File, "Output Path: %s" % self.OutputPath)
2084 FileWrite(File, "Build Environment: %s" % self.BuildEnvironment)
2085 FileWrite(File, "Build Duration: %s" % BuildDuration)
2086 if AutoGenTime:
2087 FileWrite(File, "AutoGen Duration: %s" % AutoGenTime)
2088 if MakeTime:
2089 FileWrite(File, "Make Duration: %s" % MakeTime)
2090 if GenFdsTime:
2091 FileWrite(File, "GenFds Duration: %s" % GenFdsTime)
2092 FileWrite(File, "Report Content: %s" % ", ".join(ReportType))
2093
2094 if GlobalData.MixedPcd:
2095 FileWrite(File, gSectionStart)
2096 FileWrite(File, "The following PCDs use different access methods:")
2097 FileWrite(File, gSectionSep)
2098 for PcdItem in GlobalData.MixedPcd:
2099 FileWrite(File, "%s.%s" % (str(PcdItem[1]), str(PcdItem[0])))
2100 FileWrite(File, gSectionEnd)
2101
2102 if not self._IsModuleBuild:
2103 if "PCD" in ReportType:
2104 self.PcdReport.GenerateReport(File, None)
2105
2106 if "FLASH" in ReportType:
2107 for FdReportListItem in self.FdReportList:
2108 FdReportListItem.GenerateReport(File)
2109
2110 for ModuleReportItem in self.ModuleReportList:
2111 ModuleReportItem.GenerateReport(File, self.PcdReport, self.PredictionReport, self.DepexParser, ReportType)
2112
2113 if not self._IsModuleBuild:
2114 if "EXECUTION_ORDER" in ReportType:
2115 self.PredictionReport.GenerateReport(File, None)
2116
2117 ## BuildReport class
2118 #
2119 # This base class contain the routines to collect data and then
2120 # applies certain format to the output report
2121 #
2122 class BuildReport(object):
2123 ##
2124 # Constructor function for class BuildReport
2125 #
2126 # This constructor function generates BuildReport object a platform build.
2127 # It generates report for platform summary, flash, global PCDs and detailed
2128 # module information for modules involved in platform build.
2129 #
2130 # @param self The object pointer
2131 # @param ReportFile The file name to save report file
2132 # @param ReportType The kind of report items in the final report file
2133 #
2134 def __init__(self, ReportFile, ReportType):
2135 self.ReportFile = ReportFile
2136 if ReportFile:
2137 self.ReportList = []
2138 self.ReportType = []
2139 if ReportType:
2140 for ReportTypeItem in ReportType:
2141 if ReportTypeItem not in self.ReportType:
2142 self.ReportType.append(ReportTypeItem)
2143 else:
2144 self.ReportType = ["PCD", "LIBRARY", "BUILD_FLAGS", "DEPEX", "HASH", "FLASH", "FIXED_ADDRESS"]
2145 ##
2146 # Adds platform report to the list
2147 #
2148 # This function adds a platform report to the final report list.
2149 #
2150 # @param self The object pointer
2151 # @param Wa Workspace context information
2152 # @param MaList The list of modules in the platform build
2153 #
2154 def AddPlatformReport(self, Wa, MaList=None):
2155 if self.ReportFile:
2156 self.ReportList.append((Wa, MaList))
2157
2158 ##
2159 # Generates the final report.
2160 #
2161 # This function generates platform build report. It invokes GenerateReport()
2162 # method for every platform report in the list.
2163 #
2164 # @param self The object pointer
2165 # @param BuildDuration The total time to build the modules
2166 # @param AutoGenTime The total time of AutoGen phase
2167 # @param MakeTime The total time of Make phase
2168 # @param GenFdsTime The total time of GenFds phase
2169 #
2170 def GenerateReport(self, BuildDuration, AutoGenTime, MakeTime, GenFdsTime):
2171 if self.ReportFile:
2172 try:
2173 File = StringIO('')
2174 for (Wa, MaList) in self.ReportList:
2175 PlatformReport(Wa, MaList, self.ReportType).GenerateReport(File, BuildDuration, AutoGenTime, MakeTime, GenFdsTime, self.ReportType)
2176 Content = FileLinesSplit(File.getvalue(), gLineMaxLength)
2177 SaveFileOnChange(self.ReportFile, Content, True)
2178 EdkLogger.quiet("Build report can be found at %s" % os.path.abspath(self.ReportFile))
2179 except IOError:
2180 EdkLogger.error(None, FILE_WRITE_FAILURE, ExtraData=self.ReportFile)
2181 except:
2182 EdkLogger.error("BuildReport", CODE_ERROR, "Unknown fatal error when generating build report", ExtraData=self.ReportFile, RaiseError=False)
2183 EdkLogger.quiet("(Python %s on %s\n%s)" % (platform.python_version(), sys.platform, traceback.format_exc()))
2184 File.close()
2185
2186 # This acts like the main() function for the script, unless it is 'import'ed into another script.
2187 if __name__ == '__main__':
2188 pass
2189