MdePkg/Include: Add DCC and BCM2835 SPCR UART types

[mirror_edk2.git] / BaseTools / Source / Python / AutoGen / ModuleAutoGen.py

## @file\r
# Create makefile for MS nmake and GNU make\r
#\r
# Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>\r
# SPDX-License-Identifier: BSD-2-Clause-Patent\r
#\r
from __future__ import absolute_import\r
from AutoGen.AutoGen import AutoGen\r
from Common.LongFilePathSupport import LongFilePath, CopyLongFilePath\r
from Common.BuildToolError import *\r
from Common.DataType import *\r
from Common.Misc import *\r
from Common.StringUtils import NormPath,GetSplitList\r
from collections import defaultdict\r
from Workspace.WorkspaceCommon import OrderedListDict\r
import os.path as path\r
import copy\r
import hashlib\r
from . import InfSectionParser\r
from . import GenC\r
from . import GenMake\r
from . import GenDepex\r
from io import BytesIO\r
from GenPatchPcdTable.GenPatchPcdTable import parsePcdInfoFromMapFile\r
from Workspace.MetaFileCommentParser import UsageList\r
from .GenPcdDb import CreatePcdDatabaseCode\r
from Common.caching import cached_class_function\r
from AutoGen.ModuleAutoGenHelper import PlatformInfo,WorkSpaceInfo\r
import json\r
import tempfile\r
\r
## Mapping Makefile type\r
gMakeTypeMap = {TAB_COMPILER_MSFT:"nmake", "GCC":"gmake"}\r
#\r
# Regular expression for finding Include Directories, the difference between MSFT and INTEL/GCC/RVCT\r
# is the former use /I , the Latter used -I to specify include directories\r
#\r
gBuildOptIncludePatternMsft = re.compile(r"(?:.*?)/I[ \t]*([^ ]*)", re.MULTILINE | re.DOTALL)\r
gBuildOptIncludePatternOther = re.compile(r"(?:.*?)-I[ \t]*([^ ]*)", re.MULTILINE | re.DOTALL)\r
\r
## default file name for AutoGen\r
gAutoGenCodeFileName = "AutoGen.c"\r
gAutoGenHeaderFileName = "AutoGen.h"\r
gAutoGenStringFileName = "%(module_name)sStrDefs.h"\r
gAutoGenStringFormFileName = "%(module_name)sStrDefs.hpk"\r
gAutoGenDepexFileName = "%(module_name)s.depex"\r
gAutoGenImageDefFileName = "%(module_name)sImgDefs.h"\r
gAutoGenIdfFileName = "%(module_name)sIdf.hpk"\r
gInfSpecVersion = "0x00010017"\r
\r
#\r
# Match name = variable\r
#\r
gEfiVarStoreNamePattern = re.compile("\s*name\s*=\s*(\w+)")\r
#\r
# The format of guid in efivarstore statement likes following and must be correct:\r
# guid = {0xA04A27f4, 0xDF00, 0x4D42, {0xB5, 0x52, 0x39, 0x51, 0x13, 0x02, 0x11, 0x3D}}\r
#\r
gEfiVarStoreGuidPattern = re.compile("\s*guid\s*=\s*({.*?{.*?}\s*})")\r
\r
#\r
# Template string to generic AsBuilt INF\r
#\r
gAsBuiltInfHeaderString = TemplateString("""${header_comments}\r
\r
# DO NOT EDIT\r
# FILE auto-generated\r
\r
[Defines]\r
  INF_VERSION                = ${module_inf_version}\r
  BASE_NAME                  = ${module_name}\r
  FILE_GUID                  = ${module_guid}\r
  MODULE_TYPE                = ${module_module_type}${BEGIN}\r
  VERSION_STRING             = ${module_version_string}${END}${BEGIN}\r
  PCD_IS_DRIVER              = ${pcd_is_driver_string}${END}${BEGIN}\r
  UEFI_SPECIFICATION_VERSION = ${module_uefi_specification_version}${END}${BEGIN}\r
  PI_SPECIFICATION_VERSION   = ${module_pi_specification_version}${END}${BEGIN}\r
  ENTRY_POINT                = ${module_entry_point}${END}${BEGIN}\r
  UNLOAD_IMAGE               = ${module_unload_image}${END}${BEGIN}\r
  CONSTRUCTOR                = ${module_constructor}${END}${BEGIN}\r
  DESTRUCTOR                 = ${module_destructor}${END}${BEGIN}\r
  SHADOW                     = ${module_shadow}${END}${BEGIN}\r
  PCI_VENDOR_ID              = ${module_pci_vendor_id}${END}${BEGIN}\r
  PCI_DEVICE_ID              = ${module_pci_device_id}${END}${BEGIN}\r
  PCI_CLASS_CODE             = ${module_pci_class_code}${END}${BEGIN}\r
  PCI_REVISION               = ${module_pci_revision}${END}${BEGIN}\r
  BUILD_NUMBER               = ${module_build_number}${END}${BEGIN}\r
  SPEC                       = ${module_spec}${END}${BEGIN}\r
  UEFI_HII_RESOURCE_SECTION  = ${module_uefi_hii_resource_section}${END}${BEGIN}\r
  MODULE_UNI_FILE            = ${module_uni_file}${END}\r
\r
[Packages.${module_arch}]${BEGIN}\r
  ${package_item}${END}\r
\r
[Binaries.${module_arch}]${BEGIN}\r
  ${binary_item}${END}\r
\r
[PatchPcd.${module_arch}]${BEGIN}\r
  ${patchablepcd_item}\r
${END}\r
\r
[Protocols.${module_arch}]${BEGIN}\r
  ${protocol_item}\r
${END}\r
\r
[Ppis.${module_arch}]${BEGIN}\r
  ${ppi_item}\r
${END}\r
\r
[Guids.${module_arch}]${BEGIN}\r
  ${guid_item}\r
${END}\r
\r
[PcdEx.${module_arch}]${BEGIN}\r
  ${pcd_item}\r
${END}\r
\r
[LibraryClasses.${module_arch}]\r
## @LIB_INSTANCES${BEGIN}\r
#  ${libraryclasses_item}${END}\r
\r
${depexsection_item}\r
\r
${userextension_tianocore_item}\r
\r
${tail_comments}\r
\r
[BuildOptions.${module_arch}]\r
## @AsBuilt${BEGIN}\r
##   ${flags_item}${END}\r
""")\r
#\r
# extend lists contained in a dictionary with lists stored in another dictionary\r
# if CopyToDict is not derived from DefaultDict(list) then this may raise exception\r
#\r
def ExtendCopyDictionaryLists(CopyToDict, CopyFromDict):\r
    for Key in CopyFromDict:\r
        CopyToDict[Key].extend(CopyFromDict[Key])\r
\r
# Create a directory specified by a set of path elements and return the full path\r
def _MakeDir(PathList):\r
    RetVal = path.join(*PathList)\r
    CreateDirectory(RetVal)\r
    return RetVal\r
\r
#\r
# Convert string to C format array\r
#\r
def _ConvertStringToByteArray(Value):\r
    Value = Value.strip()\r
    if not Value:\r
        return None\r
    if Value[0] == '{':\r
        if not Value.endswith('}'):\r
            return None\r
        Value = Value.replace(' ', '').replace('{', '').replace('}', '')\r
        ValFields = Value.split(',')\r
        try:\r
            for Index in range(len(ValFields)):\r
                ValFields[Index] = str(int(ValFields[Index], 0))\r
        except ValueError:\r
            return None\r
        Value = '{' + ','.join(ValFields) + '}'\r
        return Value\r
\r
    Unicode = False\r
    if Value.startswith('L"'):\r
        if not Value.endswith('"'):\r
            return None\r
        Value = Value[1:]\r
        Unicode = True\r
    elif not Value.startswith('"') or not Value.endswith('"'):\r
        return None\r
\r
    Value = eval(Value)         # translate escape character\r
    NewValue = '{'\r
    for Index in range(0, len(Value)):\r
        if Unicode:\r
            NewValue = NewValue + str(ord(Value[Index]) % 0x10000) + ','\r
        else:\r
            NewValue = NewValue + str(ord(Value[Index]) % 0x100) + ','\r
    Value = NewValue + '0}'\r
    return Value\r
\r
## ModuleAutoGen class\r
#\r
# This class encapsules the AutoGen behaviors for the build tools. In addition to\r
# the generation of AutoGen.h and AutoGen.c, it will generate *.depex file according\r
# to the [depex] section in module's inf file.\r
#\r
class ModuleAutoGen(AutoGen):\r
    # call super().__init__ then call the worker function with different parameter count\r
    def __init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):\r
        if not hasattr(self, "_Init"):\r
            self._InitWorker(Workspace, MetaFile, Target, Toolchain, Arch, *args)\r
            self._Init = True\r
\r
    ## Cache the timestamps of metafiles of every module in a class attribute\r
    #\r
    TimeDict = {}\r
\r
    def __new__(cls, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):\r
#         check if this module is employed by active platform\r
        if not PlatformInfo(Workspace, args[0], Target, Toolchain, Arch,args[-1]).ValidModule(MetaFile):\r
            EdkLogger.verbose("Module [%s] for [%s] is not employed by active platform\n" \\r
                              % (MetaFile, Arch))\r
            return None\r
        return super(ModuleAutoGen, cls).__new__(cls, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
\r
    ## Initialize ModuleAutoGen\r
    #\r
    #   @param      Workspace           EdkIIWorkspaceBuild object\r
    #   @param      ModuleFile          The path of module file\r
    #   @param      Target              Build target (DEBUG, RELEASE)\r
    #   @param      Toolchain           Name of tool chain\r
    #   @param      Arch                The arch the module supports\r
    #   @param      PlatformFile        Platform meta-file\r
    #\r
    def _InitWorker(self, Workspace, ModuleFile, Target, Toolchain, Arch, PlatformFile,DataPipe):\r
        EdkLogger.debug(EdkLogger.DEBUG_9, "AutoGen module [%s] [%s]" % (ModuleFile, Arch))\r
        GlobalData.gProcessingFile = "%s [%s, %s, %s]" % (ModuleFile, Arch, Toolchain, Target)\r
\r
        self.Workspace = Workspace\r
        self.WorkspaceDir = ""\r
        self.PlatformInfo = None\r
        self.DataPipe = DataPipe\r
        self.__init_platform_info__()\r
        self.MetaFile = ModuleFile\r
        self.SourceDir = self.MetaFile.SubDir\r
        self.SourceDir = mws.relpath(self.SourceDir, self.WorkspaceDir)\r
\r
        self.ToolChain = Toolchain\r
        self.BuildTarget = Target\r
        self.Arch = Arch\r
        self.ToolChainFamily = self.PlatformInfo.ToolChainFamily\r
        self.BuildRuleFamily = self.PlatformInfo.BuildRuleFamily\r
\r
        self.IsCodeFileCreated = False\r
        self.IsAsBuiltInfCreated = False\r
        self.DepexGenerated = False\r
\r
        self.BuildDatabase = self.Workspace.BuildDatabase\r
        self.BuildRuleOrder = None\r
        self.BuildTime      = 0\r
\r
        self._GuidComments = OrderedListDict()\r
        self._ProtocolComments = OrderedListDict()\r
        self._PpiComments = OrderedListDict()\r
        self._BuildTargets            = None\r
        self._IntroBuildTargetList    = None\r
        self._FinalBuildTargetList    = None\r
        self._FileTypes               = None\r
\r
        self.AutoGenDepSet = set()\r
        self.ReferenceModules = []\r
        self.ConstPcd                  = {}\r
        self.Makefile         = None\r
        self.FileDependCache  = {}\r
\r
    def __init_platform_info__(self):\r
        pinfo = self.DataPipe.Get("P_Info")\r
        self.WorkspaceDir = pinfo.get("WorkspaceDir")\r
        self.PlatformInfo = PlatformInfo(self.Workspace,pinfo.get("ActivePlatform"),pinfo.get("Target"),pinfo.get("ToolChain"),pinfo.get("Arch"),self.DataPipe)\r
    ## hash() operator of ModuleAutoGen\r
    #\r
    #  The module file path and arch string will be used to represent\r
    #  hash value of this object\r
    #\r
    #   @retval   int Hash value of the module file path and arch\r
    #\r
    @cached_class_function\r
    def __hash__(self):\r
        return hash((self.MetaFile, self.Arch))\r
    def __repr__(self):\r
        return "%s [%s]" % (self.MetaFile, self.Arch)\r
\r
    # Get FixedAtBuild Pcds of this Module\r
    @cached_property\r
    def FixedAtBuildPcds(self):\r
        RetVal = []\r
        for Pcd in self.ModulePcdList:\r
            if Pcd.Type != TAB_PCDS_FIXED_AT_BUILD:\r
                continue\r
            if Pcd not in RetVal:\r
                RetVal.append(Pcd)\r
        return RetVal\r
\r
    @cached_property\r
    def FixedVoidTypePcds(self):\r
        RetVal = {}\r
        for Pcd in self.FixedAtBuildPcds:\r
            if Pcd.DatumType == TAB_VOID:\r
                if '.'.join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName)) not in RetVal:\r
                    RetVal['.'.join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName))] = Pcd.DefaultValue\r
        return RetVal\r
\r
    @property\r
    def UniqueBaseName(self):\r
        ModuleNames = self.DataPipe.Get("M_Name")\r
        if not ModuleNames:\r
            return self.Name\r
        return ModuleNames.get((self.Name,self.MetaFile),self.Name)\r
\r
    # Macros could be used in build_rule.txt (also Makefile)\r
    @cached_property\r
    def Macros(self):\r
        return OrderedDict((\r
            ("WORKSPACE" ,self.WorkspaceDir),\r
            ("MODULE_NAME" ,self.Name),\r
            ("MODULE_NAME_GUID" ,self.UniqueBaseName),\r
            ("MODULE_GUID" ,self.Guid),\r
            ("MODULE_VERSION" ,self.Version),\r
            ("MODULE_TYPE" ,self.ModuleType),\r
            ("MODULE_FILE" ,str(self.MetaFile)),\r
            ("MODULE_FILE_BASE_NAME" ,self.MetaFile.BaseName),\r
            ("MODULE_RELATIVE_DIR" ,self.SourceDir),\r
            ("MODULE_DIR" ,self.SourceDir),\r
            ("BASE_NAME" ,self.Name),\r
            ("ARCH" ,self.Arch),\r
            ("TOOLCHAIN" ,self.ToolChain),\r
            ("TOOLCHAIN_TAG" ,self.ToolChain),\r
            ("TOOL_CHAIN_TAG" ,self.ToolChain),\r
            ("TARGET" ,self.BuildTarget),\r
            ("BUILD_DIR" ,self.PlatformInfo.BuildDir),\r
            ("BIN_DIR" ,os.path.join(self.PlatformInfo.BuildDir, self.Arch)),\r
            ("LIB_DIR" ,os.path.join(self.PlatformInfo.BuildDir, self.Arch)),\r
            ("MODULE_BUILD_DIR" ,self.BuildDir),\r
            ("OUTPUT_DIR" ,self.OutputDir),\r
            ("DEBUG_DIR" ,self.DebugDir),\r
            ("DEST_DIR_OUTPUT" ,self.OutputDir),\r
            ("DEST_DIR_DEBUG" ,self.DebugDir),\r
            ("PLATFORM_NAME" ,self.PlatformInfo.Name),\r
            ("PLATFORM_GUID" ,self.PlatformInfo.Guid),\r
            ("PLATFORM_VERSION" ,self.PlatformInfo.Version),\r
            ("PLATFORM_RELATIVE_DIR" ,self.PlatformInfo.SourceDir),\r
            ("PLATFORM_DIR" ,mws.join(self.WorkspaceDir, self.PlatformInfo.SourceDir)),\r
            ("PLATFORM_OUTPUT_DIR" ,self.PlatformInfo.OutputDir),\r
            ("FFS_OUTPUT_DIR" ,self.FfsOutputDir)\r
            ))\r
\r
    ## Return the module build data object\r
    @cached_property\r
    def Module(self):\r
        return self.BuildDatabase[self.MetaFile, self.Arch, self.BuildTarget, self.ToolChain]\r
\r
    ## Return the module name\r
    @cached_property\r
    def Name(self):\r
        return self.Module.BaseName\r
\r
    ## Return the module DxsFile if exist\r
    @cached_property\r
    def DxsFile(self):\r
        return self.Module.DxsFile\r
\r
    ## Return the module meta-file GUID\r
    @cached_property\r
    def Guid(self):\r
        #\r
        # To build same module more than once, the module path with FILE_GUID overridden has\r
        # the file name FILE_GUIDmodule.inf, but the relative path (self.MetaFile.File) is the real path\r
        # in DSC. The overridden GUID can be retrieved from file name\r
        #\r
        if os.path.basename(self.MetaFile.File) != os.path.basename(self.MetaFile.Path):\r
            #\r
            # Length of GUID is 36\r
            #\r
            return os.path.basename(self.MetaFile.Path)[:36]\r
        return self.Module.Guid\r
\r
    ## Return the module version\r
    @cached_property\r
    def Version(self):\r
        return self.Module.Version\r
\r
    ## Return the module type\r
    @cached_property\r
    def ModuleType(self):\r
        return self.Module.ModuleType\r
\r
    ## Return the component type (for Edk.x style of module)\r
    @cached_property\r
    def ComponentType(self):\r
        return self.Module.ComponentType\r
\r
    ## Return the build type\r
    @cached_property\r
    def BuildType(self):\r
        return self.Module.BuildType\r
\r
    ## Return the PCD_IS_DRIVER setting\r
    @cached_property\r
    def PcdIsDriver(self):\r
        return self.Module.PcdIsDriver\r
\r
    ## Return the autogen version, i.e. module meta-file version\r
    @cached_property\r
    def AutoGenVersion(self):\r
        return self.Module.AutoGenVersion\r
\r
    ## Check if the module is library or not\r
    @cached_property\r
    def IsLibrary(self):\r
        return bool(self.Module.LibraryClass)\r
\r
    ## Check if the module is binary module or not\r
    @cached_property\r
    def IsBinaryModule(self):\r
        return self.Module.IsBinaryModule\r
\r
    ## Return the directory to store intermediate files of the module\r
    @cached_property\r
    def BuildDir(self):\r
        return _MakeDir((\r
                                    self.PlatformInfo.BuildDir,\r
                                    self.Arch,\r
                                    self.SourceDir,\r
                                    self.MetaFile.BaseName\r
            ))\r
\r
    ## Return the directory to store the intermediate object files of the module\r
    @cached_property\r
    def OutputDir(self):\r
        return _MakeDir((self.BuildDir, "OUTPUT"))\r
\r
    ## Return the directory path to store ffs file\r
    @cached_property\r
    def FfsOutputDir(self):\r
        if GlobalData.gFdfParser:\r
            return path.join(self.PlatformInfo.BuildDir, TAB_FV_DIRECTORY, "Ffs", self.Guid + self.Name)\r
        return ''\r
\r
    ## Return the directory to store auto-gened source files of the module\r
    @cached_property\r
    def DebugDir(self):\r
        return _MakeDir((self.BuildDir, "DEBUG"))\r
\r
    ## Return the path of custom file\r
    @cached_property\r
    def CustomMakefile(self):\r
        RetVal = {}\r
        for Type in self.Module.CustomMakefile:\r
            MakeType = gMakeTypeMap[Type] if Type in gMakeTypeMap else 'nmake'\r
            File = os.path.join(self.SourceDir, self.Module.CustomMakefile[Type])\r
            RetVal[MakeType] = File\r
        return RetVal\r
\r
    ## Return the directory of the makefile\r
    #\r
    #   @retval     string  The directory string of module's makefile\r
    #\r
    @cached_property\r
    def MakeFileDir(self):\r
        return self.BuildDir\r
\r
    ## Return build command string\r
    #\r
    #   @retval     string  Build command string\r
    #\r
    @cached_property\r
    def BuildCommand(self):\r
        return self.PlatformInfo.BuildCommand\r
\r
    ## Get Module package and Platform package\r
    #\r
    #   @retval list The list of package object\r
    #\r
    @cached_property\r
    def PackageList(self):\r
        PkagList = []\r
        if self.Module.Packages:\r
            PkagList.extend(self.Module.Packages)\r
        Platform = self.BuildDatabase[self.PlatformInfo.MetaFile, self.Arch, self.BuildTarget, self.ToolChain]\r
        for Package in Platform.Packages:\r
            if Package in PkagList:\r
                continue\r
            PkagList.append(Package)\r
        return PkagList\r
\r
    ## Get object list of all packages the module and its dependent libraries belong to and the Platform depends on\r
    #\r
    #   @retval     list    The list of package object\r
    #\r
    @cached_property\r
    def DerivedPackageList(self):\r
        PackageList = []\r
        PackageList.extend(self.PackageList)\r
        for M in self.DependentLibraryList:\r
            for Package in M.Packages:\r
                if Package in PackageList:\r
                    continue\r
                PackageList.append(Package)\r
        return PackageList\r
\r
    ## Get the depex string\r
    #\r
    # @return : a string contain all depex expression.\r
    def _GetDepexExpresionString(self):\r
        DepexStr = ''\r
        DepexList = []\r
        ## DPX_SOURCE IN Define section.\r
        if self.Module.DxsFile:\r
            return DepexStr\r
        for M in [self.Module] + self.DependentLibraryList:\r
            Filename = M.MetaFile.Path\r
            InfObj = InfSectionParser.InfSectionParser(Filename)\r
            DepexExpressionList = InfObj.GetDepexExpresionList()\r
            for DepexExpression in DepexExpressionList:\r
                for key in DepexExpression:\r
                    Arch, ModuleType = key\r
                    DepexExpr = [x for x in DepexExpression[key] if not str(x).startswith('#')]\r
                    # the type of build module is USER_DEFINED.\r
                    # All different DEPEX section tags would be copied into the As Built INF file\r
                    # and there would be separate DEPEX section tags\r
                    if self.ModuleType.upper() == SUP_MODULE_USER_DEFINED or self.ModuleType.upper() == SUP_MODULE_HOST_APPLICATION:\r
                        if (Arch.upper() == self.Arch.upper()) and (ModuleType.upper() != TAB_ARCH_COMMON):\r
                            DepexList.append({(Arch, ModuleType): DepexExpr})\r
                    else:\r
                        if Arch.upper() == TAB_ARCH_COMMON or \\r
                          (Arch.upper() == self.Arch.upper() and \\r
                          ModuleType.upper() in [TAB_ARCH_COMMON, self.ModuleType.upper()]):\r
                            DepexList.append({(Arch, ModuleType): DepexExpr})\r
\r
        #the type of build module is USER_DEFINED.\r
        if self.ModuleType.upper() == SUP_MODULE_USER_DEFINED or self.ModuleType.upper() == SUP_MODULE_HOST_APPLICATION:\r
            for Depex in DepexList:\r
                for key in Depex:\r
                    DepexStr += '[Depex.%s.%s]\n' % key\r
                    DepexStr += '\n'.join('# '+ val for val in Depex[key])\r
                    DepexStr += '\n\n'\r
            if not DepexStr:\r
                return '[Depex.%s]\n' % self.Arch\r
            return DepexStr\r
\r
        #the type of build module not is USER_DEFINED.\r
        Count = 0\r
        for Depex in DepexList:\r
            Count += 1\r
            if DepexStr != '':\r
                DepexStr += ' AND '\r
            DepexStr += '('\r
            for D in Depex.values():\r
                DepexStr += ' '.join(val for val in D)\r
            Index = DepexStr.find('END')\r
            if Index > -1 and Index == len(DepexStr) - 3:\r
                DepexStr = DepexStr[:-3]\r
            DepexStr = DepexStr.strip()\r
            DepexStr += ')'\r
        if Count == 1:\r
            DepexStr = DepexStr.lstrip('(').rstrip(')').strip()\r
        if not DepexStr:\r
            return '[Depex.%s]\n' % self.Arch\r
        return '[Depex.%s]\n#  ' % self.Arch + DepexStr\r
\r
    ## Merge dependency expression\r
    #\r
    #   @retval     list    The token list of the dependency expression after parsed\r
    #\r
    @cached_property\r
    def DepexList(self):\r
        if self.DxsFile or self.IsLibrary or TAB_DEPENDENCY_EXPRESSION_FILE in self.FileTypes:\r
            return {}\r
\r
        DepexList = []\r
        #\r
        # Append depex from dependent libraries, if not "BEFORE", "AFTER" expression\r
        #\r
        FixedVoidTypePcds = {}\r
        for M in [self] + self.LibraryAutoGenList:\r
            FixedVoidTypePcds.update(M.FixedVoidTypePcds)\r
        for M in [self] + self.LibraryAutoGenList:\r
            Inherited = False\r
            for D in M.Module.Depex[self.Arch, self.ModuleType]:\r
                if DepexList != []:\r
                    DepexList.append('AND')\r
                DepexList.append('(')\r
                #replace D with value if D is FixedAtBuild PCD\r
                NewList = []\r
                for item in D:\r
                    if '.' not in item:\r
                        NewList.append(item)\r
                    else:\r
                        try:\r
                            Value = FixedVoidTypePcds[item]\r
                            if len(Value.split(',')) != 16:\r
                                EdkLogger.error("build", FORMAT_INVALID,\r
                                                "{} used in [Depex] section should be used as FixedAtBuild type and VOID* datum type and 16 bytes in the module.".format(item))\r
                            NewList.append(Value)\r
                        except:\r
                            EdkLogger.error("build", FORMAT_INVALID, "{} used in [Depex] section should be used as FixedAtBuild type and VOID* datum type in the module.".format(item))\r
\r
                DepexList.extend(NewList)\r
                if DepexList[-1] == 'END':  # no need of a END at this time\r
                    DepexList.pop()\r
                DepexList.append(')')\r
                Inherited = True\r
            if Inherited:\r
                EdkLogger.verbose("DEPEX[%s] (+%s) = %s" % (self.Name, M.Module.BaseName, DepexList))\r
            if 'BEFORE' in DepexList or 'AFTER' in DepexList:\r
                break\r
            if len(DepexList) > 0:\r
                EdkLogger.verbose('')\r
        return {self.ModuleType:DepexList}\r
\r
    ## Merge dependency expression\r
    #\r
    #   @retval     list    The token list of the dependency expression after parsed\r
    #\r
    @cached_property\r
    def DepexExpressionDict(self):\r
        if self.DxsFile or self.IsLibrary or TAB_DEPENDENCY_EXPRESSION_FILE in self.FileTypes:\r
            return {}\r
\r
        DepexExpressionString = ''\r
        #\r
        # Append depex from dependent libraries, if not "BEFORE", "AFTER" expresion\r
        #\r
        for M in [self.Module] + self.DependentLibraryList:\r
            Inherited = False\r
            for D in M.DepexExpression[self.Arch, self.ModuleType]:\r
                if DepexExpressionString != '':\r
                    DepexExpressionString += ' AND '\r
                DepexExpressionString += '('\r
                DepexExpressionString += D\r
                DepexExpressionString = DepexExpressionString.rstrip('END').strip()\r
                DepexExpressionString += ')'\r
                Inherited = True\r
            if Inherited:\r
                EdkLogger.verbose("DEPEX[%s] (+%s) = %s" % (self.Name, M.BaseName, DepexExpressionString))\r
            if 'BEFORE' in DepexExpressionString or 'AFTER' in DepexExpressionString:\r
                break\r
        if len(DepexExpressionString) > 0:\r
            EdkLogger.verbose('')\r
\r
        return {self.ModuleType:DepexExpressionString}\r
\r
    # Get the tiano core user extension, it is contain dependent library.\r
    # @retval: a list contain tiano core userextension.\r
    #\r
    def _GetTianoCoreUserExtensionList(self):\r
        TianoCoreUserExtentionList = []\r
        for M in [self.Module] + self.DependentLibraryList:\r
            Filename = M.MetaFile.Path\r
            InfObj = InfSectionParser.InfSectionParser(Filename)\r
            TianoCoreUserExtenList = InfObj.GetUserExtensionTianoCore()\r
            for TianoCoreUserExtent in TianoCoreUserExtenList:\r
                for Section in TianoCoreUserExtent:\r
                    ItemList = Section.split(TAB_SPLIT)\r
                    Arch = self.Arch\r
                    if len(ItemList) == 4:\r
                        Arch = ItemList[3]\r
                    if Arch.upper() == TAB_ARCH_COMMON or Arch.upper() == self.Arch.upper():\r
                        TianoCoreList = []\r
                        TianoCoreList.extend([TAB_SECTION_START + Section + TAB_SECTION_END])\r
                        TianoCoreList.extend(TianoCoreUserExtent[Section][:])\r
                        TianoCoreList.append('\n')\r
                        TianoCoreUserExtentionList.append(TianoCoreList)\r
\r
        return TianoCoreUserExtentionList\r
\r
    ## Return the list of specification version required for the module\r
    #\r
    #   @retval     list    The list of specification defined in module file\r
    #\r
    @cached_property\r
    def Specification(self):\r
        return self.Module.Specification\r
\r
    ## Tool option for the module build\r
    #\r
    #   @param      PlatformInfo    The object of PlatformBuildInfo\r
    #   @retval     dict            The dict containing valid options\r
    #\r
    @cached_property\r
    def BuildOption(self):\r
        RetVal, self.BuildRuleOrder = self.PlatformInfo.ApplyBuildOption(self.Module)\r
        if self.BuildRuleOrder:\r
            self.BuildRuleOrder = ['.%s' % Ext for Ext in self.BuildRuleOrder.split()]\r
        return RetVal\r
\r
    ## Get include path list from tool option for the module build\r
    #\r
    #   @retval     list            The include path list\r
    #\r
    @cached_property\r
    def BuildOptionIncPathList(self):\r
        #\r
        # Regular expression for finding Include Directories, the difference between MSFT and INTEL/GCC/RVCT\r
        # is the former use /I , the Latter used -I to specify include directories\r
        #\r
        if self.PlatformInfo.ToolChainFamily in (TAB_COMPILER_MSFT):\r
            BuildOptIncludeRegEx = gBuildOptIncludePatternMsft\r
        elif self.PlatformInfo.ToolChainFamily in ('INTEL', 'GCC', 'RVCT'):\r
            BuildOptIncludeRegEx = gBuildOptIncludePatternOther\r
        else:\r
            #\r
            # New ToolChainFamily, don't known whether there is option to specify include directories\r
            #\r
            return []\r
\r
        RetVal = []\r
        for Tool in ('CC', 'PP', 'VFRPP', 'ASLPP', 'ASLCC', 'APP', 'ASM'):\r
            try:\r
                FlagOption = self.BuildOption[Tool]['FLAGS']\r
            except KeyError:\r
                FlagOption = ''\r
\r
            if self.ToolChainFamily != 'RVCT':\r
                IncPathList = [NormPath(Path, self.Macros) for Path in BuildOptIncludeRegEx.findall(FlagOption)]\r
            else:\r
                #\r
                # RVCT may specify a list of directory seperated by commas\r
                #\r
                IncPathList = []\r
                for Path in BuildOptIncludeRegEx.findall(FlagOption):\r
                    PathList = GetSplitList(Path, TAB_COMMA_SPLIT)\r
                    IncPathList.extend(NormPath(PathEntry, self.Macros) for PathEntry in PathList)\r
\r
            #\r
            # EDK II modules must not reference header files outside of the packages they depend on or\r
            # within the module's directory tree. Report error if violation.\r
            #\r
            if GlobalData.gDisableIncludePathCheck == False:\r
                for Path in IncPathList:\r
                    if (Path not in self.IncludePathList) and (CommonPath([Path, self.MetaFile.Dir]) != self.MetaFile.Dir):\r
                        ErrMsg = "The include directory for the EDK II module in this line is invalid %s specified in %s FLAGS '%s'" % (Path, Tool, FlagOption)\r
                        EdkLogger.error("build",\r
                                        PARAMETER_INVALID,\r
                                        ExtraData=ErrMsg,\r
                                        File=str(self.MetaFile))\r
            RetVal += IncPathList\r
        return RetVal\r
\r
    ## Return a list of files which can be built from source\r
    #\r
    #  What kind of files can be built is determined by build rules in\r
    #  $(CONF_DIRECTORY)/build_rule.txt and toolchain family.\r
    #\r
    @cached_property\r
    def SourceFileList(self):\r
        RetVal = []\r
        ToolChainTagSet = {"", TAB_STAR, self.ToolChain}\r
        ToolChainFamilySet = {"", TAB_STAR, self.ToolChainFamily, self.BuildRuleFamily}\r
        for F in self.Module.Sources:\r
            # match tool chain\r
            if F.TagName not in ToolChainTagSet:\r
                EdkLogger.debug(EdkLogger.DEBUG_9, "The toolchain [%s] for processing file [%s] is found, "\r
                                "but [%s] is currently used" % (F.TagName, str(F), self.ToolChain))\r
                continue\r
            # match tool chain family or build rule family\r
            if F.ToolChainFamily not in ToolChainFamilySet:\r
                EdkLogger.debug(\r
                            EdkLogger.DEBUG_0,\r
                            "The file [%s] must be built by tools of [%s], " \\r
                            "but current toolchain family is [%s], buildrule family is [%s]" \\r
                                % (str(F), F.ToolChainFamily, self.ToolChainFamily, self.BuildRuleFamily))\r
                continue\r
\r
            # add the file path into search path list for file including\r
            if F.Dir not in self.IncludePathList:\r
                self.IncludePathList.insert(0, F.Dir)\r
            RetVal.append(F)\r
\r
        self._MatchBuildRuleOrder(RetVal)\r
\r
        for F in RetVal:\r
            self._ApplyBuildRule(F, TAB_UNKNOWN_FILE)\r
        return RetVal\r
\r
    def _MatchBuildRuleOrder(self, FileList):\r
        Order_Dict = {}\r
        self.BuildOption\r
        for SingleFile in FileList:\r
            if self.BuildRuleOrder and SingleFile.Ext in self.BuildRuleOrder and SingleFile.Ext in self.BuildRules:\r
                key = SingleFile.Path.rsplit(SingleFile.Ext,1)[0]\r
                if key in Order_Dict:\r
                    Order_Dict[key].append(SingleFile.Ext)\r
                else:\r
                    Order_Dict[key] = [SingleFile.Ext]\r
\r
        RemoveList = []\r
        for F in Order_Dict:\r
            if len(Order_Dict[F]) > 1:\r
                Order_Dict[F].sort(key=lambda i: self.BuildRuleOrder.index(i))\r
                for Ext in Order_Dict[F][1:]:\r
                    RemoveList.append(F + Ext)\r
\r
        for item in RemoveList:\r
            FileList.remove(item)\r
\r
        return FileList\r
\r
    ## Return the list of unicode files\r
    @cached_property\r
    def UnicodeFileList(self):\r
        return self.FileTypes.get(TAB_UNICODE_FILE,[])\r
\r
    ## Return the list of vfr files\r
    @cached_property\r
    def VfrFileList(self):\r
        return self.FileTypes.get(TAB_VFR_FILE, [])\r
\r
    ## Return the list of Image Definition files\r
    @cached_property\r
    def IdfFileList(self):\r
        return self.FileTypes.get(TAB_IMAGE_FILE,[])\r
\r
    ## Return a list of files which can be built from binary\r
    #\r
    #  "Build" binary files are just to copy them to build directory.\r
    #\r
    #   @retval     list            The list of files which can be built later\r
    #\r
    @cached_property\r
    def BinaryFileList(self):\r
        RetVal = []\r
        for F in self.Module.Binaries:\r
            if F.Target not in [TAB_ARCH_COMMON, TAB_STAR] and F.Target != self.BuildTarget:\r
                continue\r
            RetVal.append(F)\r
            self._ApplyBuildRule(F, F.Type, BinaryFileList=RetVal)\r
        return RetVal\r
\r
    @cached_property\r
    def BuildRules(self):\r
        RetVal = {}\r
        BuildRuleDatabase = self.PlatformInfo.BuildRule\r
        for Type in BuildRuleDatabase.FileTypeList:\r
            #first try getting build rule by BuildRuleFamily\r
            RuleObject = BuildRuleDatabase[Type, self.BuildType, self.Arch, self.BuildRuleFamily]\r
            if not RuleObject:\r
                # build type is always module type, but ...\r
                if self.ModuleType != self.BuildType:\r
                    RuleObject = BuildRuleDatabase[Type, self.ModuleType, self.Arch, self.BuildRuleFamily]\r
            #second try getting build rule by ToolChainFamily\r
            if not RuleObject:\r
                RuleObject = BuildRuleDatabase[Type, self.BuildType, self.Arch, self.ToolChainFamily]\r
                if not RuleObject:\r
                    # build type is always module type, but ...\r
                    if self.ModuleType != self.BuildType:\r
                        RuleObject = BuildRuleDatabase[Type, self.ModuleType, self.Arch, self.ToolChainFamily]\r
            if not RuleObject:\r
                continue\r
            RuleObject = RuleObject.Instantiate(self.Macros)\r
            RetVal[Type] = RuleObject\r
            for Ext in RuleObject.SourceFileExtList:\r
                RetVal[Ext] = RuleObject\r
        return RetVal\r
\r
    def _ApplyBuildRule(self, File, FileType, BinaryFileList=None):\r
        if self._BuildTargets is None:\r
            self._IntroBuildTargetList = set()\r
            self._FinalBuildTargetList = set()\r
            self._BuildTargets = defaultdict(set)\r
            self._FileTypes = defaultdict(set)\r
\r
        if not BinaryFileList:\r
            BinaryFileList = self.BinaryFileList\r
\r
        SubDirectory = os.path.join(self.OutputDir, File.SubDir)\r
        if not os.path.exists(SubDirectory):\r
            CreateDirectory(SubDirectory)\r
        LastTarget = None\r
        RuleChain = set()\r
        SourceList = [File]\r
        Index = 0\r
        #\r
        # Make sure to get build rule order value\r
        #\r
        self.BuildOption\r
\r
        while Index < len(SourceList):\r
            Source = SourceList[Index]\r
            Index = Index + 1\r
\r
            if Source != File:\r
                CreateDirectory(Source.Dir)\r
\r
            if File.IsBinary and File == Source and File in BinaryFileList:\r
                # Skip all files that are not binary libraries\r
                if not self.IsLibrary:\r
                    continue\r
                RuleObject = self.BuildRules[TAB_DEFAULT_BINARY_FILE]\r
            elif FileType in self.BuildRules:\r
                RuleObject = self.BuildRules[FileType]\r
            elif Source.Ext in self.BuildRules:\r
                RuleObject = self.BuildRules[Source.Ext]\r
            else:\r
                # stop at no more rules\r
                if LastTarget:\r
                    self._FinalBuildTargetList.add(LastTarget)\r
                break\r
\r
            FileType = RuleObject.SourceFileType\r
            self._FileTypes[FileType].add(Source)\r
\r
            # stop at STATIC_LIBRARY for library\r
            if self.IsLibrary and FileType == TAB_STATIC_LIBRARY:\r
                if LastTarget:\r
                    self._FinalBuildTargetList.add(LastTarget)\r
                break\r
\r
            Target = RuleObject.Apply(Source, self.BuildRuleOrder)\r
            if not Target:\r
                if LastTarget:\r
                    self._FinalBuildTargetList.add(LastTarget)\r
                break\r
            elif not Target.Outputs:\r
                # Only do build for target with outputs\r
                self._FinalBuildTargetList.add(Target)\r
\r
            self._BuildTargets[FileType].add(Target)\r
\r
            if not Source.IsBinary and Source == File:\r
                self._IntroBuildTargetList.add(Target)\r
\r
            # to avoid cyclic rule\r
            if FileType in RuleChain:\r
                break\r
\r
            RuleChain.add(FileType)\r
            SourceList.extend(Target.Outputs)\r
            LastTarget = Target\r
            FileType = TAB_UNKNOWN_FILE\r
\r
    @cached_property\r
    def Targets(self):\r
        if self._BuildTargets is None:\r
            self._IntroBuildTargetList = set()\r
            self._FinalBuildTargetList = set()\r
            self._BuildTargets = defaultdict(set)\r
            self._FileTypes = defaultdict(set)\r
\r
        #TRICK: call SourceFileList property to apply build rule for source files\r
        self.SourceFileList\r
\r
        #TRICK: call _GetBinaryFileList to apply build rule for binary files\r
        self.BinaryFileList\r
\r
        return self._BuildTargets\r
\r
    @cached_property\r
    def IntroTargetList(self):\r
        self.Targets\r
        return self._IntroBuildTargetList\r
\r
    @cached_property\r
    def CodaTargetList(self):\r
        self.Targets\r
        return self._FinalBuildTargetList\r
\r
    @cached_property\r
    def FileTypes(self):\r
        self.Targets\r
        return self._FileTypes\r
\r
    ## Get the list of package object the module depends on and the Platform depends on\r
    #\r
    #   @retval     list    The package object list\r
    #\r
    @cached_property\r
    def DependentPackageList(self):\r
        return self.PackageList\r
\r
    ## Return the list of auto-generated code file\r
    #\r
    #   @retval     list        The list of auto-generated file\r
    #\r
    @cached_property\r
    def AutoGenFileList(self):\r
        AutoGenUniIdf = self.BuildType != 'UEFI_HII'\r
        UniStringBinBuffer = BytesIO()\r
        IdfGenBinBuffer = BytesIO()\r
        RetVal = {}\r
        AutoGenC = TemplateString()\r
        AutoGenH = TemplateString()\r
        StringH = TemplateString()\r
        StringIdf = TemplateString()\r
        GenC.CreateCode(self, AutoGenC, AutoGenH, StringH, AutoGenUniIdf, UniStringBinBuffer, StringIdf, AutoGenUniIdf, IdfGenBinBuffer)\r
        #\r
        # AutoGen.c is generated if there are library classes in inf, or there are object files\r
        #\r
        if str(AutoGenC) != "" and (len(self.Module.LibraryClasses) > 0\r
                                    or TAB_OBJECT_FILE in self.FileTypes):\r
            AutoFile = PathClass(gAutoGenCodeFileName, self.DebugDir)\r
            RetVal[AutoFile] = str(AutoGenC)\r
            self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
        if str(AutoGenH) != "":\r
            AutoFile = PathClass(gAutoGenHeaderFileName, self.DebugDir)\r
            RetVal[AutoFile] = str(AutoGenH)\r
            self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
        if str(StringH) != "":\r
            AutoFile = PathClass(gAutoGenStringFileName % {"module_name":self.Name}, self.DebugDir)\r
            RetVal[AutoFile] = str(StringH)\r
            self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
        if UniStringBinBuffer is not None and UniStringBinBuffer.getvalue() != b"":\r
            AutoFile = PathClass(gAutoGenStringFormFileName % {"module_name":self.Name}, self.OutputDir)\r
            RetVal[AutoFile] = UniStringBinBuffer.getvalue()\r
            AutoFile.IsBinary = True\r
            self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
        if UniStringBinBuffer is not None:\r
            UniStringBinBuffer.close()\r
        if str(StringIdf) != "":\r
            AutoFile = PathClass(gAutoGenImageDefFileName % {"module_name":self.Name}, self.DebugDir)\r
            RetVal[AutoFile] = str(StringIdf)\r
            self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
        if IdfGenBinBuffer is not None and IdfGenBinBuffer.getvalue() != b"":\r
            AutoFile = PathClass(gAutoGenIdfFileName % {"module_name":self.Name}, self.OutputDir)\r
            RetVal[AutoFile] = IdfGenBinBuffer.getvalue()\r
            AutoFile.IsBinary = True\r
            self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
        if IdfGenBinBuffer is not None:\r
            IdfGenBinBuffer.close()\r
        return RetVal\r
\r
    ## Return the list of library modules explicitly or implicitly used by this module\r
    @cached_property\r
    def DependentLibraryList(self):\r
        # only merge library classes and PCD for non-library module\r
        if self.IsLibrary:\r
            return []\r
        return self.PlatformInfo.ApplyLibraryInstance(self.Module)\r
\r
    ## Get the list of PCDs from current module\r
    #\r
    #   @retval     list                    The list of PCD\r
    #\r
    @cached_property\r
    def ModulePcdList(self):\r
        # apply PCD settings from platform\r
        RetVal = self.PlatformInfo.ApplyPcdSetting(self.Module, self.Module.Pcds)\r
\r
        return RetVal\r
    @cached_property\r
    def _PcdComments(self):\r
        ReVal = OrderedListDict()\r
        ExtendCopyDictionaryLists(ReVal, self.Module.PcdComments)\r
        if not self.IsLibrary:\r
            for Library in self.DependentLibraryList:\r
                ExtendCopyDictionaryLists(ReVal, Library.PcdComments)\r
        return ReVal\r
\r
    ## Get the list of PCDs from dependent libraries\r
    #\r
    #   @retval     list                    The list of PCD\r
    #\r
    @cached_property\r
    def LibraryPcdList(self):\r
        if self.IsLibrary:\r
            return []\r
        RetVal = []\r
        Pcds = set()\r
        # get PCDs from dependent libraries\r
        for Library in self.DependentLibraryList:\r
            PcdsInLibrary = OrderedDict()\r
            for Key in Library.Pcds:\r
                # skip duplicated PCDs\r
                if Key in self.Module.Pcds or Key in Pcds:\r
                    continue\r
                Pcds.add(Key)\r
                PcdsInLibrary[Key] = copy.copy(Library.Pcds[Key])\r
            RetVal.extend(self.PlatformInfo.ApplyPcdSetting(self.Module, PcdsInLibrary, Library=Library))\r
        return RetVal\r
\r
    ## Get the GUID value mapping\r
    #\r
    #   @retval     dict    The mapping between GUID cname and its value\r
    #\r
    @cached_property\r
    def GuidList(self):\r
        RetVal = self.Module.Guids\r
        for Library in self.DependentLibraryList:\r
            RetVal.update(Library.Guids)\r
            ExtendCopyDictionaryLists(self._GuidComments, Library.GuidComments)\r
        ExtendCopyDictionaryLists(self._GuidComments, self.Module.GuidComments)\r
        return RetVal\r
\r
    @cached_property\r
    def GetGuidsUsedByPcd(self):\r
        RetVal = OrderedDict(self.Module.GetGuidsUsedByPcd())\r
        for Library in self.DependentLibraryList:\r
            RetVal.update(Library.GetGuidsUsedByPcd())\r
        return RetVal\r
    ## Get the protocol value mapping\r
    #\r
    #   @retval     dict    The mapping between protocol cname and its value\r
    #\r
    @cached_property\r
    def ProtocolList(self):\r
        RetVal = OrderedDict(self.Module.Protocols)\r
        for Library in self.DependentLibraryList:\r
            RetVal.update(Library.Protocols)\r
            ExtendCopyDictionaryLists(self._ProtocolComments, Library.ProtocolComments)\r
        ExtendCopyDictionaryLists(self._ProtocolComments, self.Module.ProtocolComments)\r
        return RetVal\r
\r
    ## Get the PPI value mapping\r
    #\r
    #   @retval     dict    The mapping between PPI cname and its value\r
    #\r
    @cached_property\r
    def PpiList(self):\r
        RetVal = OrderedDict(self.Module.Ppis)\r
        for Library in self.DependentLibraryList:\r
            RetVal.update(Library.Ppis)\r
            ExtendCopyDictionaryLists(self._PpiComments, Library.PpiComments)\r
        ExtendCopyDictionaryLists(self._PpiComments, self.Module.PpiComments)\r
        return RetVal\r
\r
    ## Get the list of include search path\r
    #\r
    #   @retval     list                    The list path\r
    #\r
    @cached_property\r
    def IncludePathList(self):\r
        RetVal = []\r
        RetVal.append(self.MetaFile.Dir)\r
        RetVal.append(self.DebugDir)\r
\r
        for Package in self.PackageList:\r
            PackageDir = mws.join(self.WorkspaceDir, Package.MetaFile.Dir)\r
            if PackageDir not in RetVal:\r
                RetVal.append(PackageDir)\r
            IncludesList = Package.Includes\r
            if Package._PrivateIncludes:\r
                if not self.MetaFile.OriginalPath.Path.startswith(PackageDir):\r
                    IncludesList = list(set(Package.Includes).difference(set(Package._PrivateIncludes)))\r
            for Inc in IncludesList:\r
                if Inc not in RetVal:\r
                    RetVal.append(str(Inc))\r
        RetVal.extend(self.IncPathFromBuildOptions)\r
        return RetVal\r
\r
    @cached_property\r
    def IncPathFromBuildOptions(self):\r
        IncPathList = []\r
        for tool in self.BuildOption:\r
            if 'FLAGS' in self.BuildOption[tool]:\r
                flags = self.BuildOption[tool]['FLAGS']\r
                whitespace = False\r
                for flag in flags.split(" "):\r
                    flag = flag.strip()\r
                    if flag.startswith(("/I","-I")):\r
                        if len(flag)>2:\r
                            if os.path.exists(flag[2:]):\r
                                IncPathList.append(flag[2:])\r
                        else:\r
                            whitespace = True\r
                            continue\r
                    if whitespace and flag:\r
                        if os.path.exists(flag):\r
                            IncPathList.append(flag)\r
                            whitespace = False\r
        return IncPathList\r
\r
    @cached_property\r
    def IncludePathLength(self):\r
        return sum(len(inc)+1 for inc in self.IncludePathList)\r
\r
    ## Get the list of include paths from the packages\r
    #\r
    #   @IncludesList     list             The list path\r
    #\r
    @cached_property\r
    def PackageIncludePathList(self):\r
        IncludesList = []\r
        for Package in self.PackageList:\r
            PackageDir = mws.join(self.WorkspaceDir, Package.MetaFile.Dir)\r
            IncludesList = Package.Includes\r
            if Package._PrivateIncludes:\r
                if not self.MetaFile.Path.startswith(PackageDir):\r
                    IncludesList = list(set(Package.Includes).difference(set(Package._PrivateIncludes)))\r
        return IncludesList\r
\r
    ## Get HII EX PCDs which maybe used by VFR\r
    #\r
    #  efivarstore used by VFR may relate with HII EX PCDs\r
    #  Get the variable name and GUID from efivarstore and HII EX PCD\r
    #  List the HII EX PCDs in As Built INF if both name and GUID match.\r
    #\r
    #  @retval    list    HII EX PCDs\r
    #\r
    def _GetPcdsMaybeUsedByVfr(self):\r
        if not self.SourceFileList:\r
            return []\r
\r
        NameGuids = set()\r
        for SrcFile in self.SourceFileList:\r
            if SrcFile.Ext.lower() != '.vfr':\r
                continue\r
            Vfri = os.path.join(self.OutputDir, SrcFile.BaseName + '.i')\r
            if not os.path.exists(Vfri):\r
                continue\r
            VfriFile = open(Vfri, 'r')\r
            Content = VfriFile.read()\r
            VfriFile.close()\r
            Pos = Content.find('efivarstore')\r
            while Pos != -1:\r
                #\r
                # Make sure 'efivarstore' is the start of efivarstore statement\r
                # In case of the value of 'name' (name = efivarstore) is equal to 'efivarstore'\r
                #\r
                Index = Pos - 1\r
                while Index >= 0 and Content[Index] in ' \t\r\n':\r
                    Index -= 1\r
                if Index >= 0 and Content[Index] != ';':\r
                    Pos = Content.find('efivarstore', Pos + len('efivarstore'))\r
                    continue\r
                #\r
                # 'efivarstore' must be followed by name and guid\r
                #\r
                Name = gEfiVarStoreNamePattern.search(Content, Pos)\r
                if not Name:\r
                    break\r
                Guid = gEfiVarStoreGuidPattern.search(Content, Pos)\r
                if not Guid:\r
                    break\r
                NameArray = _ConvertStringToByteArray('L"' + Name.group(1) + '"')\r
                NameGuids.add((NameArray, GuidStructureStringToGuidString(Guid.group(1))))\r
                Pos = Content.find('efivarstore', Name.end())\r
        if not NameGuids:\r
            return []\r
        HiiExPcds = []\r
        for Pcd in self.PlatformInfo.Pcds.values():\r
            if Pcd.Type != TAB_PCDS_DYNAMIC_EX_HII:\r
                continue\r
            for SkuInfo in Pcd.SkuInfoList.values():\r
                Value = GuidValue(SkuInfo.VariableGuid, self.PlatformInfo.PackageList, self.MetaFile.Path)\r
                if not Value:\r
                    continue\r
                Name = _ConvertStringToByteArray(SkuInfo.VariableName)\r
                Guid = GuidStructureStringToGuidString(Value)\r
                if (Name, Guid) in NameGuids and Pcd not in HiiExPcds:\r
                    HiiExPcds.append(Pcd)\r
                    break\r
\r
        return HiiExPcds\r
\r
    def _GenOffsetBin(self):\r
        VfrUniBaseName = {}\r
        for SourceFile in self.Module.Sources:\r
            if SourceFile.Type.upper() == ".VFR" :\r
                #\r
                # search the .map file to find the offset of vfr binary in the PE32+/TE file.\r
                #\r
                VfrUniBaseName[SourceFile.BaseName] = (SourceFile.BaseName + "Bin")\r
            elif SourceFile.Type.upper() == ".UNI" :\r
                #\r
                # search the .map file to find the offset of Uni strings binary in the PE32+/TE file.\r
                #\r
                VfrUniBaseName["UniOffsetName"] = (self.Name + "Strings")\r
\r
        if not VfrUniBaseName:\r
            return None\r
        MapFileName = os.path.join(self.OutputDir, self.Name + ".map")\r
        EfiFileName = os.path.join(self.OutputDir, self.Name + ".efi")\r
        VfrUniOffsetList = GetVariableOffset(MapFileName, EfiFileName, list(VfrUniBaseName.values()))\r
        if not VfrUniOffsetList:\r
            return None\r
\r
        OutputName = '%sOffset.bin' % self.Name\r
        UniVfrOffsetFileName    =  os.path.join( self.OutputDir, OutputName)\r
\r
        try:\r
            fInputfile = open(UniVfrOffsetFileName, "wb+", 0)\r
        except:\r
            EdkLogger.error("build", FILE_OPEN_FAILURE, "File open failed for %s" % UniVfrOffsetFileName, None)\r
\r
        # Use a instance of BytesIO to cache data\r
        fStringIO = BytesIO()\r
\r
        for Item in VfrUniOffsetList:\r
            if (Item[0].find("Strings") != -1):\r
                #\r
                # UNI offset in image.\r
                # GUID + Offset\r
                # { 0x8913c5e0, 0x33f6, 0x4d86, { 0x9b, 0xf1, 0x43, 0xef, 0x89, 0xfc, 0x6, 0x66 } }\r
                #\r
                UniGuid = b'\xe0\xc5\x13\x89\xf63\x86M\x9b\xf1C\xef\x89\xfc\x06f'\r
                fStringIO.write(UniGuid)\r
                UniValue = pack ('Q', int (Item[1], 16))\r
                fStringIO.write (UniValue)\r
            else:\r
                #\r
                # VFR binary offset in image.\r
                # GUID + Offset\r
                # { 0xd0bc7cb4, 0x6a47, 0x495f, { 0xaa, 0x11, 0x71, 0x7, 0x46, 0xda, 0x6, 0xa2 } };\r
                #\r
                VfrGuid = b'\xb4|\xbc\xd0Gj_I\xaa\x11q\x07F\xda\x06\xa2'\r
                fStringIO.write(VfrGuid)\r
                VfrValue = pack ('Q', int (Item[1], 16))\r
                fStringIO.write (VfrValue)\r
        #\r
        # write data into file.\r
        #\r
        try :\r
            fInputfile.write (fStringIO.getvalue())\r
        except:\r
            EdkLogger.error("build", FILE_WRITE_FAILURE, "Write data to file %s failed, please check whether the "\r
                            "file been locked or using by other applications." %UniVfrOffsetFileName, None)\r
\r
        fStringIO.close ()\r
        fInputfile.close ()\r
        return OutputName\r
\r
    @cached_property\r
    def OutputFile(self):\r
        retVal = set()\r
\r
        for Root, Dirs, Files in os.walk(self.BuildDir):\r
            for File in Files:\r
                # lib file is already added through above CodaTargetList, skip it here\r
                if not (File.lower().endswith('.obj') or File.lower().endswith('.debug')):\r
                    NewFile = path.join(Root, File)\r
                    retVal.add(NewFile)\r
\r
        for Root, Dirs, Files in os.walk(self.FfsOutputDir):\r
            for File in Files:\r
                NewFile = path.join(Root, File)\r
                retVal.add(NewFile)\r
\r
        return retVal\r
\r
    ## Create AsBuilt INF file the module\r
    #\r
    def CreateAsBuiltInf(self):\r
\r
        if self.IsAsBuiltInfCreated:\r
            return\r
\r
        # Skip INF file generation for libraries\r
        if self.IsLibrary:\r
            return\r
\r
        # Skip the following code for modules with no source files\r
        if not self.SourceFileList:\r
            return\r
\r
        # Skip the following code for modules without any binary files\r
        if self.BinaryFileList:\r
            return\r
\r
        ### TODO: How to handles mixed source and binary modules\r
\r
        # Find all DynamicEx and PatchableInModule PCDs used by this module and dependent libraries\r
        # Also find all packages that the DynamicEx PCDs depend on\r
        Pcds = []\r
        PatchablePcds = []\r
        Packages = []\r
        PcdCheckList = []\r
        PcdTokenSpaceList = []\r
        for Pcd in self.ModulePcdList + self.LibraryPcdList:\r
            if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:\r
                PatchablePcds.append(Pcd)\r
                PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, TAB_PCDS_PATCHABLE_IN_MODULE))\r
            elif Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
                if Pcd not in Pcds:\r
                    Pcds.append(Pcd)\r
                    PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, TAB_PCDS_DYNAMIC_EX))\r
                    PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, TAB_PCDS_DYNAMIC))\r
                    PcdTokenSpaceList.append(Pcd.TokenSpaceGuidCName)\r
        GuidList = OrderedDict(self.GuidList)\r
        for TokenSpace in self.GetGuidsUsedByPcd:\r
            # If token space is not referred by patch PCD or Ex PCD, remove the GUID from GUID list\r
            # The GUIDs in GUIDs section should really be the GUIDs in source INF or referred by Ex an patch PCDs\r
            if TokenSpace not in PcdTokenSpaceList and TokenSpace in GuidList:\r
                GuidList.pop(TokenSpace)\r
        CheckList = (GuidList, self.PpiList, self.ProtocolList, PcdCheckList)\r
        for Package in self.DerivedPackageList:\r
            if Package in Packages:\r
                continue\r
            BeChecked = (Package.Guids, Package.Ppis, Package.Protocols, Package.Pcds)\r
            Found = False\r
            for Index in range(len(BeChecked)):\r
                for Item in CheckList[Index]:\r
                    if Item in BeChecked[Index]:\r
                        Packages.append(Package)\r
                        Found = True\r
                        break\r
                if Found:\r
                    break\r
\r
        VfrPcds = self._GetPcdsMaybeUsedByVfr()\r
        for Pkg in self.PlatformInfo.PackageList:\r
            if Pkg in Packages:\r
                continue\r
            for VfrPcd in VfrPcds:\r
                if ((VfrPcd.TokenCName, VfrPcd.TokenSpaceGuidCName, TAB_PCDS_DYNAMIC_EX) in Pkg.Pcds or\r
                    (VfrPcd.TokenCName, VfrPcd.TokenSpaceGuidCName, TAB_PCDS_DYNAMIC) in Pkg.Pcds):\r
                    Packages.append(Pkg)\r
                    break\r
\r
        ModuleType = SUP_MODULE_DXE_DRIVER if self.ModuleType == SUP_MODULE_UEFI_DRIVER and self.DepexGenerated else self.ModuleType\r
        DriverType = self.PcdIsDriver if self.PcdIsDriver else ''\r
        Guid = self.Guid\r
        MDefs = self.Module.Defines\r
\r
        AsBuiltInfDict = {\r
          'module_name'                       : self.Name,\r
          'module_guid'                       : Guid,\r
          'module_module_type'                : ModuleType,\r
          'module_version_string'             : [MDefs['VERSION_STRING']] if 'VERSION_STRING' in MDefs else [],\r
          'pcd_is_driver_string'              : [],\r
          'module_uefi_specification_version' : [],\r
          'module_pi_specification_version'   : [],\r
          'module_entry_point'                : self.Module.ModuleEntryPointList,\r
          'module_unload_image'               : self.Module.ModuleUnloadImageList,\r
          'module_constructor'                : self.Module.ConstructorList,\r
          'module_destructor'                 : self.Module.DestructorList,\r
          'module_shadow'                     : [MDefs['SHADOW']] if 'SHADOW' in MDefs else [],\r
          'module_pci_vendor_id'              : [MDefs['PCI_VENDOR_ID']] if 'PCI_VENDOR_ID' in MDefs else [],\r
          'module_pci_device_id'              : [MDefs['PCI_DEVICE_ID']] if 'PCI_DEVICE_ID' in MDefs else [],\r
          'module_pci_class_code'             : [MDefs['PCI_CLASS_CODE']] if 'PCI_CLASS_CODE' in MDefs else [],\r
          'module_pci_revision'               : [MDefs['PCI_REVISION']] if 'PCI_REVISION' in MDefs else [],\r
          'module_build_number'               : [MDefs['BUILD_NUMBER']] if 'BUILD_NUMBER' in MDefs else [],\r
          'module_spec'                       : [MDefs['SPEC']] if 'SPEC' in MDefs else [],\r
          'module_uefi_hii_resource_section'  : [MDefs['UEFI_HII_RESOURCE_SECTION']] if 'UEFI_HII_RESOURCE_SECTION' in MDefs else [],\r
          'module_uni_file'                   : [MDefs['MODULE_UNI_FILE']] if 'MODULE_UNI_FILE' in MDefs else [],\r
          'module_arch'                       : self.Arch,\r
          'package_item'                      : [Package.MetaFile.File.replace('\\', '/') for Package in Packages],\r
          'binary_item'                       : [],\r
          'patchablepcd_item'                 : [],\r
          'pcd_item'                          : [],\r
          'protocol_item'                     : [],\r
          'ppi_item'                          : [],\r
          'guid_item'                         : [],\r
          'flags_item'                        : [],\r
          'libraryclasses_item'               : []\r
        }\r
\r
        if 'MODULE_UNI_FILE' in MDefs:\r
            UNIFile = os.path.join(self.MetaFile.Dir, MDefs['MODULE_UNI_FILE'])\r
            if os.path.isfile(UNIFile):\r
                shutil.copy2(UNIFile, self.OutputDir)\r
\r
        if self.AutoGenVersion > int(gInfSpecVersion, 0):\r
            AsBuiltInfDict['module_inf_version'] = '0x%08x' % self.AutoGenVersion\r
        else:\r
            AsBuiltInfDict['module_inf_version'] = gInfSpecVersion\r
\r
        if DriverType:\r
            AsBuiltInfDict['pcd_is_driver_string'].append(DriverType)\r
\r
        if 'UEFI_SPECIFICATION_VERSION' in self.Specification:\r
            AsBuiltInfDict['module_uefi_specification_version'].append(self.Specification['UEFI_SPECIFICATION_VERSION'])\r
        if 'PI_SPECIFICATION_VERSION' in self.Specification:\r
            AsBuiltInfDict['module_pi_specification_version'].append(self.Specification['PI_SPECIFICATION_VERSION'])\r
\r
        OutputDir = self.OutputDir.replace('\\', '/').strip('/')\r
        DebugDir = self.DebugDir.replace('\\', '/').strip('/')\r
        for Item in self.CodaTargetList:\r
            File = Item.Target.Path.replace('\\', '/').strip('/').replace(DebugDir, '').replace(OutputDir, '').strip('/')\r
            if os.path.isabs(File):\r
                File = File.replace('\\', '/').strip('/').replace(OutputDir, '').strip('/')\r
            if Item.Target.Ext.lower() == '.aml':\r
                AsBuiltInfDict['binary_item'].append('ASL|' + File)\r
            elif Item.Target.Ext.lower() == '.acpi':\r
                AsBuiltInfDict['binary_item'].append('ACPI|' + File)\r
            elif Item.Target.Ext.lower() == '.efi':\r
                AsBuiltInfDict['binary_item'].append('PE32|' + self.Name + '.efi')\r
            else:\r
                AsBuiltInfDict['binary_item'].append('BIN|' + File)\r
        if not self.DepexGenerated:\r
            DepexFile = os.path.join(self.OutputDir, self.Name + '.depex')\r
            if os.path.exists(DepexFile):\r
                self.DepexGenerated = True\r
        if self.DepexGenerated:\r
            if self.ModuleType in [SUP_MODULE_PEIM]:\r
                AsBuiltInfDict['binary_item'].append('PEI_DEPEX|' + self.Name + '.depex')\r
            elif self.ModuleType in [SUP_MODULE_DXE_DRIVER, SUP_MODULE_DXE_RUNTIME_DRIVER, SUP_MODULE_DXE_SAL_DRIVER, SUP_MODULE_UEFI_DRIVER]:\r
                AsBuiltInfDict['binary_item'].append('DXE_DEPEX|' + self.Name + '.depex')\r
            elif self.ModuleType in [SUP_MODULE_DXE_SMM_DRIVER]:\r
                AsBuiltInfDict['binary_item'].append('SMM_DEPEX|' + self.Name + '.depex')\r
\r
        Bin = self._GenOffsetBin()\r
        if Bin:\r
            AsBuiltInfDict['binary_item'].append('BIN|%s' % Bin)\r
\r
        for Root, Dirs, Files in os.walk(OutputDir):\r
            for File in Files:\r
                if File.lower().endswith('.pdb'):\r
                    AsBuiltInfDict['binary_item'].append('DISPOSABLE|' + File)\r
        HeaderComments = self.Module.HeaderComments\r
        StartPos = 0\r
        for Index in range(len(HeaderComments)):\r
            if HeaderComments[Index].find('@BinaryHeader') != -1:\r
                HeaderComments[Index] = HeaderComments[Index].replace('@BinaryHeader', '@file')\r
                StartPos = Index\r
                break\r
        AsBuiltInfDict['header_comments'] = '\n'.join(HeaderComments[StartPos:]).replace(':#', '://')\r
        AsBuiltInfDict['tail_comments'] = '\n'.join(self.Module.TailComments)\r
\r
        GenList = [\r
            (self.ProtocolList, self._ProtocolComments, 'protocol_item'),\r
            (self.PpiList, self._PpiComments, 'ppi_item'),\r
            (GuidList, self._GuidComments, 'guid_item')\r
        ]\r
        for Item in GenList:\r
            for CName in Item[0]:\r
                Comments = '\n  '.join(Item[1][CName]) if CName in Item[1] else ''\r
                Entry = Comments + '\n  ' + CName if Comments else CName\r
                AsBuiltInfDict[Item[2]].append(Entry)\r
        PatchList = parsePcdInfoFromMapFile(\r
                            os.path.join(self.OutputDir, self.Name + '.map'),\r
                            os.path.join(self.OutputDir, self.Name + '.efi')\r
                        )\r
        if PatchList:\r
            for Pcd in PatchablePcds:\r
                TokenCName = Pcd.TokenCName\r
                for PcdItem in GlobalData.MixedPcd:\r
                    if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:\r
                        TokenCName = PcdItem[0]\r
                        break\r
                for PatchPcd in PatchList:\r
                    if TokenCName == PatchPcd[0]:\r
                        break\r
                else:\r
                    continue\r
                PcdValue = ''\r
                if Pcd.DatumType == 'BOOLEAN':\r
                    BoolValue = Pcd.DefaultValue.upper()\r
                    if BoolValue == 'TRUE':\r
                        Pcd.DefaultValue = '1'\r
                    elif BoolValue == 'FALSE':\r
                        Pcd.DefaultValue = '0'\r
\r
                if Pcd.DatumType in TAB_PCD_NUMERIC_TYPES:\r
                    HexFormat = '0x%02x'\r
                    if Pcd.DatumType == TAB_UINT16:\r
                        HexFormat = '0x%04x'\r
                    elif Pcd.DatumType == TAB_UINT32:\r
                        HexFormat = '0x%08x'\r
                    elif Pcd.DatumType == TAB_UINT64:\r
                        HexFormat = '0x%016x'\r
                    PcdValue = HexFormat % int(Pcd.DefaultValue, 0)\r
                else:\r
                    if Pcd.MaxDatumSize is None or Pcd.MaxDatumSize == '':\r
                        EdkLogger.error("build", AUTOGEN_ERROR,\r
                                        "Unknown [MaxDatumSize] of PCD [%s.%s]" % (Pcd.TokenSpaceGuidCName, TokenCName)\r
                                        )\r
                    ArraySize = int(Pcd.MaxDatumSize, 0)\r
                    PcdValue = Pcd.DefaultValue\r
                    if PcdValue[0] != '{':\r
                        Unicode = False\r
                        if PcdValue[0] == 'L':\r
                            Unicode = True\r
                        PcdValue = PcdValue.lstrip('L')\r
                        PcdValue = eval(PcdValue)\r
                        NewValue = '{'\r
                        for Index in range(0, len(PcdValue)):\r
                            if Unicode:\r
                                CharVal = ord(PcdValue[Index])\r
                                NewValue = NewValue + '0x%02x' % (CharVal & 0x00FF) + ', ' \\r
                                        + '0x%02x' % (CharVal >> 8) + ', '\r
                            else:\r
                                NewValue = NewValue + '0x%02x' % (ord(PcdValue[Index]) % 0x100) + ', '\r
                        Padding = '0x00, '\r
                        if Unicode:\r
                            Padding = Padding * 2\r
                            ArraySize = ArraySize // 2\r
                        if ArraySize < (len(PcdValue) + 1):\r
                            if Pcd.MaxSizeUserSet:\r
                                EdkLogger.error("build", AUTOGEN_ERROR,\r
                                            "The maximum size of VOID* type PCD '%s.%s' is less than its actual size occupied." % (Pcd.TokenSpaceGuidCName, TokenCName)\r
                                            )\r
                            else:\r
                                ArraySize = len(PcdValue) + 1\r
                        if ArraySize > len(PcdValue) + 1:\r
                            NewValue = NewValue + Padding * (ArraySize - len(PcdValue) - 1)\r
                        PcdValue = NewValue + Padding.strip().rstrip(',') + '}'\r
                    elif len(PcdValue.split(',')) <= ArraySize:\r
                        PcdValue = PcdValue.rstrip('}') + ', 0x00' * (ArraySize - len(PcdValue.split(',')))\r
                        PcdValue += '}'\r
                    else:\r
                        if Pcd.MaxSizeUserSet:\r
                            EdkLogger.error("build", AUTOGEN_ERROR,\r
                                        "The maximum size of VOID* type PCD '%s.%s' is less than its actual size occupied." % (Pcd.TokenSpaceGuidCName, TokenCName)\r
                                        )\r
                        else:\r
                            ArraySize = len(PcdValue) + 1\r
                PcdItem = '%s.%s|%s|0x%X' % \\r
                    (Pcd.TokenSpaceGuidCName, TokenCName, PcdValue, PatchPcd[1])\r
                PcdComments = ''\r
                if (Pcd.TokenSpaceGuidCName, Pcd.TokenCName) in self._PcdComments:\r
                    PcdComments = '\n  '.join(self._PcdComments[Pcd.TokenSpaceGuidCName, Pcd.TokenCName])\r
                if PcdComments:\r
                    PcdItem = PcdComments + '\n  ' + PcdItem\r
                AsBuiltInfDict['patchablepcd_item'].append(PcdItem)\r
\r
        for Pcd in Pcds + VfrPcds:\r
            PcdCommentList = []\r
            HiiInfo = ''\r
            TokenCName = Pcd.TokenCName\r
            for PcdItem in GlobalData.MixedPcd:\r
                if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:\r
                    TokenCName = PcdItem[0]\r
                    break\r
            if Pcd.Type == TAB_PCDS_DYNAMIC_EX_HII:\r
                for SkuName in Pcd.SkuInfoList:\r
                    SkuInfo = Pcd.SkuInfoList[SkuName]\r
                    HiiInfo = '## %s|%s|%s' % (SkuInfo.VariableName, SkuInfo.VariableGuid, SkuInfo.VariableOffset)\r
                    break\r
            if (Pcd.TokenSpaceGuidCName, Pcd.TokenCName) in self._PcdComments:\r
                PcdCommentList = self._PcdComments[Pcd.TokenSpaceGuidCName, Pcd.TokenCName][:]\r
            if HiiInfo:\r
                UsageIndex = -1\r
                UsageStr = ''\r
                for Index, Comment in enumerate(PcdCommentList):\r
                    for Usage in UsageList:\r
                        if Comment.find(Usage) != -1:\r
                            UsageStr = Usage\r
                            UsageIndex = Index\r
                            break\r
                if UsageIndex != -1:\r
                    PcdCommentList[UsageIndex] = '## %s %s %s' % (UsageStr, HiiInfo, PcdCommentList[UsageIndex].replace(UsageStr, ''))\r
                else:\r
                    PcdCommentList.append('## UNDEFINED ' + HiiInfo)\r
            PcdComments = '\n  '.join(PcdCommentList)\r
            PcdEntry = Pcd.TokenSpaceGuidCName + '.' + TokenCName\r
            if PcdComments:\r
                PcdEntry = PcdComments + '\n  ' + PcdEntry\r
            AsBuiltInfDict['pcd_item'].append(PcdEntry)\r
        for Item in self.BuildOption:\r
            if 'FLAGS' in self.BuildOption[Item]:\r
                AsBuiltInfDict['flags_item'].append('%s:%s_%s_%s_%s_FLAGS = %s' % (self.ToolChainFamily, self.BuildTarget, self.ToolChain, self.Arch, Item, self.BuildOption[Item]['FLAGS'].strip()))\r
\r
        # Generated LibraryClasses section in comments.\r
        for Library in self.LibraryAutoGenList:\r
            AsBuiltInfDict['libraryclasses_item'].append(Library.MetaFile.File.replace('\\', '/'))\r
\r
        # Generated UserExtensions TianoCore section.\r
        # All tianocore user extensions are copied.\r
        UserExtStr = ''\r
        for TianoCore in self._GetTianoCoreUserExtensionList():\r
            UserExtStr += '\n'.join(TianoCore)\r
            ExtensionFile = os.path.join(self.MetaFile.Dir, TianoCore[1])\r
            if os.path.isfile(ExtensionFile):\r
                shutil.copy2(ExtensionFile, self.OutputDir)\r
        AsBuiltInfDict['userextension_tianocore_item'] = UserExtStr\r
\r
        # Generated depex expression section in comments.\r
        DepexExpression = self._GetDepexExpresionString()\r
        AsBuiltInfDict['depexsection_item'] = DepexExpression if DepexExpression else ''\r
\r
        AsBuiltInf = TemplateString()\r
        AsBuiltInf.Append(gAsBuiltInfHeaderString.Replace(AsBuiltInfDict))\r
\r
        SaveFileOnChange(os.path.join(self.OutputDir, self.Name + '.inf'), str(AsBuiltInf), False)\r
\r
        self.IsAsBuiltInfCreated = True\r
\r
    def CacheCopyFile(self, DestDir, SourceDir, File):\r
        if os.path.isdir(File):\r
            return\r
\r
        sub_dir = os.path.relpath(File, SourceDir)\r
        destination_file = os.path.join(DestDir, sub_dir)\r
        destination_dir = os.path.dirname(destination_file)\r
        CreateDirectory(destination_dir)\r
        try:\r
            CopyFileOnChange(File, destination_dir)\r
        except:\r
            EdkLogger.quiet("[cache warning]: fail to copy file:%s to folder:%s" % (File, destination_dir))\r
            return\r
\r
    def CopyModuleToCache(self):\r
        # Find the MakeHashStr and PreMakeHashStr from latest MakeHashFileList\r
        # and PreMakeHashFileList files\r
        MakeHashStr = None\r
        PreMakeHashStr = None\r
        MakeTimeStamp = 0\r
        PreMakeTimeStamp = 0\r
        Files = [f for f in os.listdir(LongFilePath(self.BuildDir)) if path.isfile(LongFilePath(path.join(self.BuildDir, f)))]\r
        for File in Files:\r
            if ".MakeHashFileList." in File:\r
                #find lastest file through time stamp\r
                FileTimeStamp = os.stat(LongFilePath(path.join(self.BuildDir, File)))[8]\r
                if FileTimeStamp > MakeTimeStamp:\r
                    MakeTimeStamp = FileTimeStamp\r
                    MakeHashStr = File.split('.')[-1]\r
                    if len(MakeHashStr) != 32:\r
                        EdkLogger.quiet("[cache error]: wrong MakeHashFileList file:%s" % (File))\r
            if ".PreMakeHashFileList." in File:\r
                FileTimeStamp = os.stat(LongFilePath(path.join(self.BuildDir, File)))[8]\r
                if FileTimeStamp > PreMakeTimeStamp:\r
                    PreMakeTimeStamp = FileTimeStamp\r
                    PreMakeHashStr = File.split('.')[-1]\r
                    if len(PreMakeHashStr) != 32:\r
                        EdkLogger.quiet("[cache error]: wrong PreMakeHashFileList file:%s" % (File))\r
\r
        if not MakeHashStr:\r
            EdkLogger.quiet("[cache error]: No MakeHashFileList file for module:%s[%s]" % (self.MetaFile.Path, self.Arch))\r
            return\r
        if not PreMakeHashStr:\r
            EdkLogger.quiet("[cache error]: No PreMakeHashFileList file for module:%s[%s]" % (self.MetaFile.Path, self.Arch))\r
            return\r
\r
        # Create Cache destination dirs\r
        FileDir = path.join(GlobalData.gBinCacheDest, self.PlatformInfo.OutputDir, self.BuildTarget + "_" + self.ToolChain, self.Arch, self.SourceDir, self.MetaFile.BaseName)\r
        FfsDir = path.join(GlobalData.gBinCacheDest, self.PlatformInfo.OutputDir, self.BuildTarget + "_" + self.ToolChain, TAB_FV_DIRECTORY, "Ffs", self.Guid + self.Name)\r
        CacheFileDir = path.join(FileDir, MakeHashStr)\r
        CacheFfsDir = path.join(FfsDir, MakeHashStr)\r
        CreateDirectory (CacheFileDir)\r
        CreateDirectory (CacheFfsDir)\r
\r
        # Create ModuleHashPair file to support multiple version cache together\r
        ModuleHashPair = path.join(FileDir, self.Name + ".ModuleHashPair")\r
        ModuleHashPairList = [] # tuple list: [tuple(PreMakefileHash, MakeHash)]\r
        if os.path.exists(ModuleHashPair):\r
            with open(ModuleHashPair, 'r') as f:\r
                ModuleHashPairList = json.load(f)\r
        if not (PreMakeHashStr, MakeHashStr) in set(map(tuple, ModuleHashPairList)):\r
            ModuleHashPairList.insert(0, (PreMakeHashStr, MakeHashStr))\r
            with open(ModuleHashPair, 'w') as f:\r
                json.dump(ModuleHashPairList, f, indent=2)\r
\r
        # Copy files to Cache destination dirs\r
        if not self.OutputFile:\r
            Ma = self.BuildDatabase[self.MetaFile, self.Arch, self.BuildTarget, self.ToolChain]\r
            self.OutputFile = Ma.Binaries\r
        for File in self.OutputFile:\r
            if File.startswith(os.path.abspath(self.FfsOutputDir)+os.sep):\r
                self.CacheCopyFile(CacheFfsDir, self.FfsOutputDir, File)\r
            else:\r
                if  self.Name + ".autogen.hash." in File or \\r
                    self.Name + ".autogen.hashchain." in File or \\r
                    self.Name + ".hash." in File or \\r
                    self.Name + ".hashchain." in File or \\r
                    self.Name + ".PreMakeHashFileList." in File or \\r
                    self.Name + ".MakeHashFileList." in File:\r
                    self.CacheCopyFile(FileDir, self.BuildDir, File)\r
                else:\r
                    self.CacheCopyFile(CacheFileDir, self.BuildDir, File)\r
    ## Create makefile for the module and its dependent libraries\r
    #\r
    #   @param      CreateLibraryMakeFile   Flag indicating if or not the makefiles of\r
    #                                       dependent libraries will be created\r
    #\r
    @cached_class_function\r
    def CreateMakeFile(self, CreateLibraryMakeFile=True, GenFfsList = []):\r
\r
        # nest this function inside it's only caller.\r
        def CreateTimeStamp():\r
            FileSet = {self.MetaFile.Path}\r
\r
            for SourceFile in self.Module.Sources:\r
                FileSet.add (SourceFile.Path)\r
\r
            for Lib in self.DependentLibraryList:\r
                FileSet.add (Lib.MetaFile.Path)\r
\r
            for f in self.AutoGenDepSet:\r
                FileSet.add (f.Path)\r
\r
            if os.path.exists (self.TimeStampPath):\r
                os.remove (self.TimeStampPath)\r
\r
            SaveFileOnChange(self.TimeStampPath, "\n".join(FileSet), False)\r
\r
        # Ignore generating makefile when it is a binary module\r
        if self.IsBinaryModule:\r
            return\r
\r
        self.GenFfsList = GenFfsList\r
\r
        if not self.IsLibrary and CreateLibraryMakeFile:\r
            for LibraryAutoGen in self.LibraryAutoGenList:\r
                LibraryAutoGen.CreateMakeFile()\r
\r
        # CanSkip uses timestamps to determine build skipping\r
        if self.CanSkip():\r
            return\r
\r
        if len(self.CustomMakefile) == 0:\r
            Makefile = GenMake.ModuleMakefile(self)\r
        else:\r
            Makefile = GenMake.CustomMakefile(self)\r
        if Makefile.Generate():\r
            EdkLogger.debug(EdkLogger.DEBUG_9, "Generated makefile for module %s [%s]" %\r
                            (self.Name, self.Arch))\r
        else:\r
            EdkLogger.debug(EdkLogger.DEBUG_9, "Skipped the generation of makefile for module %s [%s]" %\r
                            (self.Name, self.Arch))\r
\r
        CreateTimeStamp()\r
\r
        MakefileType = Makefile._FileType\r
        MakefileName = Makefile._FILE_NAME_[MakefileType]\r
        MakefilePath = os.path.join(self.MakeFileDir, MakefileName)\r
        FilePath = path.join(self.BuildDir, self.Name + ".makefile")\r
        SaveFileOnChange(FilePath, MakefilePath, False)\r
\r
    def CopyBinaryFiles(self):\r
        for File in self.Module.Binaries:\r
            SrcPath = File.Path\r
            DstPath = os.path.join(self.OutputDir, os.path.basename(SrcPath))\r
            CopyLongFilePath(SrcPath, DstPath)\r
    ## Create autogen code for the module and its dependent libraries\r
    #\r
    #   @param      CreateLibraryCodeFile   Flag indicating if or not the code of\r
    #                                       dependent libraries will be created\r
    #\r
    def CreateCodeFile(self, CreateLibraryCodeFile=True):\r
\r
        if self.IsCodeFileCreated:\r
            return\r
\r
        # Need to generate PcdDatabase even PcdDriver is binarymodule\r
        if self.IsBinaryModule and self.PcdIsDriver != '':\r
            CreatePcdDatabaseCode(self, TemplateString(), TemplateString())\r
            return\r
        if self.IsBinaryModule:\r
            if self.IsLibrary:\r
                self.CopyBinaryFiles()\r
            return\r
\r
        if not self.IsLibrary and CreateLibraryCodeFile:\r
            for LibraryAutoGen in self.LibraryAutoGenList:\r
                LibraryAutoGen.CreateCodeFile()\r
\r
        # CanSkip uses timestamps to determine build skipping\r
        if self.CanSkip():\r
            return\r
        self.LibraryAutoGenList\r
        AutoGenList = []\r
        IgoredAutoGenList = []\r
\r
        for File in self.AutoGenFileList:\r
            if GenC.Generate(File.Path, self.AutoGenFileList[File], File.IsBinary):\r
                AutoGenList.append(str(File))\r
            else:\r
                IgoredAutoGenList.append(str(File))\r
\r
\r
        for ModuleType in self.DepexList:\r
            # Ignore empty [depex] section or [depex] section for SUP_MODULE_USER_DEFINED module\r
            if len(self.DepexList[ModuleType]) == 0 or ModuleType == SUP_MODULE_USER_DEFINED or ModuleType == SUP_MODULE_HOST_APPLICATION:\r
                continue\r
\r
            Dpx = GenDepex.DependencyExpression(self.DepexList[ModuleType], ModuleType, True)\r
            DpxFile = gAutoGenDepexFileName % {"module_name" : self.Name}\r
\r
            if len(Dpx.PostfixNotation) != 0:\r
                self.DepexGenerated = True\r
\r
            if Dpx.Generate(path.join(self.OutputDir, DpxFile)):\r
                AutoGenList.append(str(DpxFile))\r
            else:\r
                IgoredAutoGenList.append(str(DpxFile))\r
\r
        if IgoredAutoGenList == []:\r
            EdkLogger.debug(EdkLogger.DEBUG_9, "Generated [%s] files for module %s [%s]" %\r
                            (" ".join(AutoGenList), self.Name, self.Arch))\r
        elif AutoGenList == []:\r
            EdkLogger.debug(EdkLogger.DEBUG_9, "Skipped the generation of [%s] files for module %s [%s]" %\r
                            (" ".join(IgoredAutoGenList), self.Name, self.Arch))\r
        else:\r
            EdkLogger.debug(EdkLogger.DEBUG_9, "Generated [%s] (skipped %s) files for module %s [%s]" %\r
                            (" ".join(AutoGenList), " ".join(IgoredAutoGenList), self.Name, self.Arch))\r
\r
        self.IsCodeFileCreated = True\r
\r
        return AutoGenList\r
\r
    ## Summarize the ModuleAutoGen objects of all libraries used by this module\r
    @cached_property\r
    def LibraryAutoGenList(self):\r
        RetVal = []\r
        for Library in self.DependentLibraryList:\r
            La = ModuleAutoGen(\r
                        self.Workspace,\r
                        Library.MetaFile,\r
                        self.BuildTarget,\r
                        self.ToolChain,\r
                        self.Arch,\r
                        self.PlatformInfo.MetaFile,\r
                        self.DataPipe\r
                        )\r
            La.IsLibrary = True\r
            if La not in RetVal:\r
                RetVal.append(La)\r
                for Lib in La.CodaTargetList:\r
                    self._ApplyBuildRule(Lib.Target, TAB_UNKNOWN_FILE)\r
        return RetVal\r
\r
    def GenCMakeHash(self):\r
        # GenCMakeHash can only be called in --binary-destination\r
        # Never called in multiprocessing and always directly save result in main process,\r
        # so no need remote dict to share the gCMakeHashFile result with main process\r
\r
        DependencyFileSet = set()\r
        # Add AutoGen files\r
        if self.AutoGenFileList:\r
            for File in set(self.AutoGenFileList):\r
                DependencyFileSet.add(File)\r
\r
        # Add Makefile\r
        abspath = path.join(self.BuildDir, self.Name + ".makefile")\r
        try:\r
            with open(LongFilePath(abspath),"r") as fd:\r
                lines = fd.readlines()\r
        except Exception as e:\r
            EdkLogger.error("build",FILE_NOT_FOUND, "%s doesn't exist" % abspath, ExtraData=str(e), RaiseError=False)\r
        if lines:\r
            DependencyFileSet.update(lines)\r
\r
        # Caculate all above dependency files hash\r
        # Initialze hash object\r
        FileList = []\r
        m = hashlib.md5()\r
        for File in sorted(DependencyFileSet, key=lambda x: str(x)):\r
            if not path.exists(LongFilePath(str(File))):\r
                EdkLogger.quiet("[cache warning]: header file %s is missing for module: %s[%s]" % (File, self.MetaFile.Path, self.Arch))\r
                continue\r
            with open(LongFilePath(str(File)), 'rb') as f:\r
                Content = f.read()\r
            m.update(Content)\r
            FileList.append((str(File), hashlib.md5(Content).hexdigest()))\r
\r
        HashChainFile = path.join(self.BuildDir, self.Name + ".autogen.hashchain." + m.hexdigest())\r
        GlobalData.gCMakeHashFile[(self.MetaFile.Path, self.Arch)] = HashChainFile\r
        try:\r
            with open(LongFilePath(HashChainFile), 'w') as f:\r
                json.dump(FileList, f, indent=2)\r
        except:\r
            EdkLogger.quiet("[cache warning]: fail to save hashchain file:%s" % HashChainFile)\r
            return False\r
\r
    def GenModuleHash(self):\r
        # GenModuleHash only called after autogen phase\r
        # Never called in multiprocessing and always directly save result in main process,\r
        # so no need remote dict to share the gModuleHashFile result with main process\r
        #\r
        # GenPreMakefileHashList consume no dict.\r
        # GenPreMakefileHashList produce local gModuleHashFile dict.\r
\r
        DependencyFileSet = set()\r
        # Add Module Meta file\r
        DependencyFileSet.add(self.MetaFile.Path)\r
\r
        # Add Module's source files\r
        if self.SourceFileList:\r
            for File in set(self.SourceFileList):\r
                DependencyFileSet.add(File.Path)\r
\r
        # Add modules's include header files\r
        # Directly use the deps.txt file in the module BuildDir\r
        abspath = path.join(self.BuildDir, "deps.txt")\r
        rt = None\r
        try:\r
            with open(LongFilePath(abspath),"r") as fd:\r
                lines = fd.readlines()\r
                if lines:\r
                    rt = set([item.lstrip().strip("\n") for item in lines if item.strip("\n").endswith(".h")])\r
        except Exception as e:\r
            EdkLogger.error("build",FILE_NOT_FOUND, "%s doesn't exist" % abspath, ExtraData=str(e), RaiseError=False)\r
\r
        if rt:\r
            DependencyFileSet.update(rt)\r
\r
\r
        # Caculate all above dependency files hash\r
        # Initialze hash object\r
        FileList = []\r
        m = hashlib.md5()\r
        BuildDirStr = path.abspath(self.BuildDir).lower()\r
        for File in sorted(DependencyFileSet, key=lambda x: str(x)):\r
            # Skip the AutoGen files in BuildDir which already been\r
            # included in .autogen.hash. file\r
            if BuildDirStr in path.abspath(File).lower():\r
                continue\r
            if not path.exists(LongFilePath(File)):\r
                EdkLogger.quiet("[cache warning]: header file %s is missing for module: %s[%s]" % (File, self.MetaFile.Path, self.Arch))\r
                continue\r
            with open(LongFilePath(File), 'rb') as f:\r
                Content = f.read()\r
            m.update(Content)\r
            FileList.append((File, hashlib.md5(Content).hexdigest()))\r
\r
        HashChainFile = path.join(self.BuildDir, self.Name + ".hashchain." + m.hexdigest())\r
        GlobalData.gModuleHashFile[(self.MetaFile.Path, self.Arch)] = HashChainFile\r
        try:\r
            with open(LongFilePath(HashChainFile), 'w') as f:\r
                json.dump(FileList, f, indent=2)\r
        except:\r
            EdkLogger.quiet("[cache warning]: fail to save hashchain file:%s" % HashChainFile)\r
            return False\r
\r
    def GenPreMakefileHashList(self):\r
        # GenPreMakefileHashList consume below dicts:\r
        #     gPlatformHashFile\r
        #     gPackageHashFile\r
        #     gModuleHashFile\r
        # GenPreMakefileHashList produce no dict.\r
        # gModuleHashFile items might be produced in multiprocessing, so\r
        # need check gModuleHashFile remote dict\r
\r
        # skip binary module\r
        if self.IsBinaryModule:\r
            return\r
\r
        FileList = []\r
        m = hashlib.md5()\r
        # Add Platform level hash\r
        HashFile = GlobalData.gPlatformHashFile\r
        if path.exists(LongFilePath(HashFile)):\r
            FileList.append(HashFile)\r
            m.update(HashFile.encode('utf-8'))\r
        else:\r
            EdkLogger.quiet("[cache warning]: No Platform HashFile: %s" % HashFile)\r
\r
        # Add Package level hash\r
        if self.DependentPackageList:\r
            for Pkg in sorted(self.DependentPackageList, key=lambda x: x.PackageName):\r
                if not (Pkg.PackageName, Pkg.Arch) in GlobalData.gPackageHashFile:\r
                    EdkLogger.quiet("[cache warning]:No Package %s for module %s[%s]" % (Pkg.PackageName, self.MetaFile.Path, self.Arch))\r
                    continue\r
                HashFile = GlobalData.gPackageHashFile[(Pkg.PackageName, Pkg.Arch)]\r
                if path.exists(LongFilePath(HashFile)):\r
                    FileList.append(HashFile)\r
                    m.update(HashFile.encode('utf-8'))\r
                else:\r
                    EdkLogger.quiet("[cache warning]:No Package HashFile: %s" % HashFile)\r
\r
        # Add Module self\r
        # GenPreMakefileHashList needed in both --binary-destination\r
        # and --hash. And --hash might save ModuleHashFile in remote dict\r
        # during multiprocessing.\r
        if (self.MetaFile.Path, self.Arch) in GlobalData.gModuleHashFile:\r
            HashFile = GlobalData.gModuleHashFile[(self.MetaFile.Path, self.Arch)]\r
        else:\r
            EdkLogger.quiet("[cache error]:No ModuleHashFile for module: %s[%s]" % (self.MetaFile.Path, self.Arch))\r
        if path.exists(LongFilePath(HashFile)):\r
            FileList.append(HashFile)\r
            m.update(HashFile.encode('utf-8'))\r
        else:\r
            EdkLogger.quiet("[cache warning]:No Module HashFile: %s" % HashFile)\r
\r
        # Add Library hash\r
        if self.LibraryAutoGenList:\r
            for Lib in sorted(self.LibraryAutoGenList, key=lambda x: x.MetaFile.Path):\r
\r
                if (Lib.MetaFile.Path, Lib.Arch) in GlobalData.gModuleHashFile:\r
                    HashFile = GlobalData.gModuleHashFile[(Lib.MetaFile.Path, Lib.Arch)]\r
                else:\r
                    EdkLogger.quiet("[cache error]:No ModuleHashFile for lib: %s[%s]" % (Lib.MetaFile.Path, Lib.Arch))\r
                if path.exists(LongFilePath(HashFile)):\r
                    FileList.append(HashFile)\r
                    m.update(HashFile.encode('utf-8'))\r
                else:\r
                    EdkLogger.quiet("[cache warning]:No Lib HashFile: %s" % HashFile)\r
\r
        # Save PreMakeHashFileList\r
        FilePath = path.join(self.BuildDir, self.Name + ".PreMakeHashFileList." + m.hexdigest())\r
        try:\r
            with open(LongFilePath(FilePath), 'w') as f:\r
                json.dump(FileList, f, indent=0)\r
        except:\r
            EdkLogger.quiet("[cache warning]: fail to save PreMake HashFileList: %s" % FilePath)\r
\r
    def GenMakefileHashList(self):\r
        # GenMakefileHashList only need in --binary-destination which will\r
        # everything in local dict. So don't need check remote dict.\r
\r
        # skip binary module\r
        if self.IsBinaryModule:\r
            return\r
\r
        FileList = []\r
        m = hashlib.md5()\r
        # Add AutoGen hash\r
        HashFile = GlobalData.gCMakeHashFile[(self.MetaFile.Path, self.Arch)]\r
        if path.exists(LongFilePath(HashFile)):\r
            FileList.append(HashFile)\r
            m.update(HashFile.encode('utf-8'))\r
        else:\r
            EdkLogger.quiet("[cache warning]:No AutoGen HashFile: %s" % HashFile)\r
\r
        # Add Module self\r
        if (self.MetaFile.Path, self.Arch) in GlobalData.gModuleHashFile:\r
            HashFile = GlobalData.gModuleHashFile[(self.MetaFile.Path, self.Arch)]\r
        else:\r
            EdkLogger.quiet("[cache error]:No ModuleHashFile for module: %s[%s]" % (self.MetaFile.Path, self.Arch))\r
        if path.exists(LongFilePath(HashFile)):\r
            FileList.append(HashFile)\r
            m.update(HashFile.encode('utf-8'))\r
        else:\r
            EdkLogger.quiet("[cache warning]:No Module HashFile: %s" % HashFile)\r
\r
        # Add Library hash\r
        if self.LibraryAutoGenList:\r
            for Lib in sorted(self.LibraryAutoGenList, key=lambda x: x.MetaFile.Path):\r
                if (Lib.MetaFile.Path, Lib.Arch) in GlobalData.gModuleHashFile:\r
                    HashFile = GlobalData.gModuleHashFile[(Lib.MetaFile.Path, Lib.Arch)]\r
                else:\r
                    EdkLogger.quiet("[cache error]:No ModuleHashFile for lib: %s[%s]" % (Lib.MetaFile.Path, Lib.Arch))\r
                if path.exists(LongFilePath(HashFile)):\r
                    FileList.append(HashFile)\r
                    m.update(HashFile.encode('utf-8'))\r
                else:\r
                    EdkLogger.quiet("[cache warning]:No Lib HashFile: %s" % HashFile)\r
\r
        # Save MakeHashFileList\r
        FilePath = path.join(self.BuildDir, self.Name + ".MakeHashFileList." + m.hexdigest())\r
        try:\r
            with open(LongFilePath(FilePath), 'w') as f:\r
                json.dump(FileList, f, indent=0)\r
        except:\r
            EdkLogger.quiet("[cache warning]: fail to save Make HashFileList: %s" % FilePath)\r
\r
    def CheckHashChainFile(self, HashChainFile):\r
        # Assume the HashChainFile basename format is the 'x.hashchain.16BytesHexStr'\r
        # The x is module name and the 16BytesHexStr is md5 hexdigest of\r
        # all hashchain files content\r
        HashStr = HashChainFile.split('.')[-1]\r
        if len(HashStr) != 32:\r
            EdkLogger.quiet("[cache error]: wrong format HashChainFile:%s" % (File))\r
            return False\r
\r
        try:\r
            with open(LongFilePath(HashChainFile), 'r') as f:\r
                HashChainList = json.load(f)\r
        except:\r
            EdkLogger.quiet("[cache error]: fail to load HashChainFile: %s" % HashChainFile)\r
            return False\r
\r
        # Print the different file info\r
        # print(HashChainFile)\r
        for idx, (SrcFile, SrcHash) in enumerate (HashChainList):\r
            if SrcFile in GlobalData.gFileHashDict:\r
                DestHash = GlobalData.gFileHashDict[SrcFile]\r
            else:\r
                try:\r
                    with open(LongFilePath(SrcFile), 'rb') as f:\r
                        Content = f.read()\r
                        DestHash = hashlib.md5(Content).hexdigest()\r
                        GlobalData.gFileHashDict[SrcFile] = DestHash\r
                except IOError as X:\r
                    # cache miss if SrcFile is removed in new version code\r
                    GlobalData.gFileHashDict[SrcFile] = 0\r
                    EdkLogger.quiet("[cache insight]: first cache miss file in %s is %s" % (HashChainFile, SrcFile))\r
                    return False\r
            if SrcHash != DestHash:\r
                EdkLogger.quiet("[cache insight]: first cache miss file in %s is %s" % (HashChainFile, SrcFile))\r
                return False\r
\r
        return True\r
\r
    ## Decide whether we can skip the left autogen and make process\r
    def CanSkipbyMakeCache(self):\r
        # For --binary-source only\r
        # CanSkipbyMakeCache consume below dicts:\r
        #     gModuleMakeCacheStatus\r
        #     gHashChainStatus\r
        # GenPreMakefileHashList produce gModuleMakeCacheStatus, gModuleHashFile dict.\r
        # all these dicts might be produced in multiprocessing, so\r
        # need check these remote dict\r
\r
        if not GlobalData.gBinCacheSource:\r
            return False\r
\r
        if (self.MetaFile.Path, self.Arch) in GlobalData.gModuleMakeCacheStatus:\r
            return GlobalData.gModuleMakeCacheStatus[(self.MetaFile.Path, self.Arch)]\r
\r
        # If Module is binary, which has special build rule, do not skip by cache.\r
        if self.IsBinaryModule:\r
            print("[cache miss]: MakeCache: Skip BinaryModule:", self.MetaFile.Path, self.Arch)\r
            GlobalData.gModuleMakeCacheStatus[(self.MetaFile.Path, self.Arch)] = False\r
            return False\r
\r
        # see .inc as binary file, do not skip by hash\r
        for f_ext in self.SourceFileList:\r
            if '.inc' in str(f_ext):\r
                print("[cache miss]: MakeCache: Skip '.inc' File:", self.MetaFile.Path, self.Arch)\r
                GlobalData.gModuleMakeCacheStatus[(self.MetaFile.Path, self.Arch)] = False\r
                return False\r
\r
        ModuleCacheDir = path.join(GlobalData.gBinCacheSource, self.PlatformInfo.OutputDir, self.BuildTarget + "_" + self.ToolChain, self.Arch, self.SourceDir, self.MetaFile.BaseName)\r
        FfsDir = path.join(GlobalData.gBinCacheSource, self.PlatformInfo.OutputDir, self.BuildTarget + "_" + self.ToolChain, TAB_FV_DIRECTORY, "Ffs", self.Guid + self.Name)\r
\r
        ModuleHashPairList = [] # tuple list: [tuple(PreMakefileHash, MakeHash)]\r
        ModuleHashPair = path.join(ModuleCacheDir, self.Name + ".ModuleHashPair")\r
        try:\r
            with open(LongFilePath(ModuleHashPair), 'r') as f:\r
                ModuleHashPairList = json.load(f)\r
        except:\r
            # ModuleHashPair might not exist for new added module\r
            GlobalData.gModuleMakeCacheStatus[(self.MetaFile.Path, self.Arch)] = False\r
            EdkLogger.quiet("[cache warning]: fail to load ModuleHashPair file: %s" % ModuleHashPair)\r
            print("[cache miss]: MakeCache:", self.MetaFile.Path, self.Arch)\r
            return False\r
\r
        # Check the PreMakeHash in ModuleHashPairList one by one\r
        for idx, (PreMakefileHash, MakeHash) in enumerate (ModuleHashPairList):\r
            SourceHashDir = path.join(ModuleCacheDir, MakeHash)\r
            SourceFfsHashDir = path.join(FfsDir, MakeHash)\r
            PreMakeHashFileList_FilePah = path.join(ModuleCacheDir, self.Name + ".PreMakeHashFileList." + PreMakefileHash)\r
            MakeHashFileList_FilePah = path.join(ModuleCacheDir, self.Name + ".MakeHashFileList." + MakeHash)\r
\r
            try:\r
                with open(LongFilePath(MakeHashFileList_FilePah), 'r') as f:\r
                    MakeHashFileList = json.load(f)\r
            except:\r
                EdkLogger.quiet("[cache error]: fail to load MakeHashFileList file: %s" % MakeHashFileList_FilePah)\r
                continue\r
\r
            HashMiss = False\r
            for HashChainFile in MakeHashFileList:\r
                HashChainStatus = None\r
                if HashChainFile in GlobalData.gHashChainStatus:\r
                    HashChainStatus = GlobalData.gHashChainStatus[HashChainFile]\r
                if HashChainStatus == False:\r
                    HashMiss = True\r
                    break\r
                elif HashChainStatus == True:\r
                    continue\r
                # Convert to path start with cache source dir\r
                RelativePath = os.path.relpath(HashChainFile, self.WorkspaceDir)\r
                NewFilePath = os.path.join(GlobalData.gBinCacheSource, RelativePath)\r
                if self.CheckHashChainFile(NewFilePath):\r
                    GlobalData.gHashChainStatus[HashChainFile] = True\r
                    # Save the module self HashFile for GenPreMakefileHashList later usage\r
                    if self.Name + ".hashchain." in HashChainFile:\r
                        GlobalData.gModuleHashFile[(self.MetaFile.Path, self.Arch)] = HashChainFile\r
                else:\r
                    GlobalData.gHashChainStatus[HashChainFile] = False\r
                    HashMiss = True\r
                    break\r
\r
            if HashMiss:\r
                continue\r
\r
            # PreMakefile cache hit, restore the module build result\r
            for root, dir, files in os.walk(SourceHashDir):\r
                for f in files:\r
                    File = path.join(root, f)\r
                    self.CacheCopyFile(self.BuildDir, SourceHashDir, File)\r
            if os.path.exists(SourceFfsHashDir):\r
                for root, dir, files in os.walk(SourceFfsHashDir):\r
                    for f in files:\r
                        File = path.join(root, f)\r
                        self.CacheCopyFile(self.FfsOutputDir, SourceFfsHashDir, File)\r
\r
            if self.Name == "PcdPeim" or self.Name == "PcdDxe":\r
                CreatePcdDatabaseCode(self, TemplateString(), TemplateString())\r
\r
            print("[cache hit]: MakeCache:", self.MetaFile.Path, self.Arch)\r
            GlobalData.gModuleMakeCacheStatus[(self.MetaFile.Path, self.Arch)] = True\r
            return True\r
\r
        print("[cache miss]: MakeCache:", self.MetaFile.Path, self.Arch)\r
        GlobalData.gModuleMakeCacheStatus[(self.MetaFile.Path, self.Arch)] = False\r
        return False\r
\r
    ## Decide whether we can skip the left autogen and make process\r
    def CanSkipbyPreMakeCache(self):\r
        # CanSkipbyPreMakeCache consume below dicts:\r
        #     gModulePreMakeCacheStatus\r
        #     gHashChainStatus\r
        #     gModuleHashFile\r
        # GenPreMakefileHashList produce gModulePreMakeCacheStatus dict.\r
        # all these dicts might be produced in multiprocessing, so\r
        # need check these remote dicts\r
\r
        if not GlobalData.gUseHashCache or GlobalData.gBinCacheDest:\r
            return False\r
\r
        if (self.MetaFile.Path, self.Arch) in GlobalData.gModulePreMakeCacheStatus:\r
            return GlobalData.gModulePreMakeCacheStatus[(self.MetaFile.Path, self.Arch)]\r
\r
        # If Module is binary, which has special build rule, do not skip by cache.\r
        if self.IsBinaryModule:\r
            print("[cache miss]: PreMakeCache: Skip BinaryModule:", self.MetaFile.Path, self.Arch)\r
            GlobalData.gModulePreMakeCacheStatus[(self.MetaFile.Path, self.Arch)] = False\r
            return False\r
\r
        # see .inc as binary file, do not skip by hash\r
        for f_ext in self.SourceFileList:\r
            if '.inc' in str(f_ext):\r
                print("[cache miss]: PreMakeCache: Skip '.inc' File:", self.MetaFile.Path, self.Arch)\r
                GlobalData.gModulePreMakeCacheStatus[(self.MetaFile.Path, self.Arch)] = False\r
                return False\r
\r
        # For --hash only in the incremental build\r
        if not GlobalData.gBinCacheSource:\r
            Files = [path.join(self.BuildDir, f) for f in os.listdir(self.BuildDir) if path.isfile(path.join(self.BuildDir, f))]\r
            PreMakeHashFileList_FilePah = None\r
            MakeTimeStamp = 0\r
            # Find latest PreMakeHashFileList file in self.BuildDir folder\r
            for File in Files:\r
                if ".PreMakeHashFileList." in File:\r
                    FileTimeStamp = os.stat(path.join(self.BuildDir, File))[8]\r
                    if FileTimeStamp > MakeTimeStamp:\r
                        MakeTimeStamp = FileTimeStamp\r
                        PreMakeHashFileList_FilePah = File\r
            if not PreMakeHashFileList_FilePah:\r
                GlobalData.gModulePreMakeCacheStatus[(self.MetaFile.Path, self.Arch)] = False\r
                return False\r
\r
            try:\r
                with open(LongFilePath(PreMakeHashFileList_FilePah), 'r') as f:\r
                    PreMakeHashFileList = json.load(f)\r
            except:\r
                EdkLogger.quiet("[cache error]: fail to load PreMakeHashFileList file: %s" % PreMakeHashFileList_FilePah)\r
                print("[cache miss]: PreMakeCache:", self.MetaFile.Path, self.Arch)\r
                GlobalData.gModulePreMakeCacheStatus[(self.MetaFile.Path, self.Arch)] = False\r
                return False\r
\r
            HashMiss = False\r
            for HashChainFile in PreMakeHashFileList:\r
                HashChainStatus = None\r
                if HashChainFile in GlobalData.gHashChainStatus:\r
                    HashChainStatus = GlobalData.gHashChainStatus[HashChainFile]\r
                if HashChainStatus == False:\r
                    HashMiss = True\r
                    break\r
                elif HashChainStatus == True:\r
                    continue\r
                if self.CheckHashChainFile(HashChainFile):\r
                    GlobalData.gHashChainStatus[HashChainFile] = True\r
                    # Save the module self HashFile for GenPreMakefileHashList later usage\r
                    if self.Name + ".hashchain." in HashChainFile:\r
                        GlobalData.gModuleHashFile[(self.MetaFile.Path, self.Arch)] = HashChainFile\r
                else:\r
                    GlobalData.gHashChainStatus[HashChainFile] = False\r
                    HashMiss = True\r
                    break\r
\r
            if HashMiss:\r
                print("[cache miss]: PreMakeCache:", self.MetaFile.Path, self.Arch)\r
                GlobalData.gModulePreMakeCacheStatus[(self.MetaFile.Path, self.Arch)] = False\r
                return False\r
            else:\r
                print("[cache hit]: PreMakeCache:", self.MetaFile.Path, self.Arch)\r
                GlobalData.gModulePreMakeCacheStatus[(self.MetaFile.Path, self.Arch)] = True\r
                return True\r
\r
        ModuleCacheDir = path.join(GlobalData.gBinCacheSource, self.PlatformInfo.OutputDir, self.BuildTarget + "_" + self.ToolChain, self.Arch, self.SourceDir, self.MetaFile.BaseName)\r
        FfsDir = path.join(GlobalData.gBinCacheSource, self.PlatformInfo.OutputDir, self.BuildTarget + "_" + self.ToolChain, TAB_FV_DIRECTORY, "Ffs", self.Guid + self.Name)\r
\r
        ModuleHashPairList = [] # tuple list: [tuple(PreMakefileHash, MakeHash)]\r
        ModuleHashPair = path.join(ModuleCacheDir, self.Name + ".ModuleHashPair")\r
        try:\r
            with open(LongFilePath(ModuleHashPair), 'r') as f:\r
                ModuleHashPairList = json.load(f)\r
        except:\r
            # ModuleHashPair might not exist for new added module\r
            GlobalData.gModulePreMakeCacheStatus[(self.MetaFile.Path, self.Arch)] = False\r
            EdkLogger.quiet("[cache warning]: fail to load ModuleHashPair file: %s" % ModuleHashPair)\r
            print("[cache miss]: PreMakeCache:", self.MetaFile.Path, self.Arch)\r
            return False\r
\r
        # Check the PreMakeHash in ModuleHashPairList one by one\r
        for idx, (PreMakefileHash, MakeHash) in enumerate (ModuleHashPairList):\r
            SourceHashDir = path.join(ModuleCacheDir, MakeHash)\r
            SourceFfsHashDir = path.join(FfsDir, MakeHash)\r
            PreMakeHashFileList_FilePah = path.join(ModuleCacheDir, self.Name + ".PreMakeHashFileList." + PreMakefileHash)\r
            MakeHashFileList_FilePah = path.join(ModuleCacheDir, self.Name + ".MakeHashFileList." + MakeHash)\r
\r
            try:\r
                with open(LongFilePath(PreMakeHashFileList_FilePah), 'r') as f:\r
                    PreMakeHashFileList = json.load(f)\r
            except:\r
                EdkLogger.quiet("[cache error]: fail to load PreMakeHashFileList file: %s" % PreMakeHashFileList_FilePah)\r
                continue\r
\r
            HashMiss = False\r
            for HashChainFile in PreMakeHashFileList:\r
                HashChainStatus = None\r
                if HashChainFile in GlobalData.gHashChainStatus:\r
                    HashChainStatus = GlobalData.gHashChainStatus[HashChainFile]\r
                if HashChainStatus == False:\r
                    HashMiss = True\r
                    break\r
                elif HashChainStatus == True:\r
                    continue\r
                # Convert to path start with cache source dir\r
                RelativePath = os.path.relpath(HashChainFile, self.WorkspaceDir)\r
                NewFilePath = os.path.join(GlobalData.gBinCacheSource, RelativePath)\r
                if self.CheckHashChainFile(NewFilePath):\r
                    GlobalData.gHashChainStatus[HashChainFile] = True\r
                else:\r
                    GlobalData.gHashChainStatus[HashChainFile] = False\r
                    HashMiss = True\r
                    break\r
\r
            if HashMiss:\r
                continue\r
\r
            # PreMakefile cache hit, restore the module build result\r
            for root, dir, files in os.walk(SourceHashDir):\r
                for f in files:\r
                    File = path.join(root, f)\r
                    self.CacheCopyFile(self.BuildDir, SourceHashDir, File)\r
            if os.path.exists(SourceFfsHashDir):\r
                for root, dir, files in os.walk(SourceFfsHashDir):\r
                    for f in files:\r
                        File = path.join(root, f)\r
                        self.CacheCopyFile(self.FfsOutputDir, SourceFfsHashDir, File)\r
\r
            if self.Name == "PcdPeim" or self.Name == "PcdDxe":\r
                CreatePcdDatabaseCode(self, TemplateString(), TemplateString())\r
\r
            print("[cache hit]: PreMakeCache:", self.MetaFile.Path, self.Arch)\r
            GlobalData.gModulePreMakeCacheStatus[(self.MetaFile.Path, self.Arch)] = True\r
            return True\r
\r
        print("[cache miss]: PreMakeCache:", self.MetaFile.Path, self.Arch)\r
        GlobalData.gModulePreMakeCacheStatus[(self.MetaFile.Path, self.Arch)] = False\r
        return False\r
\r
    ## Decide whether we can skip the Module build\r
    def CanSkipbyCache(self, gHitSet):\r
        # Hashing feature is off\r
        if not GlobalData.gBinCacheSource:\r
            return False\r
\r
        if self in gHitSet:\r
            return True\r
\r
        return False\r
\r
    ## Decide whether we can skip the ModuleAutoGen process\r
    #  If any source file is newer than the module than we cannot skip\r
    #\r
    def CanSkip(self):\r
        # Don't skip if cache feature enabled\r
        if GlobalData.gUseHashCache or GlobalData.gBinCacheDest or GlobalData.gBinCacheSource:\r
            return False\r
        if self.MakeFileDir in GlobalData.gSikpAutoGenCache:\r
            return True\r
        if not os.path.exists(self.TimeStampPath):\r
            return False\r
        #last creation time of the module\r
        DstTimeStamp = os.stat(self.TimeStampPath)[8]\r
\r
        SrcTimeStamp = self.Workspace._SrcTimeStamp\r
        if SrcTimeStamp > DstTimeStamp:\r
            return False\r
\r
        with open(self.TimeStampPath,'r') as f:\r
            for source in f:\r
                source = source.rstrip('\n')\r
                if not os.path.exists(source):\r
                    return False\r
                if source not in ModuleAutoGen.TimeDict :\r
                    ModuleAutoGen.TimeDict[source] = os.stat(source)[8]\r
                if ModuleAutoGen.TimeDict[source] > DstTimeStamp:\r
                    return False\r
        GlobalData.gSikpAutoGenCache.add(self.MakeFileDir)\r
        return True\r
\r
    @cached_property\r
    def TimeStampPath(self):\r
        return os.path.join(self.MakeFileDir, 'AutoGenTimeStamp')\r