| | 1 | ## @file\r |
| | 2 | # Routines for generating build report.\r |
| | 3 | #\r |
| | 4 | # This module contains the functionality to generate build report after\r |
| | 5 | # build all target completes successfully.\r |
| | 6 | #\r |
| | 7 | # Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved.<BR>\r |
| | 8 | # SPDX-License-Identifier: BSD-2-Clause-Patent\r |
| | 9 | #\r |
| | 10 | \r |
| | 11 | ## Import Modules\r |
| | 12 | #\r |
| | 13 | import Common.LongFilePathOs as os\r |
| | 14 | import re\r |
| | 15 | import platform\r |
| | 16 | import textwrap\r |
| | 17 | import traceback\r |
| | 18 | import sys\r |
| | 19 | import time\r |
| | 20 | import struct\r |
| | 21 | import hashlib\r |
| | 22 | import subprocess\r |
| | 23 | import threading\r |
| | 24 | from datetime import datetime\r |
| | 25 | from io import BytesIO\r |
| | 26 | from Common import EdkLogger\r |
| | 27 | from Common.Misc import SaveFileOnChange\r |
| | 28 | from Common.Misc import GuidStructureByteArrayToGuidString\r |
| | 29 | from Common.Misc import GuidStructureStringToGuidString\r |
| | 30 | from Common.BuildToolError import FILE_WRITE_FAILURE\r |
| | 31 | from Common.BuildToolError import CODE_ERROR\r |
| | 32 | from Common.BuildToolError import COMMAND_FAILURE\r |
| | 33 | from Common.BuildToolError import FORMAT_INVALID\r |
| | 34 | from Common.LongFilePathSupport import OpenLongFilePath as open\r |
| | 35 | from Common.MultipleWorkspace import MultipleWorkspace as mws\r |
| | 36 | import Common.GlobalData as GlobalData\r |
| | 37 | from AutoGen.ModuleAutoGen import ModuleAutoGen\r |
| | 38 | from Common.Misc import PathClass\r |
| | 39 | from Common.StringUtils import NormPath\r |
| | 40 | from Common.DataType import *\r |
| | 41 | import collections\r |
| | 42 | from Common.Expression import *\r |
| | 43 | from GenFds.AprioriSection import DXE_APRIORI_GUID, PEI_APRIORI_GUID\r |
| | 44 | \r |
| | 45 | ## Pattern to extract contents in EDK DXS files\r |
| | 46 | gDxsDependencyPattern = re.compile(r"DEPENDENCY_START(.+)DEPENDENCY_END", re.DOTALL)\r |
| | 47 | \r |
| | 48 | ## Pattern to find total FV total size, occupied size in flash report intermediate file\r |
| | 49 | gFvTotalSizePattern = re.compile(r"EFI_FV_TOTAL_SIZE = (0x[0-9a-fA-F]+)")\r |
| | 50 | gFvTakenSizePattern = re.compile(r"EFI_FV_TAKEN_SIZE = (0x[0-9a-fA-F]+)")\r |
| | 51 | \r |
| | 52 | ## Pattern to find module size and time stamp in module summary report intermediate file\r |
| | 53 | gModuleSizePattern = re.compile(r"MODULE_SIZE = (\d+)")\r |
| | 54 | gTimeStampPattern = re.compile(r"TIME_STAMP = (\d+)")\r |
| | 55 | \r |
| | 56 | ## Pattern to find GUID value in flash description files\r |
| | 57 | gPcdGuidPattern = re.compile(r"PCD\((\w+)[.](\w+)\)")\r |
| | 58 | \r |
| | 59 | ## Pattern to collect offset, GUID value pair in the flash report intermediate file\r |
| | 60 | gOffsetGuidPattern = re.compile(r"(0x[0-9A-Fa-f]+) ([-A-Fa-f0-9]+)")\r |
| | 61 | \r |
| | 62 | ## Pattern to find module base address and entry point in fixed flash map file\r |
| | 63 | gModulePattern = r"\n[-\w]+\s*\(([^,]+),\s*BaseAddress=%(Address)s,\s*EntryPoint=%(Address)s,\s*Type=\w+\)\s*\(GUID=([-0-9A-Fa-f]+)[^)]*\)"\r |
| | 64 | gMapFileItemPattern = re.compile(gModulePattern % {"Address" : "(-?0[xX][0-9A-Fa-f]+)"})\r |
| | 65 | \r |
| | 66 | ## Pattern to find all module referenced header files in source files\r |
| | 67 | gIncludePattern = re.compile(r'#include\s*["<]([^">]+)[">]')\r |
| | 68 | gIncludePattern2 = re.compile(r"#include\s+EFI_([A-Z_]+)\s*[(]\s*(\w+)\s*[)]")\r |
| | 69 | \r |
| | 70 | ## Pattern to find the entry point for EDK module using EDKII Glue library\r |
| | 71 | gGlueLibEntryPoint = re.compile(r"__EDKII_GLUE_MODULE_ENTRY_POINT__\s*=\s*(\w+)")\r |
| | 72 | \r |
| | 73 | ## Tags for MaxLength of line in report\r |
| | 74 | gLineMaxLength = 120\r |
| | 75 | \r |
| | 76 | ## Tags for end of line in report\r |
| | 77 | gEndOfLine = "\r\n"\r |
| | 78 | \r |
| | 79 | ## Tags for section start, end and separator\r |
| | 80 | gSectionStart = ">" + "=" * (gLineMaxLength - 2) + "<"\r |
| | 81 | gSectionEnd = "<" + "=" * (gLineMaxLength - 2) + ">" + "\n"\r |
| | 82 | gSectionSep = "=" * gLineMaxLength\r |
| | 83 | \r |
| | 84 | ## Tags for subsection start, end and separator\r |
| | 85 | gSubSectionStart = ">" + "-" * (gLineMaxLength - 2) + "<"\r |
| | 86 | gSubSectionEnd = "<" + "-" * (gLineMaxLength - 2) + ">"\r |
| | 87 | gSubSectionSep = "-" * gLineMaxLength\r |
| | 88 | \r |
| | 89 | \r |
| | 90 | ## The look up table to map PCD type to pair of report display type and DEC type\r |
| | 91 | gPcdTypeMap = {\r |
| | 92 | TAB_PCDS_FIXED_AT_BUILD : ('FIXED', TAB_PCDS_FIXED_AT_BUILD),\r |
| | 93 | TAB_PCDS_PATCHABLE_IN_MODULE: ('PATCH', TAB_PCDS_PATCHABLE_IN_MODULE),\r |
| | 94 | TAB_PCDS_FEATURE_FLAG : ('FLAG', TAB_PCDS_FEATURE_FLAG),\r |
| | 95 | TAB_PCDS_DYNAMIC : ('DYN', TAB_PCDS_DYNAMIC),\r |
| | 96 | TAB_PCDS_DYNAMIC_HII : ('DYNHII', TAB_PCDS_DYNAMIC),\r |
| | 97 | TAB_PCDS_DYNAMIC_VPD : ('DYNVPD', TAB_PCDS_DYNAMIC),\r |
| | 98 | TAB_PCDS_DYNAMIC_EX : ('DEX', TAB_PCDS_DYNAMIC_EX),\r |
| | 99 | TAB_PCDS_DYNAMIC_EX_HII : ('DEXHII', TAB_PCDS_DYNAMIC_EX),\r |
| | 100 | TAB_PCDS_DYNAMIC_EX_VPD : ('DEXVPD', TAB_PCDS_DYNAMIC_EX),\r |
| | 101 | }\r |
| | 102 | \r |
| | 103 | ## The look up table to map module type to driver type\r |
| | 104 | gDriverTypeMap = {\r |
| | 105 | SUP_MODULE_SEC : '0x3 (SECURITY_CORE)',\r |
| | 106 | SUP_MODULE_PEI_CORE : '0x4 (PEI_CORE)',\r |
| | 107 | SUP_MODULE_PEIM : '0x6 (PEIM)',\r |
| | 108 | SUP_MODULE_DXE_CORE : '0x5 (DXE_CORE)',\r |
| | 109 | SUP_MODULE_DXE_DRIVER : '0x7 (DRIVER)',\r |
| | 110 | SUP_MODULE_DXE_SAL_DRIVER : '0x7 (DRIVER)',\r |
| | 111 | SUP_MODULE_DXE_SMM_DRIVER : '0x7 (DRIVER)',\r |
| | 112 | SUP_MODULE_DXE_RUNTIME_DRIVER: '0x7 (DRIVER)',\r |
| | 113 | SUP_MODULE_UEFI_DRIVER : '0x7 (DRIVER)',\r |
| | 114 | SUP_MODULE_UEFI_APPLICATION : '0x9 (APPLICATION)',\r |
| | 115 | SUP_MODULE_SMM_CORE : '0xD (SMM_CORE)',\r |
| | 116 | 'SMM_DRIVER' : '0xA (SMM)', # Extension of module type to support PI 1.1 SMM drivers\r |
| | 117 | SUP_MODULE_MM_STANDALONE : '0xE (MM_STANDALONE)',\r |
| | 118 | SUP_MODULE_MM_CORE_STANDALONE : '0xF (MM_CORE_STANDALONE)'\r |
| | 119 | }\r |
| | 120 | \r |
| | 121 | ## The look up table of the supported opcode in the dependency expression binaries\r |
| | 122 | gOpCodeList = ["BEFORE", "AFTER", "PUSH", "AND", "OR", "NOT", "TRUE", "FALSE", "END", "SOR"]\r |
| | 123 | \r |
| | 124 | ## Save VPD Pcd\r |
| | 125 | VPDPcdList = []\r |
| | 126 | \r |
| | 127 | ##\r |
| | 128 | # Writes a string to the file object.\r |
| | 129 | #\r |
| | 130 | # This function writes a string to the file object and a new line is appended\r |
| | 131 | # afterwards. It may optionally wraps the string for better readability.\r |
| | 132 | #\r |
| | 133 | # @File The file object to write\r |
| | 134 | # @String The string to be written to the file\r |
| | 135 | # @Wrapper Indicates whether to wrap the string\r |
| | 136 | #\r |
| | 137 | def FileWrite(File, String, Wrapper=False):\r |
| | 138 | if Wrapper:\r |
| | 139 | String = textwrap.fill(String, 120)\r |
| | 140 | File.append(String + gEndOfLine)\r |
| | 141 | \r |
| | 142 | def ByteArrayForamt(Value):\r |
| | 143 | IsByteArray = False\r |
| | 144 | SplitNum = 16\r |
| | 145 | ArrayList = []\r |
| | 146 | if Value.startswith('{') and Value.endswith('}') and not Value.startswith("{CODE("):\r |
| | 147 | Value = Value[1:-1]\r |
| | 148 | ValueList = Value.split(',')\r |
| | 149 | if len(ValueList) >= SplitNum:\r |
| | 150 | IsByteArray = True\r |
| | 151 | if IsByteArray:\r |
| | 152 | if ValueList:\r |
| | 153 | Len = len(ValueList)/SplitNum\r |
| | 154 | for i, element in enumerate(ValueList):\r |
| | 155 | ValueList[i] = '0x%02X' % int(element.strip(), 16)\r |
| | 156 | if Len:\r |
| | 157 | Id = 0\r |
| | 158 | while (Id <= Len):\r |
| | 159 | End = min(SplitNum*(Id+1), len(ValueList))\r |
| | 160 | Str = ','.join(ValueList[SplitNum*Id : End])\r |
| | 161 | if End == len(ValueList):\r |
| | 162 | Str += '}'\r |
| | 163 | ArrayList.append(Str)\r |
| | 164 | break\r |
| | 165 | else:\r |
| | 166 | Str += ','\r |
| | 167 | ArrayList.append(Str)\r |
| | 168 | Id += 1\r |
| | 169 | else:\r |
| | 170 | ArrayList = [Value + '}']\r |
| | 171 | return IsByteArray, ArrayList\r |
| | 172 | \r |
| | 173 | ##\r |
| | 174 | # Find all the header file that the module source directly includes.\r |
| | 175 | #\r |
| | 176 | # This function scans source code to find all header files the module may\r |
| | 177 | # include. This is not accurate but very effective to find all the header\r |
| | 178 | # file the module might include with #include statement.\r |
| | 179 | #\r |
| | 180 | # @Source The source file name\r |
| | 181 | # @IncludePathList The list of include path to find the source file.\r |
| | 182 | # @IncludeFiles The dictionary of current found include files.\r |
| | 183 | #\r |
| | 184 | def FindIncludeFiles(Source, IncludePathList, IncludeFiles):\r |
| | 185 | FileContents = open(Source).read()\r |
| | 186 | #\r |
| | 187 | # Find header files with pattern #include "XXX.h" or #include <XXX.h>\r |
| | 188 | #\r |
| | 189 | for Match in gIncludePattern.finditer(FileContents):\r |
| | 190 | FileName = Match.group(1).strip()\r |
| | 191 | for Dir in [os.path.dirname(Source)] + IncludePathList:\r |
| | 192 | FullFileName = os.path.normpath(os.path.join(Dir, FileName))\r |
| | 193 | if os.path.exists(FullFileName):\r |
| | 194 | IncludeFiles[FullFileName.lower().replace("\\", "/")] = FullFileName\r |
| | 195 | break\r |
| | 196 | \r |
| | 197 | #\r |
| | 198 | # Find header files with pattern like #include EFI_PPI_CONSUMER(XXX)\r |
| | 199 | #\r |
| | 200 | for Match in gIncludePattern2.finditer(FileContents):\r |
| | 201 | Key = Match.group(2)\r |
| | 202 | Type = Match.group(1)\r |
| | 203 | if "ARCH_PROTOCOL" in Type:\r |
| | 204 | FileName = "ArchProtocol/%(Key)s/%(Key)s.h" % {"Key" : Key}\r |
| | 205 | elif "PROTOCOL" in Type:\r |
| | 206 | FileName = "Protocol/%(Key)s/%(Key)s.h" % {"Key" : Key}\r |
| | 207 | elif "PPI" in Type:\r |
| | 208 | FileName = "Ppi/%(Key)s/%(Key)s.h" % {"Key" : Key}\r |
| | 209 | elif TAB_GUID in Type:\r |
| | 210 | FileName = "Guid/%(Key)s/%(Key)s.h" % {"Key" : Key}\r |
| | 211 | else:\r |
| | 212 | continue\r |
| | 213 | for Dir in IncludePathList:\r |
| | 214 | FullFileName = os.path.normpath(os.path.join(Dir, FileName))\r |
| | 215 | if os.path.exists(FullFileName):\r |
| | 216 | IncludeFiles[FullFileName.lower().replace("\\", "/")] = FullFileName\r |
| | 217 | break\r |
| | 218 | \r |
| | 219 | ## Split each lines in file\r |
| | 220 | #\r |
| | 221 | # This method is used to split the lines in file to make the length of each line\r |
| | 222 | # less than MaxLength.\r |
| | 223 | #\r |
| | 224 | # @param Content The content of file\r |
| | 225 | # @param MaxLength The Max Length of the line\r |
| | 226 | #\r |
| | 227 | def FileLinesSplit(Content=None, MaxLength=None):\r |
| | 228 | ContentList = Content.split(TAB_LINE_BREAK)\r |
| | 229 | NewContent = ''\r |
| | 230 | NewContentList = []\r |
| | 231 | for Line in ContentList:\r |
| | 232 | while len(Line.rstrip()) > MaxLength:\r |
| | 233 | LineSpaceIndex = Line.rfind(TAB_SPACE_SPLIT, 0, MaxLength)\r |
| | 234 | LineSlashIndex = Line.rfind(TAB_SLASH, 0, MaxLength)\r |
| | 235 | LineBackSlashIndex = Line.rfind(TAB_BACK_SLASH, 0, MaxLength)\r |
| | 236 | if max(LineSpaceIndex, LineSlashIndex, LineBackSlashIndex) > 0:\r |
| | 237 | LineBreakIndex = max(LineSpaceIndex, LineSlashIndex, LineBackSlashIndex)\r |
| | 238 | else:\r |
| | 239 | LineBreakIndex = MaxLength\r |
| | 240 | NewContentList.append(Line[:LineBreakIndex])\r |
| | 241 | Line = Line[LineBreakIndex:]\r |
| | 242 | if Line:\r |
| | 243 | NewContentList.append(Line)\r |
| | 244 | for NewLine in NewContentList:\r |
| | 245 | NewContent += NewLine + TAB_LINE_BREAK\r |
| | 246 | \r |
| | 247 | NewContent = NewContent.replace(gEndOfLine, TAB_LINE_BREAK).replace('\r\r\n', gEndOfLine)\r |
| | 248 | return NewContent\r |
| | 249 | \r |
| | 250 | \r |
| | 251 | \r |
| | 252 | ##\r |
| | 253 | # Parse binary dependency expression section\r |
| | 254 | #\r |
| | 255 | # This utility class parses the dependency expression section and translate the readable\r |
| | 256 | # GUID name and value.\r |
| | 257 | #\r |
| | 258 | class DepexParser(object):\r |
| | 259 | ##\r |
| | 260 | # Constructor function for class DepexParser\r |
| | 261 | #\r |
| | 262 | # This constructor function collect GUID values so that the readable\r |
| | 263 | # GUID name can be translated.\r |
| | 264 | #\r |
| | 265 | # @param self The object pointer\r |
| | 266 | # @param Wa Workspace context information\r |
| | 267 | #\r |
| | 268 | def __init__(self, Wa):\r |
| | 269 | self._GuidDb = {}\r |
| | 270 | for Pa in Wa.AutoGenObjectList:\r |
| | 271 | for Package in Pa.PackageList:\r |
| | 272 | for Protocol in Package.Protocols:\r |
| | 273 | GuidValue = GuidStructureStringToGuidString(Package.Protocols[Protocol])\r |
| | 274 | self._GuidDb[GuidValue.upper()] = Protocol\r |
| | 275 | for Ppi in Package.Ppis:\r |
| | 276 | GuidValue = GuidStructureStringToGuidString(Package.Ppis[Ppi])\r |
| | 277 | self._GuidDb[GuidValue.upper()] = Ppi\r |
| | 278 | for Guid in Package.Guids:\r |
| | 279 | GuidValue = GuidStructureStringToGuidString(Package.Guids[Guid])\r |
| | 280 | self._GuidDb[GuidValue.upper()] = Guid\r |
| | 281 | for Ma in Pa.ModuleAutoGenList:\r |
| | 282 | for Pcd in Ma.FixedVoidTypePcds:\r |
| | 283 | PcdValue = Ma.FixedVoidTypePcds[Pcd]\r |
| | 284 | if len(PcdValue.split(',')) == 16:\r |
| | 285 | GuidValue = GuidStructureByteArrayToGuidString(PcdValue)\r |
| | 286 | self._GuidDb[GuidValue.upper()] = Pcd\r |
| | 287 | ##\r |
| | 288 | # Parse the binary dependency expression files.\r |
| | 289 | #\r |
| | 290 | # This function parses the binary dependency expression file and translate it\r |
| | 291 | # to the instruction list.\r |
| | 292 | #\r |
| | 293 | # @param self The object pointer\r |
| | 294 | # @param DepexFileName The file name of binary dependency expression file.\r |
| | 295 | #\r |
| | 296 | def ParseDepexFile(self, DepexFileName):\r |
| | 297 | DepexFile = open(DepexFileName, "rb")\r |
| | 298 | DepexStatement = []\r |
| | 299 | OpCode = DepexFile.read(1)\r |
| | 300 | while OpCode:\r |
| | 301 | Statement = gOpCodeList[struct.unpack("B", OpCode)[0]]\r |
| | 302 | if Statement in ["BEFORE", "AFTER", "PUSH"]:\r |
| | 303 | GuidValue = "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X" % \\r |
| | 304 | struct.unpack(PACK_PATTERN_GUID, DepexFile.read(16))\r |
| | 305 | GuidString = self._GuidDb.get(GuidValue, GuidValue)\r |
| | 306 | Statement = "%s %s" % (Statement, GuidString)\r |
| | 307 | DepexStatement.append(Statement)\r |
| | 308 | OpCode = DepexFile.read(1)\r |
| | 309 | \r |
| | 310 | return DepexStatement\r |
| | 311 | \r |
| | 312 | ##\r |
| | 313 | # Reports library information\r |
| | 314 | #\r |
| | 315 | # This class reports the module library subsection in the build report file.\r |
| | 316 | #\r |
| | 317 | class LibraryReport(object):\r |
| | 318 | ##\r |
| | 319 | # Constructor function for class LibraryReport\r |
| | 320 | #\r |
| | 321 | # This constructor function generates LibraryReport object for\r |
| | 322 | # a module.\r |
| | 323 | #\r |
| | 324 | # @param self The object pointer\r |
| | 325 | # @param M Module context information\r |
| | 326 | #\r |
| | 327 | def __init__(self, M):\r |
| | 328 | self.LibraryList = []\r |
| | 329 | \r |
| | 330 | for Lib in M.DependentLibraryList:\r |
| | 331 | LibInfPath = str(Lib)\r |
| | 332 | LibClassList = Lib.LibraryClass[0].LibraryClass\r |
| | 333 | LibConstructorList = Lib.ConstructorList\r |
| | 334 | LibDesstructorList = Lib.DestructorList\r |
| | 335 | LibDepexList = Lib.DepexExpression[M.Arch, M.ModuleType]\r |
| | 336 | for LibAutoGen in M.LibraryAutoGenList:\r |
| | 337 | if LibInfPath == LibAutoGen.MetaFile.Path:\r |
| | 338 | LibTime = LibAutoGen.BuildTime\r |
| | 339 | break\r |
| | 340 | self.LibraryList.append((LibInfPath, LibClassList, LibConstructorList, LibDesstructorList, LibDepexList, LibTime))\r |
| | 341 | \r |
| | 342 | ##\r |
| | 343 | # Generate report for module library information\r |
| | 344 | #\r |
| | 345 | # This function generates report for the module library.\r |
| | 346 | # If the module is EDKII style one, the additional library class, library\r |
| | 347 | # constructor/destructor and dependency expression may also be reported.\r |
| | 348 | #\r |
| | 349 | # @param self The object pointer\r |
| | 350 | # @param File The file object for report\r |
| | 351 | #\r |
| | 352 | def GenerateReport(self, File):\r |
| | 353 | if len(self.LibraryList) > 0:\r |
| | 354 | FileWrite(File, gSubSectionStart)\r |
| | 355 | FileWrite(File, TAB_BRG_LIBRARY)\r |
| | 356 | FileWrite(File, gSubSectionSep)\r |
| | 357 | for LibraryItem in self.LibraryList:\r |
| | 358 | LibInfPath = LibraryItem[0]\r |
| | 359 | FileWrite(File, LibInfPath)\r |
| | 360 | \r |
| | 361 | LibClass = LibraryItem[1]\r |
| | 362 | EdkIILibInfo = ""\r |
| | 363 | LibConstructor = " ".join(LibraryItem[2])\r |
| | 364 | if LibConstructor:\r |
| | 365 | EdkIILibInfo += " C = " + LibConstructor\r |
| | 366 | LibDestructor = " ".join(LibraryItem[3])\r |
| | 367 | if LibDestructor:\r |
| | 368 | EdkIILibInfo += " D = " + LibDestructor\r |
| | 369 | LibDepex = " ".join(LibraryItem[4])\r |
| | 370 | if LibDepex:\r |
| | 371 | EdkIILibInfo += " Depex = " + LibDepex\r |
| | 372 | if LibraryItem[5]:\r |
| | 373 | EdkIILibInfo += " Time = " + LibraryItem[5]\r |
| | 374 | if EdkIILibInfo:\r |
| | 375 | FileWrite(File, "{%s: %s}" % (LibClass, EdkIILibInfo))\r |
| | 376 | else:\r |
| | 377 | FileWrite(File, "{%s}" % LibClass)\r |
| | 378 | \r |
| | 379 | FileWrite(File, gSubSectionEnd)\r |
| | 380 | \r |
| | 381 | ##\r |
| | 382 | # Reports dependency expression information\r |
| | 383 | #\r |
| | 384 | # This class reports the module dependency expression subsection in the build report file.\r |
| | 385 | #\r |
| | 386 | class DepexReport(object):\r |
| | 387 | ##\r |
| | 388 | # Constructor function for class DepexReport\r |
| | 389 | #\r |
| | 390 | # This constructor function generates DepexReport object for\r |
| | 391 | # a module. If the module source contains the DXS file (usually EDK\r |
| | 392 | # style module), it uses the dependency in DXS file; otherwise,\r |
| | 393 | # it uses the dependency expression from its own INF [Depex] section\r |
| | 394 | # and then merges with the ones from its dependent library INF.\r |
| | 395 | #\r |
| | 396 | # @param self The object pointer\r |
| | 397 | # @param M Module context information\r |
| | 398 | #\r |
| | 399 | def __init__(self, M):\r |
| | 400 | self.Depex = ""\r |
| | 401 | self._DepexFileName = os.path.join(M.BuildDir, "OUTPUT", M.Module.BaseName + ".depex")\r |
| | 402 | ModuleType = M.ModuleType\r |
| | 403 | if not ModuleType:\r |
| | 404 | ModuleType = COMPONENT_TO_MODULE_MAP_DICT.get(M.ComponentType, "")\r |
| | 405 | \r |
| | 406 | 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]:\r |
| | 407 | return\r |
| | 408 | \r |
| | 409 | for Source in M.SourceFileList:\r |
| | 410 | if os.path.splitext(Source.Path)[1].lower() == ".dxs":\r |
| | 411 | Match = gDxsDependencyPattern.search(open(Source.Path).read())\r |
| | 412 | if Match:\r |
| | 413 | self.Depex = Match.group(1).strip()\r |
| | 414 | self.Source = "DXS"\r |
| | 415 | break\r |
| | 416 | else:\r |
| | 417 | self.Depex = M.DepexExpressionDict.get(M.ModuleType, "")\r |
| | 418 | self.ModuleDepex = " ".join(M.Module.DepexExpression[M.Arch, M.ModuleType])\r |
| | 419 | if not self.ModuleDepex:\r |
| | 420 | self.ModuleDepex = "(None)"\r |
| | 421 | \r |
| | 422 | LibDepexList = []\r |
| | 423 | for Lib in M.DependentLibraryList:\r |
| | 424 | LibDepex = " ".join(Lib.DepexExpression[M.Arch, M.ModuleType]).strip()\r |
| | 425 | if LibDepex != "":\r |
| | 426 | LibDepexList.append("(" + LibDepex + ")")\r |
| | 427 | self.LibraryDepex = " AND ".join(LibDepexList)\r |
| | 428 | if not self.LibraryDepex:\r |
| | 429 | self.LibraryDepex = "(None)"\r |
| | 430 | self.Source = "INF"\r |
| | 431 | \r |
| | 432 | ##\r |
| | 433 | # Generate report for module dependency expression information\r |
| | 434 | #\r |
| | 435 | # This function generates report for the module dependency expression.\r |
| | 436 | #\r |
| | 437 | # @param self The object pointer\r |
| | 438 | # @param File The file object for report\r |
| | 439 | # @param GlobalDepexParser The platform global Dependency expression parser object\r |
| | 440 | #\r |
| | 441 | def GenerateReport(self, File, GlobalDepexParser):\r |
| | 442 | if not self.Depex:\r |
| | 443 | return\r |
| | 444 | FileWrite(File, gSubSectionStart)\r |
| | 445 | if os.path.isfile(self._DepexFileName):\r |
| | 446 | try:\r |
| | 447 | DepexStatements = GlobalDepexParser.ParseDepexFile(self._DepexFileName)\r |
| | 448 | FileWrite(File, "Final Dependency Expression (DEPEX) Instructions")\r |
| | 449 | for DepexStatement in DepexStatements:\r |
| | 450 | FileWrite(File, " %s" % DepexStatement)\r |
| | 451 | FileWrite(File, gSubSectionSep)\r |
| | 452 | except:\r |
| | 453 | EdkLogger.warn(None, "Dependency expression file is corrupted", self._DepexFileName)\r |
| | 454 | \r |
| | 455 | FileWrite(File, "Dependency Expression (DEPEX) from %s" % self.Source)\r |
| | 456 | \r |
| | 457 | if self.Source == "INF":\r |
| | 458 | FileWrite(File, self.Depex, True)\r |
| | 459 | FileWrite(File, gSubSectionSep)\r |
| | 460 | FileWrite(File, "From Module INF: %s" % self.ModuleDepex, True)\r |
| | 461 | FileWrite(File, "From Library INF: %s" % self.LibraryDepex, True)\r |
| | 462 | else:\r |
| | 463 | FileWrite(File, self.Depex)\r |
| | 464 | FileWrite(File, gSubSectionEnd)\r |
| | 465 | \r |
| | 466 | ##\r |
| | 467 | # Reports dependency expression information\r |
| | 468 | #\r |
| | 469 | # This class reports the module build flags subsection in the build report file.\r |
| | 470 | #\r |
| | 471 | class BuildFlagsReport(object):\r |
| | 472 | ##\r |
| | 473 | # Constructor function for class BuildFlagsReport\r |
| | 474 | #\r |
| | 475 | # This constructor function generates BuildFlagsReport object for\r |
| | 476 | # a module. It reports the build tool chain tag and all relevant\r |
| | 477 | # build flags to build the module.\r |
| | 478 | #\r |
| | 479 | # @param self The object pointer\r |
| | 480 | # @param M Module context information\r |
| | 481 | #\r |
| | 482 | def __init__(self, M):\r |
| | 483 | BuildOptions = {}\r |
| | 484 | #\r |
| | 485 | # Add build flags according to source file extension so that\r |
| | 486 | # irrelevant ones can be filtered out.\r |
| | 487 | #\r |
| | 488 | for Source in M.SourceFileList:\r |
| | 489 | Ext = os.path.splitext(Source.File)[1].lower()\r |
| | 490 | if Ext in [".c", ".cc", ".cpp"]:\r |
| | 491 | BuildOptions["CC"] = 1\r |
| | 492 | elif Ext in [".s", ".asm"]:\r |
| | 493 | BuildOptions["PP"] = 1\r |
| | 494 | BuildOptions["ASM"] = 1\r |
| | 495 | elif Ext in [".vfr"]:\r |
| | 496 | BuildOptions["VFRPP"] = 1\r |
| | 497 | BuildOptions["VFR"] = 1\r |
| | 498 | elif Ext in [".dxs"]:\r |
| | 499 | BuildOptions["APP"] = 1\r |
| | 500 | BuildOptions["CC"] = 1\r |
| | 501 | elif Ext in [".asl"]:\r |
| | 502 | BuildOptions["ASLPP"] = 1\r |
| | 503 | BuildOptions["ASL"] = 1\r |
| | 504 | elif Ext in [".aslc"]:\r |
| | 505 | BuildOptions["ASLCC"] = 1\r |
| | 506 | BuildOptions["ASLDLINK"] = 1\r |
| | 507 | BuildOptions["CC"] = 1\r |
| | 508 | elif Ext in [".asm16"]:\r |
| | 509 | BuildOptions["ASMLINK"] = 1\r |
| | 510 | BuildOptions["SLINK"] = 1\r |
| | 511 | BuildOptions["DLINK"] = 1\r |
| | 512 | \r |
| | 513 | #\r |
| | 514 | # Save module build flags.\r |
| | 515 | #\r |
| | 516 | self.ToolChainTag = M.ToolChain\r |
| | 517 | self.BuildFlags = {}\r |
| | 518 | for Tool in BuildOptions:\r |
| | 519 | self.BuildFlags[Tool + "_FLAGS"] = M.BuildOption.get(Tool, {}).get("FLAGS", "")\r |
| | 520 | \r |
| | 521 | ##\r |
| | 522 | # Generate report for module build flags information\r |
| | 523 | #\r |
| | 524 | # This function generates report for the module build flags expression.\r |
| | 525 | #\r |
| | 526 | # @param self The object pointer\r |
| | 527 | # @param File The file object for report\r |
| | 528 | #\r |
| | 529 | def GenerateReport(self, File):\r |
| | 530 | FileWrite(File, gSubSectionStart)\r |
| | 531 | FileWrite(File, "Build Flags")\r |
| | 532 | FileWrite(File, "Tool Chain Tag: %s" % self.ToolChainTag)\r |
| | 533 | for Tool in self.BuildFlags:\r |
| | 534 | FileWrite(File, gSubSectionSep)\r |
| | 535 | FileWrite(File, "%s = %s" % (Tool, self.BuildFlags[Tool]), True)\r |
| | 536 | \r |
| | 537 | FileWrite(File, gSubSectionEnd)\r |
| | 538 | \r |
| | 539 | \r |
| | 540 | ##\r |
| | 541 | # Reports individual module information\r |
| | 542 | #\r |
| | 543 | # This class reports the module section in the build report file.\r |
| | 544 | # It comprises of module summary, module PCD, library, dependency expression,\r |
| | 545 | # build flags sections.\r |
| | 546 | #\r |
| | 547 | class ModuleReport(object):\r |
| | 548 | ##\r |
| | 549 | # Constructor function for class ModuleReport\r |
| | 550 | #\r |
| | 551 | # This constructor function generates ModuleReport object for\r |
| | 552 | # a separate module in a platform build.\r |
| | 553 | #\r |
| | 554 | # @param self The object pointer\r |
| | 555 | # @param M Module context information\r |
| | 556 | # @param ReportType The kind of report items in the final report file\r |
| | 557 | #\r |
| | 558 | def __init__(self, M, ReportType):\r |
| | 559 | self.ModuleName = M.Module.BaseName\r |
| | 560 | self.ModuleInfPath = M.MetaFile.File\r |
| | 561 | self.ModuleArch = M.Arch\r |
| | 562 | self.FileGuid = M.Guid\r |
| | 563 | self.Size = 0\r |
| | 564 | self.BuildTimeStamp = None\r |
| | 565 | self.Hash = 0\r |
| | 566 | self.DriverType = ""\r |
| | 567 | if not M.IsLibrary:\r |
| | 568 | ModuleType = M.ModuleType\r |
| | 569 | if not ModuleType:\r |
| | 570 | ModuleType = COMPONENT_TO_MODULE_MAP_DICT.get(M.ComponentType, "")\r |
| | 571 | #\r |
| | 572 | # If a module complies to PI 1.1, promote Module type to "SMM_DRIVER"\r |
| | 573 | #\r |
| | 574 | if ModuleType == SUP_MODULE_DXE_SMM_DRIVER:\r |
| | 575 | PiSpec = M.Module.Specification.get("PI_SPECIFICATION_VERSION", "0x00010000")\r |
| | 576 | if int(PiSpec, 0) >= 0x0001000A:\r |
| | 577 | ModuleType = "SMM_DRIVER"\r |
| | 578 | self.DriverType = gDriverTypeMap.get(ModuleType, "0x2 (FREE_FORM)")\r |
| | 579 | self.UefiSpecVersion = M.Module.Specification.get("UEFI_SPECIFICATION_VERSION", "")\r |
| | 580 | self.PiSpecVersion = M.Module.Specification.get("PI_SPECIFICATION_VERSION", "")\r |
| | 581 | self.PciDeviceId = M.Module.Defines.get("PCI_DEVICE_ID", "")\r |
| | 582 | self.PciVendorId = M.Module.Defines.get("PCI_VENDOR_ID", "")\r |
| | 583 | self.PciClassCode = M.Module.Defines.get("PCI_CLASS_CODE", "")\r |
| | 584 | self.BuildTime = M.BuildTime\r |
| | 585 | \r |
| | 586 | self._BuildDir = M.BuildDir\r |
| | 587 | self.ModulePcdSet = {}\r |
| | 588 | if "PCD" in ReportType:\r |
| | 589 | #\r |
| | 590 | # Collect all module used PCD set: module INF referenced directly or indirectly.\r |
| | 591 | # It also saves module INF default values of them in case they exist.\r |
| | 592 | #\r |
| | 593 | for Pcd in M.ModulePcdList + M.LibraryPcdList:\r |
| | 594 | self.ModulePcdSet.setdefault((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Type), (Pcd.InfDefaultValue, Pcd.DefaultValue))\r |
| | 595 | \r |
| | 596 | self.LibraryReport = None\r |
| | 597 | if "LIBRARY" in ReportType:\r |
| | 598 | self.LibraryReport = LibraryReport(M)\r |
| | 599 | \r |
| | 600 | self.DepexReport = None\r |
| | 601 | if "DEPEX" in ReportType:\r |
| | 602 | self.DepexReport = DepexReport(M)\r |
| | 603 | \r |
| | 604 | if "BUILD_FLAGS" in ReportType:\r |
| | 605 | self.BuildFlagsReport = BuildFlagsReport(M)\r |
| | 606 | \r |
| | 607 | \r |
| | 608 | ##\r |
| | 609 | # Generate report for module information\r |
| | 610 | #\r |
| | 611 | # This function generates report for separate module expression\r |
| | 612 | # in a platform build.\r |
| | 613 | #\r |
| | 614 | # @param self The object pointer\r |
| | 615 | # @param File The file object for report\r |
| | 616 | # @param GlobalPcdReport The platform global PCD report object\r |
| | 617 | # @param GlobalPredictionReport The platform global Prediction report object\r |
| | 618 | # @param GlobalDepexParser The platform global Dependency expression parser object\r |
| | 619 | # @param ReportType The kind of report items in the final report file\r |
| | 620 | #\r |
| | 621 | def GenerateReport(self, File, GlobalPcdReport, GlobalPredictionReport, GlobalDepexParser, ReportType):\r |
| | 622 | FileWrite(File, gSectionStart)\r |
| | 623 | \r |
| | 624 | FwReportFileName = os.path.join(self._BuildDir, "OUTPUT", self.ModuleName + ".txt")\r |
| | 625 | if os.path.isfile(FwReportFileName):\r |
| | 626 | try:\r |
| | 627 | FileContents = open(FwReportFileName).read()\r |
| | 628 | Match = gModuleSizePattern.search(FileContents)\r |
| | 629 | if Match:\r |
| | 630 | self.Size = int(Match.group(1))\r |
| | 631 | \r |
| | 632 | Match = gTimeStampPattern.search(FileContents)\r |
| | 633 | if Match:\r |
| | 634 | self.BuildTimeStamp = datetime.utcfromtimestamp(int(Match.group(1)))\r |
| | 635 | except IOError:\r |
| | 636 | EdkLogger.warn(None, "Fail to read report file", FwReportFileName)\r |
| | 637 | \r |
| | 638 | if "HASH" in ReportType:\r |
| | 639 | OutputDir = os.path.join(self._BuildDir, "OUTPUT")\r |
| | 640 | DefaultEFIfile = os.path.join(OutputDir, self.ModuleName + ".efi")\r |
| | 641 | if os.path.isfile(DefaultEFIfile):\r |
| | 642 | Tempfile = os.path.join(OutputDir, self.ModuleName + "_hash.tmp")\r |
| | 643 | # rebase the efi image since its base address may not zero\r |
| | 644 | cmd = ["GenFw", "--rebase", str(0), "-o", Tempfile, DefaultEFIfile]\r |
| | 645 | try:\r |
| | 646 | PopenObject = subprocess.Popen(' '.join(cmd), stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)\r |
| | 647 | except Exception as X:\r |
| | 648 | EdkLogger.error("GenFw", COMMAND_FAILURE, ExtraData="%s: %s" % (str(X), cmd[0]))\r |
| | 649 | EndOfProcedure = threading.Event()\r |
| | 650 | EndOfProcedure.clear()\r |
| | 651 | if PopenObject.stderr:\r |
| | 652 | StdErrThread = threading.Thread(target=ReadMessage, args=(PopenObject.stderr, EdkLogger.quiet, EndOfProcedure))\r |
| | 653 | StdErrThread.setName("STDERR-Redirector")\r |
| | 654 | StdErrThread.setDaemon(False)\r |
| | 655 | StdErrThread.start()\r |
| | 656 | # waiting for program exit\r |
| | 657 | PopenObject.wait()\r |
| | 658 | if PopenObject.stderr:\r |
| | 659 | StdErrThread.join()\r |
| | 660 | if PopenObject.returncode != 0:\r |
| | 661 | EdkLogger.error("GenFw", COMMAND_FAILURE, "Failed to generate firmware hash image for %s" % (DefaultEFIfile))\r |
| | 662 | if os.path.isfile(Tempfile):\r |
| | 663 | self.Hash = hashlib.sha1()\r |
| | 664 | buf = open(Tempfile, 'rb').read()\r |
| | 665 | if self.Hash.update(buf):\r |
| | 666 | self.Hash = self.Hash.update(buf)\r |
| | 667 | self.Hash = self.Hash.hexdigest()\r |
| | 668 | os.remove(Tempfile)\r |
| | 669 | \r |
| | 670 | FileWrite(File, "Module Summary")\r |
| | 671 | FileWrite(File, "Module Name: %s" % self.ModuleName)\r |
| | 672 | FileWrite(File, "Module Arch: %s" % self.ModuleArch)\r |
| | 673 | FileWrite(File, "Module INF Path: %s" % self.ModuleInfPath)\r |
| | 674 | FileWrite(File, "File GUID: %s" % self.FileGuid)\r |
| | 675 | if self.Size:\r |
| | 676 | FileWrite(File, "Size: 0x%X (%.2fK)" % (self.Size, self.Size / 1024.0))\r |
| | 677 | if self.Hash:\r |
| | 678 | FileWrite(File, "SHA1 HASH: %s *%s" % (self.Hash, self.ModuleName + ".efi"))\r |
| | 679 | if self.BuildTimeStamp:\r |
| | 680 | FileWrite(File, "Build Time Stamp: %s" % self.BuildTimeStamp)\r |
| | 681 | if self.BuildTime:\r |
| | 682 | FileWrite(File, "Module Build Time: %s" % self.BuildTime)\r |
| | 683 | if self.DriverType:\r |
| | 684 | FileWrite(File, "Driver Type: %s" % self.DriverType)\r |
| | 685 | if self.UefiSpecVersion:\r |
| | 686 | FileWrite(File, "UEFI Spec Version: %s" % self.UefiSpecVersion)\r |
| | 687 | if self.PiSpecVersion:\r |
| | 688 | FileWrite(File, "PI Spec Version: %s" % self.PiSpecVersion)\r |
| | 689 | if self.PciDeviceId:\r |
| | 690 | FileWrite(File, "PCI Device ID: %s" % self.PciDeviceId)\r |
| | 691 | if self.PciVendorId:\r |
| | 692 | FileWrite(File, "PCI Vendor ID: %s" % self.PciVendorId)\r |
| | 693 | if self.PciClassCode:\r |
| | 694 | FileWrite(File, "PCI Class Code: %s" % self.PciClassCode)\r |
| | 695 | \r |
| | 696 | FileWrite(File, gSectionSep)\r |
| | 697 | \r |
| | 698 | if "PCD" in ReportType:\r |
| | 699 | GlobalPcdReport.GenerateReport(File, self.ModulePcdSet,self.FileGuid)\r |
| | 700 | \r |
| | 701 | if "LIBRARY" in ReportType:\r |
| | 702 | self.LibraryReport.GenerateReport(File)\r |
| | 703 | \r |
| | 704 | if "DEPEX" in ReportType:\r |
| | 705 | self.DepexReport.GenerateReport(File, GlobalDepexParser)\r |
| | 706 | \r |
| | 707 | if "BUILD_FLAGS" in ReportType:\r |
| | 708 | self.BuildFlagsReport.GenerateReport(File)\r |
| | 709 | \r |
| | 710 | if "FIXED_ADDRESS" in ReportType and self.FileGuid:\r |
| | 711 | GlobalPredictionReport.GenerateReport(File, self.FileGuid)\r |
| | 712 | \r |
| | 713 | FileWrite(File, gSectionEnd)\r |
| | 714 | \r |
| | 715 | def ReadMessage(From, To, ExitFlag):\r |
| | 716 | while True:\r |
| | 717 | # read one line a time\r |
| | 718 | Line = From.readline()\r |
| | 719 | # empty string means "end"\r |
| | 720 | if Line is not None and Line != b"":\r |
| | 721 | To(Line.rstrip().decode(encoding='utf-8', errors='ignore'))\r |
| | 722 | else:\r |
| | 723 | break\r |
| | 724 | if ExitFlag.isSet():\r |
| | 725 | break\r |
| | 726 | \r |
| | 727 | ##\r |
| | 728 | # Reports platform and module PCD information\r |
| | 729 | #\r |
| | 730 | # This class reports the platform PCD section and module PCD subsection\r |
| | 731 | # in the build report file.\r |
| | 732 | #\r |
| | 733 | class PcdReport(object):\r |
| | 734 | ##\r |
| | 735 | # Constructor function for class PcdReport\r |
| | 736 | #\r |
| | 737 | # This constructor function generates PcdReport object a platform build.\r |
| | 738 | # It collects the whole PCD database from platform DSC files, platform\r |
| | 739 | # flash description file and package DEC files.\r |
| | 740 | #\r |
| | 741 | # @param self The object pointer\r |
| | 742 | # @param Wa Workspace context information\r |
| | 743 | #\r |
| | 744 | def __init__(self, Wa):\r |
| | 745 | self.AllPcds = {}\r |
| | 746 | self.UnusedPcds = {}\r |
| | 747 | self.ConditionalPcds = {}\r |
| | 748 | self.MaxLen = 0\r |
| | 749 | self.Arch = None\r |
| | 750 | if Wa.FdfProfile:\r |
| | 751 | self.FdfPcdSet = Wa.FdfProfile.PcdDict\r |
| | 752 | else:\r |
| | 753 | self.FdfPcdSet = {}\r |
| | 754 | \r |
| | 755 | self.DefaultStoreSingle = True\r |
| | 756 | self.SkuSingle = True\r |
| | 757 | if GlobalData.gDefaultStores and len(GlobalData.gDefaultStores) > 1:\r |
| | 758 | self.DefaultStoreSingle = False\r |
| | 759 | if GlobalData.gSkuids and len(GlobalData.gSkuids) > 1:\r |
| | 760 | self.SkuSingle = False\r |
| | 761 | \r |
| | 762 | self.ModulePcdOverride = {}\r |
| | 763 | for Pa in Wa.AutoGenObjectList:\r |
| | 764 | self.Arch = Pa.Arch\r |
| | 765 | #\r |
| | 766 | # Collect all platform referenced PCDs and grouped them by PCD token space\r |
| | 767 | # GUID C Names\r |
| | 768 | #\r |
| | 769 | for Pcd in Pa.AllPcdList:\r |
| | 770 | PcdList = self.AllPcds.setdefault(Pcd.TokenSpaceGuidCName, {}).setdefault(Pcd.Type, [])\r |
| | 771 | if Pcd not in PcdList:\r |
| | 772 | PcdList.append(Pcd)\r |
| | 773 | if len(Pcd.TokenCName) > self.MaxLen:\r |
| | 774 | self.MaxLen = len(Pcd.TokenCName)\r |
| | 775 | #\r |
| | 776 | # Collect the PCD defined in DSC/FDF file, but not used in module\r |
| | 777 | #\r |
| | 778 | UnusedPcdFullList = []\r |
| | 779 | StructPcdDict = GlobalData.gStructurePcd.get(self.Arch, collections.OrderedDict())\r |
| | 780 | for Name, Guid in StructPcdDict:\r |
| | 781 | if (Name, Guid) not in Pa.Platform.Pcds:\r |
| | 782 | Pcd = StructPcdDict[(Name, Guid)]\r |
| | 783 | PcdList = self.AllPcds.setdefault(Guid, {}).setdefault(Pcd.Type, [])\r |
| | 784 | if Pcd not in PcdList and Pcd not in UnusedPcdFullList:\r |
| | 785 | UnusedPcdFullList.append(Pcd)\r |
| | 786 | for item in Pa.Platform.Pcds:\r |
| | 787 | Pcd = Pa.Platform.Pcds[item]\r |
| | 788 | if not Pcd.Type:\r |
| | 789 | # check the Pcd in FDF file, whether it is used in module first\r |
| | 790 | for T in PCD_TYPE_LIST:\r |
| | 791 | PcdList = self.AllPcds.setdefault(Pcd.TokenSpaceGuidCName, {}).setdefault(T, [])\r |
| | 792 | if Pcd in PcdList:\r |
| | 793 | Pcd.Type = T\r |
| | 794 | break\r |
| | 795 | if not Pcd.Type:\r |
| | 796 | PcdTypeFlag = False\r |
| | 797 | for package in Pa.PackageList:\r |
| | 798 | for T in PCD_TYPE_LIST:\r |
| | 799 | if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, T) in package.Pcds:\r |
| | 800 | Pcd.Type = T\r |
| | 801 | PcdTypeFlag = True\r |
| | 802 | if not Pcd.DatumType:\r |
| | 803 | Pcd.DatumType = package.Pcds[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName, T)].DatumType\r |
| | 804 | break\r |
| | 805 | if PcdTypeFlag:\r |
| | 806 | break\r |
| | 807 | if not Pcd.DatumType:\r |
| | 808 | PcdType = Pcd.Type\r |
| | 809 | # Try to remove Hii and Vpd suffix\r |
| | 810 | if PcdType.startswith(TAB_PCDS_DYNAMIC_EX):\r |
| | 811 | PcdType = TAB_PCDS_DYNAMIC_EX\r |
| | 812 | elif PcdType.startswith(TAB_PCDS_DYNAMIC):\r |
| | 813 | PcdType = TAB_PCDS_DYNAMIC\r |
| | 814 | for package in Pa.PackageList:\r |
| | 815 | if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, PcdType) in package.Pcds:\r |
| | 816 | Pcd.DatumType = package.Pcds[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName, PcdType)].DatumType\r |
| | 817 | break\r |
| | 818 | \r |
| | 819 | PcdList = self.AllPcds.setdefault(Pcd.TokenSpaceGuidCName, {}).setdefault(Pcd.Type, [])\r |
| | 820 | UnusedPcdList = self.UnusedPcds.setdefault(Pcd.TokenSpaceGuidCName, {}).setdefault(Pcd.Type, [])\r |
| | 821 | if Pcd in UnusedPcdList:\r |
| | 822 | UnusedPcdList.remove(Pcd)\r |
| | 823 | if Pcd not in PcdList and Pcd not in UnusedPcdFullList:\r |
| | 824 | UnusedPcdFullList.append(Pcd)\r |
| | 825 | if len(Pcd.TokenCName) > self.MaxLen:\r |
| | 826 | self.MaxLen = len(Pcd.TokenCName)\r |
| | 827 | \r |
| | 828 | if GlobalData.gConditionalPcds:\r |
| | 829 | for PcdItem in GlobalData.gConditionalPcds:\r |
| | 830 | if '.' in PcdItem:\r |
| | 831 | (TokenSpaceGuidCName, TokenCName) = PcdItem.split('.')\r |
| | 832 | if (TokenCName, TokenSpaceGuidCName) in Pa.Platform.Pcds:\r |
| | 833 | Pcd = Pa.Platform.Pcds[(TokenCName, TokenSpaceGuidCName)]\r |
| | 834 | PcdList = self.ConditionalPcds.setdefault(Pcd.TokenSpaceGuidCName, {}).setdefault(Pcd.Type, [])\r |
| | 835 | if Pcd not in PcdList:\r |
| | 836 | PcdList.append(Pcd)\r |
| | 837 | \r |
| | 838 | UnusedPcdList = []\r |
| | 839 | if UnusedPcdFullList:\r |
| | 840 | for Pcd in UnusedPcdFullList:\r |
| | 841 | if Pcd.TokenSpaceGuidCName + '.' + Pcd.TokenCName in GlobalData.gConditionalPcds:\r |
| | 842 | continue\r |
| | 843 | UnusedPcdList.append(Pcd)\r |
| | 844 | \r |
| | 845 | for Pcd in UnusedPcdList:\r |
| | 846 | PcdList = self.UnusedPcds.setdefault(Pcd.TokenSpaceGuidCName, {}).setdefault(Pcd.Type, [])\r |
| | 847 | if Pcd not in PcdList:\r |
| | 848 | PcdList.append(Pcd)\r |
| | 849 | \r |
| | 850 | for Module in Pa.Platform.Modules.values():\r |
| | 851 | #\r |
| | 852 | # Collect module override PCDs\r |
| | 853 | #\r |
| | 854 | for ModulePcd in Module.M.ModulePcdList + Module.M.LibraryPcdList:\r |
| | 855 | TokenCName = ModulePcd.TokenCName\r |
| | 856 | TokenSpaceGuid = ModulePcd.TokenSpaceGuidCName\r |
| | 857 | ModuleDefault = ModulePcd.DefaultValue\r |
| | 858 | ModulePath = os.path.basename(Module.M.MetaFile.File)\r |
| | 859 | self.ModulePcdOverride.setdefault((TokenCName, TokenSpaceGuid), {})[ModulePath] = ModuleDefault\r |
| | 860 | \r |
| | 861 | \r |
| | 862 | #\r |
| | 863 | # Collect PCD DEC default value.\r |
| | 864 | #\r |
| | 865 | self.DecPcdDefault = {}\r |
| | 866 | self._GuidDict = {}\r |
| | 867 | for Pa in Wa.AutoGenObjectList:\r |
| | 868 | for Package in Pa.PackageList:\r |
| | 869 | Guids = Package.Guids\r |
| | 870 | self._GuidDict.update(Guids)\r |
| | 871 | for (TokenCName, TokenSpaceGuidCName, DecType) in Package.Pcds:\r |
| | 872 | DecDefaultValue = Package.Pcds[TokenCName, TokenSpaceGuidCName, DecType].DefaultValue\r |
| | 873 | self.DecPcdDefault.setdefault((TokenCName, TokenSpaceGuidCName, DecType), DecDefaultValue)\r |
| | 874 | #\r |
| | 875 | # Collect PCDs defined in DSC common section\r |
| | 876 | #\r |
| | 877 | self.DscPcdDefault = {}\r |
| | 878 | for Pa in Wa.AutoGenObjectList:\r |
| | 879 | for (TokenCName, TokenSpaceGuidCName) in Pa.Platform.Pcds:\r |
| | 880 | DscDefaultValue = Pa.Platform.Pcds[(TokenCName, TokenSpaceGuidCName)].DscDefaultValue\r |
| | 881 | if DscDefaultValue:\r |
| | 882 | self.DscPcdDefault[(TokenCName, TokenSpaceGuidCName)] = DscDefaultValue\r |
| | 883 | \r |
| | 884 | def GenerateReport(self, File, ModulePcdSet,ModuleGuid=None):\r |
| | 885 | if not ModulePcdSet:\r |
| | 886 | if self.ConditionalPcds:\r |
| | 887 | self.GenerateReportDetail(File, ModulePcdSet, 1)\r |
| | 888 | if self.UnusedPcds:\r |
| | 889 | IsEmpty = True\r |
| | 890 | for Token in self.UnusedPcds:\r |
| | 891 | TokenDict = self.UnusedPcds[Token]\r |
| | 892 | for Type in TokenDict:\r |
| | 893 | if TokenDict[Type]:\r |
| | 894 | IsEmpty = False\r |
| | 895 | break\r |
| | 896 | if not IsEmpty:\r |
| | 897 | break\r |
| | 898 | if not IsEmpty:\r |
| | 899 | self.GenerateReportDetail(File, ModulePcdSet, 2)\r |
| | 900 | self.GenerateReportDetail(File, ModulePcdSet,ModuleGuid = ModuleGuid)\r |
| | 901 | \r |
| | 902 | ##\r |
| | 903 | # Generate report for PCD information\r |
| | 904 | #\r |
| | 905 | # This function generates report for separate module expression\r |
| | 906 | # in a platform build.\r |
| | 907 | #\r |
| | 908 | # @param self The object pointer\r |
| | 909 | # @param File The file object for report\r |
| | 910 | # @param ModulePcdSet Set of all PCDs referenced by module or None for\r |
| | 911 | # platform PCD report\r |
| | 912 | # @param ReportySubType 0 means platform/module PCD report, 1 means Conditional\r |
| | 913 | # directives section report, 2 means Unused Pcds section report\r |
| | 914 | # @param DscOverridePcds Module DSC override PCDs set\r |
| | 915 | #\r |
| | 916 | def GenerateReportDetail(self, File, ModulePcdSet, ReportSubType = 0,ModuleGuid=None):\r |
| | 917 | PcdDict = self.AllPcds\r |
| | 918 | if ReportSubType == 1:\r |
| | 919 | PcdDict = self.ConditionalPcds\r |
| | 920 | elif ReportSubType == 2:\r |
| | 921 | PcdDict = self.UnusedPcds\r |
| | 922 | \r |
| | 923 | if not ModulePcdSet:\r |
| | 924 | FileWrite(File, gSectionStart)\r |
| | 925 | if ReportSubType == 1:\r |
| | 926 | FileWrite(File, "Conditional Directives used by the build system")\r |
| | 927 | elif ReportSubType == 2:\r |
| | 928 | FileWrite(File, "PCDs not used by modules or in conditional directives")\r |
| | 929 | else:\r |
| | 930 | FileWrite(File, "Platform Configuration Database Report")\r |
| | 931 | \r |
| | 932 | FileWrite(File, " *B - PCD override in the build option")\r |
| | 933 | FileWrite(File, " *P - Platform scoped PCD override in DSC file")\r |
| | 934 | FileWrite(File, " *F - Platform scoped PCD override in FDF file")\r |
| | 935 | if not ReportSubType:\r |
| | 936 | FileWrite(File, " *M - Module scoped PCD override")\r |
| | 937 | FileWrite(File, gSectionSep)\r |
| | 938 | else:\r |
| | 939 | if not ReportSubType and ModulePcdSet:\r |
| | 940 | #\r |
| | 941 | # For module PCD sub-section\r |
| | 942 | #\r |
| | 943 | FileWrite(File, gSubSectionStart)\r |
| | 944 | FileWrite(File, TAB_BRG_PCD)\r |
| | 945 | FileWrite(File, gSubSectionSep)\r |
| | 946 | AllPcdDict = {}\r |
| | 947 | for Key in PcdDict:\r |
| | 948 | AllPcdDict[Key] = {}\r |
| | 949 | for Type in PcdDict[Key]:\r |
| | 950 | for Pcd in PcdDict[Key][Type]:\r |
| | 951 | AllPcdDict[Key][(Pcd.TokenCName, Type)] = Pcd\r |
| | 952 | for Key in sorted(AllPcdDict):\r |
| | 953 | #\r |
| | 954 | # Group PCD by their token space GUID C Name\r |
| | 955 | #\r |
| | 956 | First = True\r |
| | 957 | for PcdTokenCName, Type in sorted(AllPcdDict[Key]):\r |
| | 958 | #\r |
| | 959 | # Group PCD by their usage type\r |
| | 960 | #\r |
| | 961 | Pcd = AllPcdDict[Key][(PcdTokenCName, Type)]\r |
| | 962 | TypeName, DecType = gPcdTypeMap.get(Type, ("", Type))\r |
| | 963 | MixedPcdFlag = False\r |
| | 964 | if GlobalData.MixedPcd:\r |
| | 965 | for PcdKey in GlobalData.MixedPcd:\r |
| | 966 | if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdKey]:\r |
| | 967 | PcdTokenCName = PcdKey[0]\r |
| | 968 | MixedPcdFlag = True\r |
| | 969 | if MixedPcdFlag and not ModulePcdSet:\r |
| | 970 | continue\r |
| | 971 | #\r |
| | 972 | # Get PCD default value and their override relationship\r |
| | 973 | #\r |
| | 974 | DecDefaultValue = self.DecPcdDefault.get((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, DecType))\r |
| | 975 | DscDefaultValue = self.DscPcdDefault.get((Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r |
| | 976 | DscDefaultValBak = DscDefaultValue\r |
| | 977 | Field = ''\r |
| | 978 | for (CName, Guid, Field) in self.FdfPcdSet:\r |
| | 979 | if CName == PcdTokenCName and Guid == Key:\r |
| | 980 | DscDefaultValue = self.FdfPcdSet[(CName, Guid, Field)]\r |
| | 981 | break\r |
| | 982 | if DscDefaultValue != DscDefaultValBak:\r |
| | 983 | try:\r |
| | 984 | DscDefaultValue = ValueExpressionEx(DscDefaultValue, Pcd.DatumType, self._GuidDict)(True)\r |
| | 985 | except BadExpression as DscDefaultValue:\r |
| | 986 | EdkLogger.error('BuildReport', FORMAT_INVALID, "PCD Value: %s, Type: %s" %(DscDefaultValue, Pcd.DatumType))\r |
| | 987 | \r |
| | 988 | InfDefaultValue = None\r |
| | 989 | \r |
| | 990 | PcdValue = DecDefaultValue\r |
| | 991 | if DscDefaultValue:\r |
| | 992 | PcdValue = DscDefaultValue\r |
| | 993 | #The DefaultValue of StructurePcd already be the latest, no need to update.\r |
| | 994 | if not self.IsStructurePcd(Pcd.TokenCName, Pcd.TokenSpaceGuidCName):\r |
| | 995 | Pcd.DefaultValue = PcdValue\r |
| | 996 | PcdComponentValue = None\r |
| | 997 | if ModulePcdSet is not None:\r |
| | 998 | if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Type) not in ModulePcdSet:\r |
| | 999 | continue\r |
| | 1000 | InfDefaultValue, PcdComponentValue = ModulePcdSet[Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Type]\r |
| | 1001 | PcdValue = PcdComponentValue\r |
| | 1002 | #The DefaultValue of StructurePcd already be the latest, no need to update.\r |
| | 1003 | if not self.IsStructurePcd(Pcd.TokenCName, Pcd.TokenSpaceGuidCName):\r |
| | 1004 | Pcd.DefaultValue = PcdValue\r |
| | 1005 | if InfDefaultValue:\r |
| | 1006 | try:\r |
| | 1007 | InfDefaultValue = ValueExpressionEx(InfDefaultValue, Pcd.DatumType, self._GuidDict)(True)\r |
| | 1008 | except BadExpression as InfDefaultValue:\r |
| | 1009 | EdkLogger.error('BuildReport', FORMAT_INVALID, "PCD Value: %s, Type: %s" % (InfDefaultValue, Pcd.DatumType))\r |
| | 1010 | if InfDefaultValue == "":\r |
| | 1011 | InfDefaultValue = None\r |
| | 1012 | \r |
| | 1013 | BuildOptionMatch = False\r |
| | 1014 | if GlobalData.BuildOptionPcd:\r |
| | 1015 | for pcd in GlobalData.BuildOptionPcd:\r |
| | 1016 | if (Pcd.TokenSpaceGuidCName, Pcd.TokenCName) == (pcd[0], pcd[1]):\r |
| | 1017 | if pcd[2]:\r |
| | 1018 | continue\r |
| | 1019 | PcdValue = pcd[3]\r |
| | 1020 | #The DefaultValue of StructurePcd already be the latest, no need to update.\r |
| | 1021 | if not self.IsStructurePcd(Pcd.TokenCName, Pcd.TokenSpaceGuidCName):\r |
| | 1022 | Pcd.DefaultValue = PcdValue\r |
| | 1023 | BuildOptionMatch = True\r |
| | 1024 | break\r |
| | 1025 | \r |
| | 1026 | if First:\r |
| | 1027 | if ModulePcdSet is None:\r |
| | 1028 | FileWrite(File, "")\r |
| | 1029 | FileWrite(File, Key)\r |
| | 1030 | First = False\r |
| | 1031 | \r |
| | 1032 | \r |
| | 1033 | if Pcd.DatumType in TAB_PCD_NUMERIC_TYPES:\r |
| | 1034 | if PcdValue.startswith('0') and not PcdValue.lower().startswith('0x') and \\r |
| | 1035 | len(PcdValue) > 1 and PcdValue.lstrip('0'):\r |
| | 1036 | PcdValue = PcdValue.lstrip('0')\r |
| | 1037 | PcdValueNumber = int(PcdValue.strip(), 0)\r |
| | 1038 | if DecDefaultValue is None:\r |
| | 1039 | DecMatch = True\r |
| | 1040 | else:\r |
| | 1041 | if DecDefaultValue.startswith('0') and not DecDefaultValue.lower().startswith('0x') and \\r |
| | 1042 | len(DecDefaultValue) > 1 and DecDefaultValue.lstrip('0'):\r |
| | 1043 | DecDefaultValue = DecDefaultValue.lstrip('0')\r |
| | 1044 | DecDefaultValueNumber = int(DecDefaultValue.strip(), 0)\r |
| | 1045 | DecMatch = (DecDefaultValueNumber == PcdValueNumber)\r |
| | 1046 | \r |
| | 1047 | if InfDefaultValue is None:\r |
| | 1048 | InfMatch = True\r |
| | 1049 | else:\r |
| | 1050 | if InfDefaultValue.startswith('0') and not InfDefaultValue.lower().startswith('0x') and \\r |
| | 1051 | len(InfDefaultValue) > 1 and InfDefaultValue.lstrip('0'):\r |
| | 1052 | InfDefaultValue = InfDefaultValue.lstrip('0')\r |
| | 1053 | InfDefaultValueNumber = int(InfDefaultValue.strip(), 0)\r |
| | 1054 | InfMatch = (InfDefaultValueNumber == PcdValueNumber)\r |
| | 1055 | \r |
| | 1056 | if DscDefaultValue is None:\r |
| | 1057 | DscMatch = True\r |
| | 1058 | else:\r |
| | 1059 | if DscDefaultValue.startswith('0') and not DscDefaultValue.lower().startswith('0x') and \\r |
| | 1060 | len(DscDefaultValue) > 1 and DscDefaultValue.lstrip('0'):\r |
| | 1061 | DscDefaultValue = DscDefaultValue.lstrip('0')\r |
| | 1062 | DscDefaultValueNumber = int(DscDefaultValue.strip(), 0)\r |
| | 1063 | DscMatch = (DscDefaultValueNumber == PcdValueNumber)\r |
| | 1064 | else:\r |
| | 1065 | if DecDefaultValue is None:\r |
| | 1066 | DecMatch = True\r |
| | 1067 | else:\r |
| | 1068 | DecMatch = (DecDefaultValue.strip() == PcdValue.strip())\r |
| | 1069 | \r |
| | 1070 | if InfDefaultValue is None:\r |
| | 1071 | InfMatch = True\r |
| | 1072 | else:\r |
| | 1073 | InfMatch = (InfDefaultValue.strip() == PcdValue.strip())\r |
| | 1074 | \r |
| | 1075 | if DscDefaultValue is None:\r |
| | 1076 | DscMatch = True\r |
| | 1077 | else:\r |
| | 1078 | DscMatch = (DscDefaultValue.strip() == PcdValue.strip())\r |
| | 1079 | \r |
| | 1080 | IsStructure = False\r |
| | 1081 | if self.IsStructurePcd(Pcd.TokenCName, Pcd.TokenSpaceGuidCName):\r |
| | 1082 | IsStructure = True\r |
| | 1083 | if TypeName in ('DYNVPD', 'DEXVPD'):\r |
| | 1084 | SkuInfoList = Pcd.SkuInfoList\r |
| | 1085 | Pcd = GlobalData.gStructurePcd[self.Arch][(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)]\r |
| | 1086 | if ModulePcdSet and ModulePcdSet.get((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Type)):\r |
| | 1087 | InfDefaultValue, PcdComponentValue = ModulePcdSet[Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Type]\r |
| | 1088 | DscDefaultValBak = Pcd.DefaultValue\r |
| | 1089 | Pcd.DefaultValue = PcdComponentValue\r |
| | 1090 | \r |
| | 1091 | Pcd.DatumType = Pcd.StructName\r |
| | 1092 | if TypeName in ('DYNVPD', 'DEXVPD'):\r |
| | 1093 | Pcd.SkuInfoList = SkuInfoList\r |
| | 1094 | if Pcd.PcdValueFromComm or Pcd.PcdFieldValueFromComm:\r |
| | 1095 | BuildOptionMatch = True\r |
| | 1096 | DecMatch = False\r |
| | 1097 | elif Pcd.PcdValueFromFdf or Pcd.PcdFieldValueFromFdf:\r |
| | 1098 | DscDefaultValue = True\r |
| | 1099 | DscMatch = True\r |
| | 1100 | DecMatch = False\r |
| | 1101 | else:\r |
| | 1102 | if Pcd.Type in PCD_DYNAMIC_TYPE_SET | PCD_DYNAMIC_EX_TYPE_SET:\r |
| | 1103 | DscOverride = False\r |
| | 1104 | if Pcd.DefaultFromDSC:\r |
| | 1105 | DscOverride = True\r |
| | 1106 | else:\r |
| | 1107 | DictLen = 0\r |
| | 1108 | for item in Pcd.SkuOverrideValues:\r |
| | 1109 | DictLen += len(Pcd.SkuOverrideValues[item])\r |
| | 1110 | if not DictLen:\r |
| | 1111 | DscOverride = False\r |
| | 1112 | else:\r |
| | 1113 | if not Pcd.SkuInfoList:\r |
| | 1114 | OverrideValues = Pcd.SkuOverrideValues\r |
| | 1115 | if OverrideValues:\r |
| | 1116 | for Data in OverrideValues.values():\r |
| | 1117 | Struct = list(Data.values())\r |
| | 1118 | if Struct:\r |
| | 1119 | DscOverride = self.ParseStruct(Struct[0])\r |
| | 1120 | break\r |
| | 1121 | else:\r |
| | 1122 | SkuList = sorted(Pcd.SkuInfoList.keys())\r |
| | 1123 | for Sku in SkuList:\r |
| | 1124 | SkuInfo = Pcd.SkuInfoList[Sku]\r |
| | 1125 | if SkuInfo.DefaultStoreDict:\r |
| | 1126 | DefaultStoreList = sorted(SkuInfo.DefaultStoreDict.keys())\r |
| | 1127 | for DefaultStore in DefaultStoreList:\r |
| | 1128 | OverrideValues = Pcd.SkuOverrideValues.get(Sku)\r |
| | 1129 | if OverrideValues:\r |
| | 1130 | DscOverride = self.ParseStruct(OverrideValues[DefaultStore])\r |
| | 1131 | if DscOverride:\r |
| | 1132 | break\r |
| | 1133 | if DscOverride:\r |
| | 1134 | break\r |
| | 1135 | if DscOverride:\r |
| | 1136 | DscDefaultValue = True\r |
| | 1137 | DscMatch = True\r |
| | 1138 | DecMatch = False\r |
| | 1139 | else:\r |
| | 1140 | DecMatch = True\r |
| | 1141 | else:\r |
| | 1142 | if Pcd.DscRawValue or (ModuleGuid and ModuleGuid.replace("-","S") in Pcd.PcdValueFromComponents):\r |
| | 1143 | DscDefaultValue = True\r |
| | 1144 | DscMatch = True\r |
| | 1145 | DecMatch = False\r |
| | 1146 | else:\r |
| | 1147 | DscDefaultValue = False\r |
| | 1148 | DecMatch = True\r |
| | 1149 | \r |
| | 1150 | #\r |
| | 1151 | # Report PCD item according to their override relationship\r |
| | 1152 | #\r |
| | 1153 | if Pcd.DatumType == 'BOOLEAN':\r |
| | 1154 | if DscDefaultValue:\r |
| | 1155 | DscDefaultValue = str(int(DscDefaultValue, 0))\r |
| | 1156 | if DecDefaultValue:\r |
| | 1157 | DecDefaultValue = str(int(DecDefaultValue, 0))\r |
| | 1158 | if InfDefaultValue:\r |
| | 1159 | InfDefaultValue = str(int(InfDefaultValue, 0))\r |
| | 1160 | if Pcd.DefaultValue:\r |
| | 1161 | Pcd.DefaultValue = str(int(Pcd.DefaultValue, 0))\r |
| | 1162 | if DecMatch:\r |
| | 1163 | self.PrintPcdValue(File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValBak, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, ' ')\r |
| | 1164 | elif InfDefaultValue and InfMatch:\r |
| | 1165 | self.PrintPcdValue(File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValBak, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, '*M')\r |
| | 1166 | elif BuildOptionMatch:\r |
| | 1167 | self.PrintPcdValue(File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValBak, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, '*B')\r |
| | 1168 | else:\r |
| | 1169 | if PcdComponentValue:\r |
| | 1170 | self.PrintPcdValue(File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValBak, InfMatch, PcdComponentValue, DecMatch, DecDefaultValue, '*M', ModuleGuid)\r |
| | 1171 | elif DscDefaultValue and DscMatch:\r |
| | 1172 | if (Pcd.TokenCName, Key, Field) in self.FdfPcdSet:\r |
| | 1173 | self.PrintPcdValue(File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValBak, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, '*F')\r |
| | 1174 | else:\r |
| | 1175 | self.PrintPcdValue(File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValBak, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, '*P')\r |
| | 1176 | \r |
| | 1177 | \r |
| | 1178 | if ModulePcdSet is None:\r |
| | 1179 | if IsStructure:\r |
| | 1180 | continue\r |
| | 1181 | if not TypeName in ('PATCH', 'FLAG', 'FIXED'):\r |
| | 1182 | continue\r |
| | 1183 | if not BuildOptionMatch:\r |
| | 1184 | ModuleOverride = self.ModulePcdOverride.get((Pcd.TokenCName, Pcd.TokenSpaceGuidCName), {})\r |
| | 1185 | for ModulePath in ModuleOverride:\r |
| | 1186 | ModuleDefault = ModuleOverride[ModulePath]\r |
| | 1187 | if Pcd.DatumType in TAB_PCD_NUMERIC_TYPES:\r |
| | 1188 | if ModuleDefault.startswith('0') and not ModuleDefault.lower().startswith('0x') and \\r |
| | 1189 | len(ModuleDefault) > 1 and ModuleDefault.lstrip('0'):\r |
| | 1190 | ModuleDefault = ModuleDefault.lstrip('0')\r |
| | 1191 | ModulePcdDefaultValueNumber = int(ModuleDefault.strip(), 0)\r |
| | 1192 | Match = (ModulePcdDefaultValueNumber == PcdValueNumber)\r |
| | 1193 | if Pcd.DatumType == 'BOOLEAN':\r |
| | 1194 | ModuleDefault = str(ModulePcdDefaultValueNumber)\r |
| | 1195 | else:\r |
| | 1196 | Match = (ModuleDefault.strip() == PcdValue.strip())\r |
| | 1197 | if Match:\r |
| | 1198 | continue\r |
| | 1199 | IsByteArray, ArrayList = ByteArrayForamt(ModuleDefault.strip())\r |
| | 1200 | if IsByteArray:\r |
| | 1201 | FileWrite(File, ' *M %-*s = %s' % (self.MaxLen + 15, ModulePath, '{'))\r |
| | 1202 | for Array in ArrayList:\r |
| | 1203 | FileWrite(File, Array)\r |
| | 1204 | else:\r |
| | 1205 | Value = ModuleDefault.strip()\r |
| | 1206 | if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:\r |
| | 1207 | if Value.startswith(('0x', '0X')):\r |
| | 1208 | Value = '{} ({:d})'.format(Value, int(Value, 0))\r |
| | 1209 | else:\r |
| | 1210 | Value = "0x{:X} ({})".format(int(Value, 0), Value)\r |
| | 1211 | FileWrite(File, ' *M %-*s = %s' % (self.MaxLen + 15, ModulePath, Value))\r |
| | 1212 | \r |
| | 1213 | if ModulePcdSet is None:\r |
| | 1214 | FileWrite(File, gSectionEnd)\r |
| | 1215 | else:\r |
| | 1216 | if not ReportSubType and ModulePcdSet:\r |
| | 1217 | FileWrite(File, gSubSectionEnd)\r |
| | 1218 | \r |
| | 1219 | def ParseStruct(self, struct):\r |
| | 1220 | HasDscOverride = False\r |
| | 1221 | if struct:\r |
| | 1222 | for _, Values in list(struct.items()):\r |
| | 1223 | for Key, value in Values.items():\r |
| | 1224 | if value[1] and value[1].endswith('.dsc'):\r |
| | 1225 | HasDscOverride = True\r |
| | 1226 | break\r |
| | 1227 | if HasDscOverride == True:\r |
| | 1228 | break\r |
| | 1229 | return HasDscOverride\r |
| | 1230 | \r |
| | 1231 | def PrintPcdDefault(self, File, Pcd, IsStructure, DscMatch, DscDefaultValue, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue):\r |
| | 1232 | if not DscMatch and DscDefaultValue is not None:\r |
| | 1233 | Value = DscDefaultValue.strip()\r |
| | 1234 | IsByteArray, ArrayList = ByteArrayForamt(Value)\r |
| | 1235 | if IsByteArray:\r |
| | 1236 | FileWrite(File, ' %*s = %s' % (self.MaxLen + 19, 'DSC DEFAULT', "{"))\r |
| | 1237 | for Array in ArrayList:\r |
| | 1238 | FileWrite(File, Array)\r |
| | 1239 | else:\r |
| | 1240 | if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:\r |
| | 1241 | if Value.startswith(('0x', '0X')):\r |
| | 1242 | Value = '{} ({:d})'.format(Value, int(Value, 0))\r |
| | 1243 | else:\r |
| | 1244 | Value = "0x{:X} ({})".format(int(Value, 0), Value)\r |
| | 1245 | FileWrite(File, ' %*s = %s' % (self.MaxLen + 19, 'DSC DEFAULT', Value))\r |
| | 1246 | if not InfMatch and InfDefaultValue is not None:\r |
| | 1247 | Value = InfDefaultValue.strip()\r |
| | 1248 | IsByteArray, ArrayList = ByteArrayForamt(Value)\r |
| | 1249 | if IsByteArray:\r |
| | 1250 | FileWrite(File, ' %*s = %s' % (self.MaxLen + 19, 'INF DEFAULT', "{"))\r |
| | 1251 | for Array in ArrayList:\r |
| | 1252 | FileWrite(File, Array)\r |
| | 1253 | else:\r |
| | 1254 | if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:\r |
| | 1255 | if Value.startswith(('0x', '0X')):\r |
| | 1256 | Value = '{} ({:d})'.format(Value, int(Value, 0))\r |
| | 1257 | else:\r |
| | 1258 | Value = "0x{:X} ({})".format(int(Value, 0), Value)\r |
| | 1259 | FileWrite(File, ' %*s = %s' % (self.MaxLen + 19, 'INF DEFAULT', Value))\r |
| | 1260 | \r |
| | 1261 | if not DecMatch and DecDefaultValue is not None:\r |
| | 1262 | Value = DecDefaultValue.strip()\r |
| | 1263 | IsByteArray, ArrayList = ByteArrayForamt(Value)\r |
| | 1264 | if IsByteArray:\r |
| | 1265 | FileWrite(File, ' %*s = %s' % (self.MaxLen + 19, 'DEC DEFAULT', "{"))\r |
| | 1266 | for Array in ArrayList:\r |
| | 1267 | FileWrite(File, Array)\r |
| | 1268 | else:\r |
| | 1269 | if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:\r |
| | 1270 | if Value.startswith(('0x', '0X')):\r |
| | 1271 | Value = '{} ({:d})'.format(Value, int(Value, 0))\r |
| | 1272 | else:\r |
| | 1273 | Value = "0x{:X} ({})".format(int(Value, 0), Value)\r |
| | 1274 | FileWrite(File, ' %*s = %s' % (self.MaxLen + 19, 'DEC DEFAULT', Value))\r |
| | 1275 | if IsStructure:\r |
| | 1276 | for filedvalues in Pcd.DefaultValues.values():\r |
| | 1277 | self.PrintStructureInfo(File, filedvalues)\r |
| | 1278 | if DecMatch and IsStructure:\r |
| | 1279 | for filedvalues in Pcd.DefaultValues.values():\r |
| | 1280 | self.PrintStructureInfo(File, filedvalues)\r |
| | 1281 | \r |
| | 1282 | def PrintPcdValue(self, File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValue, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, Flag = ' ',ModuleGuid=None):\r |
| | 1283 | if not Pcd.SkuInfoList:\r |
| | 1284 | Value = Pcd.DefaultValue\r |
| | 1285 | IsByteArray, ArrayList = ByteArrayForamt(Value)\r |
| | 1286 | if IsByteArray:\r |
| | 1287 | FileWrite(File, ' %-*s : %6s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '{'))\r |
| | 1288 | for Array in ArrayList:\r |
| | 1289 | FileWrite(File, Array)\r |
| | 1290 | else:\r |
| | 1291 | if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:\r |
| | 1292 | if Value.startswith('0') and not Value.lower().startswith('0x') and len(Value) > 1 and Value.lstrip('0'):\r |
| | 1293 | Value = Value.lstrip('0')\r |
| | 1294 | if Value.startswith(('0x', '0X')):\r |
| | 1295 | Value = '{} ({:d})'.format(Value, int(Value, 0))\r |
| | 1296 | else:\r |
| | 1297 | Value = "0x{:X} ({})".format(int(Value, 0), Value)\r |
| | 1298 | FileWrite(File, ' %-*s : %6s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', Value))\r |
| | 1299 | if IsStructure:\r |
| | 1300 | FiledOverrideFlag = False\r |
| | 1301 | if (Pcd.TokenCName,Pcd.TokenSpaceGuidCName) in GlobalData.gPcdSkuOverrides:\r |
| | 1302 | OverrideValues = GlobalData.gPcdSkuOverrides[(Pcd.TokenCName,Pcd.TokenSpaceGuidCName)]\r |
| | 1303 | else:\r |
| | 1304 | OverrideValues = Pcd.SkuOverrideValues\r |
| | 1305 | FieldOverrideValues = None\r |
| | 1306 | if OverrideValues:\r |
| | 1307 | for Data in OverrideValues.values():\r |
| | 1308 | Struct = list(Data.values())\r |
| | 1309 | if Struct:\r |
| | 1310 | FieldOverrideValues = Struct[0]\r |
| | 1311 | FiledOverrideFlag = True\r |
| | 1312 | break\r |
| | 1313 | if Pcd.PcdFiledValueFromDscComponent and ModuleGuid and ModuleGuid.replace("-","S") in Pcd.PcdFiledValueFromDscComponent:\r |
| | 1314 | FieldOverrideValues = Pcd.PcdFiledValueFromDscComponent[ModuleGuid.replace("-","S")]\r |
| | 1315 | if FieldOverrideValues:\r |
| | 1316 | OverrideFieldStruct = self.OverrideFieldValue(Pcd, FieldOverrideValues)\r |
| | 1317 | self.PrintStructureInfo(File, OverrideFieldStruct)\r |
| | 1318 | \r |
| | 1319 | if not FiledOverrideFlag and (Pcd.PcdFieldValueFromComm or Pcd.PcdFieldValueFromFdf):\r |
| | 1320 | OverrideFieldStruct = self.OverrideFieldValue(Pcd, {})\r |
| | 1321 | self.PrintStructureInfo(File, OverrideFieldStruct)\r |
| | 1322 | self.PrintPcdDefault(File, Pcd, IsStructure, DscMatch, DscDefaultValue, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue)\r |
| | 1323 | else:\r |
| | 1324 | FirstPrint = True\r |
| | 1325 | SkuList = sorted(Pcd.SkuInfoList.keys())\r |
| | 1326 | for Sku in SkuList:\r |
| | 1327 | SkuInfo = Pcd.SkuInfoList[Sku]\r |
| | 1328 | SkuIdName = SkuInfo.SkuIdName\r |
| | 1329 | if TypeName in ('DYNHII', 'DEXHII'):\r |
| | 1330 | if SkuInfo.DefaultStoreDict:\r |
| | 1331 | DefaultStoreList = sorted(SkuInfo.DefaultStoreDict.keys())\r |
| | 1332 | for DefaultStore in DefaultStoreList:\r |
| | 1333 | Value = SkuInfo.DefaultStoreDict[DefaultStore]\r |
| | 1334 | IsByteArray, ArrayList = ByteArrayForamt(Value)\r |
| | 1335 | if Pcd.DatumType == 'BOOLEAN':\r |
| | 1336 | Value = str(int(Value, 0))\r |
| | 1337 | if FirstPrint:\r |
| | 1338 | FirstPrint = False\r |
| | 1339 | if IsByteArray:\r |
| | 1340 | if self.DefaultStoreSingle and self.SkuSingle:\r |
| | 1341 | FileWrite(File, ' %-*s : %6s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '{'))\r |
| | 1342 | elif self.DefaultStoreSingle and not self.SkuSingle:\r |
| | 1343 | FileWrite(File, ' %-*s : %6s %10s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', '{'))\r |
| | 1344 | elif not self.DefaultStoreSingle and self.SkuSingle:\r |
| | 1345 | FileWrite(File, ' %-*s : %6s %10s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '(' + DefaultStore + ')', '{'))\r |
| | 1346 | else:\r |
| | 1347 | FileWrite(File, ' %-*s : %6s %10s %10s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', '(' + DefaultStore + ')', '{'))\r |
| | 1348 | for Array in ArrayList:\r |
| | 1349 | FileWrite(File, Array)\r |
| | 1350 | else:\r |
| | 1351 | if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:\r |
| | 1352 | if Value.startswith(('0x', '0X')):\r |
| | 1353 | Value = '{} ({:d})'.format(Value, int(Value, 0))\r |
| | 1354 | else:\r |
| | 1355 | Value = "0x{:X} ({})".format(int(Value, 0), Value)\r |
| | 1356 | if self.DefaultStoreSingle and self.SkuSingle:\r |
| | 1357 | FileWrite(File, ' %-*s : %6s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', Value))\r |
| | 1358 | elif self.DefaultStoreSingle and not self.SkuSingle:\r |
| | 1359 | FileWrite(File, ' %-*s : %6s %10s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', Value))\r |
| | 1360 | elif not self.DefaultStoreSingle and self.SkuSingle:\r |
| | 1361 | FileWrite(File, ' %-*s : %6s %10s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '(' + DefaultStore + ')', Value))\r |
| | 1362 | else:\r |
| | 1363 | FileWrite(File, ' %-*s : %6s %10s %10s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', '(' + DefaultStore + ')', Value))\r |
| | 1364 | else:\r |
| | 1365 | if IsByteArray:\r |
| | 1366 | if self.DefaultStoreSingle and self.SkuSingle:\r |
| | 1367 | FileWrite(File, ' %-*s : %6s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', '{'))\r |
| | 1368 | elif self.DefaultStoreSingle and not self.SkuSingle:\r |
| | 1369 | FileWrite(File, ' %-*s : %6s %10s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', '{'))\r |
| | 1370 | elif not self.DefaultStoreSingle and self.SkuSingle:\r |
| | 1371 | FileWrite(File, ' %-*s : %6s %10s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', '(' + DefaultStore + ')', '{'))\r |
| | 1372 | else:\r |
| | 1373 | FileWrite(File, ' %-*s : %6s %10s %10s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', '(' + DefaultStore + ')', '{'))\r |
| | 1374 | for Array in ArrayList:\r |
| | 1375 | FileWrite(File, Array)\r |
| | 1376 | else:\r |
| | 1377 | if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:\r |
| | 1378 | if Value.startswith(('0x', '0X')):\r |
| | 1379 | Value = '{} ({:d})'.format(Value, int(Value, 0))\r |
| | 1380 | else:\r |
| | 1381 | Value = "0x{:X} ({})".format(int(Value, 0), Value)\r |
| | 1382 | if self.DefaultStoreSingle and self.SkuSingle:\r |
| | 1383 | FileWrite(File, ' %-*s : %6s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', Value))\r |
| | 1384 | elif self.DefaultStoreSingle and not self.SkuSingle:\r |
| | 1385 | FileWrite(File, ' %-*s : %6s %10s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', Value))\r |
| | 1386 | elif not self.DefaultStoreSingle and self.SkuSingle:\r |
| | 1387 | FileWrite(File, ' %-*s : %6s %10s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', '(' + DefaultStore + ')', Value))\r |
| | 1388 | else:\r |
| | 1389 | FileWrite(File, ' %-*s : %6s %10s %10s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', '(' + DefaultStore + ')', Value))\r |
| | 1390 | FileWrite(File, '%*s: %s: %s' % (self.MaxLen + 4, SkuInfo.VariableGuid, SkuInfo.VariableName, SkuInfo.VariableOffset))\r |
| | 1391 | if IsStructure:\r |
| | 1392 | OverrideValues = Pcd.SkuOverrideValues.get(Sku)\r |
| | 1393 | if OverrideValues:\r |
| | 1394 | OverrideFieldStruct = self.OverrideFieldValue(Pcd, OverrideValues[DefaultStore])\r |
| | 1395 | self.PrintStructureInfo(File, OverrideFieldStruct)\r |
| | 1396 | self.PrintPcdDefault(File, Pcd, IsStructure, DscMatch, DscDefaultValue, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue)\r |
| | 1397 | else:\r |
| | 1398 | Value = SkuInfo.DefaultValue\r |
| | 1399 | IsByteArray, ArrayList = ByteArrayForamt(Value)\r |
| | 1400 | if Pcd.DatumType == 'BOOLEAN':\r |
| | 1401 | Value = str(int(Value, 0))\r |
| | 1402 | if FirstPrint:\r |
| | 1403 | FirstPrint = False\r |
| | 1404 | if IsByteArray:\r |
| | 1405 | if self.SkuSingle:\r |
| | 1406 | FileWrite(File, ' %-*s : %6s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', "{"))\r |
| | 1407 | else:\r |
| | 1408 | FileWrite(File, ' %-*s : %6s %10s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', "{"))\r |
| | 1409 | for Array in ArrayList:\r |
| | 1410 | FileWrite(File, Array)\r |
| | 1411 | else:\r |
| | 1412 | if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:\r |
| | 1413 | if Value.startswith(('0x', '0X')):\r |
| | 1414 | Value = '{} ({:d})'.format(Value, int(Value, 0))\r |
| | 1415 | else:\r |
| | 1416 | Value = "0x{:X} ({})".format(int(Value, 0), Value)\r |
| | 1417 | if self.SkuSingle:\r |
| | 1418 | FileWrite(File, ' %-*s : %6s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', Value))\r |
| | 1419 | else:\r |
| | 1420 | FileWrite(File, ' %-*s : %6s %10s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', Value))\r |
| | 1421 | else:\r |
| | 1422 | if IsByteArray:\r |
| | 1423 | if self.SkuSingle:\r |
| | 1424 | FileWrite(File, ' %-*s : %6s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', "{"))\r |
| | 1425 | else:\r |
| | 1426 | FileWrite(File, ' %-*s : %6s %10s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', "{"))\r |
| | 1427 | for Array in ArrayList:\r |
| | 1428 | FileWrite(File, Array)\r |
| | 1429 | else:\r |
| | 1430 | if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:\r |
| | 1431 | if Value.startswith(('0x', '0X')):\r |
| | 1432 | Value = '{} ({:d})'.format(Value, int(Value, 0))\r |
| | 1433 | else:\r |
| | 1434 | Value = "0x{:X} ({})".format(int(Value, 0), Value)\r |
| | 1435 | if self.SkuSingle:\r |
| | 1436 | FileWrite(File, ' %-*s : %6s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', Value))\r |
| | 1437 | else:\r |
| | 1438 | FileWrite(File, ' %-*s : %6s %10s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', Value))\r |
| | 1439 | if TypeName in ('DYNVPD', 'DEXVPD'):\r |
| | 1440 | FileWrite(File, '%*s' % (self.MaxLen + 4, SkuInfo.VpdOffset))\r |
| | 1441 | VPDPcdItem = (Pcd.TokenSpaceGuidCName + '.' + PcdTokenCName, SkuIdName, SkuInfo.VpdOffset, Pcd.MaxDatumSize, SkuInfo.DefaultValue)\r |
| | 1442 | if VPDPcdItem not in VPDPcdList:\r |
| | 1443 | PcdGuidList = self.UnusedPcds.get(Pcd.TokenSpaceGuidCName)\r |
| | 1444 | if PcdGuidList:\r |
| | 1445 | PcdList = PcdGuidList.get(Pcd.Type)\r |
| | 1446 | if not PcdList:\r |
| | 1447 | VPDPcdList.append(VPDPcdItem)\r |
| | 1448 | for VpdPcd in PcdList:\r |
| | 1449 | if PcdTokenCName == VpdPcd.TokenCName:\r |
| | 1450 | break\r |
| | 1451 | else:\r |
| | 1452 | VPDPcdList.append(VPDPcdItem)\r |
| | 1453 | if IsStructure:\r |
| | 1454 | FiledOverrideFlag = False\r |
| | 1455 | OverrideValues = Pcd.SkuOverrideValues.get(Sku)\r |
| | 1456 | if OverrideValues:\r |
| | 1457 | Keys = list(OverrideValues.keys())\r |
| | 1458 | OverrideFieldStruct = self.OverrideFieldValue(Pcd, OverrideValues[Keys[0]])\r |
| | 1459 | self.PrintStructureInfo(File, OverrideFieldStruct)\r |
| | 1460 | FiledOverrideFlag = True\r |
| | 1461 | if not FiledOverrideFlag and (Pcd.PcdFieldValueFromComm or Pcd.PcdFieldValueFromFdf):\r |
| | 1462 | OverrideFieldStruct = self.OverrideFieldValue(Pcd, {})\r |
| | 1463 | self.PrintStructureInfo(File, OverrideFieldStruct)\r |
| | 1464 | self.PrintPcdDefault(File, Pcd, IsStructure, DscMatch, DscDefaultValue, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue)\r |
| | 1465 | \r |
| | 1466 | def OverrideFieldValue(self, Pcd, OverrideStruct):\r |
| | 1467 | OverrideFieldStruct = collections.OrderedDict()\r |
| | 1468 | if OverrideStruct:\r |
| | 1469 | for _, Values in OverrideStruct.items():\r |
| | 1470 | for Key,value in Values.items():\r |
| | 1471 | if value[1] and value[1].endswith('.dsc'):\r |
| | 1472 | OverrideFieldStruct[Key] = value\r |
| | 1473 | if Pcd.PcdFieldValueFromFdf:\r |
| | 1474 | for Key, Values in Pcd.PcdFieldValueFromFdf.items():\r |
| | 1475 | if Key in OverrideFieldStruct and Values[0] == OverrideFieldStruct[Key][0]:\r |
| | 1476 | continue\r |
| | 1477 | OverrideFieldStruct[Key] = Values\r |
| | 1478 | if Pcd.PcdFieldValueFromComm:\r |
| | 1479 | for Key, Values in Pcd.PcdFieldValueFromComm.items():\r |
| | 1480 | if Key in OverrideFieldStruct and Values[0] == OverrideFieldStruct[Key][0]:\r |
| | 1481 | continue\r |
| | 1482 | OverrideFieldStruct[Key] = Values\r |
| | 1483 | return OverrideFieldStruct\r |
| | 1484 | \r |
| | 1485 | def PrintStructureInfo(self, File, Struct):\r |
| | 1486 | for Key, Value in sorted(Struct.items(), key=lambda x: x[0]):\r |
| | 1487 | if Value[1] and 'build command options' in Value[1]:\r |
| | 1488 | FileWrite(File, ' *B %-*s = %s' % (self.MaxLen + 4, '.' + Key, Value[0]))\r |
| | 1489 | elif Value[1] and Value[1].endswith('.fdf'):\r |
| | 1490 | FileWrite(File, ' *F %-*s = %s' % (self.MaxLen + 4, '.' + Key, Value[0]))\r |
| | 1491 | else:\r |
| | 1492 | FileWrite(File, ' %-*s = %s' % (self.MaxLen + 4, '.' + Key, Value[0]))\r |
| | 1493 | \r |
| | 1494 | def StrtoHex(self, value):\r |
| | 1495 | try:\r |
| | 1496 | value = hex(int(value))\r |
| | 1497 | return value\r |
| | 1498 | except:\r |
| | 1499 | if value.startswith("L\"") and value.endswith("\""):\r |
| | 1500 | valuelist = []\r |
| | 1501 | for ch in value[2:-1]:\r |
| | 1502 | valuelist.append(hex(ord(ch)))\r |
| | 1503 | valuelist.append('0x00')\r |
| | 1504 | return valuelist\r |
| | 1505 | elif value.startswith("\"") and value.endswith("\""):\r |
| | 1506 | return hex(ord(value[1:-1]))\r |
| | 1507 | elif value.startswith("{") and value.endswith("}"):\r |
| | 1508 | valuelist = []\r |
| | 1509 | if ',' not in value:\r |
| | 1510 | return value[1:-1]\r |
| | 1511 | for ch in value[1:-1].split(','):\r |
| | 1512 | ch = ch.strip()\r |
| | 1513 | if ch.startswith('0x') or ch.startswith('0X'):\r |
| | 1514 | valuelist.append(ch)\r |
| | 1515 | continue\r |
| | 1516 | try:\r |
| | 1517 | valuelist.append(hex(int(ch.strip())))\r |
| | 1518 | except:\r |
| | 1519 | pass\r |
| | 1520 | return valuelist\r |
| | 1521 | else:\r |
| | 1522 | return value\r |
| | 1523 | \r |
| | 1524 | def IsStructurePcd(self, PcdToken, PcdTokenSpaceGuid):\r |
| | 1525 | if GlobalData.gStructurePcd and (self.Arch in GlobalData.gStructurePcd) and ((PcdToken, PcdTokenSpaceGuid) in GlobalData.gStructurePcd[self.Arch]):\r |
| | 1526 | return True\r |
| | 1527 | else:\r |
| | 1528 | return False\r |
| | 1529 | \r |
| | 1530 | ##\r |
| | 1531 | # Reports platform and module Prediction information\r |
| | 1532 | #\r |
| | 1533 | # This class reports the platform execution order prediction section and\r |
| | 1534 | # module load fixed address prediction subsection in the build report file.\r |
| | 1535 | #\r |
| | 1536 | class PredictionReport(object):\r |
| | 1537 | ##\r |
| | 1538 | # Constructor function for class PredictionReport\r |
| | 1539 | #\r |
| | 1540 | # This constructor function generates PredictionReport object for the platform.\r |
| | 1541 | #\r |
| | 1542 | # @param self: The object pointer\r |
| | 1543 | # @param Wa Workspace context information\r |
| | 1544 | #\r |
| | 1545 | def __init__(self, Wa):\r |
| | 1546 | self._MapFileName = os.path.join(Wa.BuildDir, Wa.Name + ".map")\r |
| | 1547 | self._MapFileParsed = False\r |
| | 1548 | self._EotToolInvoked = False\r |
| | 1549 | self._FvDir = Wa.FvDir\r |
| | 1550 | self._EotDir = Wa.BuildDir\r |
| | 1551 | self._FfsEntryPoint = {}\r |
| | 1552 | self._GuidMap = {}\r |
| | 1553 | self._SourceList = []\r |
| | 1554 | self.FixedMapDict = {}\r |
| | 1555 | self.ItemList = []\r |
| | 1556 | self.MaxLen = 0\r |
| | 1557 | \r |
| | 1558 | #\r |
| | 1559 | # Collect all platform reference source files and GUID C Name\r |
| | 1560 | #\r |
| | 1561 | for Pa in Wa.AutoGenObjectList:\r |
| | 1562 | for Module in Pa.LibraryAutoGenList + Pa.ModuleAutoGenList:\r |
| | 1563 | #\r |
| | 1564 | # BASE typed modules are EFI agnostic, so we need not scan\r |
| | 1565 | # their source code to find PPI/Protocol produce or consume\r |
| | 1566 | # information.\r |
| | 1567 | #\r |
| | 1568 | if Module.ModuleType == SUP_MODULE_BASE:\r |
| | 1569 | continue\r |
| | 1570 | #\r |
| | 1571 | # Add module referenced source files\r |
| | 1572 | #\r |
| | 1573 | self._SourceList.append(str(Module))\r |
| | 1574 | IncludeList = {}\r |
| | 1575 | for Source in Module.SourceFileList:\r |
| | 1576 | if os.path.splitext(str(Source))[1].lower() == ".c":\r |
| | 1577 | self._SourceList.append(" " + str(Source))\r |
| | 1578 | FindIncludeFiles(Source.Path, Module.IncludePathList, IncludeList)\r |
| | 1579 | for IncludeFile in IncludeList.values():\r |
| | 1580 | self._SourceList.append(" " + IncludeFile)\r |
| | 1581 | \r |
| | 1582 | for Guid in Module.PpiList:\r |
| | 1583 | self._GuidMap[Guid] = GuidStructureStringToGuidString(Module.PpiList[Guid])\r |
| | 1584 | for Guid in Module.ProtocolList:\r |
| | 1585 | self._GuidMap[Guid] = GuidStructureStringToGuidString(Module.ProtocolList[Guid])\r |
| | 1586 | for Guid in Module.GuidList:\r |
| | 1587 | self._GuidMap[Guid] = GuidStructureStringToGuidString(Module.GuidList[Guid])\r |
| | 1588 | \r |
| | 1589 | if Module.Guid and not Module.IsLibrary:\r |
| | 1590 | EntryPoint = " ".join(Module.Module.ModuleEntryPointList)\r |
| | 1591 | \r |
| | 1592 | RealEntryPoint = "_ModuleEntryPoint"\r |
| | 1593 | \r |
| | 1594 | self._FfsEntryPoint[Module.Guid.upper()] = (EntryPoint, RealEntryPoint)\r |
| | 1595 | \r |
| | 1596 | \r |
| | 1597 | #\r |
| | 1598 | # Collect platform firmware volume list as the input of EOT.\r |
| | 1599 | #\r |
| | 1600 | self._FvList = []\r |
| | 1601 | if Wa.FdfProfile:\r |
| | 1602 | for Fd in Wa.FdfProfile.FdDict:\r |
| | 1603 | for FdRegion in Wa.FdfProfile.FdDict[Fd].RegionList:\r |
| | 1604 | if FdRegion.RegionType != BINARY_FILE_TYPE_FV:\r |
| | 1605 | continue\r |
| | 1606 | for FvName in FdRegion.RegionDataList:\r |
| | 1607 | if FvName in self._FvList:\r |
| | 1608 | continue\r |
| | 1609 | self._FvList.append(FvName)\r |
| | 1610 | for Ffs in Wa.FdfProfile.FvDict[FvName.upper()].FfsList:\r |
| | 1611 | for Section in Ffs.SectionList:\r |
| | 1612 | try:\r |
| | 1613 | for FvSection in Section.SectionList:\r |
| | 1614 | if FvSection.FvName in self._FvList:\r |
| | 1615 | continue\r |
| | 1616 | self._FvList.append(FvSection.FvName)\r |
| | 1617 | except AttributeError:\r |
| | 1618 | pass\r |
| | 1619 | \r |
| | 1620 | \r |
| | 1621 | ##\r |
| | 1622 | # Parse platform fixed address map files\r |
| | 1623 | #\r |
| | 1624 | # This function parses the platform final fixed address map file to get\r |
| | 1625 | # the database of predicted fixed address for module image base, entry point\r |
| | 1626 | # etc.\r |
| | 1627 | #\r |
| | 1628 | # @param self: The object pointer\r |
| | 1629 | #\r |
| | 1630 | def _ParseMapFile(self):\r |
| | 1631 | if self._MapFileParsed:\r |
| | 1632 | return\r |
| | 1633 | self._MapFileParsed = True\r |
| | 1634 | if os.path.isfile(self._MapFileName):\r |
| | 1635 | try:\r |
| | 1636 | FileContents = open(self._MapFileName).read()\r |
| | 1637 | for Match in gMapFileItemPattern.finditer(FileContents):\r |
| | 1638 | AddressType = Match.group(1)\r |
| | 1639 | BaseAddress = Match.group(2)\r |
| | 1640 | EntryPoint = Match.group(3)\r |
| | 1641 | Guid = Match.group(4).upper()\r |
| | 1642 | List = self.FixedMapDict.setdefault(Guid, [])\r |
| | 1643 | List.append((AddressType, BaseAddress, "*I"))\r |
| | 1644 | List.append((AddressType, EntryPoint, "*E"))\r |
| | 1645 | except:\r |
| | 1646 | EdkLogger.warn(None, "Cannot open file to read", self._MapFileName)\r |
| | 1647 | \r |
| | 1648 | ##\r |
| | 1649 | # Invokes EOT tool to get the predicted the execution order.\r |
| | 1650 | #\r |
| | 1651 | # This function invokes EOT tool to calculate the predicted dispatch order\r |
| | 1652 | #\r |
| | 1653 | # @param self: The object pointer\r |
| | 1654 | #\r |
| | 1655 | def _InvokeEotTool(self):\r |
| | 1656 | if self._EotToolInvoked:\r |
| | 1657 | return\r |
| | 1658 | \r |
| | 1659 | self._EotToolInvoked = True\r |
| | 1660 | FvFileList = []\r |
| | 1661 | for FvName in self._FvList:\r |
| | 1662 | FvFile = os.path.join(self._FvDir, FvName + ".Fv")\r |
| | 1663 | if os.path.isfile(FvFile):\r |
| | 1664 | FvFileList.append(FvFile)\r |
| | 1665 | \r |
| | 1666 | if len(FvFileList) == 0:\r |
| | 1667 | return\r |
| | 1668 | #\r |
| | 1669 | # Write source file list and GUID file list to an intermediate file\r |
| | 1670 | # as the input for EOT tool and dispatch List as the output file\r |
| | 1671 | # from EOT tool.\r |
| | 1672 | #\r |
| | 1673 | SourceList = os.path.join(self._EotDir, "SourceFile.txt")\r |
| | 1674 | GuidList = os.path.join(self._EotDir, "GuidList.txt")\r |
| | 1675 | DispatchList = os.path.join(self._EotDir, "Dispatch.txt")\r |
| | 1676 | \r |
| | 1677 | TempFile = []\r |
| | 1678 | for Item in self._SourceList:\r |
| | 1679 | FileWrite(TempFile, Item)\r |
| | 1680 | SaveFileOnChange(SourceList, "".join(TempFile), False)\r |
| | 1681 | TempFile = []\r |
| | 1682 | for Key in self._GuidMap:\r |
| | 1683 | FileWrite(TempFile, "%s %s" % (Key, self._GuidMap[Key]))\r |
| | 1684 | SaveFileOnChange(GuidList, "".join(TempFile), False)\r |
| | 1685 | \r |
| | 1686 | try:\r |
| | 1687 | from Eot.EotMain import Eot\r |
| | 1688 | \r |
| | 1689 | #\r |
| | 1690 | # Invoke EOT tool and echo its runtime performance\r |
| | 1691 | #\r |
| | 1692 | EotStartTime = time.time()\r |
| | 1693 | Eot(CommandLineOption=False, SourceFileList=SourceList, GuidList=GuidList,\r |
| | 1694 | FvFileList=' '.join(FvFileList), Dispatch=DispatchList, IsInit=True)\r |
| | 1695 | EotEndTime = time.time()\r |
| | 1696 | EotDuration = time.strftime("%H:%M:%S", time.gmtime(int(round(EotEndTime - EotStartTime))))\r |
| | 1697 | EdkLogger.quiet("EOT run time: %s\n" % EotDuration)\r |
| | 1698 | \r |
| | 1699 | #\r |
| | 1700 | # Parse the output of EOT tool\r |
| | 1701 | #\r |
| | 1702 | for Line in open(DispatchList):\r |
| | 1703 | if len(Line.split()) < 4:\r |
| | 1704 | continue\r |
| | 1705 | (Guid, Phase, FfsName, FilePath) = Line.split()\r |
| | 1706 | Symbol = self._FfsEntryPoint.get(Guid, [FfsName, ""])[0]\r |
| | 1707 | if len(Symbol) > self.MaxLen:\r |
| | 1708 | self.MaxLen = len(Symbol)\r |
| | 1709 | self.ItemList.append((Phase, Symbol, FilePath))\r |
| | 1710 | except:\r |
| | 1711 | EdkLogger.quiet("(Python %s on %s\n%s)" % (platform.python_version(), sys.platform, traceback.format_exc()))\r |
| | 1712 | EdkLogger.warn(None, "Failed to generate execution order prediction report, for some error occurred in executing EOT.")\r |
| | 1713 | \r |
| | 1714 | \r |
| | 1715 | ##\r |
| | 1716 | # Generate platform execution order report\r |
| | 1717 | #\r |
| | 1718 | # This function generates the predicted module execution order.\r |
| | 1719 | #\r |
| | 1720 | # @param self The object pointer\r |
| | 1721 | # @param File The file object for report\r |
| | 1722 | #\r |
| | 1723 | def _GenerateExecutionOrderReport(self, File):\r |
| | 1724 | self._InvokeEotTool()\r |
| | 1725 | if len(self.ItemList) == 0:\r |
| | 1726 | return\r |
| | 1727 | FileWrite(File, gSectionStart)\r |
| | 1728 | FileWrite(File, "Execution Order Prediction")\r |
| | 1729 | FileWrite(File, "*P PEI phase")\r |
| | 1730 | FileWrite(File, "*D DXE phase")\r |
| | 1731 | FileWrite(File, "*E Module INF entry point name")\r |
| | 1732 | FileWrite(File, "*N Module notification function name")\r |
| | 1733 | \r |
| | 1734 | FileWrite(File, "Type %-*s %s" % (self.MaxLen, "Symbol", "Module INF Path"))\r |
| | 1735 | FileWrite(File, gSectionSep)\r |
| | 1736 | for Item in self.ItemList:\r |
| | 1737 | FileWrite(File, "*%sE %-*s %s" % (Item[0], self.MaxLen, Item[1], Item[2]))\r |
| | 1738 | \r |
| | 1739 | FileWrite(File, gSectionStart)\r |
| | 1740 | \r |
| | 1741 | ##\r |
| | 1742 | # Generate Fixed Address report.\r |
| | 1743 | #\r |
| | 1744 | # This function generate the predicted fixed address report for a module\r |
| | 1745 | # specified by Guid.\r |
| | 1746 | #\r |
| | 1747 | # @param self The object pointer\r |
| | 1748 | # @param File The file object for report\r |
| | 1749 | # @param Guid The module Guid value.\r |
| | 1750 | # @param NotifyList The list of all notify function in a module\r |
| | 1751 | #\r |
| | 1752 | def _GenerateFixedAddressReport(self, File, Guid, NotifyList):\r |
| | 1753 | self._ParseMapFile()\r |
| | 1754 | FixedAddressList = self.FixedMapDict.get(Guid)\r |
| | 1755 | if not FixedAddressList:\r |
| | 1756 | return\r |
| | 1757 | \r |
| | 1758 | FileWrite(File, gSubSectionStart)\r |
| | 1759 | FileWrite(File, "Fixed Address Prediction")\r |
| | 1760 | FileWrite(File, "*I Image Loading Address")\r |
| | 1761 | FileWrite(File, "*E Entry Point Address")\r |
| | 1762 | FileWrite(File, "*N Notification Function Address")\r |
| | 1763 | FileWrite(File, "*F Flash Address")\r |
| | 1764 | FileWrite(File, "*M Memory Address")\r |
| | 1765 | FileWrite(File, "*S SMM RAM Offset")\r |
| | 1766 | FileWrite(File, "TOM Top of Memory")\r |
| | 1767 | \r |
| | 1768 | FileWrite(File, "Type Address Name")\r |
| | 1769 | FileWrite(File, gSubSectionSep)\r |
| | 1770 | for Item in FixedAddressList:\r |
| | 1771 | Type = Item[0]\r |
| | 1772 | Value = Item[1]\r |
| | 1773 | Symbol = Item[2]\r |
| | 1774 | if Symbol == "*I":\r |
| | 1775 | Name = "(Image Base)"\r |
| | 1776 | elif Symbol == "*E":\r |
| | 1777 | Name = self._FfsEntryPoint.get(Guid, ["", "_ModuleEntryPoint"])[1]\r |
| | 1778 | elif Symbol in NotifyList:\r |
| | 1779 | Name = Symbol\r |
| | 1780 | Symbol = "*N"\r |
| | 1781 | else:\r |
| | 1782 | continue\r |
| | 1783 | \r |
| | 1784 | if "Flash" in Type:\r |
| | 1785 | Symbol += "F"\r |
| | 1786 | elif "Memory" in Type:\r |
| | 1787 | Symbol += "M"\r |
| | 1788 | else:\r |
| | 1789 | Symbol += "S"\r |
| | 1790 | \r |
| | 1791 | if Value[0] == "-":\r |
| | 1792 | Value = "TOM" + Value\r |
| | 1793 | \r |
| | 1794 | FileWrite(File, "%s %-16s %s" % (Symbol, Value, Name))\r |
| | 1795 | \r |
| | 1796 | ##\r |
| | 1797 | # Generate report for the prediction part\r |
| | 1798 | #\r |
| | 1799 | # This function generate the predicted fixed address report for a module or\r |
| | 1800 | # predicted module execution order for a platform.\r |
| | 1801 | # If the input Guid is None, then, it generates the predicted module execution order;\r |
| | 1802 | # otherwise it generated the module fixed loading address for the module specified by\r |
| | 1803 | # Guid.\r |
| | 1804 | #\r |
| | 1805 | # @param self The object pointer\r |
| | 1806 | # @param File The file object for report\r |
| | 1807 | # @param Guid The module Guid value.\r |
| | 1808 | #\r |
| | 1809 | def GenerateReport(self, File, Guid):\r |
| | 1810 | if Guid:\r |
| | 1811 | self._GenerateFixedAddressReport(File, Guid.upper(), [])\r |
| | 1812 | else:\r |
| | 1813 | self._GenerateExecutionOrderReport(File)\r |
| | 1814 | \r |
| | 1815 | ##\r |
| | 1816 | # Reports FD region information\r |
| | 1817 | #\r |
| | 1818 | # This class reports the FD subsection in the build report file.\r |
| | 1819 | # It collects region information of platform flash device.\r |
| | 1820 | # If the region is a firmware volume, it lists the set of modules\r |
| | 1821 | # and its space information; otherwise, it only lists its region name,\r |
| | 1822 | # base address and size in its sub-section header.\r |
| | 1823 | # If there are nesting FVs, the nested FVs will list immediate after\r |
| | 1824 | # this FD region subsection\r |
| | 1825 | #\r |
| | 1826 | class FdRegionReport(object):\r |
| | 1827 | ##\r |
| | 1828 | # Discover all the nested FV name list.\r |
| | 1829 | #\r |
| | 1830 | # This is an internal worker function to discover the all the nested FV information\r |
| | 1831 | # in the parent firmware volume. It uses deep first search algorithm recursively to\r |
| | 1832 | # find all the FV list name and append them to the list.\r |
| | 1833 | #\r |
| | 1834 | # @param self The object pointer\r |
| | 1835 | # @param FvName The name of current firmware file system\r |
| | 1836 | # @param Wa Workspace context information\r |
| | 1837 | #\r |
| | 1838 | def _DiscoverNestedFvList(self, FvName, Wa):\r |
| | 1839 | FvDictKey=FvName.upper()\r |
| | 1840 | if FvDictKey in Wa.FdfProfile.FvDict:\r |
| | 1841 | for Ffs in Wa.FdfProfile.FvDict[FvName.upper()].FfsList:\r |
| | 1842 | for Section in Ffs.SectionList:\r |
| | 1843 | try:\r |
| | 1844 | for FvSection in Section.SectionList:\r |
| | 1845 | if FvSection.FvName in self.FvList:\r |
| | 1846 | continue\r |
| | 1847 | self._GuidsDb[Ffs.NameGuid.upper()] = FvSection.FvName\r |
| | 1848 | self.FvList.append(FvSection.FvName)\r |
| | 1849 | self.FvInfo[FvSection.FvName] = ("Nested FV", 0, 0)\r |
| | 1850 | self._DiscoverNestedFvList(FvSection.FvName, Wa)\r |
| | 1851 | except AttributeError:\r |
| | 1852 | pass\r |
| | 1853 | \r |
| | 1854 | ##\r |
| | 1855 | # Constructor function for class FdRegionReport\r |
| | 1856 | #\r |
| | 1857 | # This constructor function generates FdRegionReport object for a specified FdRegion.\r |
| | 1858 | # If the FdRegion is a firmware volume, it will recursively find all its nested Firmware\r |
| | 1859 | # volume list. This function also collects GUID map in order to dump module identification\r |
| | 1860 | # in the final report.\r |
| | 1861 | #\r |
| | 1862 | # @param self: The object pointer\r |
| | 1863 | # @param FdRegion The current FdRegion object\r |
| | 1864 | # @param Wa Workspace context information\r |
| | 1865 | #\r |
| | 1866 | def __init__(self, FdRegion, Wa):\r |
| | 1867 | self.Type = FdRegion.RegionType\r |
| | 1868 | self.BaseAddress = FdRegion.Offset\r |
| | 1869 | self.Size = FdRegion.Size\r |
| | 1870 | self.FvList = []\r |
| | 1871 | self.FvInfo = {}\r |
| | 1872 | self._GuidsDb = {}\r |
| | 1873 | self._FvDir = Wa.FvDir\r |
| | 1874 | self._WorkspaceDir = Wa.WorkspaceDir\r |
| | 1875 | \r |
| | 1876 | #\r |
| | 1877 | # If the input FdRegion is not a firmware volume,\r |
| | 1878 | # we are done.\r |
| | 1879 | #\r |
| | 1880 | if self.Type != BINARY_FILE_TYPE_FV:\r |
| | 1881 | return\r |
| | 1882 | \r |
| | 1883 | #\r |
| | 1884 | # Find all nested FVs in the FdRegion\r |
| | 1885 | #\r |
| | 1886 | for FvName in FdRegion.RegionDataList:\r |
| | 1887 | if FvName in self.FvList:\r |
| | 1888 | continue\r |
| | 1889 | self.FvList.append(FvName)\r |
| | 1890 | self.FvInfo[FvName] = ("Fd Region", self.BaseAddress, self.Size)\r |
| | 1891 | self._DiscoverNestedFvList(FvName, Wa)\r |
| | 1892 | \r |
| | 1893 | PlatformPcds = {}\r |
| | 1894 | #\r |
| | 1895 | # Collect PCDs declared in DEC files.\r |
| | 1896 | #\r |
| | 1897 | for Pa in Wa.AutoGenObjectList:\r |
| | 1898 | for Package in Pa.PackageList:\r |
| | 1899 | for (TokenCName, TokenSpaceGuidCName, DecType) in Package.Pcds:\r |
| | 1900 | DecDefaultValue = Package.Pcds[TokenCName, TokenSpaceGuidCName, DecType].DefaultValue\r |
| | 1901 | PlatformPcds[(TokenCName, TokenSpaceGuidCName)] = DecDefaultValue\r |
| | 1902 | #\r |
| | 1903 | # Collect PCDs defined in DSC file\r |
| | 1904 | #\r |
| | 1905 | for Pa in Wa.AutoGenObjectList:\r |
| | 1906 | for (TokenCName, TokenSpaceGuidCName) in Pa.Platform.Pcds:\r |
| | 1907 | DscDefaultValue = Pa.Platform.Pcds[(TokenCName, TokenSpaceGuidCName)].DefaultValue\r |
| | 1908 | PlatformPcds[(TokenCName, TokenSpaceGuidCName)] = DscDefaultValue\r |
| | 1909 | \r |
| | 1910 | #\r |
| | 1911 | # Add PEI and DXE a priori files GUIDs defined in PI specification.\r |
| | 1912 | #\r |
| | 1913 | self._GuidsDb[PEI_APRIORI_GUID] = "PEI Apriori"\r |
| | 1914 | self._GuidsDb[DXE_APRIORI_GUID] = "DXE Apriori"\r |
| | 1915 | #\r |
| | 1916 | # Add ACPI table storage file\r |
| | 1917 | #\r |
| | 1918 | self._GuidsDb["7E374E25-8E01-4FEE-87F2-390C23C606CD"] = "ACPI table storage"\r |
| | 1919 | \r |
| | 1920 | for Pa in Wa.AutoGenObjectList:\r |
| | 1921 | for ModuleKey in Pa.Platform.Modules:\r |
| | 1922 | M = Pa.Platform.Modules[ModuleKey].M\r |
| | 1923 | InfPath = mws.join(Wa.WorkspaceDir, M.MetaFile.File)\r |
| | 1924 | self._GuidsDb[M.Guid.upper()] = "%s (%s)" % (M.Module.BaseName, InfPath)\r |
| | 1925 | \r |
| | 1926 | #\r |
| | 1927 | # Collect the GUID map in the FV firmware volume\r |
| | 1928 | #\r |
| | 1929 | for FvName in self.FvList:\r |
| | 1930 | FvDictKey=FvName.upper()\r |
| | 1931 | if FvDictKey in Wa.FdfProfile.FvDict:\r |
| | 1932 | for Ffs in Wa.FdfProfile.FvDict[FvName.upper()].FfsList:\r |
| | 1933 | try:\r |
| | 1934 | #\r |
| | 1935 | # collect GUID map for binary EFI file in FDF file.\r |
| | 1936 | #\r |
| | 1937 | Guid = Ffs.NameGuid.upper()\r |
| | 1938 | Match = gPcdGuidPattern.match(Ffs.NameGuid)\r |
| | 1939 | if Match:\r |
| | 1940 | PcdTokenspace = Match.group(1)\r |
| | 1941 | PcdToken = Match.group(2)\r |
| | 1942 | if (PcdToken, PcdTokenspace) in PlatformPcds:\r |
| | 1943 | GuidValue = PlatformPcds[(PcdToken, PcdTokenspace)]\r |
| | 1944 | Guid = GuidStructureByteArrayToGuidString(GuidValue).upper()\r |
| | 1945 | for Section in Ffs.SectionList:\r |
| | 1946 | try:\r |
| | 1947 | ModuleSectFile = mws.join(Wa.WorkspaceDir, Section.SectFileName)\r |
| | 1948 | self._GuidsDb[Guid] = ModuleSectFile\r |
| | 1949 | except AttributeError:\r |
| | 1950 | pass\r |
| | 1951 | except AttributeError:\r |
| | 1952 | pass\r |
| | 1953 | \r |
| | 1954 | \r |
| | 1955 | ##\r |
| | 1956 | # Internal worker function to generate report for the FD region\r |
| | 1957 | #\r |
| | 1958 | # This internal worker function to generate report for the FD region.\r |
| | 1959 | # It the type is firmware volume, it lists offset and module identification.\r |
| | 1960 | #\r |
| | 1961 | # @param self The object pointer\r |
| | 1962 | # @param File The file object for report\r |
| | 1963 | # @param Title The title for the FD subsection\r |
| | 1964 | # @param BaseAddress The base address for the FD region\r |
| | 1965 | # @param Size The size of the FD region\r |
| | 1966 | # @param FvName The FV name if the FD region is a firmware volume\r |
| | 1967 | #\r |
| | 1968 | def _GenerateReport(self, File, Title, Type, BaseAddress, Size=0, FvName=None):\r |
| | 1969 | FileWrite(File, gSubSectionStart)\r |
| | 1970 | FileWrite(File, Title)\r |
| | 1971 | FileWrite(File, "Type: %s" % Type)\r |
| | 1972 | FileWrite(File, "Base Address: 0x%X" % BaseAddress)\r |
| | 1973 | \r |
| | 1974 | if self.Type == BINARY_FILE_TYPE_FV:\r |
| | 1975 | FvTotalSize = 0\r |
| | 1976 | FvTakenSize = 0\r |
| | 1977 | FvFreeSize = 0\r |
| | 1978 | if FvName.upper().endswith('.FV'):\r |
| | 1979 | FileExt = FvName + ".txt"\r |
| | 1980 | else:\r |
| | 1981 | FileExt = FvName + ".Fv.txt"\r |
| | 1982 | \r |
| | 1983 | if not os.path.isfile(FileExt):\r |
| | 1984 | FvReportFileName = mws.join(self._WorkspaceDir, FileExt)\r |
| | 1985 | if not os.path.isfile(FvReportFileName):\r |
| | 1986 | FvReportFileName = os.path.join(self._FvDir, FileExt)\r |
| | 1987 | try:\r |
| | 1988 | #\r |
| | 1989 | # Collect size info in the firmware volume.\r |
| | 1990 | #\r |
| | 1991 | FvReport = open(FvReportFileName).read()\r |
| | 1992 | Match = gFvTotalSizePattern.search(FvReport)\r |
| | 1993 | if Match:\r |
| | 1994 | FvTotalSize = int(Match.group(1), 16)\r |
| | 1995 | Match = gFvTakenSizePattern.search(FvReport)\r |
| | 1996 | if Match:\r |
| | 1997 | FvTakenSize = int(Match.group(1), 16)\r |
| | 1998 | FvFreeSize = FvTotalSize - FvTakenSize\r |
| | 1999 | #\r |
| | 2000 | # Write size information to the report file.\r |
| | 2001 | #\r |
| | 2002 | FileWrite(File, "Size: 0x%X (%.0fK)" % (FvTotalSize, FvTotalSize / 1024.0))\r |
| | 2003 | FileWrite(File, "Fv Name: %s (%.1f%% Full)" % (FvName, FvTakenSize * 100.0 / FvTotalSize))\r |
| | 2004 | FileWrite(File, "Occupied Size: 0x%X (%.0fK)" % (FvTakenSize, FvTakenSize / 1024.0))\r |
| | 2005 | FileWrite(File, "Free Size: 0x%X (%.0fK)" % (FvFreeSize, FvFreeSize / 1024.0))\r |
| | 2006 | FileWrite(File, "Offset Module")\r |
| | 2007 | FileWrite(File, gSubSectionSep)\r |
| | 2008 | #\r |
| | 2009 | # Write module offset and module identification to the report file.\r |
| | 2010 | #\r |
| | 2011 | OffsetInfo = {}\r |
| | 2012 | for Match in gOffsetGuidPattern.finditer(FvReport):\r |
| | 2013 | Guid = Match.group(2).upper()\r |
| | 2014 | OffsetInfo[Match.group(1)] = self._GuidsDb.get(Guid, Guid)\r |
| | 2015 | OffsetList = sorted(OffsetInfo.keys())\r |
| | 2016 | for Offset in OffsetList:\r |
| | 2017 | FileWrite (File, "%s %s" % (Offset, OffsetInfo[Offset]))\r |
| | 2018 | except IOError:\r |
| | 2019 | EdkLogger.warn(None, "Fail to read report file", FvReportFileName)\r |
| | 2020 | else:\r |
| | 2021 | FileWrite(File, "Size: 0x%X (%.0fK)" % (Size, Size / 1024.0))\r |
| | 2022 | FileWrite(File, gSubSectionEnd)\r |
| | 2023 | \r |
| | 2024 | ##\r |
| | 2025 | # Generate report for the FD region\r |
| | 2026 | #\r |
| | 2027 | # This function generates report for the FD region.\r |
| | 2028 | #\r |
| | 2029 | # @param self The object pointer\r |
| | 2030 | # @param File The file object for report\r |
| | 2031 | #\r |
| | 2032 | def GenerateReport(self, File):\r |
| | 2033 | if (len(self.FvList) > 0):\r |
| | 2034 | for FvItem in self.FvList:\r |
| | 2035 | Info = self.FvInfo[FvItem]\r |
| | 2036 | self._GenerateReport(File, Info[0], TAB_FV_DIRECTORY, Info[1], Info[2], FvItem)\r |
| | 2037 | else:\r |
| | 2038 | self._GenerateReport(File, "FD Region", self.Type, self.BaseAddress, self.Size)\r |
| | 2039 | \r |
| | 2040 | ##\r |
| | 2041 | # Reports FD information\r |
| | 2042 | #\r |
| | 2043 | # This class reports the FD section in the build report file.\r |
| | 2044 | # It collects flash device information for a platform.\r |
| | 2045 | #\r |
| | 2046 | class FdReport(object):\r |
| | 2047 | ##\r |
| | 2048 | # Constructor function for class FdReport\r |
| | 2049 | #\r |
| | 2050 | # This constructor function generates FdReport object for a specified\r |
| | 2051 | # firmware device.\r |
| | 2052 | #\r |
| | 2053 | # @param self The object pointer\r |
| | 2054 | # @param Fd The current Firmware device object\r |
| | 2055 | # @param Wa Workspace context information\r |
| | 2056 | #\r |
| | 2057 | def __init__(self, Fd, Wa):\r |
| | 2058 | self.FdName = Fd.FdUiName\r |
| | 2059 | self.BaseAddress = Fd.BaseAddress\r |
| | 2060 | self.Size = Fd.Size\r |
| | 2061 | self.FdRegionList = [FdRegionReport(FdRegion, Wa) for FdRegion in Fd.RegionList]\r |
| | 2062 | self.FvPath = os.path.join(Wa.BuildDir, TAB_FV_DIRECTORY)\r |
| | 2063 | self.VPDBaseAddress = 0\r |
| | 2064 | self.VPDSize = 0\r |
| | 2065 | for index, FdRegion in enumerate(Fd.RegionList):\r |
| | 2066 | if str(FdRegion.RegionType) == 'FILE' and Wa.Platform.VpdToolGuid in str(FdRegion.RegionDataList):\r |
| | 2067 | self.VPDBaseAddress = self.FdRegionList[index].BaseAddress\r |
| | 2068 | self.VPDSize = self.FdRegionList[index].Size\r |
| | 2069 | break\r |
| | 2070 | \r |
| | 2071 | ##\r |
| | 2072 | # Generate report for the firmware device.\r |
| | 2073 | #\r |
| | 2074 | # This function generates report for the firmware device.\r |
| | 2075 | #\r |
| | 2076 | # @param self The object pointer\r |
| | 2077 | # @param File The file object for report\r |
| | 2078 | #\r |
| | 2079 | def GenerateReport(self, File):\r |
| | 2080 | FileWrite(File, gSectionStart)\r |
| | 2081 | FileWrite(File, "Firmware Device (FD)")\r |
| | 2082 | FileWrite(File, "FD Name: %s" % self.FdName)\r |
| | 2083 | FileWrite(File, "Base Address: %s" % self.BaseAddress)\r |
| | 2084 | FileWrite(File, "Size: 0x%X (%.0fK)" % (self.Size, self.Size / 1024.0))\r |
| | 2085 | if len(self.FdRegionList) > 0:\r |
| | 2086 | FileWrite(File, gSectionSep)\r |
| | 2087 | for FdRegionItem in self.FdRegionList:\r |
| | 2088 | FdRegionItem.GenerateReport(File)\r |
| | 2089 | \r |
| | 2090 | if VPDPcdList:\r |
| | 2091 | VPDPcdList.sort(key=lambda x: int(x[2], 0))\r |
| | 2092 | FileWrite(File, gSubSectionStart)\r |
| | 2093 | FileWrite(File, "FD VPD Region")\r |
| | 2094 | FileWrite(File, "Base Address: 0x%X" % self.VPDBaseAddress)\r |
| | 2095 | FileWrite(File, "Size: 0x%X (%.0fK)" % (self.VPDSize, self.VPDSize / 1024.0))\r |
| | 2096 | FileWrite(File, gSubSectionSep)\r |
| | 2097 | for item in VPDPcdList:\r |
| | 2098 | # Add BaseAddress for offset\r |
| | 2099 | Offset = '0x%08X' % (int(item[2], 16) + self.VPDBaseAddress)\r |
| | 2100 | IsByteArray, ArrayList = ByteArrayForamt(item[-1])\r |
| | 2101 | Skuinfo = item[1]\r |
| | 2102 | if len(GlobalData.gSkuids) == 1 :\r |
| | 2103 | Skuinfo = GlobalData.gSkuids[0]\r |
| | 2104 | if IsByteArray:\r |
| | 2105 | FileWrite(File, "%s | %s | %s | %s | %s" % (item[0], Skuinfo, Offset, item[3], '{'))\r |
| | 2106 | for Array in ArrayList:\r |
| | 2107 | FileWrite(File, Array)\r |
| | 2108 | else:\r |
| | 2109 | FileWrite(File, "%s | %s | %s | %s | %s" % (item[0], Skuinfo, Offset, item[3], item[-1]))\r |
| | 2110 | FileWrite(File, gSubSectionEnd)\r |
| | 2111 | FileWrite(File, gSectionEnd)\r |
| | 2112 | \r |
| | 2113 | \r |
| | 2114 | \r |
| | 2115 | ##\r |
| | 2116 | # Reports platform information\r |
| | 2117 | #\r |
| | 2118 | # This class reports the whole platform information\r |
| | 2119 | #\r |
| | 2120 | class PlatformReport(object):\r |
| | 2121 | ##\r |
| | 2122 | # Constructor function for class PlatformReport\r |
| | 2123 | #\r |
| | 2124 | # This constructor function generates PlatformReport object a platform build.\r |
| | 2125 | # It generates report for platform summary, flash, global PCDs and detailed\r |
| | 2126 | # module information for modules involved in platform build.\r |
| | 2127 | #\r |
| | 2128 | # @param self The object pointer\r |
| | 2129 | # @param Wa Workspace context information\r |
| | 2130 | # @param MaList The list of modules in the platform build\r |
| | 2131 | #\r |
| | 2132 | def __init__(self, Wa, MaList, ReportType):\r |
| | 2133 | self._WorkspaceDir = Wa.WorkspaceDir\r |
| | 2134 | self.PlatformName = Wa.Name\r |
| | 2135 | self.PlatformDscPath = Wa.Platform\r |
| | 2136 | self.Architectures = " ".join(Wa.ArchList)\r |
| | 2137 | self.ToolChain = Wa.ToolChain\r |
| | 2138 | self.Target = Wa.BuildTarget\r |
| | 2139 | self.OutputPath = os.path.join(Wa.WorkspaceDir, Wa.OutputDir)\r |
| | 2140 | self.BuildEnvironment = platform.platform()\r |
| | 2141 | \r |
| | 2142 | self.PcdReport = None\r |
| | 2143 | if "PCD" in ReportType:\r |
| | 2144 | self.PcdReport = PcdReport(Wa)\r |
| | 2145 | \r |
| | 2146 | self.FdReportList = []\r |
| | 2147 | if "FLASH" in ReportType and Wa.FdfProfile and MaList is None:\r |
| | 2148 | for Fd in Wa.FdfProfile.FdDict:\r |
| | 2149 | self.FdReportList.append(FdReport(Wa.FdfProfile.FdDict[Fd], Wa))\r |
| | 2150 | \r |
| | 2151 | self.PredictionReport = None\r |
| | 2152 | if "FIXED_ADDRESS" in ReportType or "EXECUTION_ORDER" in ReportType:\r |
| | 2153 | self.PredictionReport = PredictionReport(Wa)\r |
| | 2154 | \r |
| | 2155 | self.DepexParser = None\r |
| | 2156 | if "DEPEX" in ReportType:\r |
| | 2157 | self.DepexParser = DepexParser(Wa)\r |
| | 2158 | \r |
| | 2159 | self.ModuleReportList = []\r |
| | 2160 | if MaList is not None:\r |
| | 2161 | self._IsModuleBuild = True\r |
| | 2162 | for Ma in MaList:\r |
| | 2163 | self.ModuleReportList.append(ModuleReport(Ma, ReportType))\r |
| | 2164 | else:\r |
| | 2165 | self._IsModuleBuild = False\r |
| | 2166 | for Pa in Wa.AutoGenObjectList:\r |
| | 2167 | ModuleAutoGenList = []\r |
| | 2168 | for ModuleKey in Pa.Platform.Modules:\r |
| | 2169 | ModuleAutoGenList.append(Pa.Platform.Modules[ModuleKey].M)\r |
| | 2170 | if GlobalData.gFdfParser is not None:\r |
| | 2171 | if Pa.Arch in GlobalData.gFdfParser.Profile.InfDict:\r |
| | 2172 | INFList = GlobalData.gFdfParser.Profile.InfDict[Pa.Arch]\r |
| | 2173 | for InfName in INFList:\r |
| | 2174 | InfClass = PathClass(NormPath(InfName), Wa.WorkspaceDir, Pa.Arch)\r |
| | 2175 | Ma = ModuleAutoGen(Wa, InfClass, Pa.BuildTarget, Pa.ToolChain, Pa.Arch, Wa.MetaFile, Pa.DataPipe)\r |
| | 2176 | if Ma is None:\r |
| | 2177 | continue\r |
| | 2178 | if Ma not in ModuleAutoGenList:\r |
| | 2179 | ModuleAutoGenList.append(Ma)\r |
| | 2180 | for MGen in ModuleAutoGenList:\r |
| | 2181 | self.ModuleReportList.append(ModuleReport(MGen, ReportType))\r |
| | 2182 | \r |
| | 2183 | \r |
| | 2184 | \r |
| | 2185 | ##\r |
| | 2186 | # Generate report for the whole platform.\r |
| | 2187 | #\r |
| | 2188 | # This function generates report for platform information.\r |
| | 2189 | # It comprises of platform summary, global PCD, flash and\r |
| | 2190 | # module list sections.\r |
| | 2191 | #\r |
| | 2192 | # @param self The object pointer\r |
| | 2193 | # @param File The file object for report\r |
| | 2194 | # @param BuildDuration The total time to build the modules\r |
| | 2195 | # @param AutoGenTime The total time of AutoGen Phase\r |
| | 2196 | # @param MakeTime The total time of Make Phase\r |
| | 2197 | # @param GenFdsTime The total time of GenFds Phase\r |
| | 2198 | # @param ReportType The kind of report items in the final report file\r |
| | 2199 | #\r |
| | 2200 | def GenerateReport(self, File, BuildDuration, AutoGenTime, MakeTime, GenFdsTime, ReportType):\r |
| | 2201 | FileWrite(File, "Platform Summary")\r |
| | 2202 | FileWrite(File, "Platform Name: %s" % self.PlatformName)\r |
| | 2203 | FileWrite(File, "Platform DSC Path: %s" % self.PlatformDscPath)\r |
| | 2204 | FileWrite(File, "Architectures: %s" % self.Architectures)\r |
| | 2205 | FileWrite(File, "Tool Chain: %s" % self.ToolChain)\r |
| | 2206 | FileWrite(File, "Target: %s" % self.Target)\r |
| | 2207 | if GlobalData.gSkuids:\r |
| | 2208 | FileWrite(File, "SKUID: %s" % " ".join(GlobalData.gSkuids))\r |
| | 2209 | if GlobalData.gDefaultStores:\r |
| | 2210 | FileWrite(File, "DefaultStore: %s" % " ".join(GlobalData.gDefaultStores))\r |
| | 2211 | FileWrite(File, "Output Path: %s" % self.OutputPath)\r |
| | 2212 | FileWrite(File, "Build Environment: %s" % self.BuildEnvironment)\r |
| | 2213 | FileWrite(File, "Build Duration: %s" % BuildDuration)\r |
| | 2214 | if AutoGenTime:\r |
| | 2215 | FileWrite(File, "AutoGen Duration: %s" % AutoGenTime)\r |
| | 2216 | if MakeTime:\r |
| | 2217 | FileWrite(File, "Make Duration: %s" % MakeTime)\r |
| | 2218 | if GenFdsTime:\r |
| | 2219 | FileWrite(File, "GenFds Duration: %s" % GenFdsTime)\r |
| | 2220 | FileWrite(File, "Report Content: %s" % ", ".join(ReportType))\r |
| | 2221 | \r |
| | 2222 | if GlobalData.MixedPcd:\r |
| | 2223 | FileWrite(File, gSectionStart)\r |
| | 2224 | FileWrite(File, "The following PCDs use different access methods:")\r |
| | 2225 | FileWrite(File, gSectionSep)\r |
| | 2226 | for PcdItem in GlobalData.MixedPcd:\r |
| | 2227 | FileWrite(File, "%s.%s" % (str(PcdItem[1]), str(PcdItem[0])))\r |
| | 2228 | FileWrite(File, gSectionEnd)\r |
| | 2229 | \r |
| | 2230 | if not self._IsModuleBuild:\r |
| | 2231 | if "PCD" in ReportType:\r |
| | 2232 | self.PcdReport.GenerateReport(File, None)\r |
| | 2233 | \r |
| | 2234 | if "FLASH" in ReportType:\r |
| | 2235 | for FdReportListItem in self.FdReportList:\r |
| | 2236 | FdReportListItem.GenerateReport(File)\r |
| | 2237 | \r |
| | 2238 | for ModuleReportItem in self.ModuleReportList:\r |
| | 2239 | ModuleReportItem.GenerateReport(File, self.PcdReport, self.PredictionReport, self.DepexParser, ReportType)\r |
| | 2240 | \r |
| | 2241 | if not self._IsModuleBuild:\r |
| | 2242 | if "EXECUTION_ORDER" in ReportType:\r |
| | 2243 | self.PredictionReport.GenerateReport(File, None)\r |
| | 2244 | \r |
| | 2245 | ## BuildReport class\r |
| | 2246 | #\r |
| | 2247 | # This base class contain the routines to collect data and then\r |
| | 2248 | # applies certain format to the output report\r |
| | 2249 | #\r |
| | 2250 | class BuildReport(object):\r |
| | 2251 | ##\r |
| | 2252 | # Constructor function for class BuildReport\r |
| | 2253 | #\r |
| | 2254 | # This constructor function generates BuildReport object a platform build.\r |
| | 2255 | # It generates report for platform summary, flash, global PCDs and detailed\r |
| | 2256 | # module information for modules involved in platform build.\r |
| | 2257 | #\r |
| | 2258 | # @param self The object pointer\r |
| | 2259 | # @param ReportFile The file name to save report file\r |
| | 2260 | # @param ReportType The kind of report items in the final report file\r |
| | 2261 | #\r |
| | 2262 | def __init__(self, ReportFile, ReportType):\r |
| | 2263 | self.ReportFile = ReportFile\r |
| | 2264 | if ReportFile:\r |
| | 2265 | self.ReportList = []\r |
| | 2266 | self.ReportType = []\r |
| | 2267 | if ReportType:\r |
| | 2268 | for ReportTypeItem in ReportType:\r |
| | 2269 | if ReportTypeItem not in self.ReportType:\r |
| | 2270 | self.ReportType.append(ReportTypeItem)\r |
| | 2271 | else:\r |
| | 2272 | self.ReportType = ["PCD", "LIBRARY", "BUILD_FLAGS", "DEPEX", "HASH", "FLASH", "FIXED_ADDRESS"]\r |
| | 2273 | ##\r |
| | 2274 | # Adds platform report to the list\r |
| | 2275 | #\r |
| | 2276 | # This function adds a platform report to the final report list.\r |
| | 2277 | #\r |
| | 2278 | # @param self The object pointer\r |
| | 2279 | # @param Wa Workspace context information\r |
| | 2280 | # @param MaList The list of modules in the platform build\r |
| | 2281 | #\r |
| | 2282 | def AddPlatformReport(self, Wa, MaList=None):\r |
| | 2283 | if self.ReportFile:\r |
| | 2284 | self.ReportList.append((Wa, MaList))\r |
| | 2285 | \r |
| | 2286 | ##\r |
| | 2287 | # Generates the final report.\r |
| | 2288 | #\r |
| | 2289 | # This function generates platform build report. It invokes GenerateReport()\r |
| | 2290 | # method for every platform report in the list.\r |
| | 2291 | #\r |
| | 2292 | # @param self The object pointer\r |
| | 2293 | # @param BuildDuration The total time to build the modules\r |
| | 2294 | # @param AutoGenTime The total time of AutoGen phase\r |
| | 2295 | # @param MakeTime The total time of Make phase\r |
| | 2296 | # @param GenFdsTime The total time of GenFds phase\r |
| | 2297 | #\r |
| | 2298 | def GenerateReport(self, BuildDuration, AutoGenTime, MakeTime, GenFdsTime):\r |
| | 2299 | if self.ReportFile:\r |
| | 2300 | try:\r |
| | 2301 | File = []\r |
| | 2302 | for (Wa, MaList) in self.ReportList:\r |
| | 2303 | PlatformReport(Wa, MaList, self.ReportType).GenerateReport(File, BuildDuration, AutoGenTime, MakeTime, GenFdsTime, self.ReportType)\r |
| | 2304 | Content = FileLinesSplit(''.join(File), gLineMaxLength)\r |
| | 2305 | SaveFileOnChange(self.ReportFile, Content, False)\r |
| | 2306 | EdkLogger.quiet("Build report can be found at %s" % os.path.abspath(self.ReportFile))\r |
| | 2307 | except IOError:\r |
| | 2308 | EdkLogger.error(None, FILE_WRITE_FAILURE, ExtraData=self.ReportFile)\r |
| | 2309 | except:\r |
| | 2310 | EdkLogger.error("BuildReport", CODE_ERROR, "Unknown fatal error when generating build report", ExtraData=self.ReportFile, RaiseError=False)\r |
| | 2311 | EdkLogger.quiet("(Python %s on %s\n%s)" % (platform.python_version(), sys.platform, traceback.format_exc()))\r |
| | 2312 | \r |
| | 2313 | # This acts like the main() function for the script, unless it is 'import'ed into another script.\r |
| | 2314 | if __name__ == '__main__':\r |
| | 2315 | pass\r |
| | 2316 | \r |
projects / mirror_edk2.git / blame_incremental