Renormalized end-of-lines from master@27b044605cd5f6b33a3d231576003850b3fe305btrunk

1 files changed, 1605 insertions, 1605 deletions

diff --git a/BaseTools/Source/Python/AutoGen/PlatformAutoGen.py b/BaseTools/Source/Python/AutoGen/PlatformAutoGen.py
index dac81454a9..fa4a4abaab 100644
--- a/BaseTools/Source/Python/AutoGen/PlatformAutoGen.py
+++ b/BaseTools/Source/Python/AutoGen/PlatformAutoGen.py
@@ -1,1605 +1,1605 @@
-## @file

-# Create makefile for MS nmake and GNU make

-#

-# Copyright (c) 2019 - 2021, Intel Corporation. All rights reserved.<BR>

-#  Copyright (c) 2020, ARM Limited. All rights reserved.<BR>

-# SPDX-License-Identifier: BSD-2-Clause-Patent

-#

-

-## Import Modules

-#

-from __future__ import print_function

-from __future__ import absolute_import

-import os.path as path

-import copy

-from collections import defaultdict

-

-from .BuildEngine import BuildRule,gDefaultBuildRuleFile,AutoGenReqBuildRuleVerNum

-from .GenVar import VariableMgr, var_info

-from . import GenMake

-from AutoGen.DataPipe import MemoryDataPipe

-from AutoGen.ModuleAutoGen import ModuleAutoGen

-from AutoGen.AutoGen import AutoGen

-from AutoGen.AutoGen import CalculatePriorityValue

-from Workspace.WorkspaceCommon import GetModuleLibInstances

-from CommonDataClass.CommonClass import SkuInfoClass

-from Common.caching import cached_class_function

-from Common.Expression import ValueExpressionEx

-from Common.StringUtils import StringToArray,NormPath

-from Common.BuildToolError import *

-from Common.DataType import *

-from Common.Misc import *

-import Common.VpdInfoFile as VpdInfoFile

-

-## Split command line option string to list

-#

-# subprocess.Popen needs the args to be a sequence. Otherwise there's problem

-# in non-windows platform to launch command

-#

-def _SplitOption(OptionString):

-    OptionList = []

-    LastChar = " "

-    OptionStart = 0

-    QuotationMark = ""

-    for Index in range(0, len(OptionString)):

-        CurrentChar = OptionString[Index]

-        if CurrentChar in ['"', "'"]:

-            if QuotationMark == CurrentChar:

-                QuotationMark = ""

-            elif QuotationMark == "":

-                QuotationMark = CurrentChar

-            continue

-        elif QuotationMark:

-            continue

-

-        if CurrentChar in ["/", "-"] and LastChar in [" ", "\t", "\r", "\n"]:

-            if Index > OptionStart:

-                OptionList.append(OptionString[OptionStart:Index - 1])

-            OptionStart = Index

-        LastChar = CurrentChar

-    OptionList.append(OptionString[OptionStart:])

-    return OptionList

-

-## AutoGen class for platform

-#

-#  PlatformAutoGen class will process the original information in platform

-#  file in order to generate makefile for platform.

-#

-class PlatformAutoGen(AutoGen):

-    # call super().__init__ then call the worker function with different parameter count

-    def __init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):

-        if not hasattr(self, "_Init"):

-            self._InitWorker(Workspace, MetaFile, Target, Toolchain, Arch)

-            self._Init = True

-    #

-    # Used to store all PCDs for both PEI and DXE phase, in order to generate

-    # correct PCD database

-    #

-    _DynaPcdList_ = []

-    _NonDynaPcdList_ = []

-    _PlatformPcds = {}

-

-

-

-    ## Initialize PlatformAutoGen

-    #

-    #

-    #   @param      Workspace       WorkspaceAutoGen object

-    #   @param      PlatformFile    Platform file (DSC file)

-    #   @param      Target          Build target (DEBUG, RELEASE)

-    #   @param      Toolchain       Name of tool chain

-    #   @param      Arch            arch of the platform supports

-    #

-    def _InitWorker(self, Workspace, PlatformFile, Target, Toolchain, Arch):

-        EdkLogger.debug(EdkLogger.DEBUG_9, "AutoGen platform [%s] [%s]" % (PlatformFile, Arch))

-        GlobalData.gProcessingFile = "%s [%s, %s, %s]" % (PlatformFile, Arch, Toolchain, Target)

-

-        self.MetaFile = PlatformFile

-        self.Workspace = Workspace

-        self.WorkspaceDir = Workspace.WorkspaceDir

-        self.ToolChain = Toolchain

-        self.BuildTarget = Target

-        self.Arch = Arch

-        self.SourceDir = PlatformFile.SubDir

-        self.FdTargetList = self.Workspace.FdTargetList

-        self.FvTargetList = self.Workspace.FvTargetList

-        # get the original module/package/platform objects

-        self.BuildDatabase = Workspace.BuildDatabase

-        self.DscBuildDataObj = Workspace.Platform

-

-        # MakeFileName is used to get the Makefile name and as a flag

-        # indicating whether the file has been created.

-        self.MakeFileName = ""

-

-        self._DynamicPcdList = None    # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]

-        self._NonDynamicPcdList = None # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]

-

-        self._AsBuildInfList = []

-        self._AsBuildModuleList = []

-

-        self.VariableInfo = None

-

-        if GlobalData.gFdfParser is not None:

-            self._AsBuildInfList = GlobalData.gFdfParser.Profile.InfList

-            for Inf in self._AsBuildInfList:

-                InfClass = PathClass(NormPath(Inf), GlobalData.gWorkspace, self.Arch)

-                M = self.BuildDatabase[InfClass, self.Arch, self.BuildTarget, self.ToolChain]

-                if not M.IsBinaryModule:

-                    continue

-                self._AsBuildModuleList.append(InfClass)

-        # get library/modules for build

-        self.LibraryBuildDirectoryList = []

-        self.ModuleBuildDirectoryList = []

-

-        self.DataPipe = MemoryDataPipe(self.BuildDir)

-        self.DataPipe.FillData(self)

-

-        return True

-    def FillData_LibConstPcd(self):

-        libConstPcd = {}

-        for LibAuto in self.LibraryAutoGenList:

-            if LibAuto.ConstPcd:

-                libConstPcd[(LibAuto.MetaFile.File,LibAuto.MetaFile.Root,LibAuto.Arch,LibAuto.MetaFile.Path)] = LibAuto.ConstPcd

-        self.DataPipe.DataContainer = {"LibConstPcd":libConstPcd}

-    ## hash() operator of PlatformAutoGen

-    #

-    #  The platform file path and arch string will be used to represent

-    #  hash value of this object

-    #

-    #   @retval   int Hash value of the platform file path and arch

-    #

-    @cached_class_function

-    def __hash__(self):

-        return hash((self.MetaFile, self.Arch,self.ToolChain,self.BuildTarget))

-    @cached_class_function

-    def __repr__(self):

-        return "%s [%s]" % (self.MetaFile, self.Arch)

-

-    ## Create autogen code for platform and modules

-    #

-    #  Since there's no autogen code for platform, this method will do nothing

-    #  if CreateModuleCodeFile is set to False.

-    #

-    #   @param      CreateModuleCodeFile    Flag indicating if creating module's

-    #                                       autogen code file or not

-    #

-    @cached_class_function

-    def CreateCodeFile(self, CreateModuleCodeFile=False):

-        # only module has code to be created, so do nothing if CreateModuleCodeFile is False

-        if not CreateModuleCodeFile:

-            return

-

-        for Ma in self.ModuleAutoGenList:

-            Ma.CreateCodeFile(CreateModuleCodeFile)

-

-    ## Generate Fds Command

-    @cached_property

-    def GenFdsCommand(self):

-        return self.Workspace.GenFdsCommand

-

-    ## Create makefile for the platform and modules in it

-    #

-    #   @param      CreateModuleMakeFile    Flag indicating if the makefile for

-    #                                       modules will be created as well

-    #

-    def CreateMakeFile(self, CreateModuleMakeFile=False, FfsCommand = {}):

-        if CreateModuleMakeFile:

-            for Ma in self._MaList:

-                key = (Ma.MetaFile.File, self.Arch)

-                if key in FfsCommand:

-                    Ma.CreateMakeFile(CreateModuleMakeFile, FfsCommand[key])

-                else:

-                    Ma.CreateMakeFile(CreateModuleMakeFile)

-        self.CreateLibModuelDirs()

-

-    def CreateLibModuelDirs(self):

-        # No need to create makefile for the platform more than once.

-        if self.MakeFileName:

-            return

-

-        # create library/module build dirs for platform

-        Makefile = GenMake.PlatformMakefile(self)

-        self.LibraryBuildDirectoryList = Makefile.GetLibraryBuildDirectoryList()

-        self.ModuleBuildDirectoryList = Makefile.GetModuleBuildDirectoryList()

-        self.MakeFileName = Makefile.getMakefileName()

-

-    @property

-    def AllPcdList(self):

-        return self.DynamicPcdList + self.NonDynamicPcdList

-    ## Deal with Shared FixedAtBuild Pcds

-    #

-    def CollectFixedAtBuildPcds(self):

-        for LibAuto in self.LibraryAutoGenList:

-            FixedAtBuildPcds = {}

-            ShareFixedAtBuildPcdsSameValue = {}

-            for Module in LibAuto.ReferenceModules:

-                for Pcd in set(Module.FixedAtBuildPcds + LibAuto.FixedAtBuildPcds):

-                    DefaultValue = Pcd.DefaultValue

-                    # Cover the case: DSC component override the Pcd value and the Pcd only used in one Lib

-                    if Pcd in Module.LibraryPcdList:

-                        Index = Module.LibraryPcdList.index(Pcd)

-                        DefaultValue = Module.LibraryPcdList[Index].DefaultValue

-                    key = ".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName))

-                    if key not in FixedAtBuildPcds:

-                        ShareFixedAtBuildPcdsSameValue[key] = True

-                        FixedAtBuildPcds[key] = DefaultValue

-                    else:

-                        if FixedAtBuildPcds[key] != DefaultValue:

-                            ShareFixedAtBuildPcdsSameValue[key] = False

-            for Pcd in LibAuto.FixedAtBuildPcds:

-                key = ".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName))

-                if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in self.NonDynamicPcdDict:

-                    continue

-                else:

-                    DscPcd = self.NonDynamicPcdDict[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)]

-                    if DscPcd.Type != TAB_PCDS_FIXED_AT_BUILD:

-                        continue

-                if key in ShareFixedAtBuildPcdsSameValue and ShareFixedAtBuildPcdsSameValue[key]:

-                    LibAuto.ConstPcd[key] = FixedAtBuildPcds[key]

-

-    def CollectVariables(self, DynamicPcdSet):

-        VpdRegionSize = 0

-        VpdRegionBase = 0

-        if self.Workspace.FdfFile:

-            FdDict = self.Workspace.FdfProfile.FdDict[GlobalData.gFdfParser.CurrentFdName]

-            for FdRegion in FdDict.RegionList:

-                for item in FdRegion.RegionDataList:

-                    if self.Platform.VpdToolGuid.strip() and self.Platform.VpdToolGuid in item:

-                        VpdRegionSize = FdRegion.Size

-                        VpdRegionBase = FdRegion.Offset

-                        break

-

-        VariableInfo = VariableMgr(self.DscBuildDataObj._GetDefaultStores(), self.DscBuildDataObj.SkuIds)

-        VariableInfo.SetVpdRegionMaxSize(VpdRegionSize)

-        VariableInfo.SetVpdRegionOffset(VpdRegionBase)

-        Index = 0

-        for Pcd in sorted(DynamicPcdSet):

-            pcdname = ".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName))

-            for SkuName in Pcd.SkuInfoList:

-                Sku = Pcd.SkuInfoList[SkuName]

-                SkuId = Sku.SkuId

-                if SkuId is None or SkuId == '':

-                    continue

-                if len(Sku.VariableName) > 0:

-                    if Sku.VariableAttribute and 'NV' not in Sku.VariableAttribute:

-                        continue

-                    VariableGuidStructure = Sku.VariableGuidValue

-                    VariableGuid = GuidStructureStringToGuidString(VariableGuidStructure)

-                    for StorageName in Sku.DefaultStoreDict:

-                        VariableInfo.append_variable(var_info(Index, pcdname, StorageName, SkuName, StringToArray(Sku.VariableName), VariableGuid, Sku.VariableOffset, Sku.VariableAttribute, Sku.HiiDefaultValue, Sku.DefaultStoreDict[StorageName] if Pcd.DatumType in TAB_PCD_NUMERIC_TYPES else StringToArray(Sku.DefaultStoreDict[StorageName]), Pcd.DatumType, Pcd.CustomAttribute['DscPosition'], Pcd.CustomAttribute.get('IsStru',False)))

-            Index += 1

-        return VariableInfo

-

-    def UpdateNVStoreMaxSize(self, OrgVpdFile):

-        if self.VariableInfo:

-            VpdMapFilePath = os.path.join(self.BuildDir, TAB_FV_DIRECTORY, "%s.map" % self.Platform.VpdToolGuid)

-            PcdNvStoreDfBuffer = [item for item in self._DynamicPcdList if item.TokenCName == "PcdNvStoreDefaultValueBuffer" and item.TokenSpaceGuidCName == "gEfiMdeModulePkgTokenSpaceGuid"]

-

-            if PcdNvStoreDfBuffer:

-                try:

-                    OrgVpdFile.Read(VpdMapFilePath)

-                    PcdItems = OrgVpdFile.GetOffset(PcdNvStoreDfBuffer[0])

-                    NvStoreOffset = list(PcdItems.values())[0].strip() if PcdItems else '0'

-                except:

-                    EdkLogger.error("build", FILE_READ_FAILURE, "Can not find VPD map file %s to fix up VPD offset." % VpdMapFilePath)

-

-                NvStoreOffset = int(NvStoreOffset, 16) if NvStoreOffset.upper().startswith("0X") else int(NvStoreOffset)

-                default_skuobj = PcdNvStoreDfBuffer[0].SkuInfoList.get(TAB_DEFAULT)

-                maxsize = self.VariableInfo.VpdRegionSize  - NvStoreOffset if self.VariableInfo.VpdRegionSize else len(default_skuobj.DefaultValue.split(","))

-                var_data = self.VariableInfo.PatchNVStoreDefaultMaxSize(maxsize)

-

-                if var_data and default_skuobj:

-                    default_skuobj.DefaultValue = var_data

-                    PcdNvStoreDfBuffer[0].DefaultValue = var_data

-                    PcdNvStoreDfBuffer[0].SkuInfoList.clear()

-                    PcdNvStoreDfBuffer[0].SkuInfoList[TAB_DEFAULT] = default_skuobj

-                    PcdNvStoreDfBuffer[0].MaxDatumSize = str(len(default_skuobj.DefaultValue.split(",")))

-

-        return OrgVpdFile

-

-    ## Collect dynamic PCDs

-    #

-    #  Gather dynamic PCDs list from each module and their settings from platform

-    #  This interface should be invoked explicitly when platform action is created.

-    #

-    def CollectPlatformDynamicPcds(self):

-        self.CategoryPcds()

-        self.SortDynamicPcd()

-

-    def CategoryPcds(self):

-        # Category Pcds into DynamicPcds and NonDynamicPcds

-        # for gathering error information

-        NoDatumTypePcdList = set()

-        FdfModuleList = []

-        for InfName in self._AsBuildInfList:

-            InfName = mws.join(self.WorkspaceDir, InfName)

-            FdfModuleList.append(os.path.normpath(InfName))

-        for M in self._MbList:

-#            F is the Module for which M is the module autogen

-            ModPcdList = self.ApplyPcdSetting(M, M.ModulePcdList)

-            LibPcdList = []

-            for lib in M.LibraryPcdList:

-                LibPcdList.extend(self.ApplyPcdSetting(M, M.LibraryPcdList[lib], lib))

-            for PcdFromModule in ModPcdList + LibPcdList:

-

-                # make sure that the "VOID*" kind of datum has MaxDatumSize set

-                if PcdFromModule.DatumType == TAB_VOID and not PcdFromModule.MaxDatumSize:

-                    NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, M.MetaFile))

-

-                # Check the PCD from Binary INF or Source INF

-                if M.IsBinaryModule == True:

-                    PcdFromModule.IsFromBinaryInf = True

-

-                # Check the PCD from DSC or not

-                PcdFromModule.IsFromDsc = (PcdFromModule.TokenCName, PcdFromModule.TokenSpaceGuidCName) in self.Platform.Pcds

-

-                if PcdFromModule.Type in PCD_DYNAMIC_TYPE_SET or PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET:

-                    if M.MetaFile.Path not in FdfModuleList:

-                        # If one of the Source built modules listed in the DSC is not listed

-                        # in FDF modules, and the INF lists a PCD can only use the PcdsDynamic

-                        # access method (it is only listed in the DEC file that declares the

-                        # PCD as PcdsDynamic), then build tool will report warning message

-                        # notify the PI that they are attempting to build a module that must

-                        # be included in a flash image in order to be functional. These Dynamic

-                        # PCD will not be added into the Database unless it is used by other

-                        # modules that are included in the FDF file.

-                        if PcdFromModule.Type in PCD_DYNAMIC_TYPE_SET and \

-                            PcdFromModule.IsFromBinaryInf == False:

-                            # Print warning message to let the developer make a determine.

-                            continue

-                        # If one of the Source built modules listed in the DSC is not listed in

-                        # FDF modules, and the INF lists a PCD can only use the PcdsDynamicEx

-                        # access method (it is only listed in the DEC file that declares the

-                        # PCD as PcdsDynamicEx), then DO NOT break the build; DO NOT add the

-                        # PCD to the Platform's PCD Database.

-                        if PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET:

-                            continue

-                    #

-                    # If a dynamic PCD used by a PEM module/PEI module & DXE module,

-                    # it should be stored in Pcd PEI database, If a dynamic only

-                    # used by DXE module, it should be stored in DXE PCD database.

-                    # The default Phase is DXE

-                    #

-                    if M.ModuleType in SUP_MODULE_SET_PEI:

-                        PcdFromModule.Phase = "PEI"

-                    if PcdFromModule not in self._DynaPcdList_:

-                        self._DynaPcdList_.append(PcdFromModule)

-                    elif PcdFromModule.Phase == 'PEI':

-                        # overwrite any the same PCD existing, if Phase is PEI

-                        Index = self._DynaPcdList_.index(PcdFromModule)

-                        self._DynaPcdList_[Index] = PcdFromModule

-                elif PcdFromModule not in self._NonDynaPcdList_:

-                    self._NonDynaPcdList_.append(PcdFromModule)

-                elif PcdFromModule in self._NonDynaPcdList_ and PcdFromModule.IsFromBinaryInf == True:

-                    Index = self._NonDynaPcdList_.index(PcdFromModule)

-                    if self._NonDynaPcdList_[Index].IsFromBinaryInf == False:

-                        #The PCD from Binary INF will override the same one from source INF

-                        self._NonDynaPcdList_.remove (self._NonDynaPcdList_[Index])

-                        PcdFromModule.Pending = False

-                        self._NonDynaPcdList_.append (PcdFromModule)

-        DscModuleSet = {os.path.normpath(ModuleInf.Path) for ModuleInf in self.Platform.Modules}

-        # add the PCD from modules that listed in FDF but not in DSC to Database

-        for InfName in FdfModuleList:

-            if InfName not in DscModuleSet:

-                InfClass = PathClass(InfName)

-                M = self.BuildDatabase[InfClass, self.Arch, self.BuildTarget, self.ToolChain]

-                # If a module INF in FDF but not in current arch's DSC module list, it must be module (either binary or source)

-                # for different Arch. PCDs in source module for different Arch is already added before, so skip the source module here.

-                # For binary module, if in current arch, we need to list the PCDs into database.

-                if not M.IsBinaryModule:

-                    continue

-                # Override the module PCD setting by platform setting

-                ModulePcdList = self.ApplyPcdSetting(M, M.Pcds)

-                for PcdFromModule in ModulePcdList:

-                    PcdFromModule.IsFromBinaryInf = True

-                    PcdFromModule.IsFromDsc = False

-                    # Only allow the DynamicEx and Patchable PCD in AsBuild INF

-                    if PcdFromModule.Type not in PCD_DYNAMIC_EX_TYPE_SET and PcdFromModule.Type not in TAB_PCDS_PATCHABLE_IN_MODULE:

-                        EdkLogger.error("build", AUTOGEN_ERROR, "PCD setting error",

-                                        File=self.MetaFile,

-                                        ExtraData="\n\tExisted %s PCD %s in:\n\t\t%s\n"

-                                        % (PcdFromModule.Type, PcdFromModule.TokenCName, InfName))

-                    # make sure that the "VOID*" kind of datum has MaxDatumSize set

-                    if PcdFromModule.DatumType == TAB_VOID and not PcdFromModule.MaxDatumSize:

-                        NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, InfName))

-                    if M.ModuleType in SUP_MODULE_SET_PEI:

-                        PcdFromModule.Phase = "PEI"

-                    if PcdFromModule not in self._DynaPcdList_ and PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET:

-                        self._DynaPcdList_.append(PcdFromModule)

-                    elif PcdFromModule not in self._NonDynaPcdList_ and PcdFromModule.Type in TAB_PCDS_PATCHABLE_IN_MODULE:

-                        self._NonDynaPcdList_.append(PcdFromModule)

-                    if PcdFromModule in self._DynaPcdList_ and PcdFromModule.Phase == 'PEI' and PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET:

-                        # Overwrite the phase of any the same PCD existing, if Phase is PEI.

-                        # It is to solve the case that a dynamic PCD used by a PEM module/PEI

-                        # module & DXE module at a same time.

-                        # Overwrite the type of the PCDs in source INF by the type of AsBuild

-                        # INF file as DynamicEx.

-                        Index = self._DynaPcdList_.index(PcdFromModule)

-                        self._DynaPcdList_[Index].Phase = PcdFromModule.Phase

-                        self._DynaPcdList_[Index].Type = PcdFromModule.Type

-        for PcdFromModule in self._NonDynaPcdList_:

-            # If a PCD is not listed in the DSC file, but binary INF files used by

-            # this platform all (that use this PCD) list the PCD in a [PatchPcds]

-            # section, AND all source INF files used by this platform the build

-            # that use the PCD list the PCD in either a [Pcds] or [PatchPcds]

-            # section, then the tools must NOT add the PCD to the Platform's PCD

-            # Database; the build must assign the access method for this PCD as

-            # PcdsPatchableInModule.

-            if PcdFromModule not in self._DynaPcdList_:

-                continue

-            Index = self._DynaPcdList_.index(PcdFromModule)

-            if PcdFromModule.IsFromDsc == False and \

-                PcdFromModule.Type in TAB_PCDS_PATCHABLE_IN_MODULE and \

-                PcdFromModule.IsFromBinaryInf == True and \

-                self._DynaPcdList_[Index].IsFromBinaryInf == False:

-                Index = self._DynaPcdList_.index(PcdFromModule)

-                self._DynaPcdList_.remove (self._DynaPcdList_[Index])

-

-        # print out error information and break the build, if error found

-        if len(NoDatumTypePcdList) > 0:

-            NoDatumTypePcdListString = "\n\t\t".join(NoDatumTypePcdList)

-            EdkLogger.error("build", AUTOGEN_ERROR, "PCD setting error",

-                            File=self.MetaFile,

-                            ExtraData="\n\tPCD(s) without MaxDatumSize:\n\t\t%s\n"

-                                      % NoDatumTypePcdListString)

-        self._NonDynamicPcdList = sorted(self._NonDynaPcdList_)

-        self._DynamicPcdList = self._DynaPcdList_

-

-    def SortDynamicPcd(self):

-        #

-        # Sort dynamic PCD list to:

-        # 1) If PCD's datum type is VOID* and value is unicode string which starts with L, the PCD item should

-        #    try to be put header of dynamicd List

-        # 2) If PCD is HII type, the PCD item should be put after unicode type PCD

-        #

-        # The reason of sorting is make sure the unicode string is in double-byte alignment in string table.

-        #

-        UnicodePcdArray = set()

-        HiiPcdArray     = set()

-        OtherPcdArray   = set()

-        VpdPcdDict      = {}

-        VpdFile               = VpdInfoFile.VpdInfoFile()

-        NeedProcessVpdMapFile = False

-

-        for pcd in self.Platform.Pcds:

-            if pcd not in self._PlatformPcds:

-                self._PlatformPcds[pcd] = self.Platform.Pcds[pcd]

-

-        for item in self._PlatformPcds:

-            if self._PlatformPcds[item].DatumType and self._PlatformPcds[item].DatumType not in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]:

-                self._PlatformPcds[item].DatumType = TAB_VOID

-

-        if (self.Workspace.ArchList[-1] == self.Arch):

-            for Pcd in self._DynamicPcdList:

-                # just pick the a value to determine whether is unicode string type

-                Sku = Pcd.SkuInfoList.get(TAB_DEFAULT)

-                Sku.VpdOffset = Sku.VpdOffset.strip()

-

-                if Pcd.DatumType not in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]:

-                    Pcd.DatumType = TAB_VOID

-

-                    # if found PCD which datum value is unicode string the insert to left size of UnicodeIndex

-                    # if found HII type PCD then insert to right of UnicodeIndex

-                if Pcd.Type in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD]:

-                    VpdPcdDict[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)] = Pcd

-

-            #Collect DynamicHii PCD values and assign it to DynamicExVpd PCD gEfiMdeModulePkgTokenSpaceGuid.PcdNvStoreDefaultValueBuffer

-            PcdNvStoreDfBuffer = VpdPcdDict.get(("PcdNvStoreDefaultValueBuffer", "gEfiMdeModulePkgTokenSpaceGuid"))

-            if PcdNvStoreDfBuffer:

-                self.VariableInfo = self.CollectVariables(self._DynamicPcdList)

-                vardump = self.VariableInfo.dump()

-                if vardump:

-                    #

-                    #According to PCD_DATABASE_INIT in edk2\MdeModulePkg\Include\Guid\PcdDataBaseSignatureGuid.h,

-                    #the max size for string PCD should not exceed USHRT_MAX 65535(0xffff).

-                    #typedef UINT16 SIZE_INFO;

-                    #//SIZE_INFO  SizeTable[];

-                    if len(vardump.split(",")) > 0xffff:

-                        EdkLogger.error("build", RESOURCE_OVERFLOW, 'The current length of PCD %s value is %d, it exceeds to the max size of String PCD.' %(".".join([PcdNvStoreDfBuffer.TokenSpaceGuidCName,PcdNvStoreDfBuffer.TokenCName]) ,len(vardump.split(","))))

-                    PcdNvStoreDfBuffer.DefaultValue = vardump

-                    for skuname in PcdNvStoreDfBuffer.SkuInfoList:

-                        PcdNvStoreDfBuffer.SkuInfoList[skuname].DefaultValue = vardump

-                        PcdNvStoreDfBuffer.MaxDatumSize = str(len(vardump.split(",")))

-            else:

-                #If the end user define [DefaultStores] and [XXX.Menufacturing] in DSC, but forget to configure PcdNvStoreDefaultValueBuffer to PcdsDynamicVpd

-                if [Pcd for Pcd in self._DynamicPcdList if Pcd.UserDefinedDefaultStoresFlag]:

-                    EdkLogger.warn("build", "PcdNvStoreDefaultValueBuffer should be defined as PcdsDynamicExVpd in dsc file since the DefaultStores is enabled for this platform.\n%s" %self.Platform.MetaFile.Path)

-            PlatformPcds = sorted(self._PlatformPcds.keys())

-            #

-            # Add VPD type PCD into VpdFile and determine whether the VPD PCD need to be fixed up.

-            #

-            VpdSkuMap = {}

-            for PcdKey in PlatformPcds:

-                Pcd = self._PlatformPcds[PcdKey]

-                if Pcd.Type in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD] and \

-                   PcdKey in VpdPcdDict:

-                    Pcd = VpdPcdDict[PcdKey]

-                    SkuValueMap = {}

-                    DefaultSku = Pcd.SkuInfoList.get(TAB_DEFAULT)

-                    if DefaultSku:

-                        PcdValue = DefaultSku.DefaultValue

-                        if PcdValue not in SkuValueMap:

-                            SkuValueMap[PcdValue] = []

-                            VpdFile.Add(Pcd, TAB_DEFAULT, DefaultSku.VpdOffset)

-                        SkuValueMap[PcdValue].append(DefaultSku)

-

-                    for (SkuName, Sku) in Pcd.SkuInfoList.items():

-                        Sku.VpdOffset = Sku.VpdOffset.strip()

-                        PcdValue = Sku.DefaultValue

-                        if PcdValue == "":

-                            PcdValue  = Pcd.DefaultValue

-                        if Sku.VpdOffset != TAB_STAR:

-                            if PcdValue.startswith("{"):

-                                Alignment = 8

-                            elif PcdValue.startswith("L"):

-                                Alignment = 2

-                            else:

-                                Alignment = 1

-                            try:

-                                VpdOffset = int(Sku.VpdOffset)

-                            except:

-                                try:

-                                    VpdOffset = int(Sku.VpdOffset, 16)

-                                except:

-                                    EdkLogger.error("build", FORMAT_INVALID, "Invalid offset value %s for PCD %s.%s." % (Sku.VpdOffset, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))

-                            if VpdOffset % Alignment != 0:

-                                if PcdValue.startswith("{"):

-                                    EdkLogger.warn("build", "The offset value of PCD %s.%s is not 8-byte aligned!" %(Pcd.TokenSpaceGuidCName, Pcd.TokenCName), File=self.MetaFile)

-                                else:

-                                    EdkLogger.error("build", FORMAT_INVALID, 'The offset value of PCD %s.%s should be %s-byte aligned.' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, Alignment))

-                        if PcdValue not in SkuValueMap:

-                            SkuValueMap[PcdValue] = []

-                            VpdFile.Add(Pcd, SkuName, Sku.VpdOffset)

-                        SkuValueMap[PcdValue].append(Sku)

-                        # if the offset of a VPD is *, then it need to be fixed up by third party tool.

-                        if not NeedProcessVpdMapFile and Sku.VpdOffset == TAB_STAR:

-                            NeedProcessVpdMapFile = True

-                            if self.Platform.VpdToolGuid is None or self.Platform.VpdToolGuid == '':

-                                EdkLogger.error("Build", FILE_NOT_FOUND, \

-                                                "Fail to find third-party BPDG tool to process VPD PCDs. BPDG Guid tool need to be defined in tools_def.txt and VPD_TOOL_GUID need to be provided in DSC file.")

-

-                    VpdSkuMap[PcdKey] = SkuValueMap

-            #

-            # Fix the PCDs define in VPD PCD section that never referenced by module.

-            # An example is PCD for signature usage.

-            #

-            for DscPcd in PlatformPcds:

-                DscPcdEntry = self._PlatformPcds[DscPcd]

-                if DscPcdEntry.Type in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD]:

-                    if not (self.Platform.VpdToolGuid is None or self.Platform.VpdToolGuid == ''):

-                        FoundFlag = False

-                        for VpdPcd in VpdFile._VpdArray:

-                            # This PCD has been referenced by module

-                            if (VpdPcd.TokenSpaceGuidCName == DscPcdEntry.TokenSpaceGuidCName) and \

-                               (VpdPcd.TokenCName == DscPcdEntry.TokenCName):

-                                    FoundFlag = True

-

-                        # Not found, it should be signature

-                        if not FoundFlag :

-                            # just pick the a value to determine whether is unicode string type

-                            SkuValueMap = {}

-                            SkuObjList = list(DscPcdEntry.SkuInfoList.items())

-                            DefaultSku = DscPcdEntry.SkuInfoList.get(TAB_DEFAULT)

-                            if DefaultSku:

-                                defaultindex = SkuObjList.index((TAB_DEFAULT, DefaultSku))

-                                SkuObjList[0], SkuObjList[defaultindex] = SkuObjList[defaultindex], SkuObjList[0]

-                            for (SkuName, Sku) in SkuObjList:

-                                Sku.VpdOffset = Sku.VpdOffset.strip()

-

-                                # Need to iterate DEC pcd information to get the value & datumtype

-                                for eachDec in self.PackageList:

-                                    for DecPcd in eachDec.Pcds:

-                                        DecPcdEntry = eachDec.Pcds[DecPcd]

-                                        if (DecPcdEntry.TokenSpaceGuidCName == DscPcdEntry.TokenSpaceGuidCName) and \

-                                           (DecPcdEntry.TokenCName == DscPcdEntry.TokenCName):

-                                            # Print warning message to let the developer make a determine.

-                                            EdkLogger.warn("build", "Unreferenced vpd pcd used!",

-                                                            File=self.MetaFile, \

-                                                            ExtraData = "PCD: %s.%s used in the DSC file %s is unreferenced." \

-                                                            %(DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName, self.Platform.MetaFile.Path))

-

-                                            DscPcdEntry.DatumType    = DecPcdEntry.DatumType

-                                            DscPcdEntry.DefaultValue = DecPcdEntry.DefaultValue

-                                            DscPcdEntry.TokenValue = DecPcdEntry.TokenValue

-                                            DscPcdEntry.TokenSpaceGuidValue = eachDec.Guids[DecPcdEntry.TokenSpaceGuidCName]

-                                            # Only fix the value while no value provided in DSC file.

-                                            if not Sku.DefaultValue:

-                                                DscPcdEntry.SkuInfoList[list(DscPcdEntry.SkuInfoList.keys())[0]].DefaultValue = DecPcdEntry.DefaultValue

-

-                                if DscPcdEntry not in self._DynamicPcdList:

-                                    self._DynamicPcdList.append(DscPcdEntry)

-                                Sku.VpdOffset = Sku.VpdOffset.strip()

-                                PcdValue = Sku.DefaultValue

-                                if PcdValue == "":

-                                    PcdValue  = DscPcdEntry.DefaultValue

-                                if Sku.VpdOffset != TAB_STAR:

-                                    if PcdValue.startswith("{"):

-                                        Alignment = 8

-                                    elif PcdValue.startswith("L"):

-                                        Alignment = 2

-                                    else:

-                                        Alignment = 1

-                                    try:

-                                        VpdOffset = int(Sku.VpdOffset)

-                                    except:

-                                        try:

-                                            VpdOffset = int(Sku.VpdOffset, 16)

-                                        except:

-                                            EdkLogger.error("build", FORMAT_INVALID, "Invalid offset value %s for PCD %s.%s." % (Sku.VpdOffset, DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName))

-                                    if VpdOffset % Alignment != 0:

-                                        if PcdValue.startswith("{"):

-                                            EdkLogger.warn("build", "The offset value of PCD %s.%s is not 8-byte aligned!" %(DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName), File=self.MetaFile)

-                                        else:

-                                            EdkLogger.error("build", FORMAT_INVALID, 'The offset value of PCD %s.%s should be %s-byte aligned.' % (DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName, Alignment))

-                                if PcdValue not in SkuValueMap:

-                                    SkuValueMap[PcdValue] = []

-                                    VpdFile.Add(DscPcdEntry, SkuName, Sku.VpdOffset)

-                                SkuValueMap[PcdValue].append(Sku)

-                                if not NeedProcessVpdMapFile and Sku.VpdOffset == TAB_STAR:

-                                    NeedProcessVpdMapFile = True

-                            if DscPcdEntry.DatumType == TAB_VOID and PcdValue.startswith("L"):

-                                UnicodePcdArray.add(DscPcdEntry)

-                            elif len(Sku.VariableName) > 0:

-                                HiiPcdArray.add(DscPcdEntry)

-                            else:

-                                OtherPcdArray.add(DscPcdEntry)

-

-                                # if the offset of a VPD is *, then it need to be fixed up by third party tool.

-                            VpdSkuMap[DscPcd] = SkuValueMap

-            if (self.Platform.FlashDefinition is None or self.Platform.FlashDefinition == '') and \

-               VpdFile.GetCount() != 0:

-                EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE,

-                                "Fail to get FLASH_DEFINITION definition in DSC file %s which is required when DSC contains VPD PCD." % str(self.Platform.MetaFile))

-

-            if VpdFile.GetCount() != 0:

-

-                self.FixVpdOffset(VpdFile)

-

-                self.FixVpdOffset(self.UpdateNVStoreMaxSize(VpdFile))

-                PcdNvStoreDfBuffer = [item for item in self._DynamicPcdList if item.TokenCName == "PcdNvStoreDefaultValueBuffer" and item.TokenSpaceGuidCName == "gEfiMdeModulePkgTokenSpaceGuid"]

-                if PcdNvStoreDfBuffer:

-                    PcdName,PcdGuid = PcdNvStoreDfBuffer[0].TokenCName, PcdNvStoreDfBuffer[0].TokenSpaceGuidCName

-                    if (PcdName,PcdGuid) in VpdSkuMap:

-                        DefaultSku = PcdNvStoreDfBuffer[0].SkuInfoList.get(TAB_DEFAULT)

-                        VpdSkuMap[(PcdName,PcdGuid)] = {DefaultSku.DefaultValue:[SkuObj for SkuObj in PcdNvStoreDfBuffer[0].SkuInfoList.values() ]}

-

-                # Process VPD map file generated by third party BPDG tool

-                if NeedProcessVpdMapFile:

-                    VpdMapFilePath = os.path.join(self.BuildDir, TAB_FV_DIRECTORY, "%s.map" % self.Platform.VpdToolGuid)

-                    try:

-                        VpdFile.Read(VpdMapFilePath)

-

-                        # Fixup TAB_STAR offset

-                        for pcd in VpdSkuMap:

-                            vpdinfo = VpdFile.GetVpdInfo(pcd)

-                            if vpdinfo is None:

-                            # just pick the a value to determine whether is unicode string type

-                                continue

-                            for pcdvalue in VpdSkuMap[pcd]:

-                                for sku in VpdSkuMap[pcd][pcdvalue]:

-                                    for item in vpdinfo:

-                                        if item[2] == pcdvalue:

-                                            sku.VpdOffset = item[1]

-                    except:

-                        EdkLogger.error("build", FILE_READ_FAILURE, "Can not find VPD map file %s to fix up VPD offset." % VpdMapFilePath)

-

-            # Delete the DynamicPcdList At the last time enter into this function

-            for Pcd in self._DynamicPcdList:

-                # just pick the a value to determine whether is unicode string type

-                Sku = Pcd.SkuInfoList.get(TAB_DEFAULT)

-                Sku.VpdOffset = Sku.VpdOffset.strip()

-

-                if Pcd.DatumType not in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]:

-                    Pcd.DatumType = TAB_VOID

-

-                PcdValue = Sku.DefaultValue

-                if Pcd.DatumType == TAB_VOID and PcdValue.startswith("L"):

-                    # if found PCD which datum value is unicode string the insert to left size of UnicodeIndex

-                    UnicodePcdArray.add(Pcd)

-                elif len(Sku.VariableName) > 0:

-                    # if found HII type PCD then insert to right of UnicodeIndex

-                    HiiPcdArray.add(Pcd)

-                else:

-                    OtherPcdArray.add(Pcd)

-            del self._DynamicPcdList[:]

-        self._DynamicPcdList.extend(list(UnicodePcdArray))

-        self._DynamicPcdList.extend(list(HiiPcdArray))

-        self._DynamicPcdList.extend(list(OtherPcdArray))

-        self._DynamicPcdList.sort()

-        allskuset = [(SkuName, Sku.SkuId) for pcd in self._DynamicPcdList for (SkuName, Sku) in pcd.SkuInfoList.items()]

-        # Remove duplicate sets in the list

-        allskuset = list(set(allskuset))

-        for pcd in self._DynamicPcdList:

-            if len(pcd.SkuInfoList) == 1:

-                for (SkuName, SkuId) in allskuset:

-                    if isinstance(SkuId, str) and eval(SkuId) == 0 or SkuId == 0:

-                        continue

-                    pcd.SkuInfoList[SkuName] = copy.deepcopy(pcd.SkuInfoList[TAB_DEFAULT])

-                    pcd.SkuInfoList[SkuName].SkuId = SkuId

-                    pcd.SkuInfoList[SkuName].SkuIdName = SkuName

-

-    def FixVpdOffset(self, VpdFile ):

-        FvPath = os.path.join(self.BuildDir, TAB_FV_DIRECTORY)

-        if not os.path.exists(FvPath):

-            try:

-                os.makedirs(FvPath)

-            except:

-                EdkLogger.error("build", FILE_WRITE_FAILURE, "Fail to create FV folder under %s" % self.BuildDir)

-

-        VpdFilePath = os.path.join(FvPath, "%s.txt" % self.Platform.VpdToolGuid)

-

-        if VpdFile.Write(VpdFilePath):

-            # retrieve BPDG tool's path from tool_def.txt according to VPD_TOOL_GUID defined in DSC file.

-            BPDGToolName = None

-            for ToolDef in self.ToolDefinition.values():

-                if TAB_GUID in ToolDef and ToolDef[TAB_GUID] == self.Platform.VpdToolGuid:

-                    if "PATH" not in ToolDef:

-                        EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "PATH attribute was not provided for BPDG guid tool %s in tools_def.txt" % self.Platform.VpdToolGuid)

-                    BPDGToolName = ToolDef["PATH"]

-                    break

-            # Call third party GUID BPDG tool.

-            if BPDGToolName is not None:

-                VpdInfoFile.CallExtenalBPDGTool(BPDGToolName, VpdFilePath)

-            else:

-                EdkLogger.error("Build", FILE_NOT_FOUND, "Fail to find third-party BPDG tool to process VPD PCDs. BPDG Guid tool need to be defined in tools_def.txt and VPD_TOOL_GUID need to be provided in DSC file.")

-

-    ## Return the platform build data object

-    @cached_property

-    def Platform(self):

-        return self.BuildDatabase[self.MetaFile, self.Arch, self.BuildTarget, self.ToolChain]

-

-    ## Return platform name

-    @cached_property

-    def Name(self):

-        return self.Platform.PlatformName

-

-    ## Return the meta file GUID

-    @cached_property

-    def Guid(self):

-        return self.Platform.Guid

-

-    ## Return the platform version

-    @cached_property

-    def Version(self):

-        return self.Platform.Version

-

-    ## Return the FDF file name

-    @cached_property

-    def FdfFile(self):

-        if self.Workspace.FdfFile:

-            RetVal= mws.join(self.WorkspaceDir, self.Workspace.FdfFile)

-        else:

-            RetVal = ''

-        return RetVal

-

-    ## Return the build output directory platform specifies

-    @cached_property

-    def OutputDir(self):

-        return self.Platform.OutputDirectory

-

-    ## Return the directory to store all intermediate and final files built

-    @cached_property

-    def BuildDir(self):

-        if os.path.isabs(self.OutputDir):

-            GlobalData.gBuildDirectory = RetVal = path.join(

-                                        path.abspath(self.OutputDir),

-                                        self.BuildTarget + "_" + self.ToolChain,

-                                        )

-        else:

-            GlobalData.gBuildDirectory = RetVal = path.join(

-                                        self.WorkspaceDir,

-                                        self.OutputDir,

-                                        self.BuildTarget + "_" + self.ToolChain,

-                                        )

-        return RetVal

-

-    ## Return directory of platform makefile

-    #

-    #   @retval     string  Makefile directory

-    #

-    @cached_property

-    def MakeFileDir(self):

-        return path.join(self.BuildDir, self.Arch)

-

-    ## Return build command string

-    #

-    #   @retval     string  Build command string

-    #

-    @cached_property

-    def BuildCommand(self):

-        if "MAKE" in self.EdkIIBuildOption and "PATH" in self.EdkIIBuildOption["MAKE"]:

-            # MAKE_PATH in DSC [BuildOptions] section is higher priority

-            Path = self.EdkIIBuildOption["MAKE"]["PATH"]

-            if Path.startswith('='):

-                Path = Path[1:].strip()

-            RetVal = _SplitOption(Path)

-        elif "MAKE" in self.ToolDefinition and "PATH" in self.ToolDefinition["MAKE"]:

-            RetVal = _SplitOption(self.ToolDefinition["MAKE"]["PATH"])

-        else:

-            return []

-        if "MAKE" in self.ToolDefinition and "FLAGS" in self.ToolDefinition["MAKE"]:

-            NewOption = self.ToolDefinition["MAKE"]["FLAGS"].strip()

-            if NewOption != '':

-                RetVal += _SplitOption(NewOption)

-        if "MAKE" in self.EdkIIBuildOption and "FLAGS" in self.EdkIIBuildOption["MAKE"]:

-            Flags = self.EdkIIBuildOption["MAKE"]["FLAGS"]

-            if Flags.startswith('='):

-                RetVal = [RetVal[0]] + _SplitOption(Flags[1:].strip())

-            else:

-                RetVal = RetVal + _SplitOption(Flags.strip())

-        return RetVal

-

-    ## Compute a tool defintion key priority value in range 0..15

-    #

-    #  TARGET_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE  15

-    #  ******_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE  14

-    #  TARGET_*********_ARCH_COMMANDTYPE_ATTRIBUTE  13

-    #  ******_*********_ARCH_COMMANDTYPE_ATTRIBUTE  12

-    #  TARGET_TOOLCHAIN_****_COMMANDTYPE_ATTRIBUTE  11

-    #  ******_TOOLCHAIN_****_COMMANDTYPE_ATTRIBUTE  10

-    #  TARGET_*********_****_COMMANDTYPE_ATTRIBUTE   9

-    #  ******_*********_****_COMMANDTYPE_ATTRIBUTE   8

-    #  TARGET_TOOLCHAIN_ARCH_***********_ATTRIBUTE   7

-    #  ******_TOOLCHAIN_ARCH_***********_ATTRIBUTE   6

-    #  TARGET_*********_ARCH_***********_ATTRIBUTE   5

-    #  ******_*********_ARCH_***********_ATTRIBUTE   4

-    #  TARGET_TOOLCHAIN_****_***********_ATTRIBUTE   3

-    #  ******_TOOLCHAIN_****_***********_ATTRIBUTE   2

-    #  TARGET_*********_****_***********_ATTRIBUTE   1

-    #  ******_*********_****_***********_ATTRIBUTE   0

-    #

-    def ToolDefinitionPriority (self,Key):

-        KeyList = Key.split('_')

-        Priority = 0

-        for Index in range (0, min(4, len(KeyList))):

-            if KeyList[Index] != '*':

-                Priority += (1 << Index)

-        return Priority

-

-    ## Get tool chain definition

-    #

-    #  Get each tool definition for given tool chain from tools_def.txt and platform

-    #

-    @cached_property

-    def ToolDefinition(self):

-        ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDictionary

-        if TAB_TOD_DEFINES_COMMAND_TYPE not in self.Workspace.ToolDef.ToolsDefTxtDatabase:

-            EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "No tools found in configuration",

-                            ExtraData="[%s]" % self.MetaFile)

-        RetVal = OrderedDict()

-        DllPathList = set()

-

-        PrioritizedDefList = sorted(ToolDefinition.keys(), key=self.ToolDefinitionPriority, reverse=True)

-        for Def in PrioritizedDefList:

-            Target, Tag, Arch, Tool, Attr = Def.split("_")

-            if Target == TAB_STAR:

-                Target = self.BuildTarget

-            if Tag == TAB_STAR:

-                Tag = self.ToolChain

-            if Arch == TAB_STAR:

-                Arch = self.Arch

-            if Target != self.BuildTarget or Tag != self.ToolChain or Arch != self.Arch:

-                continue

-

-            Value = ToolDefinition[Def]

-            # don't record the DLL

-            if Attr == "DLL":

-                DllPathList.add(Value)

-                continue

-

-            #

-            # ToolDefinition is sorted from highest priority to lowest priority.

-            # Only add the first(highest priority) match to RetVal

-            #

-            if Tool not in RetVal:

-                RetVal[Tool] = OrderedDict()

-            if Attr not in RetVal[Tool]:

-                RetVal[Tool][Attr] = Value

-

-        ToolsDef = ''

-        if GlobalData.gOptions.SilentMode and "MAKE" in RetVal:

-            if "FLAGS" not in RetVal["MAKE"]:

-                RetVal["MAKE"]["FLAGS"] = ""

-            RetVal["MAKE"]["FLAGS"] += " -s"

-        MakeFlags = ''

-

-        ToolList = list(RetVal.keys())

-        ToolList.sort()

-        for Tool in ToolList:

-            if Tool == TAB_STAR:

-                continue

-            AttrList = list(RetVal[Tool].keys())

-            if TAB_STAR in ToolList:

-                AttrList += list(RetVal[TAB_STAR])

-            AttrList.sort()

-            for Attr in AttrList:

-                if Attr in RetVal[Tool]:

-                    Value = RetVal[Tool][Attr]

-                else:

-                    Value = RetVal[TAB_STAR][Attr]

-                if Tool in self._BuildOptionWithToolDef(RetVal) and Attr in self._BuildOptionWithToolDef(RetVal)[Tool]:

-                    # check if override is indicated

-                    if self._BuildOptionWithToolDef(RetVal)[Tool][Attr].startswith('='):

-                        Value = self._BuildOptionWithToolDef(RetVal)[Tool][Attr][1:].strip()

-                    else:

-                        # Do not append PATH or GUID

-                        if Attr != 'PATH' and Attr != 'GUID':

-                            Value += " " + self._BuildOptionWithToolDef(RetVal)[Tool][Attr]

-                        else:

-                            Value = self._BuildOptionWithToolDef(RetVal)[Tool][Attr]

-                if Attr == "PATH":

-                    # Don't put MAKE definition in the file

-                    if Tool != "MAKE":

-                        ToolsDef += "%s_%s = %s\n" % (Tool, Attr, Value)

-                elif Attr != "DLL":

-                    # Don't put MAKE definition in the file

-                    if Tool == "MAKE":

-                        if Attr == "FLAGS":

-                            MakeFlags = Value

-                    else:

-                        ToolsDef += "%s_%s = %s\n" % (Tool, Attr, Value)

-            ToolsDef += "\n"

-

-        tool_def_file = os.path.join(self.MakeFileDir, "TOOLS_DEF." + self.Arch)

-        SaveFileOnChange(tool_def_file, ToolsDef, False)

-        for DllPath in DllPathList:

-            os.environ["PATH"] = DllPath + os.pathsep + os.environ["PATH"]

-        os.environ["MAKE_FLAGS"] = MakeFlags

-

-        return RetVal

-

-    ## Return the paths of tools

-    @cached_property

-    def ToolDefinitionFile(self):

-        tool_def_file = os.path.join(self.MakeFileDir, "TOOLS_DEF." + self.Arch)

-        if not os.path.exists(tool_def_file):

-            self.ToolDefinition

-        return tool_def_file

-

-    ## Retrieve the toolchain family of given toolchain tag. Default to 'MSFT'.

-    @cached_property

-    def ToolChainFamily(self):

-        ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDatabase

-        if TAB_TOD_DEFINES_FAMILY not in ToolDefinition \

-           or self.ToolChain not in ToolDefinition[TAB_TOD_DEFINES_FAMILY] \

-           or not ToolDefinition[TAB_TOD_DEFINES_FAMILY][self.ToolChain]:

-            EdkLogger.verbose("No tool chain family found in configuration for %s. Default to MSFT." \

-                               % self.ToolChain)

-            RetVal = TAB_COMPILER_MSFT

-        else:

-            RetVal = ToolDefinition[TAB_TOD_DEFINES_FAMILY][self.ToolChain]

-        return RetVal

-

-    @cached_property

-    def BuildRuleFamily(self):

-        ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDatabase

-        if TAB_TOD_DEFINES_BUILDRULEFAMILY not in ToolDefinition \

-           or self.ToolChain not in ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY] \

-           or not ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY][self.ToolChain]:

-            EdkLogger.verbose("No tool chain family found in configuration for %s. Default to MSFT." \

-                               % self.ToolChain)

-            return TAB_COMPILER_MSFT

-

-        return ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY][self.ToolChain]

-

-    ## Return the build options specific for all modules in this platform

-    @cached_property

-    def BuildOption(self):

-        return self._ExpandBuildOption(self.Platform.BuildOptions)

-

-    def _BuildOptionWithToolDef(self, ToolDef):

-        return self._ExpandBuildOption(self.Platform.BuildOptions, ToolDef=ToolDef)

-

-    ## Return the build options specific for EDK modules in this platform

-    @cached_property

-    def EdkBuildOption(self):

-        return self._ExpandBuildOption(self.Platform.BuildOptions, EDK_NAME)

-

-    ## Return the build options specific for EDKII modules in this platform

-    @cached_property

-    def EdkIIBuildOption(self):

-        return self._ExpandBuildOption(self.Platform.BuildOptions, EDKII_NAME)

-

-    ## Parse build_rule.txt in Conf Directory.

-    #

-    #   @retval     BuildRule object

-    #

-    @cached_property

-    def BuildRule(self):

-        BuildRuleFile = None

-        if TAB_TAT_DEFINES_BUILD_RULE_CONF in self.Workspace.TargetTxt.TargetTxtDictionary:

-            BuildRuleFile = self.Workspace.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_BUILD_RULE_CONF]

-        if not BuildRuleFile:

-            BuildRuleFile = gDefaultBuildRuleFile

-        RetVal = BuildRule(BuildRuleFile)

-        if RetVal._FileVersion == "":

-            RetVal._FileVersion = AutoGenReqBuildRuleVerNum

-        else:

-            if RetVal._FileVersion < AutoGenReqBuildRuleVerNum :

-                # If Build Rule's version is less than the version number required by the tools, halting the build.

-                EdkLogger.error("build", AUTOGEN_ERROR,

-                                ExtraData="The version number [%s] of build_rule.txt is less than the version number required by the AutoGen.(the minimum required version number is [%s])"\

-                                 % (RetVal._FileVersion, AutoGenReqBuildRuleVerNum))

-        return RetVal

-

-    ## Summarize the packages used by modules in this platform

-    @cached_property

-    def PackageList(self):

-        RetVal = set()

-        for Mb in self._MbList:

-            RetVal.update(Mb.Packages)

-            for lb in Mb.LibInstances:

-                RetVal.update(lb.Packages)

-        #Collect package set information from INF of FDF

-        for ModuleFile in self._AsBuildModuleList:

-            if ModuleFile in self.Platform.Modules:

-                continue

-            ModuleData = self.BuildDatabase[ModuleFile, self.Arch, self.BuildTarget, self.ToolChain]

-            RetVal.update(ModuleData.Packages)

-        RetVal.update(self.Platform.Packages)

-        return list(RetVal)

-

-    @cached_property

-    def NonDynamicPcdDict(self):

-        return {(Pcd.TokenCName, Pcd.TokenSpaceGuidCName):Pcd for Pcd in self.NonDynamicPcdList}

-

-    ## Get list of non-dynamic PCDs

-    @property

-    def NonDynamicPcdList(self):

-        if not self._NonDynamicPcdList:

-            self.CollectPlatformDynamicPcds()

-        return self._NonDynamicPcdList

-

-    ## Get list of dynamic PCDs

-    @property

-    def DynamicPcdList(self):

-        if not self._DynamicPcdList:

-            self.CollectPlatformDynamicPcds()

-        return self._DynamicPcdList

-

-    ## Generate Token Number for all PCD

-    @cached_property

-    def PcdTokenNumber(self):

-        RetVal = OrderedDict()

-        TokenNumber = 1

-        #

-        # Make the Dynamic and DynamicEx PCD use within different TokenNumber area.

-        # Such as:

-        #

-        # Dynamic PCD:

-        # TokenNumber 0 ~ 10

-        # DynamicEx PCD:

-        # TokeNumber 11 ~ 20

-        #

-        for Pcd in self.DynamicPcdList:

-            if Pcd.Phase == "PEI" and Pcd.Type in PCD_DYNAMIC_TYPE_SET:

-                EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))

-                RetVal[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber

-                TokenNumber += 1

-

-        for Pcd in self.DynamicPcdList:

-            if Pcd.Phase == "PEI" and Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:

-                EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))

-                RetVal[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber

-                TokenNumber += 1

-

-        for Pcd in self.DynamicPcdList:

-            if Pcd.Phase == "DXE" and Pcd.Type in PCD_DYNAMIC_TYPE_SET:

-                EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))

-                RetVal[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber

-                TokenNumber += 1

-

-        for Pcd in self.DynamicPcdList:

-            if Pcd.Phase == "DXE" and Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:

-                EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))

-                RetVal[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber

-                TokenNumber += 1

-

-        for Pcd in self.NonDynamicPcdList:

-            RetVal[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = 0

-        return RetVal

-

-    @cached_property

-    def _MbList(self):

-        ModuleList = []

-        for m in self.Platform.Modules:

-            component = self.Platform.Modules[m]

-            module = self.BuildDatabase[m, self.Arch, self.BuildTarget, self.ToolChain]

-            module.Guid = component.Guid

-            ModuleList.append(module)

-        return ModuleList

-

-    @cached_property

-    def _MaList(self):

-        for ModuleFile in self.Platform.Modules:

-            Ma = ModuleAutoGen(

-                  self.Workspace,

-                  ModuleFile,

-                  self.BuildTarget,

-                  self.ToolChain,

-                  self.Arch,

-                  self.MetaFile,

-                  self.DataPipe

-                  )

-            self.Platform.Modules[ModuleFile].M = Ma

-        return [x.M for x in self.Platform.Modules.values()]

-

-    ## Summarize ModuleAutoGen objects of all modules to be built for this platform

-    @cached_property

-    def ModuleAutoGenList(self):

-        RetVal = []

-        for Ma in self._MaList:

-            if Ma not in RetVal:

-                RetVal.append(Ma)

-        return RetVal

-

-    ## Summarize ModuleAutoGen objects of all libraries to be built for this platform

-    @cached_property

-    def LibraryAutoGenList(self):

-        RetVal = []

-        for Ma in self._MaList:

-            for La in Ma.LibraryAutoGenList:

-                if La not in RetVal:

-                    RetVal.append(La)

-                if Ma not in La.ReferenceModules:

-                    La.ReferenceModules.append(Ma)

-        return RetVal

-

-    ## Test if a module is supported by the platform

-    #

-    #  An error will be raised directly if the module or its arch is not supported

-    #  by the platform or current configuration

-    #

-    def ValidModule(self, Module):

-        return Module in self.Platform.Modules or Module in self.Platform.LibraryInstances \

-            or Module in self._AsBuildModuleList

-    @cached_property

-    def GetAllModuleInfo(self,WithoutPcd=True):

-        ModuleLibs = set()

-        for m in self.Platform.Modules:

-            module_obj = self.BuildDatabase[m,self.Arch,self.BuildTarget,self.ToolChain]

-            if not bool(module_obj.LibraryClass):

-                Libs = GetModuleLibInstances(module_obj, self.Platform, self.BuildDatabase, self.Arch,self.BuildTarget,self.ToolChain,self.MetaFile,EdkLogger)

-            else:

-                Libs = []

-            ModuleLibs.update( set([(l.MetaFile.File,l.MetaFile.Root,l.MetaFile.Path,l.MetaFile.BaseName,l.MetaFile.OriginalPath,l.Arch,True) for l in Libs]))

-            if WithoutPcd and module_obj.PcdIsDriver:

-                continue

-            ModuleLibs.add((m.File,m.Root,m.Path,m.BaseName,m.OriginalPath,module_obj.Arch,bool(module_obj.LibraryClass)))

-

-        return ModuleLibs

-

-    ## Resolve the library classes in a module to library instances

-    #

-    # This method will not only resolve library classes but also sort the library

-    # instances according to the dependency-ship.

-    #

-    #   @param  Module      The module from which the library classes will be resolved

-    #

-    #   @retval library_list    List of library instances sorted

-    #

-    def ApplyLibraryInstance(self, Module):

-        # Cover the case that the binary INF file is list in the FDF file but not DSC file, return empty list directly

-        if str(Module) not in self.Platform.Modules:

-            return []

-

-        return GetModuleLibInstances(Module,

-                                     self.Platform,

-                                     self.BuildDatabase,

-                                     self.Arch,

-                                     self.BuildTarget,

-                                     self.ToolChain,

-                                     self.MetaFile,

-                                     EdkLogger)

-

-    ## Override PCD setting (type, value, ...)

-    #

-    #   @param  ToPcd       The PCD to be overridden

-    #   @param  FromPcd     The PCD overriding from

-    #

-    def _OverridePcd(self, ToPcd, FromPcd, Module="", Msg="", Library=""):

-        #

-        # in case there's PCDs coming from FDF file, which have no type given.

-        # at this point, ToPcd.Type has the type found from dependent

-        # package

-        #

-        TokenCName = ToPcd.TokenCName

-        for PcdItem in GlobalData.MixedPcd:

-            if (ToPcd.TokenCName, ToPcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:

-                TokenCName = PcdItem[0]

-                break

-        if FromPcd is not None:

-            if ToPcd.Pending and FromPcd.Type:

-                ToPcd.Type = FromPcd.Type

-            elif ToPcd.Type and FromPcd.Type\

-                and ToPcd.Type != FromPcd.Type and ToPcd.Type in FromPcd.Type:

-                if ToPcd.Type.strip() == TAB_PCDS_DYNAMIC_EX:

-                    ToPcd.Type = FromPcd.Type

-            elif ToPcd.Type and FromPcd.Type \

-                and ToPcd.Type != FromPcd.Type:

-                if Library:

-                    Module = str(Module) + " 's library file (" + str(Library) + ")"

-                EdkLogger.error("build", OPTION_CONFLICT, "Mismatched PCD type",

-                                ExtraData="%s.%s is used as [%s] in module %s, but as [%s] in %s."\

-                                          % (ToPcd.TokenSpaceGuidCName, TokenCName,

-                                             ToPcd.Type, Module, FromPcd.Type, Msg),

-                                          File=self.MetaFile)

-

-            if FromPcd.MaxDatumSize:

-                ToPcd.MaxDatumSize = FromPcd.MaxDatumSize

-                ToPcd.MaxSizeUserSet = FromPcd.MaxDatumSize

-            if FromPcd.DefaultValue:

-                ToPcd.DefaultValue = FromPcd.DefaultValue

-            if FromPcd.TokenValue:

-                ToPcd.TokenValue = FromPcd.TokenValue

-            if FromPcd.DatumType:

-                ToPcd.DatumType = FromPcd.DatumType

-            if FromPcd.SkuInfoList:

-                ToPcd.SkuInfoList = FromPcd.SkuInfoList

-            if FromPcd.UserDefinedDefaultStoresFlag:

-                ToPcd.UserDefinedDefaultStoresFlag = FromPcd.UserDefinedDefaultStoresFlag

-            # Add Flexible PCD format parse

-            if ToPcd.DefaultValue:

-                try:

-                    ToPcd.DefaultValue = ValueExpressionEx(ToPcd.DefaultValue, ToPcd.DatumType, self.Platform._GuidDict)(True)

-                except BadExpression as Value:

-                    EdkLogger.error('Parser', FORMAT_INVALID, 'PCD [%s.%s] Value "%s", %s' %(ToPcd.TokenSpaceGuidCName, ToPcd.TokenCName, ToPcd.DefaultValue, Value),

-                                        File=self.MetaFile)

-

-            # check the validation of datum

-            IsValid, Cause = CheckPcdDatum(ToPcd.DatumType, ToPcd.DefaultValue)

-            if not IsValid:

-                EdkLogger.error('build', FORMAT_INVALID, Cause, File=self.MetaFile,

-                                ExtraData="%s.%s" % (ToPcd.TokenSpaceGuidCName, TokenCName))

-            ToPcd.validateranges = FromPcd.validateranges

-            ToPcd.validlists = FromPcd.validlists

-            ToPcd.expressions = FromPcd.expressions

-            ToPcd.CustomAttribute = FromPcd.CustomAttribute

-

-        if FromPcd is not None and ToPcd.DatumType == TAB_VOID and not ToPcd.MaxDatumSize:

-            EdkLogger.debug(EdkLogger.DEBUG_9, "No MaxDatumSize specified for PCD %s.%s" \

-                            % (ToPcd.TokenSpaceGuidCName, TokenCName))

-            Value = ToPcd.DefaultValue

-            if not Value:

-                ToPcd.MaxDatumSize = '1'

-            elif Value[0] == 'L':

-                ToPcd.MaxDatumSize = str((len(Value) - 2) * 2)

-            elif Value[0] == '{':

-                ToPcd.MaxDatumSize = str(len(Value.split(',')))

-            else:

-                ToPcd.MaxDatumSize = str(len(Value) - 1)

-

-        # apply default SKU for dynamic PCDS if specified one is not available

-        if (ToPcd.Type in PCD_DYNAMIC_TYPE_SET or ToPcd.Type in PCD_DYNAMIC_EX_TYPE_SET) \

-            and not ToPcd.SkuInfoList:

-            if self.Platform.SkuName in self.Platform.SkuIds:

-                SkuName = self.Platform.SkuName

-            else:

-                SkuName = TAB_DEFAULT

-            ToPcd.SkuInfoList = {

-                SkuName : SkuInfoClass(SkuName, self.Platform.SkuIds[SkuName][0], '', '', '', '', '', ToPcd.DefaultValue)

-            }

-

-    ## Apply PCD setting defined platform to a module

-    #

-    #   @param  Module  The module from which the PCD setting will be overridden

-    #

-    #   @retval PCD_list    The list PCDs with settings from platform

-    #

-    def ApplyPcdSetting(self, Module, Pcds, Library=""):

-        # for each PCD in module

-        for Name, Guid in Pcds:

-            PcdInModule = Pcds[Name, Guid]

-            # find out the PCD setting in platform

-            if (Name, Guid) in self.Platform.Pcds:

-                PcdInPlatform = self.Platform.Pcds[Name, Guid]

-            else:

-                PcdInPlatform = None

-            # then override the settings if any

-            self._OverridePcd(PcdInModule, PcdInPlatform, Module, Msg="DSC PCD sections", Library=Library)

-            # resolve the VariableGuid value

-            for SkuId in PcdInModule.SkuInfoList:

-                Sku = PcdInModule.SkuInfoList[SkuId]

-                if Sku.VariableGuid == '': continue

-                Sku.VariableGuidValue = GuidValue(Sku.VariableGuid, self.PackageList, self.MetaFile.Path)

-                if Sku.VariableGuidValue is None:

-                    PackageList = "\n\t".join(str(P) for P in self.PackageList)

-                    EdkLogger.error(

-                                'build',

-                                RESOURCE_NOT_AVAILABLE,

-                                "Value of GUID [%s] is not found in" % Sku.VariableGuid,

-                                ExtraData=PackageList + "\n\t(used with %s.%s from module %s)" \

-                                                        % (Guid, Name, str(Module)),

-                                File=self.MetaFile

-                                )

-

-        # override PCD settings with module specific setting

-        if Module in self.Platform.Modules:

-            PlatformModule = self.Platform.Modules[str(Module)]

-            for Key  in PlatformModule.Pcds:

-                if GlobalData.BuildOptionPcd:

-                    for pcd in GlobalData.BuildOptionPcd:

-                        (TokenSpaceGuidCName, TokenCName, FieldName, pcdvalue, _) = pcd

-                        if (TokenCName, TokenSpaceGuidCName) == Key and FieldName =="":

-                            PlatformModule.Pcds[Key].DefaultValue = pcdvalue

-                            PlatformModule.Pcds[Key].PcdValueFromComm = pcdvalue

-                            break

-                Flag = False

-                if Key in Pcds:

-                    ToPcd = Pcds[Key]

-                    Flag = True

-                elif Key in GlobalData.MixedPcd:

-                    for PcdItem in GlobalData.MixedPcd[Key]:

-                        if PcdItem in Pcds:

-                            ToPcd = Pcds[PcdItem]

-                            Flag = True

-                            break

-                if Flag:

-                    self._OverridePcd(ToPcd, PlatformModule.Pcds[Key], Module, Msg="DSC Components Module scoped PCD section", Library=Library)

-        # use PCD value to calculate the MaxDatumSize when it is not specified

-        for Name, Guid in Pcds:

-            Pcd = Pcds[Name, Guid]

-            if Pcd.DatumType == TAB_VOID and not Pcd.MaxDatumSize:

-                Pcd.MaxSizeUserSet = None

-                Value = Pcd.DefaultValue

-                if not Value:

-                    Pcd.MaxDatumSize = '1'

-                elif Value[0] == 'L':

-                    Pcd.MaxDatumSize = str((len(Value) - 2) * 2)

-                elif Value[0] == '{':

-                    Pcd.MaxDatumSize = str(len(Value.split(',')))

-                else:

-                    Pcd.MaxDatumSize = str(len(Value) - 1)

-        return list(Pcds.values())

-

-    ## Append build options in platform to a module

-    #

-    #   @param  Module  The module to which the build options will be appended

-    #

-    #   @retval options     The options appended with build options in platform

-    #

-    def ApplyBuildOption(self, Module):

-        # Get the different options for the different style module

-        PlatformOptions = self.EdkIIBuildOption

-        ModuleTypeOptions = self.Platform.GetBuildOptionsByModuleType(EDKII_NAME, Module.ModuleType)

-        ModuleTypeOptions = self._ExpandBuildOption(ModuleTypeOptions)

-        ModuleOptions = self._ExpandBuildOption(Module.BuildOptions)

-        if Module in self.Platform.Modules:

-            PlatformModule = self.Platform.Modules[str(Module)]

-            PlatformModuleOptions = self._ExpandBuildOption(PlatformModule.BuildOptions)

-        else:

-            PlatformModuleOptions = {}

-

-        BuildRuleOrder = None

-        for Options in [self.ToolDefinition, ModuleOptions, PlatformOptions, ModuleTypeOptions, PlatformModuleOptions]:

-            for Tool in Options:

-                for Attr in Options[Tool]:

-                    if Attr == TAB_TOD_DEFINES_BUILDRULEORDER:

-                        BuildRuleOrder = Options[Tool][Attr]

-

-        AllTools = set(list(ModuleOptions.keys()) + list(PlatformOptions.keys()) +

-                       list(PlatformModuleOptions.keys()) + list(ModuleTypeOptions.keys()) +

-                       list(self.ToolDefinition.keys()))

-        BuildOptions = defaultdict(lambda: defaultdict(str))

-        for Tool in AllTools:

-            for Options in [self.ToolDefinition, ModuleOptions, PlatformOptions, ModuleTypeOptions, PlatformModuleOptions]:

-                if Tool not in Options:

-                    continue

-                for Attr in Options[Tool]:

-                    #

-                    # Do not generate it in Makefile

-                    #

-                    if Attr == TAB_TOD_DEFINES_BUILDRULEORDER:

-                        continue

-                    Value = Options[Tool][Attr]

-                    ToolList = [Tool]

-                    if Tool == TAB_STAR:

-                        ToolList = list(AllTools)

-                        ToolList.remove(TAB_STAR)

-                    for ExpandedTool in ToolList:

-                        # check if override is indicated

-                        if Value.startswith('='):

-                            BuildOptions[ExpandedTool][Attr] = mws.handleWsMacro(Value[1:])

-                        else:

-                            if Attr != 'PATH':

-                                BuildOptions[ExpandedTool][Attr] += " " + mws.handleWsMacro(Value)

-                            else:

-                                BuildOptions[ExpandedTool][Attr] = mws.handleWsMacro(Value)

-

-        return BuildOptions, BuildRuleOrder

-

-

-    def GetGlobalBuildOptions(self,Module):

-        ModuleTypeOptions = self.Platform.GetBuildOptionsByModuleType(EDKII_NAME, Module.ModuleType)

-        ModuleTypeOptions = self._ExpandBuildOption(ModuleTypeOptions)

-

-        if Module in self.Platform.Modules:

-            PlatformModule = self.Platform.Modules[str(Module)]

-            PlatformModuleOptions = self._ExpandBuildOption(PlatformModule.BuildOptions)

-        else:

-            PlatformModuleOptions = {}

-

-        return ModuleTypeOptions,PlatformModuleOptions

-    def ModuleGuid(self,Module):

-        if os.path.basename(Module.MetaFile.File) != os.path.basename(Module.MetaFile.Path):

-            #

-            # Length of GUID is 36

-            #

-            return os.path.basename(Module.MetaFile.Path)[:36]

-        return Module.Guid

-    @cached_property

-    def UniqueBaseName(self):

-        retVal ={}

-        ModuleNameDict = {}

-        UniqueName = {}

-        for Module in self._MbList:

-            unique_base_name = '%s_%s' % (Module.BaseName,self.ModuleGuid(Module))

-            if unique_base_name not in ModuleNameDict:

-                ModuleNameDict[unique_base_name] = []

-            ModuleNameDict[unique_base_name].append(Module.MetaFile)

-            if Module.BaseName not in UniqueName:

-                UniqueName[Module.BaseName] = set()

-            UniqueName[Module.BaseName].add((self.ModuleGuid(Module),Module.MetaFile))

-        for module_paths in ModuleNameDict.values():

-            if len(set(module_paths))>1:

-                samemodules = list(set(module_paths))

-                EdkLogger.error("build", FILE_DUPLICATED, 'Modules have same BaseName and FILE_GUID:\n'

-                                    '  %s\n  %s' % (samemodules[0], samemodules[1]))

-        for name in UniqueName:

-            Guid_Path = UniqueName[name]

-            if len(Guid_Path) > 1:

-                for guid,mpath in Guid_Path:

-                    retVal[(name,mpath)] = '%s_%s' % (name,guid)

-        return retVal

-    ## Expand * in build option key

-    #

-    #   @param  Options     Options to be expanded

-    #   @param  ToolDef     Use specified ToolDef instead of full version.

-    #                       This is needed during initialization to prevent

-    #                       infinite recursion betweeh BuildOptions,

-    #                       ToolDefinition, and this function.

-    #

-    #   @retval options     Options expanded

-    #

-    def _ExpandBuildOption(self, Options, ModuleStyle=None, ToolDef=None):

-        if not ToolDef:

-            ToolDef = self.ToolDefinition

-        BuildOptions = {}

-        FamilyMatch  = False

-        FamilyIsNull = True

-

-        OverrideList = {}

-        #

-        # Construct a list contain the build options which need override.

-        #

-        for Key in Options:

-            #

-            # Key[0] -- tool family

-            # Key[1] -- TARGET_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE

-            #

-            if (Key[0] == self.BuildRuleFamily and

-                (ModuleStyle is None or len(Key) < 3 or (len(Key) > 2 and Key[2] == ModuleStyle))):

-                Target, ToolChain, Arch, CommandType, Attr = Key[1].split('_')

-                if (Target == self.BuildTarget or Target == TAB_STAR) and\

-                    (ToolChain == self.ToolChain or ToolChain == TAB_STAR) and\

-                    (Arch == self.Arch or Arch == TAB_STAR) and\

-                    Options[Key].startswith("="):

-

-                    if OverrideList.get(Key[1]) is not None:

-                        OverrideList.pop(Key[1])

-                    OverrideList[Key[1]] = Options[Key]

-

-        #

-        # Use the highest priority value.

-        #

-        if (len(OverrideList) >= 2):

-            KeyList = list(OverrideList.keys())

-            for Index in range(len(KeyList)):

-                NowKey = KeyList[Index]

-                Target1, ToolChain1, Arch1, CommandType1, Attr1 = NowKey.split("_")

-                for Index1 in range(len(KeyList) - Index - 1):

-                    NextKey = KeyList[Index1 + Index + 1]

-                    #

-                    # Compare two Key, if one is included by another, choose the higher priority one

-                    #

-                    Target2, ToolChain2, Arch2, CommandType2, Attr2 = NextKey.split("_")

-                    if (Target1 == Target2 or Target1 == TAB_STAR or Target2 == TAB_STAR) and\

-                        (ToolChain1 == ToolChain2 or ToolChain1 == TAB_STAR or ToolChain2 == TAB_STAR) and\

-                        (Arch1 == Arch2 or Arch1 == TAB_STAR or Arch2 == TAB_STAR) and\

-                        (CommandType1 == CommandType2 or CommandType1 == TAB_STAR or CommandType2 == TAB_STAR) and\

-                        (Attr1 == Attr2 or Attr1 == TAB_STAR or Attr2 == TAB_STAR):

-

-                        if CalculatePriorityValue(NowKey) > CalculatePriorityValue(NextKey):

-                            if Options.get((self.BuildRuleFamily, NextKey)) is not None:

-                                Options.pop((self.BuildRuleFamily, NextKey))

-                        else:

-                            if Options.get((self.BuildRuleFamily, NowKey)) is not None:

-                                Options.pop((self.BuildRuleFamily, NowKey))

-

-        for Key in Options:

-            if ModuleStyle is not None and len (Key) > 2:

-                # Check Module style is EDK or EDKII.

-                # Only append build option for the matched style module.

-                if ModuleStyle == EDK_NAME and Key[2] != EDK_NAME:

-                    continue

-                elif ModuleStyle == EDKII_NAME and Key[2] != EDKII_NAME:

-                    continue

-            Family = Key[0]

-            Target, Tag, Arch, Tool, Attr = Key[1].split("_")

-            # if tool chain family doesn't match, skip it

-            if Family != "":

-                Found = False

-                if Tool in ToolDef:

-                    FamilyIsNull = False

-                    if TAB_TOD_DEFINES_BUILDRULEFAMILY in ToolDef[Tool]:

-                        if Family == ToolDef[Tool][TAB_TOD_DEFINES_BUILDRULEFAMILY]:

-                            FamilyMatch = True

-                            Found = True

-                if TAB_STAR in ToolDef:

-                    FamilyIsNull = False

-                    if TAB_TOD_DEFINES_BUILDRULEFAMILY in ToolDef[TAB_STAR]:

-                        if Family == ToolDef[TAB_STAR][TAB_TOD_DEFINES_BUILDRULEFAMILY]:

-                            FamilyMatch = True

-                            Found = True

-                if not Found:

-                    continue

-

-            # expand any wildcard

-            if Target == TAB_STAR or Target == self.BuildTarget:

-                if Tag == TAB_STAR or Tag == self.ToolChain:

-                    if Arch == TAB_STAR or Arch == self.Arch:

-                        if Tool not in BuildOptions:

-                            BuildOptions[Tool] = {}

-                        if Attr != "FLAGS" or Attr not in BuildOptions[Tool] or Options[Key].startswith('='):

-                            BuildOptions[Tool][Attr] = Options[Key]

-                        else:

-                            # append options for the same tool except PATH

-                            if Attr != 'PATH':

-                                BuildOptions[Tool][Attr] += " " + Options[Key]

-                            else:

-                                BuildOptions[Tool][Attr] = Options[Key]

-        # Build Option Family has been checked, which need't to be checked again for family.

-        if FamilyMatch or FamilyIsNull:

-            return BuildOptions

-

-        for Key in Options:

-            if ModuleStyle is not None and len (Key) > 2:

-                # Check Module style is EDK or EDKII.

-                # Only append build option for the matched style module.

-                if ModuleStyle == EDK_NAME and Key[2] != EDK_NAME:

-                    continue

-                elif ModuleStyle == EDKII_NAME and Key[2] != EDKII_NAME:

-                    continue

-            Family = Key[0]

-            Target, Tag, Arch, Tool, Attr = Key[1].split("_")

-            # if tool chain family doesn't match, skip it

-            if Family == "":

-                continue

-            # option has been added before

-            Found = False

-            if Tool in ToolDef:

-                if TAB_TOD_DEFINES_FAMILY in ToolDef[Tool]:

-                    if Family == ToolDef[Tool][TAB_TOD_DEFINES_FAMILY]:

-                        Found = True

-            if TAB_STAR in ToolDef:

-                if TAB_TOD_DEFINES_FAMILY in ToolDef[TAB_STAR]:

-                    if Family == ToolDef[TAB_STAR][TAB_TOD_DEFINES_FAMILY]:

-                        Found = True

-            if not Found:

-                continue

-

-            # expand any wildcard

-            if Target == TAB_STAR or Target == self.BuildTarget:

-                if Tag == TAB_STAR or Tag == self.ToolChain:

-                    if Arch == TAB_STAR or Arch == self.Arch:

-                        if Tool not in BuildOptions:

-                            BuildOptions[Tool] = {}

-                        if Attr != "FLAGS" or Attr not in BuildOptions[Tool] or Options[Key].startswith('='):

-                            BuildOptions[Tool][Attr] = Options[Key]

-                        else:

-                            # append options for the same tool except PATH

-                            if Attr != 'PATH':

-                                BuildOptions[Tool][Attr] += " " + Options[Key]

-                            else:

-                                BuildOptions[Tool][Attr] = Options[Key]

-        return BuildOptions

+## @file
+# Create makefile for MS nmake and GNU make
+#
+# Copyright (c) 2019 - 2021, Intel Corporation. All rights reserved.<BR>
+#  Copyright (c) 2020, ARM Limited. All rights reserved.<BR>
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+#
+
+## Import Modules
+#
+from __future__ import print_function
+from __future__ import absolute_import
+import os.path as path
+import copy
+from collections import defaultdict
+
+from .BuildEngine import BuildRule,gDefaultBuildRuleFile,AutoGenReqBuildRuleVerNum
+from .GenVar import VariableMgr, var_info
+from . import GenMake
+from AutoGen.DataPipe import MemoryDataPipe
+from AutoGen.ModuleAutoGen import ModuleAutoGen
+from AutoGen.AutoGen import AutoGen
+from AutoGen.AutoGen import CalculatePriorityValue
+from Workspace.WorkspaceCommon import GetModuleLibInstances
+from CommonDataClass.CommonClass import SkuInfoClass
+from Common.caching import cached_class_function
+from Common.Expression import ValueExpressionEx
+from Common.StringUtils import StringToArray,NormPath
+from Common.BuildToolError import *
+from Common.DataType import *
+from Common.Misc import *
+import Common.VpdInfoFile as VpdInfoFile
+
+## Split command line option string to list
+#
+# subprocess.Popen needs the args to be a sequence. Otherwise there's problem
+# in non-windows platform to launch command
+#
+def _SplitOption(OptionString):
+    OptionList = []
+    LastChar = " "
+    OptionStart = 0
+    QuotationMark = ""
+    for Index in range(0, len(OptionString)):
+        CurrentChar = OptionString[Index]
+        if CurrentChar in ['"', "'"]:
+            if QuotationMark == CurrentChar:
+                QuotationMark = ""
+            elif QuotationMark == "":
+                QuotationMark = CurrentChar
+            continue
+        elif QuotationMark:
+            continue
+
+        if CurrentChar in ["/", "-"] and LastChar in [" ", "\t", "\r", "\n"]:
+            if Index > OptionStart:
+                OptionList.append(OptionString[OptionStart:Index - 1])
+            OptionStart = Index
+        LastChar = CurrentChar
+    OptionList.append(OptionString[OptionStart:])
+    return OptionList
+
+## AutoGen class for platform
+#
+#  PlatformAutoGen class will process the original information in platform
+#  file in order to generate makefile for platform.
+#
+class PlatformAutoGen(AutoGen):
+    # call super().__init__ then call the worker function with different parameter count
+    def __init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):
+        if not hasattr(self, "_Init"):
+            self._InitWorker(Workspace, MetaFile, Target, Toolchain, Arch)
+            self._Init = True
+    #
+    # Used to store all PCDs for both PEI and DXE phase, in order to generate
+    # correct PCD database
+    #
+    _DynaPcdList_ = []
+    _NonDynaPcdList_ = []
+    _PlatformPcds = {}
+
+
+
+    ## Initialize PlatformAutoGen
+    #
+    #
+    #   @param      Workspace       WorkspaceAutoGen object
+    #   @param      PlatformFile    Platform file (DSC file)
+    #   @param      Target          Build target (DEBUG, RELEASE)
+    #   @param      Toolchain       Name of tool chain
+    #   @param      Arch            arch of the platform supports
+    #
+    def _InitWorker(self, Workspace, PlatformFile, Target, Toolchain, Arch):
+        EdkLogger.debug(EdkLogger.DEBUG_9, "AutoGen platform [%s] [%s]" % (PlatformFile, Arch))
+        GlobalData.gProcessingFile = "%s [%s, %s, %s]" % (PlatformFile, Arch, Toolchain, Target)
+
+        self.MetaFile = PlatformFile
+        self.Workspace = Workspace
+        self.WorkspaceDir = Workspace.WorkspaceDir
+        self.ToolChain = Toolchain
+        self.BuildTarget = Target
+        self.Arch = Arch
+        self.SourceDir = PlatformFile.SubDir
+        self.FdTargetList = self.Workspace.FdTargetList
+        self.FvTargetList = self.Workspace.FvTargetList
+        # get the original module/package/platform objects
+        self.BuildDatabase = Workspace.BuildDatabase
+        self.DscBuildDataObj = Workspace.Platform
+
+        # MakeFileName is used to get the Makefile name and as a flag
+        # indicating whether the file has been created.
+        self.MakeFileName = ""
+
+        self._DynamicPcdList = None    # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]
+        self._NonDynamicPcdList = None # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]
+
+        self._AsBuildInfList = []
+        self._AsBuildModuleList = []
+
+        self.VariableInfo = None
+
+        if GlobalData.gFdfParser is not None:
+            self._AsBuildInfList = GlobalData.gFdfParser.Profile.InfList
+            for Inf in self._AsBuildInfList:
+                InfClass = PathClass(NormPath(Inf), GlobalData.gWorkspace, self.Arch)
+                M = self.BuildDatabase[InfClass, self.Arch, self.BuildTarget, self.ToolChain]
+                if not M.IsBinaryModule:
+                    continue
+                self._AsBuildModuleList.append(InfClass)
+        # get library/modules for build
+        self.LibraryBuildDirectoryList = []
+        self.ModuleBuildDirectoryList = []
+
+        self.DataPipe = MemoryDataPipe(self.BuildDir)
+        self.DataPipe.FillData(self)
+
+        return True
+    def FillData_LibConstPcd(self):
+        libConstPcd = {}
+        for LibAuto in self.LibraryAutoGenList:
+            if LibAuto.ConstPcd:
+                libConstPcd[(LibAuto.MetaFile.File,LibAuto.MetaFile.Root,LibAuto.Arch,LibAuto.MetaFile.Path)] = LibAuto.ConstPcd
+        self.DataPipe.DataContainer = {"LibConstPcd":libConstPcd}
+    ## hash() operator of PlatformAutoGen
+    #
+    #  The platform file path and arch string will be used to represent
+    #  hash value of this object
+    #
+    #   @retval   int Hash value of the platform file path and arch
+    #
+    @cached_class_function
+    def __hash__(self):
+        return hash((self.MetaFile, self.Arch,self.ToolChain,self.BuildTarget))
+    @cached_class_function
+    def __repr__(self):
+        return "%s [%s]" % (self.MetaFile, self.Arch)
+
+    ## Create autogen code for platform and modules
+    #
+    #  Since there's no autogen code for platform, this method will do nothing
+    #  if CreateModuleCodeFile is set to False.
+    #
+    #   @param      CreateModuleCodeFile    Flag indicating if creating module's
+    #                                       autogen code file or not
+    #
+    @cached_class_function
+    def CreateCodeFile(self, CreateModuleCodeFile=False):
+        # only module has code to be created, so do nothing if CreateModuleCodeFile is False
+        if not CreateModuleCodeFile:
+            return
+
+        for Ma in self.ModuleAutoGenList:
+            Ma.CreateCodeFile(CreateModuleCodeFile)
+
+    ## Generate Fds Command
+    @cached_property
+    def GenFdsCommand(self):
+        return self.Workspace.GenFdsCommand
+
+    ## Create makefile for the platform and modules in it
+    #
+    #   @param      CreateModuleMakeFile    Flag indicating if the makefile for
+    #                                       modules will be created as well
+    #
+    def CreateMakeFile(self, CreateModuleMakeFile=False, FfsCommand = {}):
+        if CreateModuleMakeFile:
+            for Ma in self._MaList:
+                key = (Ma.MetaFile.File, self.Arch)
+                if key in FfsCommand:
+                    Ma.CreateMakeFile(CreateModuleMakeFile, FfsCommand[key])
+                else:
+                    Ma.CreateMakeFile(CreateModuleMakeFile)
+        self.CreateLibModuelDirs()
+
+    def CreateLibModuelDirs(self):
+        # No need to create makefile for the platform more than once.
+        if self.MakeFileName:
+            return
+
+        # create library/module build dirs for platform
+        Makefile = GenMake.PlatformMakefile(self)
+        self.LibraryBuildDirectoryList = Makefile.GetLibraryBuildDirectoryList()
+        self.ModuleBuildDirectoryList = Makefile.GetModuleBuildDirectoryList()
+        self.MakeFileName = Makefile.getMakefileName()
+
+    @property
+    def AllPcdList(self):
+        return self.DynamicPcdList + self.NonDynamicPcdList
+    ## Deal with Shared FixedAtBuild Pcds
+    #
+    def CollectFixedAtBuildPcds(self):
+        for LibAuto in self.LibraryAutoGenList:
+            FixedAtBuildPcds = {}
+            ShareFixedAtBuildPcdsSameValue = {}
+            for Module in LibAuto.ReferenceModules:
+                for Pcd in set(Module.FixedAtBuildPcds + LibAuto.FixedAtBuildPcds):
+                    DefaultValue = Pcd.DefaultValue
+                    # Cover the case: DSC component override the Pcd value and the Pcd only used in one Lib
+                    if Pcd in Module.LibraryPcdList:
+                        Index = Module.LibraryPcdList.index(Pcd)
+                        DefaultValue = Module.LibraryPcdList[Index].DefaultValue
+                    key = ".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
+                    if key not in FixedAtBuildPcds:
+                        ShareFixedAtBuildPcdsSameValue[key] = True
+                        FixedAtBuildPcds[key] = DefaultValue
+                    else:
+                        if FixedAtBuildPcds[key] != DefaultValue:
+                            ShareFixedAtBuildPcdsSameValue[key] = False
+            for Pcd in LibAuto.FixedAtBuildPcds:
+                key = ".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
+                if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in self.NonDynamicPcdDict:
+                    continue
+                else:
+                    DscPcd = self.NonDynamicPcdDict[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)]
+                    if DscPcd.Type != TAB_PCDS_FIXED_AT_BUILD:
+                        continue
+                if key in ShareFixedAtBuildPcdsSameValue and ShareFixedAtBuildPcdsSameValue[key]:
+                    LibAuto.ConstPcd[key] = FixedAtBuildPcds[key]
+
+    def CollectVariables(self, DynamicPcdSet):
+        VpdRegionSize = 0
+        VpdRegionBase = 0
+        if self.Workspace.FdfFile:
+            FdDict = self.Workspace.FdfProfile.FdDict[GlobalData.gFdfParser.CurrentFdName]
+            for FdRegion in FdDict.RegionList:
+                for item in FdRegion.RegionDataList:
+                    if self.Platform.VpdToolGuid.strip() and self.Platform.VpdToolGuid in item:
+                        VpdRegionSize = FdRegion.Size
+                        VpdRegionBase = FdRegion.Offset
+                        break
+
+        VariableInfo = VariableMgr(self.DscBuildDataObj._GetDefaultStores(), self.DscBuildDataObj.SkuIds)
+        VariableInfo.SetVpdRegionMaxSize(VpdRegionSize)
+        VariableInfo.SetVpdRegionOffset(VpdRegionBase)
+        Index = 0
+        for Pcd in sorted(DynamicPcdSet):
+            pcdname = ".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
+            for SkuName in Pcd.SkuInfoList:
+                Sku = Pcd.SkuInfoList[SkuName]
+                SkuId = Sku.SkuId
+                if SkuId is None or SkuId == '':
+                    continue
+                if len(Sku.VariableName) > 0:
+                    if Sku.VariableAttribute and 'NV' not in Sku.VariableAttribute:
+                        continue
+                    VariableGuidStructure = Sku.VariableGuidValue
+                    VariableGuid = GuidStructureStringToGuidString(VariableGuidStructure)
+                    for StorageName in Sku.DefaultStoreDict:
+                        VariableInfo.append_variable(var_info(Index, pcdname, StorageName, SkuName, StringToArray(Sku.VariableName), VariableGuid, Sku.VariableOffset, Sku.VariableAttribute, Sku.HiiDefaultValue, Sku.DefaultStoreDict[StorageName] if Pcd.DatumType in TAB_PCD_NUMERIC_TYPES else StringToArray(Sku.DefaultStoreDict[StorageName]), Pcd.DatumType, Pcd.CustomAttribute['DscPosition'], Pcd.CustomAttribute.get('IsStru',False)))
+            Index += 1
+        return VariableInfo
+
+    def UpdateNVStoreMaxSize(self, OrgVpdFile):
+        if self.VariableInfo:
+            VpdMapFilePath = os.path.join(self.BuildDir, TAB_FV_DIRECTORY, "%s.map" % self.Platform.VpdToolGuid)
+            PcdNvStoreDfBuffer = [item for item in self._DynamicPcdList if item.TokenCName == "PcdNvStoreDefaultValueBuffer" and item.TokenSpaceGuidCName == "gEfiMdeModulePkgTokenSpaceGuid"]
+
+            if PcdNvStoreDfBuffer:
+                try:
+                    OrgVpdFile.Read(VpdMapFilePath)
+                    PcdItems = OrgVpdFile.GetOffset(PcdNvStoreDfBuffer[0])
+                    NvStoreOffset = list(PcdItems.values())[0].strip() if PcdItems else '0'
+                except:
+                    EdkLogger.error("build", FILE_READ_FAILURE, "Can not find VPD map file %s to fix up VPD offset." % VpdMapFilePath)
+
+                NvStoreOffset = int(NvStoreOffset, 16) if NvStoreOffset.upper().startswith("0X") else int(NvStoreOffset)
+                default_skuobj = PcdNvStoreDfBuffer[0].SkuInfoList.get(TAB_DEFAULT)
+                maxsize = self.VariableInfo.VpdRegionSize  - NvStoreOffset if self.VariableInfo.VpdRegionSize else len(default_skuobj.DefaultValue.split(","))
+                var_data = self.VariableInfo.PatchNVStoreDefaultMaxSize(maxsize)
+
+                if var_data and default_skuobj:
+                    default_skuobj.DefaultValue = var_data
+                    PcdNvStoreDfBuffer[0].DefaultValue = var_data
+                    PcdNvStoreDfBuffer[0].SkuInfoList.clear()
+                    PcdNvStoreDfBuffer[0].SkuInfoList[TAB_DEFAULT] = default_skuobj
+                    PcdNvStoreDfBuffer[0].MaxDatumSize = str(len(default_skuobj.DefaultValue.split(",")))
+
+        return OrgVpdFile
+
+    ## Collect dynamic PCDs
+    #
+    #  Gather dynamic PCDs list from each module and their settings from platform
+    #  This interface should be invoked explicitly when platform action is created.
+    #
+    def CollectPlatformDynamicPcds(self):
+        self.CategoryPcds()
+        self.SortDynamicPcd()
+
+    def CategoryPcds(self):
+        # Category Pcds into DynamicPcds and NonDynamicPcds
+        # for gathering error information
+        NoDatumTypePcdList = set()
+        FdfModuleList = []
+        for InfName in self._AsBuildInfList:
+            InfName = mws.join(self.WorkspaceDir, InfName)
+            FdfModuleList.append(os.path.normpath(InfName))
+        for M in self._MbList:
+#            F is the Module for which M is the module autogen
+            ModPcdList = self.ApplyPcdSetting(M, M.ModulePcdList)
+            LibPcdList = []
+            for lib in M.LibraryPcdList:
+                LibPcdList.extend(self.ApplyPcdSetting(M, M.LibraryPcdList[lib], lib))
+            for PcdFromModule in ModPcdList + LibPcdList:
+
+                # make sure that the "VOID*" kind of datum has MaxDatumSize set
+                if PcdFromModule.DatumType == TAB_VOID and not PcdFromModule.MaxDatumSize:
+                    NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, M.MetaFile))
+
+                # Check the PCD from Binary INF or Source INF
+                if M.IsBinaryModule == True:
+                    PcdFromModule.IsFromBinaryInf = True
+
+                # Check the PCD from DSC or not
+                PcdFromModule.IsFromDsc = (PcdFromModule.TokenCName, PcdFromModule.TokenSpaceGuidCName) in self.Platform.Pcds
+
+                if PcdFromModule.Type in PCD_DYNAMIC_TYPE_SET or PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET:
+                    if M.MetaFile.Path not in FdfModuleList:
+                        # If one of the Source built modules listed in the DSC is not listed
+                        # in FDF modules, and the INF lists a PCD can only use the PcdsDynamic
+                        # access method (it is only listed in the DEC file that declares the
+                        # PCD as PcdsDynamic), then build tool will report warning message
+                        # notify the PI that they are attempting to build a module that must
+                        # be included in a flash image in order to be functional. These Dynamic
+                        # PCD will not be added into the Database unless it is used by other
+                        # modules that are included in the FDF file.
+                        if PcdFromModule.Type in PCD_DYNAMIC_TYPE_SET and \
+                            PcdFromModule.IsFromBinaryInf == False:
+                            # Print warning message to let the developer make a determine.
+                            continue
+                        # If one of the Source built modules listed in the DSC is not listed in
+                        # FDF modules, and the INF lists a PCD can only use the PcdsDynamicEx
+                        # access method (it is only listed in the DEC file that declares the
+                        # PCD as PcdsDynamicEx), then DO NOT break the build; DO NOT add the
+                        # PCD to the Platform's PCD Database.
+                        if PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET:
+                            continue
+                    #
+                    # If a dynamic PCD used by a PEM module/PEI module & DXE module,
+                    # it should be stored in Pcd PEI database, If a dynamic only
+                    # used by DXE module, it should be stored in DXE PCD database.
+                    # The default Phase is DXE
+                    #
+                    if M.ModuleType in SUP_MODULE_SET_PEI:
+                        PcdFromModule.Phase = "PEI"
+                    if PcdFromModule not in self._DynaPcdList_:
+                        self._DynaPcdList_.append(PcdFromModule)
+                    elif PcdFromModule.Phase == 'PEI':
+                        # overwrite any the same PCD existing, if Phase is PEI
+                        Index = self._DynaPcdList_.index(PcdFromModule)
+                        self._DynaPcdList_[Index] = PcdFromModule
+                elif PcdFromModule not in self._NonDynaPcdList_:
+                    self._NonDynaPcdList_.append(PcdFromModule)
+                elif PcdFromModule in self._NonDynaPcdList_ and PcdFromModule.IsFromBinaryInf == True:
+                    Index = self._NonDynaPcdList_.index(PcdFromModule)
+                    if self._NonDynaPcdList_[Index].IsFromBinaryInf == False:
+                        #The PCD from Binary INF will override the same one from source INF
+                        self._NonDynaPcdList_.remove (self._NonDynaPcdList_[Index])
+                        PcdFromModule.Pending = False
+                        self._NonDynaPcdList_.append (PcdFromModule)
+        DscModuleSet = {os.path.normpath(ModuleInf.Path) for ModuleInf in self.Platform.Modules}
+        # add the PCD from modules that listed in FDF but not in DSC to Database
+        for InfName in FdfModuleList:
+            if InfName not in DscModuleSet:
+                InfClass = PathClass(InfName)
+                M = self.BuildDatabase[InfClass, self.Arch, self.BuildTarget, self.ToolChain]
+                # If a module INF in FDF but not in current arch's DSC module list, it must be module (either binary or source)
+                # for different Arch. PCDs in source module for different Arch is already added before, so skip the source module here.
+                # For binary module, if in current arch, we need to list the PCDs into database.
+                if not M.IsBinaryModule:
+                    continue
+                # Override the module PCD setting by platform setting
+                ModulePcdList = self.ApplyPcdSetting(M, M.Pcds)
+                for PcdFromModule in ModulePcdList:
+                    PcdFromModule.IsFromBinaryInf = True
+                    PcdFromModule.IsFromDsc = False
+                    # Only allow the DynamicEx and Patchable PCD in AsBuild INF
+                    if PcdFromModule.Type not in PCD_DYNAMIC_EX_TYPE_SET and PcdFromModule.Type not in TAB_PCDS_PATCHABLE_IN_MODULE:
+                        EdkLogger.error("build", AUTOGEN_ERROR, "PCD setting error",
+                                        File=self.MetaFile,
+                                        ExtraData="\n\tExisted %s PCD %s in:\n\t\t%s\n"
+                                        % (PcdFromModule.Type, PcdFromModule.TokenCName, InfName))
+                    # make sure that the "VOID*" kind of datum has MaxDatumSize set
+                    if PcdFromModule.DatumType == TAB_VOID and not PcdFromModule.MaxDatumSize:
+                        NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, InfName))
+                    if M.ModuleType in SUP_MODULE_SET_PEI:
+                        PcdFromModule.Phase = "PEI"
+                    if PcdFromModule not in self._DynaPcdList_ and PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET:
+                        self._DynaPcdList_.append(PcdFromModule)
+                    elif PcdFromModule not in self._NonDynaPcdList_ and PcdFromModule.Type in TAB_PCDS_PATCHABLE_IN_MODULE:
+                        self._NonDynaPcdList_.append(PcdFromModule)
+                    if PcdFromModule in self._DynaPcdList_ and PcdFromModule.Phase == 'PEI' and PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET:
+                        # Overwrite the phase of any the same PCD existing, if Phase is PEI.
+                        # It is to solve the case that a dynamic PCD used by a PEM module/PEI
+                        # module & DXE module at a same time.
+                        # Overwrite the type of the PCDs in source INF by the type of AsBuild
+                        # INF file as DynamicEx.
+                        Index = self._DynaPcdList_.index(PcdFromModule)
+                        self._DynaPcdList_[Index].Phase = PcdFromModule.Phase
+                        self._DynaPcdList_[Index].Type = PcdFromModule.Type
+        for PcdFromModule in self._NonDynaPcdList_:
+            # If a PCD is not listed in the DSC file, but binary INF files used by
+            # this platform all (that use this PCD) list the PCD in a [PatchPcds]
+            # section, AND all source INF files used by this platform the build
+            # that use the PCD list the PCD in either a [Pcds] or [PatchPcds]
+            # section, then the tools must NOT add the PCD to the Platform's PCD
+            # Database; the build must assign the access method for this PCD as
+            # PcdsPatchableInModule.
+            if PcdFromModule not in self._DynaPcdList_:
+                continue
+            Index = self._DynaPcdList_.index(PcdFromModule)
+            if PcdFromModule.IsFromDsc == False and \
+                PcdFromModule.Type in TAB_PCDS_PATCHABLE_IN_MODULE and \
+                PcdFromModule.IsFromBinaryInf == True and \
+                self._DynaPcdList_[Index].IsFromBinaryInf == False:
+                Index = self._DynaPcdList_.index(PcdFromModule)
+                self._DynaPcdList_.remove (self._DynaPcdList_[Index])
+
+        # print out error information and break the build, if error found
+        if len(NoDatumTypePcdList) > 0:
+            NoDatumTypePcdListString = "\n\t\t".join(NoDatumTypePcdList)
+            EdkLogger.error("build", AUTOGEN_ERROR, "PCD setting error",
+                            File=self.MetaFile,
+                            ExtraData="\n\tPCD(s) without MaxDatumSize:\n\t\t%s\n"
+                                      % NoDatumTypePcdListString)
+        self._NonDynamicPcdList = sorted(self._NonDynaPcdList_)
+        self._DynamicPcdList = self._DynaPcdList_
+
+    def SortDynamicPcd(self):
+        #
+        # Sort dynamic PCD list to:
+        # 1) If PCD's datum type is VOID* and value is unicode string which starts with L, the PCD item should
+        #    try to be put header of dynamicd List
+        # 2) If PCD is HII type, the PCD item should be put after unicode type PCD
+        #
+        # The reason of sorting is make sure the unicode string is in double-byte alignment in string table.
+        #
+        UnicodePcdArray = set()
+        HiiPcdArray     = set()
+        OtherPcdArray   = set()
+        VpdPcdDict      = {}
+        VpdFile               = VpdInfoFile.VpdInfoFile()
+        NeedProcessVpdMapFile = False
+
+        for pcd in self.Platform.Pcds:
+            if pcd not in self._PlatformPcds:
+                self._PlatformPcds[pcd] = self.Platform.Pcds[pcd]
+
+        for item in self._PlatformPcds:
+            if self._PlatformPcds[item].DatumType and self._PlatformPcds[item].DatumType not in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]:
+                self._PlatformPcds[item].DatumType = TAB_VOID
+
+        if (self.Workspace.ArchList[-1] == self.Arch):
+            for Pcd in self._DynamicPcdList:
+                # just pick the a value to determine whether is unicode string type
+                Sku = Pcd.SkuInfoList.get(TAB_DEFAULT)
+                Sku.VpdOffset = Sku.VpdOffset.strip()
+
+                if Pcd.DatumType not in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]:
+                    Pcd.DatumType = TAB_VOID
+
+                    # if found PCD which datum value is unicode string the insert to left size of UnicodeIndex
+                    # if found HII type PCD then insert to right of UnicodeIndex
+                if Pcd.Type in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD]:
+                    VpdPcdDict[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)] = Pcd
+
+            #Collect DynamicHii PCD values and assign it to DynamicExVpd PCD gEfiMdeModulePkgTokenSpaceGuid.PcdNvStoreDefaultValueBuffer
+            PcdNvStoreDfBuffer = VpdPcdDict.get(("PcdNvStoreDefaultValueBuffer", "gEfiMdeModulePkgTokenSpaceGuid"))
+            if PcdNvStoreDfBuffer:
+                self.VariableInfo = self.CollectVariables(self._DynamicPcdList)
+                vardump = self.VariableInfo.dump()
+                if vardump:
+                    #
+                    #According to PCD_DATABASE_INIT in edk2\MdeModulePkg\Include\Guid\PcdDataBaseSignatureGuid.h,
+                    #the max size for string PCD should not exceed USHRT_MAX 65535(0xffff).
+                    #typedef UINT16 SIZE_INFO;
+                    #//SIZE_INFO  SizeTable[];
+                    if len(vardump.split(",")) > 0xffff:
+                        EdkLogger.error("build", RESOURCE_OVERFLOW, 'The current length of PCD %s value is %d, it exceeds to the max size of String PCD.' %(".".join([PcdNvStoreDfBuffer.TokenSpaceGuidCName,PcdNvStoreDfBuffer.TokenCName]) ,len(vardump.split(","))))
+                    PcdNvStoreDfBuffer.DefaultValue = vardump
+                    for skuname in PcdNvStoreDfBuffer.SkuInfoList:
+                        PcdNvStoreDfBuffer.SkuInfoList[skuname].DefaultValue = vardump
+                        PcdNvStoreDfBuffer.MaxDatumSize = str(len(vardump.split(",")))
+            else:
+                #If the end user define [DefaultStores] and [XXX.Menufacturing] in DSC, but forget to configure PcdNvStoreDefaultValueBuffer to PcdsDynamicVpd
+                if [Pcd for Pcd in self._DynamicPcdList if Pcd.UserDefinedDefaultStoresFlag]:
+                    EdkLogger.warn("build", "PcdNvStoreDefaultValueBuffer should be defined as PcdsDynamicExVpd in dsc file since the DefaultStores is enabled for this platform.\n%s" %self.Platform.MetaFile.Path)
+            PlatformPcds = sorted(self._PlatformPcds.keys())
+            #
+            # Add VPD type PCD into VpdFile and determine whether the VPD PCD need to be fixed up.
+            #
+            VpdSkuMap = {}
+            for PcdKey in PlatformPcds:
+                Pcd = self._PlatformPcds[PcdKey]
+                if Pcd.Type in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD] and \
+                   PcdKey in VpdPcdDict:
+                    Pcd = VpdPcdDict[PcdKey]
+                    SkuValueMap = {}
+                    DefaultSku = Pcd.SkuInfoList.get(TAB_DEFAULT)
+                    if DefaultSku:
+                        PcdValue = DefaultSku.DefaultValue
+                        if PcdValue not in SkuValueMap:
+                            SkuValueMap[PcdValue] = []
+                            VpdFile.Add(Pcd, TAB_DEFAULT, DefaultSku.VpdOffset)
+                        SkuValueMap[PcdValue].append(DefaultSku)
+
+                    for (SkuName, Sku) in Pcd.SkuInfoList.items():
+                        Sku.VpdOffset = Sku.VpdOffset.strip()
+                        PcdValue = Sku.DefaultValue
+                        if PcdValue == "":
+                            PcdValue  = Pcd.DefaultValue
+                        if Sku.VpdOffset != TAB_STAR:
+                            if PcdValue.startswith("{"):
+                                Alignment = 8
+                            elif PcdValue.startswith("L"):
+                                Alignment = 2
+                            else:
+                                Alignment = 1
+                            try:
+                                VpdOffset = int(Sku.VpdOffset)
+                            except:
+                                try:
+                                    VpdOffset = int(Sku.VpdOffset, 16)
+                                except:
+                                    EdkLogger.error("build", FORMAT_INVALID, "Invalid offset value %s for PCD %s.%s." % (Sku.VpdOffset, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
+                            if VpdOffset % Alignment != 0:
+                                if PcdValue.startswith("{"):
+                                    EdkLogger.warn("build", "The offset value of PCD %s.%s is not 8-byte aligned!" %(Pcd.TokenSpaceGuidCName, Pcd.TokenCName), File=self.MetaFile)
+                                else:
+                                    EdkLogger.error("build", FORMAT_INVALID, 'The offset value of PCD %s.%s should be %s-byte aligned.' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, Alignment))
+                        if PcdValue not in SkuValueMap:
+                            SkuValueMap[PcdValue] = []
+                            VpdFile.Add(Pcd, SkuName, Sku.VpdOffset)
+                        SkuValueMap[PcdValue].append(Sku)
+                        # if the offset of a VPD is *, then it need to be fixed up by third party tool.
+                        if not NeedProcessVpdMapFile and Sku.VpdOffset == TAB_STAR:
+                            NeedProcessVpdMapFile = True
+                            if self.Platform.VpdToolGuid is None or self.Platform.VpdToolGuid == '':
+                                EdkLogger.error("Build", FILE_NOT_FOUND, \
+                                                "Fail to find third-party BPDG tool to process VPD PCDs. BPDG Guid tool need to be defined in tools_def.txt and VPD_TOOL_GUID need to be provided in DSC file.")
+
+                    VpdSkuMap[PcdKey] = SkuValueMap
+            #
+            # Fix the PCDs define in VPD PCD section that never referenced by module.
+            # An example is PCD for signature usage.
+            #
+            for DscPcd in PlatformPcds:
+                DscPcdEntry = self._PlatformPcds[DscPcd]
+                if DscPcdEntry.Type in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD]:
+                    if not (self.Platform.VpdToolGuid is None or self.Platform.VpdToolGuid == ''):
+                        FoundFlag = False
+                        for VpdPcd in VpdFile._VpdArray:
+                            # This PCD has been referenced by module
+                            if (VpdPcd.TokenSpaceGuidCName == DscPcdEntry.TokenSpaceGuidCName) and \
+                               (VpdPcd.TokenCName == DscPcdEntry.TokenCName):
+                                    FoundFlag = True
+
+                        # Not found, it should be signature
+                        if not FoundFlag :
+                            # just pick the a value to determine whether is unicode string type
+                            SkuValueMap = {}
+                            SkuObjList = list(DscPcdEntry.SkuInfoList.items())
+                            DefaultSku = DscPcdEntry.SkuInfoList.get(TAB_DEFAULT)
+                            if DefaultSku:
+                                defaultindex = SkuObjList.index((TAB_DEFAULT, DefaultSku))
+                                SkuObjList[0], SkuObjList[defaultindex] = SkuObjList[defaultindex], SkuObjList[0]
+                            for (SkuName, Sku) in SkuObjList:
+                                Sku.VpdOffset = Sku.VpdOffset.strip()
+
+                                # Need to iterate DEC pcd information to get the value & datumtype
+                                for eachDec in self.PackageList:
+                                    for DecPcd in eachDec.Pcds:
+                                        DecPcdEntry = eachDec.Pcds[DecPcd]
+                                        if (DecPcdEntry.TokenSpaceGuidCName == DscPcdEntry.TokenSpaceGuidCName) and \
+                                           (DecPcdEntry.TokenCName == DscPcdEntry.TokenCName):
+                                            # Print warning message to let the developer make a determine.
+                                            EdkLogger.warn("build", "Unreferenced vpd pcd used!",
+                                                            File=self.MetaFile, \
+                                                            ExtraData = "PCD: %s.%s used in the DSC file %s is unreferenced." \
+                                                            %(DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName, self.Platform.MetaFile.Path))
+
+                                            DscPcdEntry.DatumType    = DecPcdEntry.DatumType
+                                            DscPcdEntry.DefaultValue = DecPcdEntry.DefaultValue
+                                            DscPcdEntry.TokenValue = DecPcdEntry.TokenValue
+                                            DscPcdEntry.TokenSpaceGuidValue = eachDec.Guids[DecPcdEntry.TokenSpaceGuidCName]
+                                            # Only fix the value while no value provided in DSC file.
+                                            if not Sku.DefaultValue:
+                                                DscPcdEntry.SkuInfoList[list(DscPcdEntry.SkuInfoList.keys())[0]].DefaultValue = DecPcdEntry.DefaultValue
+
+                                if DscPcdEntry not in self._DynamicPcdList:
+                                    self._DynamicPcdList.append(DscPcdEntry)
+                                Sku.VpdOffset = Sku.VpdOffset.strip()
+                                PcdValue = Sku.DefaultValue
+                                if PcdValue == "":
+                                    PcdValue  = DscPcdEntry.DefaultValue
+                                if Sku.VpdOffset != TAB_STAR:
+                                    if PcdValue.startswith("{"):
+                                        Alignment = 8
+                                    elif PcdValue.startswith("L"):
+                                        Alignment = 2
+                                    else:
+                                        Alignment = 1
+                                    try:
+                                        VpdOffset = int(Sku.VpdOffset)
+                                    except:
+                                        try:
+                                            VpdOffset = int(Sku.VpdOffset, 16)
+                                        except:
+                                            EdkLogger.error("build", FORMAT_INVALID, "Invalid offset value %s for PCD %s.%s." % (Sku.VpdOffset, DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName))
+                                    if VpdOffset % Alignment != 0:
+                                        if PcdValue.startswith("{"):
+                                            EdkLogger.warn("build", "The offset value of PCD %s.%s is not 8-byte aligned!" %(DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName), File=self.MetaFile)
+                                        else:
+                                            EdkLogger.error("build", FORMAT_INVALID, 'The offset value of PCD %s.%s should be %s-byte aligned.' % (DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName, Alignment))
+                                if PcdValue not in SkuValueMap:
+                                    SkuValueMap[PcdValue] = []
+                                    VpdFile.Add(DscPcdEntry, SkuName, Sku.VpdOffset)
+                                SkuValueMap[PcdValue].append(Sku)
+                                if not NeedProcessVpdMapFile and Sku.VpdOffset == TAB_STAR:
+                                    NeedProcessVpdMapFile = True
+                            if DscPcdEntry.DatumType == TAB_VOID and PcdValue.startswith("L"):
+                                UnicodePcdArray.add(DscPcdEntry)
+                            elif len(Sku.VariableName) > 0:
+                                HiiPcdArray.add(DscPcdEntry)
+                            else:
+                                OtherPcdArray.add(DscPcdEntry)
+
+                                # if the offset of a VPD is *, then it need to be fixed up by third party tool.
+                            VpdSkuMap[DscPcd] = SkuValueMap
+            if (self.Platform.FlashDefinition is None or self.Platform.FlashDefinition == '') and \
+               VpdFile.GetCount() != 0:
+                EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE,
+                                "Fail to get FLASH_DEFINITION definition in DSC file %s which is required when DSC contains VPD PCD." % str(self.Platform.MetaFile))
+
+            if VpdFile.GetCount() != 0:
+
+                self.FixVpdOffset(VpdFile)
+
+                self.FixVpdOffset(self.UpdateNVStoreMaxSize(VpdFile))
+                PcdNvStoreDfBuffer = [item for item in self._DynamicPcdList if item.TokenCName == "PcdNvStoreDefaultValueBuffer" and item.TokenSpaceGuidCName == "gEfiMdeModulePkgTokenSpaceGuid"]
+                if PcdNvStoreDfBuffer:
+                    PcdName,PcdGuid = PcdNvStoreDfBuffer[0].TokenCName, PcdNvStoreDfBuffer[0].TokenSpaceGuidCName
+                    if (PcdName,PcdGuid) in VpdSkuMap:
+                        DefaultSku = PcdNvStoreDfBuffer[0].SkuInfoList.get(TAB_DEFAULT)
+                        VpdSkuMap[(PcdName,PcdGuid)] = {DefaultSku.DefaultValue:[SkuObj for SkuObj in PcdNvStoreDfBuffer[0].SkuInfoList.values() ]}
+
+                # Process VPD map file generated by third party BPDG tool
+                if NeedProcessVpdMapFile:
+                    VpdMapFilePath = os.path.join(self.BuildDir, TAB_FV_DIRECTORY, "%s.map" % self.Platform.VpdToolGuid)
+                    try:
+                        VpdFile.Read(VpdMapFilePath)
+
+                        # Fixup TAB_STAR offset
+                        for pcd in VpdSkuMap:
+                            vpdinfo = VpdFile.GetVpdInfo(pcd)
+                            if vpdinfo is None:
+                            # just pick the a value to determine whether is unicode string type
+                                continue
+                            for pcdvalue in VpdSkuMap[pcd]:
+                                for sku in VpdSkuMap[pcd][pcdvalue]:
+                                    for item in vpdinfo:
+                                        if item[2] == pcdvalue:
+                                            sku.VpdOffset = item[1]
+                    except:
+                        EdkLogger.error("build", FILE_READ_FAILURE, "Can not find VPD map file %s to fix up VPD offset." % VpdMapFilePath)
+
+            # Delete the DynamicPcdList At the last time enter into this function
+            for Pcd in self._DynamicPcdList:
+                # just pick the a value to determine whether is unicode string type
+                Sku = Pcd.SkuInfoList.get(TAB_DEFAULT)
+                Sku.VpdOffset = Sku.VpdOffset.strip()
+
+                if Pcd.DatumType not in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]:
+                    Pcd.DatumType = TAB_VOID
+
+                PcdValue = Sku.DefaultValue
+                if Pcd.DatumType == TAB_VOID and PcdValue.startswith("L"):
+                    # if found PCD which datum value is unicode string the insert to left size of UnicodeIndex
+                    UnicodePcdArray.add(Pcd)
+                elif len(Sku.VariableName) > 0:
+                    # if found HII type PCD then insert to right of UnicodeIndex
+                    HiiPcdArray.add(Pcd)
+                else:
+                    OtherPcdArray.add(Pcd)
+            del self._DynamicPcdList[:]
+        self._DynamicPcdList.extend(list(UnicodePcdArray))
+        self._DynamicPcdList.extend(list(HiiPcdArray))
+        self._DynamicPcdList.extend(list(OtherPcdArray))
+        self._DynamicPcdList.sort()
+        allskuset = [(SkuName, Sku.SkuId) for pcd in self._DynamicPcdList for (SkuName, Sku) in pcd.SkuInfoList.items()]
+        # Remove duplicate sets in the list
+        allskuset = list(set(allskuset))
+        for pcd in self._DynamicPcdList:
+            if len(pcd.SkuInfoList) == 1:
+                for (SkuName, SkuId) in allskuset:
+                    if isinstance(SkuId, str) and eval(SkuId) == 0 or SkuId == 0:
+                        continue
+                    pcd.SkuInfoList[SkuName] = copy.deepcopy(pcd.SkuInfoList[TAB_DEFAULT])
+                    pcd.SkuInfoList[SkuName].SkuId = SkuId
+                    pcd.SkuInfoList[SkuName].SkuIdName = SkuName
+
+    def FixVpdOffset(self, VpdFile ):
+        FvPath = os.path.join(self.BuildDir, TAB_FV_DIRECTORY)
+        if not os.path.exists(FvPath):
+            try:
+                os.makedirs(FvPath)
+            except:
+                EdkLogger.error("build", FILE_WRITE_FAILURE, "Fail to create FV folder under %s" % self.BuildDir)
+
+        VpdFilePath = os.path.join(FvPath, "%s.txt" % self.Platform.VpdToolGuid)
+
+        if VpdFile.Write(VpdFilePath):
+            # retrieve BPDG tool's path from tool_def.txt according to VPD_TOOL_GUID defined in DSC file.
+            BPDGToolName = None
+            for ToolDef in self.ToolDefinition.values():
+                if TAB_GUID in ToolDef and ToolDef[TAB_GUID] == self.Platform.VpdToolGuid:
+                    if "PATH" not in ToolDef:
+                        EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "PATH attribute was not provided for BPDG guid tool %s in tools_def.txt" % self.Platform.VpdToolGuid)
+                    BPDGToolName = ToolDef["PATH"]
+                    break
+            # Call third party GUID BPDG tool.
+            if BPDGToolName is not None:
+                VpdInfoFile.CallExtenalBPDGTool(BPDGToolName, VpdFilePath)
+            else:
+                EdkLogger.error("Build", FILE_NOT_FOUND, "Fail to find third-party BPDG tool to process VPD PCDs. BPDG Guid tool need to be defined in tools_def.txt and VPD_TOOL_GUID need to be provided in DSC file.")
+
+    ## Return the platform build data object
+    @cached_property
+    def Platform(self):
+        return self.BuildDatabase[self.MetaFile, self.Arch, self.BuildTarget, self.ToolChain]
+
+    ## Return platform name
+    @cached_property
+    def Name(self):
+        return self.Platform.PlatformName
+
+    ## Return the meta file GUID
+    @cached_property
+    def Guid(self):
+        return self.Platform.Guid
+
+    ## Return the platform version
+    @cached_property
+    def Version(self):
+        return self.Platform.Version
+
+    ## Return the FDF file name
+    @cached_property
+    def FdfFile(self):
+        if self.Workspace.FdfFile:
+            RetVal= mws.join(self.WorkspaceDir, self.Workspace.FdfFile)
+        else:
+            RetVal = ''
+        return RetVal
+
+    ## Return the build output directory platform specifies
+    @cached_property
+    def OutputDir(self):
+        return self.Platform.OutputDirectory
+
+    ## Return the directory to store all intermediate and final files built
+    @cached_property
+    def BuildDir(self):
+        if os.path.isabs(self.OutputDir):
+            GlobalData.gBuildDirectory = RetVal = path.join(
+                                        path.abspath(self.OutputDir),
+                                        self.BuildTarget + "_" + self.ToolChain,
+                                        )
+        else:
+            GlobalData.gBuildDirectory = RetVal = path.join(
+                                        self.WorkspaceDir,
+                                        self.OutputDir,
+                                        self.BuildTarget + "_" + self.ToolChain,
+                                        )
+        return RetVal
+
+    ## Return directory of platform makefile
+    #
+    #   @retval     string  Makefile directory
+    #
+    @cached_property
+    def MakeFileDir(self):
+        return path.join(self.BuildDir, self.Arch)
+
+    ## Return build command string
+    #
+    #   @retval     string  Build command string
+    #
+    @cached_property
+    def BuildCommand(self):
+        if "MAKE" in self.EdkIIBuildOption and "PATH" in self.EdkIIBuildOption["MAKE"]:
+            # MAKE_PATH in DSC [BuildOptions] section is higher priority
+            Path = self.EdkIIBuildOption["MAKE"]["PATH"]
+            if Path.startswith('='):
+                Path = Path[1:].strip()
+            RetVal = _SplitOption(Path)
+        elif "MAKE" in self.ToolDefinition and "PATH" in self.ToolDefinition["MAKE"]:
+            RetVal = _SplitOption(self.ToolDefinition["MAKE"]["PATH"])
+        else:
+            return []
+        if "MAKE" in self.ToolDefinition and "FLAGS" in self.ToolDefinition["MAKE"]:
+            NewOption = self.ToolDefinition["MAKE"]["FLAGS"].strip()
+            if NewOption != '':
+                RetVal += _SplitOption(NewOption)
+        if "MAKE" in self.EdkIIBuildOption and "FLAGS" in self.EdkIIBuildOption["MAKE"]:
+            Flags = self.EdkIIBuildOption["MAKE"]["FLAGS"]
+            if Flags.startswith('='):
+                RetVal = [RetVal[0]] + _SplitOption(Flags[1:].strip())
+            else:
+                RetVal = RetVal + _SplitOption(Flags.strip())
+        return RetVal
+
+    ## Compute a tool defintion key priority value in range 0..15
+    #
+    #  TARGET_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE  15
+    #  ******_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE  14
+    #  TARGET_*********_ARCH_COMMANDTYPE_ATTRIBUTE  13
+    #  ******_*********_ARCH_COMMANDTYPE_ATTRIBUTE  12
+    #  TARGET_TOOLCHAIN_****_COMMANDTYPE_ATTRIBUTE  11
+    #  ******_TOOLCHAIN_****_COMMANDTYPE_ATTRIBUTE  10
+    #  TARGET_*********_****_COMMANDTYPE_ATTRIBUTE   9
+    #  ******_*********_****_COMMANDTYPE_ATTRIBUTE   8
+    #  TARGET_TOOLCHAIN_ARCH_***********_ATTRIBUTE   7
+    #  ******_TOOLCHAIN_ARCH_***********_ATTRIBUTE   6
+    #  TARGET_*********_ARCH_***********_ATTRIBUTE   5
+    #  ******_*********_ARCH_***********_ATTRIBUTE   4
+    #  TARGET_TOOLCHAIN_****_***********_ATTRIBUTE   3
+    #  ******_TOOLCHAIN_****_***********_ATTRIBUTE   2
+    #  TARGET_*********_****_***********_ATTRIBUTE   1
+    #  ******_*********_****_***********_ATTRIBUTE   0
+    #
+    def ToolDefinitionPriority (self,Key):
+        KeyList = Key.split('_')
+        Priority = 0
+        for Index in range (0, min(4, len(KeyList))):
+            if KeyList[Index] != '*':
+                Priority += (1 << Index)
+        return Priority
+
+    ## Get tool chain definition
+    #
+    #  Get each tool definition for given tool chain from tools_def.txt and platform
+    #
+    @cached_property
+    def ToolDefinition(self):
+        ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDictionary
+        if TAB_TOD_DEFINES_COMMAND_TYPE not in self.Workspace.ToolDef.ToolsDefTxtDatabase:
+            EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "No tools found in configuration",
+                            ExtraData="[%s]" % self.MetaFile)
+        RetVal = OrderedDict()
+        DllPathList = set()
+
+        PrioritizedDefList = sorted(ToolDefinition.keys(), key=self.ToolDefinitionPriority, reverse=True)
+        for Def in PrioritizedDefList:
+            Target, Tag, Arch, Tool, Attr = Def.split("_")
+            if Target == TAB_STAR:
+                Target = self.BuildTarget
+            if Tag == TAB_STAR:
+                Tag = self.ToolChain
+            if Arch == TAB_STAR:
+                Arch = self.Arch
+            if Target != self.BuildTarget or Tag != self.ToolChain or Arch != self.Arch:
+                continue
+
+            Value = ToolDefinition[Def]
+            # don't record the DLL
+            if Attr == "DLL":
+                DllPathList.add(Value)
+                continue
+
+            #
+            # ToolDefinition is sorted from highest priority to lowest priority.
+            # Only add the first(highest priority) match to RetVal
+            #
+            if Tool not in RetVal:
+                RetVal[Tool] = OrderedDict()
+            if Attr not in RetVal[Tool]:
+                RetVal[Tool][Attr] = Value
+
+        ToolsDef = ''
+        if GlobalData.gOptions.SilentMode and "MAKE" in RetVal:
+            if "FLAGS" not in RetVal["MAKE"]:
+                RetVal["MAKE"]["FLAGS"] = ""
+            RetVal["MAKE"]["FLAGS"] += " -s"
+        MakeFlags = ''
+
+        ToolList = list(RetVal.keys())
+        ToolList.sort()
+        for Tool in ToolList:
+            if Tool == TAB_STAR:
+                continue
+            AttrList = list(RetVal[Tool].keys())
+            if TAB_STAR in ToolList:
+                AttrList += list(RetVal[TAB_STAR])
+            AttrList.sort()
+            for Attr in AttrList:
+                if Attr in RetVal[Tool]:
+                    Value = RetVal[Tool][Attr]
+                else:
+                    Value = RetVal[TAB_STAR][Attr]
+                if Tool in self._BuildOptionWithToolDef(RetVal) and Attr in self._BuildOptionWithToolDef(RetVal)[Tool]:
+                    # check if override is indicated
+                    if self._BuildOptionWithToolDef(RetVal)[Tool][Attr].startswith('='):
+                        Value = self._BuildOptionWithToolDef(RetVal)[Tool][Attr][1:].strip()
+                    else:
+                        # Do not append PATH or GUID
+                        if Attr != 'PATH' and Attr != 'GUID':
+                            Value += " " + self._BuildOptionWithToolDef(RetVal)[Tool][Attr]
+                        else:
+                            Value = self._BuildOptionWithToolDef(RetVal)[Tool][Attr]
+                if Attr == "PATH":
+                    # Don't put MAKE definition in the file
+                    if Tool != "MAKE":
+                        ToolsDef += "%s_%s = %s\n" % (Tool, Attr, Value)
+                elif Attr != "DLL":
+                    # Don't put MAKE definition in the file
+                    if Tool == "MAKE":
+                        if Attr == "FLAGS":
+                            MakeFlags = Value
+                    else:
+                        ToolsDef += "%s_%s = %s\n" % (Tool, Attr, Value)
+            ToolsDef += "\n"
+
+        tool_def_file = os.path.join(self.MakeFileDir, "TOOLS_DEF." + self.Arch)
+        SaveFileOnChange(tool_def_file, ToolsDef, False)
+        for DllPath in DllPathList:
+            os.environ["PATH"] = DllPath + os.pathsep + os.environ["PATH"]
+        os.environ["MAKE_FLAGS"] = MakeFlags
+
+        return RetVal
+
+    ## Return the paths of tools
+    @cached_property
+    def ToolDefinitionFile(self):
+        tool_def_file = os.path.join(self.MakeFileDir, "TOOLS_DEF." + self.Arch)
+        if not os.path.exists(tool_def_file):
+            self.ToolDefinition
+        return tool_def_file
+
+    ## Retrieve the toolchain family of given toolchain tag. Default to 'MSFT'.
+    @cached_property
+    def ToolChainFamily(self):
+        ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDatabase
+        if TAB_TOD_DEFINES_FAMILY not in ToolDefinition \
+           or self.ToolChain not in ToolDefinition[TAB_TOD_DEFINES_FAMILY] \
+           or not ToolDefinition[TAB_TOD_DEFINES_FAMILY][self.ToolChain]:
+            EdkLogger.verbose("No tool chain family found in configuration for %s. Default to MSFT." \
+                               % self.ToolChain)
+            RetVal = TAB_COMPILER_MSFT
+        else:
+            RetVal = ToolDefinition[TAB_TOD_DEFINES_FAMILY][self.ToolChain]
+        return RetVal
+
+    @cached_property
+    def BuildRuleFamily(self):
+        ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDatabase
+        if TAB_TOD_DEFINES_BUILDRULEFAMILY not in ToolDefinition \
+           or self.ToolChain not in ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY] \
+           or not ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY][self.ToolChain]:
+            EdkLogger.verbose("No tool chain family found in configuration for %s. Default to MSFT." \
+                               % self.ToolChain)
+            return TAB_COMPILER_MSFT
+
+        return ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY][self.ToolChain]
+
+    ## Return the build options specific for all modules in this platform
+    @cached_property
+    def BuildOption(self):
+        return self._ExpandBuildOption(self.Platform.BuildOptions)
+
+    def _BuildOptionWithToolDef(self, ToolDef):
+        return self._ExpandBuildOption(self.Platform.BuildOptions, ToolDef=ToolDef)
+
+    ## Return the build options specific for EDK modules in this platform
+    @cached_property
+    def EdkBuildOption(self):
+        return self._ExpandBuildOption(self.Platform.BuildOptions, EDK_NAME)
+
+    ## Return the build options specific for EDKII modules in this platform
+    @cached_property
+    def EdkIIBuildOption(self):
+        return self._ExpandBuildOption(self.Platform.BuildOptions, EDKII_NAME)
+
+    ## Parse build_rule.txt in Conf Directory.
+    #
+    #   @retval     BuildRule object
+    #
+    @cached_property
+    def BuildRule(self):
+        BuildRuleFile = None
+        if TAB_TAT_DEFINES_BUILD_RULE_CONF in self.Workspace.TargetTxt.TargetTxtDictionary:
+            BuildRuleFile = self.Workspace.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_BUILD_RULE_CONF]
+        if not BuildRuleFile:
+            BuildRuleFile = gDefaultBuildRuleFile
+        RetVal = BuildRule(BuildRuleFile)
+        if RetVal._FileVersion == "":
+            RetVal._FileVersion = AutoGenReqBuildRuleVerNum
+        else:
+            if RetVal._FileVersion < AutoGenReqBuildRuleVerNum :
+                # If Build Rule's version is less than the version number required by the tools, halting the build.
+                EdkLogger.error("build", AUTOGEN_ERROR,
+                                ExtraData="The version number [%s] of build_rule.txt is less than the version number required by the AutoGen.(the minimum required version number is [%s])"\
+                                 % (RetVal._FileVersion, AutoGenReqBuildRuleVerNum))
+        return RetVal
+
+    ## Summarize the packages used by modules in this platform
+    @cached_property
+    def PackageList(self):
+        RetVal = set()
+        for Mb in self._MbList:
+            RetVal.update(Mb.Packages)
+            for lb in Mb.LibInstances:
+                RetVal.update(lb.Packages)
+        #Collect package set information from INF of FDF
+        for ModuleFile in self._AsBuildModuleList:
+            if ModuleFile in self.Platform.Modules:
+                continue
+            ModuleData = self.BuildDatabase[ModuleFile, self.Arch, self.BuildTarget, self.ToolChain]
+            RetVal.update(ModuleData.Packages)
+        RetVal.update(self.Platform.Packages)
+        return list(RetVal)
+
+    @cached_property
+    def NonDynamicPcdDict(self):
+        return {(Pcd.TokenCName, Pcd.TokenSpaceGuidCName):Pcd for Pcd in self.NonDynamicPcdList}
+
+    ## Get list of non-dynamic PCDs
+    @property
+    def NonDynamicPcdList(self):
+        if not self._NonDynamicPcdList:
+            self.CollectPlatformDynamicPcds()
+        return self._NonDynamicPcdList
+
+    ## Get list of dynamic PCDs
+    @property
+    def DynamicPcdList(self):
+        if not self._DynamicPcdList:
+            self.CollectPlatformDynamicPcds()
+        return self._DynamicPcdList
+
+    ## Generate Token Number for all PCD
+    @cached_property
+    def PcdTokenNumber(self):
+        RetVal = OrderedDict()
+        TokenNumber = 1
+        #
+        # Make the Dynamic and DynamicEx PCD use within different TokenNumber area.
+        # Such as:
+        #
+        # Dynamic PCD:
+        # TokenNumber 0 ~ 10
+        # DynamicEx PCD:
+        # TokeNumber 11 ~ 20
+        #
+        for Pcd in self.DynamicPcdList:
+            if Pcd.Phase == "PEI" and Pcd.Type in PCD_DYNAMIC_TYPE_SET:
+                EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))
+                RetVal[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber
+                TokenNumber += 1
+
+        for Pcd in self.DynamicPcdList:
+            if Pcd.Phase == "PEI" and Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:
+                EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))
+                RetVal[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber
+                TokenNumber += 1
+
+        for Pcd in self.DynamicPcdList:
+            if Pcd.Phase == "DXE" and Pcd.Type in PCD_DYNAMIC_TYPE_SET:
+                EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))
+                RetVal[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber
+                TokenNumber += 1
+
+        for Pcd in self.DynamicPcdList:
+            if Pcd.Phase == "DXE" and Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:
+                EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))
+                RetVal[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber
+                TokenNumber += 1
+
+        for Pcd in self.NonDynamicPcdList:
+            RetVal[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = 0
+        return RetVal
+
+    @cached_property
+    def _MbList(self):
+        ModuleList = []
+        for m in self.Platform.Modules:
+            component = self.Platform.Modules[m]
+            module = self.BuildDatabase[m, self.Arch, self.BuildTarget, self.ToolChain]
+            module.Guid = component.Guid
+            ModuleList.append(module)
+        return ModuleList
+
+    @cached_property
+    def _MaList(self):
+        for ModuleFile in self.Platform.Modules:
+            Ma = ModuleAutoGen(
+                  self.Workspace,
+                  ModuleFile,
+                  self.BuildTarget,
+                  self.ToolChain,
+                  self.Arch,
+                  self.MetaFile,
+                  self.DataPipe
+                  )
+            self.Platform.Modules[ModuleFile].M = Ma
+        return [x.M for x in self.Platform.Modules.values()]
+
+    ## Summarize ModuleAutoGen objects of all modules to be built for this platform
+    @cached_property
+    def ModuleAutoGenList(self):
+        RetVal = []
+        for Ma in self._MaList:
+            if Ma not in RetVal:
+                RetVal.append(Ma)
+        return RetVal
+
+    ## Summarize ModuleAutoGen objects of all libraries to be built for this platform
+    @cached_property
+    def LibraryAutoGenList(self):
+        RetVal = []
+        for Ma in self._MaList:
+            for La in Ma.LibraryAutoGenList:
+                if La not in RetVal:
+                    RetVal.append(La)
+                if Ma not in La.ReferenceModules:
+                    La.ReferenceModules.append(Ma)
+        return RetVal
+
+    ## Test if a module is supported by the platform
+    #
+    #  An error will be raised directly if the module or its arch is not supported
+    #  by the platform or current configuration
+    #
+    def ValidModule(self, Module):
+        return Module in self.Platform.Modules or Module in self.Platform.LibraryInstances \
+            or Module in self._AsBuildModuleList
+    @cached_property
+    def GetAllModuleInfo(self,WithoutPcd=True):
+        ModuleLibs = set()
+        for m in self.Platform.Modules:
+            module_obj = self.BuildDatabase[m,self.Arch,self.BuildTarget,self.ToolChain]
+            if not bool(module_obj.LibraryClass):
+                Libs = GetModuleLibInstances(module_obj, self.Platform, self.BuildDatabase, self.Arch,self.BuildTarget,self.ToolChain,self.MetaFile,EdkLogger)
+            else:
+                Libs = []
+            ModuleLibs.update( set([(l.MetaFile.File,l.MetaFile.Root,l.MetaFile.Path,l.MetaFile.BaseName,l.MetaFile.OriginalPath,l.Arch,True) for l in Libs]))
+            if WithoutPcd and module_obj.PcdIsDriver:
+                continue
+            ModuleLibs.add((m.File,m.Root,m.Path,m.BaseName,m.OriginalPath,module_obj.Arch,bool(module_obj.LibraryClass)))
+
+        return ModuleLibs
+
+    ## Resolve the library classes in a module to library instances
+    #
+    # This method will not only resolve library classes but also sort the library
+    # instances according to the dependency-ship.
+    #
+    #   @param  Module      The module from which the library classes will be resolved
+    #
+    #   @retval library_list    List of library instances sorted
+    #
+    def ApplyLibraryInstance(self, Module):
+        # Cover the case that the binary INF file is list in the FDF file but not DSC file, return empty list directly
+        if str(Module) not in self.Platform.Modules:
+            return []
+
+        return GetModuleLibInstances(Module,
+                                     self.Platform,
+                                     self.BuildDatabase,
+                                     self.Arch,
+                                     self.BuildTarget,
+                                     self.ToolChain,
+                                     self.MetaFile,
+                                     EdkLogger)
+
+    ## Override PCD setting (type, value, ...)
+    #
+    #   @param  ToPcd       The PCD to be overridden
+    #   @param  FromPcd     The PCD overriding from
+    #
+    def _OverridePcd(self, ToPcd, FromPcd, Module="", Msg="", Library=""):
+        #
+        # in case there's PCDs coming from FDF file, which have no type given.
+        # at this point, ToPcd.Type has the type found from dependent
+        # package
+        #
+        TokenCName = ToPcd.TokenCName
+        for PcdItem in GlobalData.MixedPcd:
+            if (ToPcd.TokenCName, ToPcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:
+                TokenCName = PcdItem[0]
+                break
+        if FromPcd is not None:
+            if ToPcd.Pending and FromPcd.Type:
+                ToPcd.Type = FromPcd.Type
+            elif ToPcd.Type and FromPcd.Type\
+                and ToPcd.Type != FromPcd.Type and ToPcd.Type in FromPcd.Type:
+                if ToPcd.Type.strip() == TAB_PCDS_DYNAMIC_EX:
+                    ToPcd.Type = FromPcd.Type
+            elif ToPcd.Type and FromPcd.Type \
+                and ToPcd.Type != FromPcd.Type:
+                if Library:
+                    Module = str(Module) + " 's library file (" + str(Library) + ")"
+                EdkLogger.error("build", OPTION_CONFLICT, "Mismatched PCD type",
+                                ExtraData="%s.%s is used as [%s] in module %s, but as [%s] in %s."\
+                                          % (ToPcd.TokenSpaceGuidCName, TokenCName,
+                                             ToPcd.Type, Module, FromPcd.Type, Msg),
+                                          File=self.MetaFile)
+
+            if FromPcd.MaxDatumSize:
+                ToPcd.MaxDatumSize = FromPcd.MaxDatumSize
+                ToPcd.MaxSizeUserSet = FromPcd.MaxDatumSize
+            if FromPcd.DefaultValue:
+                ToPcd.DefaultValue = FromPcd.DefaultValue
+            if FromPcd.TokenValue:
+                ToPcd.TokenValue = FromPcd.TokenValue
+            if FromPcd.DatumType:
+                ToPcd.DatumType = FromPcd.DatumType
+            if FromPcd.SkuInfoList:
+                ToPcd.SkuInfoList = FromPcd.SkuInfoList
+            if FromPcd.UserDefinedDefaultStoresFlag:
+                ToPcd.UserDefinedDefaultStoresFlag = FromPcd.UserDefinedDefaultStoresFlag
+            # Add Flexible PCD format parse
+            if ToPcd.DefaultValue:
+                try:
+                    ToPcd.DefaultValue = ValueExpressionEx(ToPcd.DefaultValue, ToPcd.DatumType, self.Platform._GuidDict)(True)
+                except BadExpression as Value:
+                    EdkLogger.error('Parser', FORMAT_INVALID, 'PCD [%s.%s] Value "%s", %s' %(ToPcd.TokenSpaceGuidCName, ToPcd.TokenCName, ToPcd.DefaultValue, Value),
+                                        File=self.MetaFile)
+
+            # check the validation of datum
+            IsValid, Cause = CheckPcdDatum(ToPcd.DatumType, ToPcd.DefaultValue)
+            if not IsValid:
+                EdkLogger.error('build', FORMAT_INVALID, Cause, File=self.MetaFile,
+                                ExtraData="%s.%s" % (ToPcd.TokenSpaceGuidCName, TokenCName))
+            ToPcd.validateranges = FromPcd.validateranges
+            ToPcd.validlists = FromPcd.validlists
+            ToPcd.expressions = FromPcd.expressions
+            ToPcd.CustomAttribute = FromPcd.CustomAttribute
+
+        if FromPcd is not None and ToPcd.DatumType == TAB_VOID and not ToPcd.MaxDatumSize:
+            EdkLogger.debug(EdkLogger.DEBUG_9, "No MaxDatumSize specified for PCD %s.%s" \
+                            % (ToPcd.TokenSpaceGuidCName, TokenCName))
+            Value = ToPcd.DefaultValue
+            if not Value:
+                ToPcd.MaxDatumSize = '1'
+            elif Value[0] == 'L':
+                ToPcd.MaxDatumSize = str((len(Value) - 2) * 2)
+            elif Value[0] == '{':
+                ToPcd.MaxDatumSize = str(len(Value.split(',')))
+            else:
+                ToPcd.MaxDatumSize = str(len(Value) - 1)
+
+        # apply default SKU for dynamic PCDS if specified one is not available
+        if (ToPcd.Type in PCD_DYNAMIC_TYPE_SET or ToPcd.Type in PCD_DYNAMIC_EX_TYPE_SET) \
+            and not ToPcd.SkuInfoList:
+            if self.Platform.SkuName in self.Platform.SkuIds:
+                SkuName = self.Platform.SkuName
+            else:
+                SkuName = TAB_DEFAULT
+            ToPcd.SkuInfoList = {
+                SkuName : SkuInfoClass(SkuName, self.Platform.SkuIds[SkuName][0], '', '', '', '', '', ToPcd.DefaultValue)
+            }
+
+    ## Apply PCD setting defined platform to a module
+    #
+    #   @param  Module  The module from which the PCD setting will be overridden
+    #
+    #   @retval PCD_list    The list PCDs with settings from platform
+    #
+    def ApplyPcdSetting(self, Module, Pcds, Library=""):
+        # for each PCD in module
+        for Name, Guid in Pcds:
+            PcdInModule = Pcds[Name, Guid]
+            # find out the PCD setting in platform
+            if (Name, Guid) in self.Platform.Pcds:
+                PcdInPlatform = self.Platform.Pcds[Name, Guid]
+            else:
+                PcdInPlatform = None
+            # then override the settings if any
+            self._OverridePcd(PcdInModule, PcdInPlatform, Module, Msg="DSC PCD sections", Library=Library)
+            # resolve the VariableGuid value
+            for SkuId in PcdInModule.SkuInfoList:
+                Sku = PcdInModule.SkuInfoList[SkuId]
+                if Sku.VariableGuid == '': continue
+                Sku.VariableGuidValue = GuidValue(Sku.VariableGuid, self.PackageList, self.MetaFile.Path)
+                if Sku.VariableGuidValue is None:
+                    PackageList = "\n\t".join(str(P) for P in self.PackageList)
+                    EdkLogger.error(
+                                'build',
+                                RESOURCE_NOT_AVAILABLE,
+                                "Value of GUID [%s] is not found in" % Sku.VariableGuid,
+                                ExtraData=PackageList + "\n\t(used with %s.%s from module %s)" \
+                                                        % (Guid, Name, str(Module)),
+                                File=self.MetaFile
+                                )
+
+        # override PCD settings with module specific setting
+        if Module in self.Platform.Modules:
+            PlatformModule = self.Platform.Modules[str(Module)]
+            for Key  in PlatformModule.Pcds:
+                if GlobalData.BuildOptionPcd:
+                    for pcd in GlobalData.BuildOptionPcd:
+                        (TokenSpaceGuidCName, TokenCName, FieldName, pcdvalue, _) = pcd
+                        if (TokenCName, TokenSpaceGuidCName) == Key and FieldName =="":
+                            PlatformModule.Pcds[Key].DefaultValue = pcdvalue
+                            PlatformModule.Pcds[Key].PcdValueFromComm = pcdvalue
+                            break
+                Flag = False
+                if Key in Pcds:
+                    ToPcd = Pcds[Key]
+                    Flag = True
+                elif Key in GlobalData.MixedPcd:
+                    for PcdItem in GlobalData.MixedPcd[Key]:
+                        if PcdItem in Pcds:
+                            ToPcd = Pcds[PcdItem]
+                            Flag = True
+                            break
+                if Flag:
+                    self._OverridePcd(ToPcd, PlatformModule.Pcds[Key], Module, Msg="DSC Components Module scoped PCD section", Library=Library)
+        # use PCD value to calculate the MaxDatumSize when it is not specified
+        for Name, Guid in Pcds:
+            Pcd = Pcds[Name, Guid]
+            if Pcd.DatumType == TAB_VOID and not Pcd.MaxDatumSize:
+                Pcd.MaxSizeUserSet = None
+                Value = Pcd.DefaultValue
+                if not Value:
+                    Pcd.MaxDatumSize = '1'
+                elif Value[0] == 'L':
+                    Pcd.MaxDatumSize = str((len(Value) - 2) * 2)
+                elif Value[0] == '{':
+                    Pcd.MaxDatumSize = str(len(Value.split(',')))
+                else:
+                    Pcd.MaxDatumSize = str(len(Value) - 1)
+        return list(Pcds.values())
+
+    ## Append build options in platform to a module
+    #
+    #   @param  Module  The module to which the build options will be appended
+    #
+    #   @retval options     The options appended with build options in platform
+    #
+    def ApplyBuildOption(self, Module):
+        # Get the different options for the different style module
+        PlatformOptions = self.EdkIIBuildOption
+        ModuleTypeOptions = self.Platform.GetBuildOptionsByModuleType(EDKII_NAME, Module.ModuleType)
+        ModuleTypeOptions = self._ExpandBuildOption(ModuleTypeOptions)
+        ModuleOptions = self._ExpandBuildOption(Module.BuildOptions)
+        if Module in self.Platform.Modules:
+            PlatformModule = self.Platform.Modules[str(Module)]
+            PlatformModuleOptions = self._ExpandBuildOption(PlatformModule.BuildOptions)
+        else:
+            PlatformModuleOptions = {}
+
+        BuildRuleOrder = None
+        for Options in [self.ToolDefinition, ModuleOptions, PlatformOptions, ModuleTypeOptions, PlatformModuleOptions]:
+            for Tool in Options:
+                for Attr in Options[Tool]:
+                    if Attr == TAB_TOD_DEFINES_BUILDRULEORDER:
+                        BuildRuleOrder = Options[Tool][Attr]
+
+        AllTools = set(list(ModuleOptions.keys()) + list(PlatformOptions.keys()) +
+                       list(PlatformModuleOptions.keys()) + list(ModuleTypeOptions.keys()) +
+                       list(self.ToolDefinition.keys()))
+        BuildOptions = defaultdict(lambda: defaultdict(str))
+        for Tool in AllTools:
+            for Options in [self.ToolDefinition, ModuleOptions, PlatformOptions, ModuleTypeOptions, PlatformModuleOptions]:
+                if Tool not in Options:
+                    continue
+                for Attr in Options[Tool]:
+                    #
+                    # Do not generate it in Makefile
+                    #
+                    if Attr == TAB_TOD_DEFINES_BUILDRULEORDER:
+                        continue
+                    Value = Options[Tool][Attr]
+                    ToolList = [Tool]
+                    if Tool == TAB_STAR:
+                        ToolList = list(AllTools)
+                        ToolList.remove(TAB_STAR)
+                    for ExpandedTool in ToolList:
+                        # check if override is indicated
+                        if Value.startswith('='):
+                            BuildOptions[ExpandedTool][Attr] = mws.handleWsMacro(Value[1:])
+                        else:
+                            if Attr != 'PATH':
+                                BuildOptions[ExpandedTool][Attr] += " " + mws.handleWsMacro(Value)
+                            else:
+                                BuildOptions[ExpandedTool][Attr] = mws.handleWsMacro(Value)
+
+        return BuildOptions, BuildRuleOrder
+
+
+    def GetGlobalBuildOptions(self,Module):
+        ModuleTypeOptions = self.Platform.GetBuildOptionsByModuleType(EDKII_NAME, Module.ModuleType)
+        ModuleTypeOptions = self._ExpandBuildOption(ModuleTypeOptions)
+
+        if Module in self.Platform.Modules:
+            PlatformModule = self.Platform.Modules[str(Module)]
+            PlatformModuleOptions = self._ExpandBuildOption(PlatformModule.BuildOptions)
+        else:
+            PlatformModuleOptions = {}
+
+        return ModuleTypeOptions,PlatformModuleOptions
+    def ModuleGuid(self,Module):
+        if os.path.basename(Module.MetaFile.File) != os.path.basename(Module.MetaFile.Path):
+            #
+            # Length of GUID is 36
+            #
+            return os.path.basename(Module.MetaFile.Path)[:36]
+        return Module.Guid
+    @cached_property
+    def UniqueBaseName(self):
+        retVal ={}
+        ModuleNameDict = {}
+        UniqueName = {}
+        for Module in self._MbList:
+            unique_base_name = '%s_%s' % (Module.BaseName,self.ModuleGuid(Module))
+            if unique_base_name not in ModuleNameDict:
+                ModuleNameDict[unique_base_name] = []
+            ModuleNameDict[unique_base_name].append(Module.MetaFile)
+            if Module.BaseName not in UniqueName:
+                UniqueName[Module.BaseName] = set()
+            UniqueName[Module.BaseName].add((self.ModuleGuid(Module),Module.MetaFile))
+        for module_paths in ModuleNameDict.values():
+            if len(set(module_paths))>1:
+                samemodules = list(set(module_paths))
+                EdkLogger.error("build", FILE_DUPLICATED, 'Modules have same BaseName and FILE_GUID:\n'
+                                    '  %s\n  %s' % (samemodules[0], samemodules[1]))
+        for name in UniqueName:
+            Guid_Path = UniqueName[name]
+            if len(Guid_Path) > 1:
+                for guid,mpath in Guid_Path:
+                    retVal[(name,mpath)] = '%s_%s' % (name,guid)
+        return retVal
+    ## Expand * in build option key
+    #
+    #   @param  Options     Options to be expanded
+    #   @param  ToolDef     Use specified ToolDef instead of full version.
+    #                       This is needed during initialization to prevent
+    #                       infinite recursion betweeh BuildOptions,
+    #                       ToolDefinition, and this function.
+    #
+    #   @retval options     Options expanded
+    #
+    def _ExpandBuildOption(self, Options, ModuleStyle=None, ToolDef=None):
+        if not ToolDef:
+            ToolDef = self.ToolDefinition
+        BuildOptions = {}
+        FamilyMatch  = False
+        FamilyIsNull = True
+
+        OverrideList = {}
+        #
+        # Construct a list contain the build options which need override.
+        #
+        for Key in Options:
+            #
+            # Key[0] -- tool family
+            # Key[1] -- TARGET_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE
+            #
+            if (Key[0] == self.BuildRuleFamily and
+                (ModuleStyle is None or len(Key) < 3 or (len(Key) > 2 and Key[2] == ModuleStyle))):
+                Target, ToolChain, Arch, CommandType, Attr = Key[1].split('_')
+                if (Target == self.BuildTarget or Target == TAB_STAR) and\
+                    (ToolChain == self.ToolChain or ToolChain == TAB_STAR) and\
+                    (Arch == self.Arch or Arch == TAB_STAR) and\
+                    Options[Key].startswith("="):
+
+                    if OverrideList.get(Key[1]) is not None:
+                        OverrideList.pop(Key[1])
+                    OverrideList[Key[1]] = Options[Key]
+
+        #
+        # Use the highest priority value.
+        #
+        if (len(OverrideList) >= 2):
+            KeyList = list(OverrideList.keys())
+            for Index in range(len(KeyList)):
+                NowKey = KeyList[Index]
+                Target1, ToolChain1, Arch1, CommandType1, Attr1 = NowKey.split("_")
+                for Index1 in range(len(KeyList) - Index - 1):
+                    NextKey = KeyList[Index1 + Index + 1]
+                    #
+                    # Compare two Key, if one is included by another, choose the higher priority one
+                    #
+                    Target2, ToolChain2, Arch2, CommandType2, Attr2 = NextKey.split("_")
+                    if (Target1 == Target2 or Target1 == TAB_STAR or Target2 == TAB_STAR) and\
+                        (ToolChain1 == ToolChain2 or ToolChain1 == TAB_STAR or ToolChain2 == TAB_STAR) and\
+                        (Arch1 == Arch2 or Arch1 == TAB_STAR or Arch2 == TAB_STAR) and\
+                        (CommandType1 == CommandType2 or CommandType1 == TAB_STAR or CommandType2 == TAB_STAR) and\
+                        (Attr1 == Attr2 or Attr1 == TAB_STAR or Attr2 == TAB_STAR):
+
+                        if CalculatePriorityValue(NowKey) > CalculatePriorityValue(NextKey):
+                            if Options.get((self.BuildRuleFamily, NextKey)) is not None:
+                                Options.pop((self.BuildRuleFamily, NextKey))
+                        else:
+                            if Options.get((self.BuildRuleFamily, NowKey)) is not None:
+                                Options.pop((self.BuildRuleFamily, NowKey))
+
+        for Key in Options:
+            if ModuleStyle is not None and len (Key) > 2:
+                # Check Module style is EDK or EDKII.
+                # Only append build option for the matched style module.
+                if ModuleStyle == EDK_NAME and Key[2] != EDK_NAME:
+                    continue
+                elif ModuleStyle == EDKII_NAME and Key[2] != EDKII_NAME:
+                    continue
+            Family = Key[0]
+            Target, Tag, Arch, Tool, Attr = Key[1].split("_")
+            # if tool chain family doesn't match, skip it
+            if Family != "":
+                Found = False
+                if Tool in ToolDef:
+                    FamilyIsNull = False
+                    if TAB_TOD_DEFINES_BUILDRULEFAMILY in ToolDef[Tool]:
+                        if Family == ToolDef[Tool][TAB_TOD_DEFINES_BUILDRULEFAMILY]:
+                            FamilyMatch = True
+                            Found = True
+                if TAB_STAR in ToolDef:
+                    FamilyIsNull = False
+                    if TAB_TOD_DEFINES_BUILDRULEFAMILY in ToolDef[TAB_STAR]:
+                        if Family == ToolDef[TAB_STAR][TAB_TOD_DEFINES_BUILDRULEFAMILY]:
+                            FamilyMatch = True
+                            Found = True
+                if not Found:
+                    continue
+
+            # expand any wildcard
+            if Target == TAB_STAR or Target == self.BuildTarget:
+                if Tag == TAB_STAR or Tag == self.ToolChain:
+                    if Arch == TAB_STAR or Arch == self.Arch:
+                        if Tool not in BuildOptions:
+                            BuildOptions[Tool] = {}
+                        if Attr != "FLAGS" or Attr not in BuildOptions[Tool] or Options[Key].startswith('='):
+                            BuildOptions[Tool][Attr] = Options[Key]
+                        else:
+                            # append options for the same tool except PATH
+                            if Attr != 'PATH':
+                                BuildOptions[Tool][Attr] += " " + Options[Key]
+                            else:
+                                BuildOptions[Tool][Attr] = Options[Key]
+        # Build Option Family has been checked, which need't to be checked again for family.
+        if FamilyMatch or FamilyIsNull:
+            return BuildOptions
+
+        for Key in Options:
+            if ModuleStyle is not None and len (Key) > 2:
+                # Check Module style is EDK or EDKII.
+                # Only append build option for the matched style module.
+                if ModuleStyle == EDK_NAME and Key[2] != EDK_NAME:
+                    continue
+                elif ModuleStyle == EDKII_NAME and Key[2] != EDKII_NAME:
+                    continue
+            Family = Key[0]
+            Target, Tag, Arch, Tool, Attr = Key[1].split("_")
+            # if tool chain family doesn't match, skip it
+            if Family == "":
+                continue
+            # option has been added before
+            Found = False
+            if Tool in ToolDef:
+                if TAB_TOD_DEFINES_FAMILY in ToolDef[Tool]:
+                    if Family == ToolDef[Tool][TAB_TOD_DEFINES_FAMILY]:
+                        Found = True
+            if TAB_STAR in ToolDef:
+                if TAB_TOD_DEFINES_FAMILY in ToolDef[TAB_STAR]:
+                    if Family == ToolDef[TAB_STAR][TAB_TOD_DEFINES_FAMILY]:
+                        Found = True
+            if not Found:
+                continue
+
+            # expand any wildcard
+            if Target == TAB_STAR or Target == self.BuildTarget:
+                if Tag == TAB_STAR or Tag == self.ToolChain:
+                    if Arch == TAB_STAR or Arch == self.Arch:
+                        if Tool not in BuildOptions:
+                            BuildOptions[Tool] = {}
+                        if Attr != "FLAGS" or Attr not in BuildOptions[Tool] or Options[Key].startswith('='):
+                            BuildOptions[Tool][Attr] = Options[Key]
+                        else:
+                            # append options for the same tool except PATH
+                            if Attr != 'PATH':
+                                BuildOptions[Tool][Attr] += " " + Options[Key]
+                            else:
+                                BuildOptions[Tool][Attr] = Options[Key]
+        return BuildOptions