BaseTools: Enable structure pcd in FDF file

Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Bob Feng <bob.c.feng@intel.com>
Cc: Liming Gao <liming.gao@intel.com>
Reviewed-by: Liming Gao <liming.gao@intel.com>

6 files changed, 258 insertions, 21 deletions

diff --git a/BaseTools/Source/Python/AutoGen/AutoGen.py b/BaseTools/Source/Python/AutoGen/AutoGen.py
index 54c6b7330f..289309fff0 100644
--- a/BaseTools/Source/Python/AutoGen/AutoGen.py
+++ b/BaseTools/Source/Python/AutoGen/AutoGen.py
@@ -568,7 +568,7 @@ class WorkspaceAutoGen(AutoGen):
                     DecPcdsKey.add((Pcd[0], Pcd[1], Pcd[2]))

 

             Platform.SkuName = self.SkuId

-            for Name, Guid in PcdSet:

+            for Name, Guid,Fileds in PcdSet:

                 if (Name, Guid) not in DecPcds:

                     EdkLogger.error(

                         'build',

@@ -582,7 +582,6 @@ class WorkspaceAutoGen(AutoGen):
                     if (Name, Guid, TAB_PCDS_FIXED_AT_BUILD) in DecPcdsKey \

                         or (Name, Guid, TAB_PCDS_PATCHABLE_IN_MODULE) in DecPcdsKey \

                         or (Name, Guid, TAB_PCDS_FEATURE_FLAG) in DecPcdsKey:

-                        Platform.AddPcd(Name, Guid, PcdSet[Name, Guid])

                         continue

                     elif (Name, Guid, TAB_PCDS_DYNAMIC) in DecPcdsKey or (Name, Guid, TAB_PCDS_DYNAMIC_EX) in DecPcdsKey:

                         EdkLogger.error(

diff --git a/BaseTools/Source/Python/AutoGen/GenC.py b/BaseTools/Source/Python/AutoGen/GenC.py
index eac41ed9bf..2dca9ffd5b 100644
--- a/BaseTools/Source/Python/AutoGen/GenC.py
+++ b/BaseTools/Source/Python/AutoGen/GenC.py
@@ -890,6 +890,8 @@ def CreateModulePcdCode(Info, AutoGenC, AutoGenH, Pcd):
 

     if Pcd.PcdValueFromComm:

         Pcd.DefaultValue = Pcd.PcdValueFromComm

+    elif Pcd.PcdValueFromFdf:

+        Pcd.DefaultValue = Pcd.PcdValueFromFdf

 

     if Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:

         TokenNumber = int(Pcd.TokenValue, 0)

@@ -1183,6 +1185,8 @@ def CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd):
 

     if Pcd.PcdValueFromComm:

         Pcd.DefaultValue = Pcd.PcdValueFromComm

+    elif Pcd.PcdValueFromFdf:

+        Pcd.DefaultValue = Pcd.PcdValueFromFdf

     #

     # Write PCDs

     #

diff --git a/BaseTools/Source/Python/GenFds/FdfParser.py b/BaseTools/Source/Python/GenFds/FdfParser.py
index 67217c3b89..e2e6df7167 100644
--- a/BaseTools/Source/Python/GenFds/FdfParser.py
+++ b/BaseTools/Source/Python/GenFds/FdfParser.py
@@ -83,13 +83,12 @@ T_CHAR_BACKSLASH, T_CHAR_DOUBLE_QUOTE, T_CHAR_SINGLE_QUOTE, T_CHAR_STAR, T_CHAR_
 SEPERATOR_TUPLE = ('=', '|', ',', '{', '}')

 

 RegionSizePattern = re.compile("\s*(?P<base>(?:0x|0X)?[a-fA-F0-9]+)\s*\|\s*(?P<size>(?:0x|0X)?[a-fA-F0-9]+)\s*")

-RegionSizeGuidPattern = re.compile("\s*(?P<base>\w+\.\w+)\s*\|\s*(?P<size>\w+\.\w+)\s*")

-RegionOffsetPcdPattern = re.compile("\s*(?P<base>\w+\.\w+)\s*$")

+RegionSizeGuidPattern = re.compile("\s*(?P<base>\w+\.\w+[\.\w\[\]]*)\s*\|\s*(?P<size>\w+\.\w+[\.\w\[\]]*)\s*")

+RegionOffsetPcdPattern = re.compile("\s*(?P<base>\w+\.\w+[\.\w\[\]]*)\s*$")

 ShortcutPcdPattern = re.compile("\s*\w+\s*=\s*(?P<value>(?:0x|0X)?[a-fA-F0-9]+)\s*\|\s*(?P<name>\w+\.\w+)\s*")

 BaseAddrValuePattern = re.compile('^0[xX][0-9a-fA-F]+')

 FileExtensionPattern = re.compile(r'([a-zA-Z][a-zA-Z0-9]*)')

 TokenFindPattern = re.compile(r'([a-zA-Z0-9\-]+|\$\(TARGET\)|\*)_([a-zA-Z0-9\-]+|\$\(TOOL_CHAIN_TAG\)|\*)_([a-zA-Z0-9\-]+|\$\(ARCH\)|\*)')

-

 AllIncludeFileList = []

 

 # Get the closest parent

@@ -226,8 +225,9 @@ class FileProfile :
         except:

             EdkLogger.error("FdfParser", FILE_OPEN_FAILURE, ExtraData=FileName)

 

-

+        self.FileName = FileName

         self.PcdDict = {}

+        self.PcdLocalDict = {}

         self.InfList = []

         self.InfDict = {'ArchTBD':[]}

         # ECC will use this Dict and List information

@@ -787,7 +787,7 @@ class FdfParser:
                     continue

                 SetLine = self.CurrentLineNumber - 1

                 SetOffset = self.CurrentOffsetWithinLine - len('SET')

-                PcdPair = self.__GetNextPcdName()

+                PcdPair = self.__GetNextPcdSettings()

                 PcdName = "%s.%s" % (PcdPair[1], PcdPair[0])

                 if not self.__IsToken( "="):

                     raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

@@ -798,6 +798,7 @@ class FdfParser:
                 self.__PcdDict[PcdName] = Value

 

                 self.Profile.PcdDict[PcdPair] = Value

+                self.SetPcdLocalation(PcdPair)

                 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)

                 self.Profile.PcdFileLineDict[PcdPair] = FileLineTuple

 

@@ -1049,6 +1050,29 @@ class FdfParser:
 

         return False

 

+    def __GetNextPcdWord(self):

+        self.__SkipWhiteSpace()

+        if self.__EndOfFile():

+            return False

+

+        TempChar = self.__CurrentChar()

+        StartPos = self.CurrentOffsetWithinLine

+        if (TempChar >= 'a' and TempChar <= 'z') or (TempChar >= 'A' and TempChar <= 'Z') or TempChar == '_' or TempChar == '[' or TempChar == ']':

+            self.__GetOneChar()

+            while not self.__EndOfLine():

+                TempChar = self.__CurrentChar()

+                if (TempChar >= 'a' and TempChar <= 'z') or (TempChar >= 'A' and TempChar <= 'Z') \

+                or (TempChar >= '0' and TempChar <= '9') or TempChar == '_' or TempChar == '-' or TempChar == '[' or TempChar == ']':

+                    self.__GetOneChar()

+

+                else:

+                    break

+

+            self.__Token = self.__CurrentLine()[StartPos : self.CurrentOffsetWithinLine]

+            return True

+

+        return False

+

     ## __GetNextToken() method

     #

     #   Get next token unit before a seperator

@@ -1240,6 +1264,26 @@ class FdfParser:
 

         return (pcdCName, pcdTokenSpaceCName)

 

+    def __GetNextPcdSettings(self):

+        if not self.__GetNextWord():

+            raise Warning("expected format of <PcdTokenSpaceCName>.<PcdCName>", self.FileName, self.CurrentLineNumber)

+        pcdTokenSpaceCName = self.__Token

+

+        if not self.__IsToken( "."):

+            raise Warning("expected format of <PcdTokenSpaceCName>.<PcdCName>", self.FileName, self.CurrentLineNumber)

+

+        if not self.__GetNextWord():

+            raise Warning("expected format of <PcdTokenSpaceCName>.<PcdCName>", self.FileName, self.CurrentLineNumber)

+        pcdCName = self.__Token

+

+        Fields = []

+        while self.__IsToken("."):

+            if not self.__GetNextPcdWord():

+                raise Warning("expected format of <PcdTokenSpaceCName>.<PcdCName>", self.FileName, self.CurrentLineNumber)

+            Fields.append(self.__Token)

+

+        return (pcdCName, pcdTokenSpaceCName,".".join(Fields))

+

     ## __GetStringData() method

     #

     #   Get string contents quoted in ""

@@ -1567,6 +1611,9 @@ class FdfParser:
 

         return True

 

+    def SetPcdLocalation(self,pcdpair):

+        self.Profile.PcdLocalDict[pcdpair] = (self.Profile.FileName,self.CurrentLineNumber)

+

     ## __GetTokenStatements() method

     #

     #   Get token statements

@@ -1585,9 +1632,10 @@ class FdfParser:
             Obj.BaseAddress = self.__Token

 

             if self.__IsToken( "|"):

-                pcdPair = self.__GetNextPcdName()

+                pcdPair = self.__GetNextPcdSettings()

                 Obj.BaseAddressPcd = pcdPair

                 self.Profile.PcdDict[pcdPair] = Obj.BaseAddress

+                self.SetPcdLocalation(pcdPair)

                 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)

                 self.Profile.PcdFileLineDict[pcdPair] = FileLineTuple

             return True

@@ -1601,9 +1649,10 @@ class FdfParser:
 

             Size = self.__Token

             if self.__IsToken( "|"):

-                pcdPair = self.__GetNextPcdName()

+                pcdPair = self.__GetNextPcdSettings()

                 Obj.SizePcd = pcdPair

                 self.Profile.PcdDict[pcdPair] = Size

+                self.SetPcdLocalation(pcdPair)

                 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)

                 self.Profile.PcdFileLineDict[pcdPair] = FileLineTuple

             Obj.Size = long(Size, 0)

@@ -1694,9 +1743,10 @@ class FdfParser:
         BlockSize = self.__Token

         BlockSizePcd = None

         if self.__IsToken( "|"):

-            PcdPair = self.__GetNextPcdName()

+            PcdPair = self.__GetNextPcdSettings()

             BlockSizePcd = PcdPair

             self.Profile.PcdDict[PcdPair] = BlockSize

+            self.SetPcdLocalation(PcdPair)

             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)

             self.Profile.PcdFileLineDict[PcdPair] = FileLineTuple

         BlockSize = long(BlockSize, 0)

@@ -1777,7 +1827,7 @@ class FdfParser:
     #

     def __GetSetStatement(self, Obj):

         if self.__IsKeyword("SET"):

-            PcdPair = self.__GetNextPcdName()

+            PcdPair = self.__GetNextPcdSettings()

 

             if not self.__IsToken( "="):

                 raise Warning("expected '='", self.FileName, self.CurrentLineNumber)

@@ -1788,6 +1838,7 @@ class FdfParser:
             if Obj:

                 Obj.SetVarDict[PcdPair] = Value

             self.Profile.PcdDict[PcdPair] = Value

+            self.SetPcdLocalation(PcdPair)

             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)

             self.Profile.PcdFileLineDict[PcdPair] = FileLineTuple

             return True

@@ -1864,14 +1915,16 @@ class FdfParser:
             IsRegionPcd = (RegionSizeGuidPattern.match(self.__CurrentLine()[self.CurrentOffsetWithinLine:]) or

                            RegionOffsetPcdPattern.match(self.__CurrentLine()[self.CurrentOffsetWithinLine:]))

             if IsRegionPcd:

-                RegionObj.PcdOffset = self.__GetNextPcdName()

+                RegionObj.PcdOffset = self.__GetNextPcdSettings()

                 self.Profile.PcdDict[RegionObj.PcdOffset] = "0x%08X" % (RegionObj.Offset + long(Fd.BaseAddress, 0))

+                self.SetPcdLocalation(RegionObj.PcdOffset)

                 self.__PcdDict['%s.%s' % (RegionObj.PcdOffset[1], RegionObj.PcdOffset[0])] = "0x%x" % RegionObj.Offset

                 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)

                 self.Profile.PcdFileLineDict[RegionObj.PcdOffset] = FileLineTuple

                 if self.__IsToken( "|"):

-                    RegionObj.PcdSize = self.__GetNextPcdName()

+                    RegionObj.PcdSize = self.__GetNextPcdSettings()

                     self.Profile.PcdDict[RegionObj.PcdSize] = "0x%08X" % RegionObj.Size

+                    self.SetPcdLocalation(RegionObj.PcdSize)

                     self.__PcdDict['%s.%s' % (RegionObj.PcdSize[1], RegionObj.PcdSize[0])] = "0x%x" % RegionObj.Size

                     FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)

                     self.Profile.PcdFileLineDict[RegionObj.PcdSize] = FileLineTuple

@@ -2609,7 +2662,7 @@ class FdfParser:
             if self.__Token == 'PCD':

                 if not self.__IsToken( "("):

                     raise Warning("expected '('", self.FileName, self.CurrentLineNumber)

-                PcdPair = self.__GetNextPcdName()

+                PcdPair = self.__GetNextPcdSettings()

                 if not self.__IsToken( ")"):

                     raise Warning("expected ')'", self.FileName, self.CurrentLineNumber)

                 self.__Token = 'PCD('+PcdPair[1]+'.'+PcdPair[0]+')'

@@ -3697,7 +3750,7 @@ class FdfParser:
             if self.__Token == 'PCD':

                 if not self.__IsToken( "("):

                     raise Warning("expected '('", self.FileName, self.CurrentLineNumber)

-                PcdPair = self.__GetNextPcdName()

+                PcdPair = self.__GetNextPcdSettings()

                 if not self.__IsToken( ")"):

                     raise Warning("expected ')'", self.FileName, self.CurrentLineNumber)

                 self.__Token = 'PCD('+PcdPair[1]+'.'+PcdPair[0]+')'

@@ -3971,7 +4024,7 @@ class FdfParser:
                     if self.__Token == 'PCD':

                         if not self.__IsToken( "("):

                             raise Warning("expected '('", self.FileName, self.CurrentLineNumber)

-                        PcdPair = self.__GetNextPcdName()

+                        PcdPair = self.__GetNextPcdSettings()

                         if not self.__IsToken( ")"):

                             raise Warning("expected ')'", self.FileName, self.CurrentLineNumber)

                         self.__Token = 'PCD('+PcdPair[1]+'.'+PcdPair[0]+')'

diff --git a/BaseTools/Source/Python/Workspace/BuildClassObject.py b/BaseTools/Source/Python/Workspace/BuildClassObject.py
index c188b47534..3b47715cbc 100644
--- a/BaseTools/Source/Python/Workspace/BuildClassObject.py
+++ b/BaseTools/Source/Python/Workspace/BuildClassObject.py
@@ -70,7 +70,8 @@ class PcdClassObject(object):
         if IsDsc:

             self.DscDefaultValue = Value

         self.PcdValueFromComm = ""

-        self.DefinitionPosition = ("", "")

+        self.PcdValueFromFdf = ""

+        self.DefinitionPosition = ("","")

 

     ## Get the maximum number of bytes

     def GetPcdMaxSize(self):

@@ -78,6 +79,16 @@ class PcdClassObject(object):
             return MAX_SIZE_TYPE[self.DatumType]

 

         MaxSize = int(self.MaxDatumSize, 10) if self.MaxDatumSize else 0

+        if self.PcdValueFromFdf:

+            if self.PcdValueFromFdf.startswith("{") and self.PcdValueFromFdf.endswith("}"):

+                MaxSize =  max([len(self.PcdValueFromFdf.split(",")),MaxSize])

+            elif self.PcdValueFromFdf.startswith("\"") or self.PcdValueFromFdf.startswith("\'"):

+                MaxSize =  max([len(self.PcdValueFromFdf)-2+1,MaxSize])

+            elif self.PcdValueFromFdf.startswith("L\""):

+                MaxSize =  max([2*(len(self.PcdValueFromFdf)-3+1),MaxSize])

+            else:

+                MaxSize = max([len(self.PcdValueFromFdf),MaxSize])

+

         if self.PcdValueFromComm:

             if self.PcdValueFromComm.startswith("{") and self.PcdValueFromComm.endswith("}"):

                 return max([len(self.PcdValueFromComm.split(",")), MaxSize])

@@ -169,6 +180,7 @@ class StructurePcd(PcdClassObject):
         self.DefaultValueFromDec = ""

         self.ValueChain = set()

         self.PcdFieldValueFromComm = collections.OrderedDict()

+        self.PcdFieldValueFromFdf = collections.OrderedDict()

     def __repr__(self):

         return self.TypeName

 

@@ -216,6 +228,7 @@ class StructurePcd(PcdClassObject):
         self.expressions = PcdObject.expressions if PcdObject.expressions else self.expressions

         self.DscRawValue = PcdObject.DscRawValue if PcdObject.DscRawValue else self.DscRawValue

         self.PcdValueFromComm = PcdObject.PcdValueFromComm if PcdObject.PcdValueFromComm else self.PcdValueFromComm

+        self.PcdValueFromFdf = PcdObject.PcdValueFromFdf if PcdObject.PcdValueFromFdf else self.PcdValueFromFdf

         self.DefinitionPosition = PcdObject.DefinitionPosition if PcdObject.DefinitionPosition else self.DefinitionPosition

         if isinstance(PcdObject, StructurePcd):

             self.StructuredPcdIncludeFile = PcdObject.StructuredPcdIncludeFile if PcdObject.StructuredPcdIncludeFile else self.StructuredPcdIncludeFile

@@ -231,6 +244,7 @@ class StructurePcd(PcdClassObject):
             self.PkgPath = PcdObject.PkgPath if PcdObject.PkgPath else self.PkgPath

             self.ValueChain = PcdObject.ValueChain if PcdObject.ValueChain else self.ValueChain

             self.PcdFieldValueFromComm = PcdObject.PcdFieldValueFromComm if PcdObject.PcdFieldValueFromComm else self.PcdFieldValueFromComm

+            self.PcdFieldValueFromFdf = PcdObject.PcdFieldValueFromFdf if PcdObject.PcdFieldValueFromFdf else self.PcdFieldValueFromFdf

 

 ## LibraryClassObject

 #

diff --git a/BaseTools/Source/Python/Workspace/DscBuildData.py b/BaseTools/Source/Python/Workspace/DscBuildData.py
index 5cc814185e..1db201f3b9 100644
--- a/BaseTools/Source/Python/Workspace/DscBuildData.py
+++ b/BaseTools/Source/Python/Workspace/DscBuildData.py
@@ -1131,7 +1131,8 @@ class DscBuildData(PlatformBuildClassObject):
             self._Pcds.update(self._GetDynamicVpdPcd(MODEL_PCD_DYNAMIC_EX_VPD))

 

             self._Pcds = self.CompletePcdValues(self._Pcds)

-            self._Pcds = self.OverrideByFdfCommOverAll(self._Pcds)

+            self._Pcds = self.OverrideByFdfOverAll(self._Pcds)

+            self._Pcds = self.OverrideByCommOverAll(self._Pcds)

             self._Pcds = self.UpdateStructuredPcds(MODEL_PCD_TYPE_LIST, self._Pcds)

             self._Pcds = self.CompleteHiiPcdsDefaultStores(self._Pcds)

             self._Pcds = self._FilterPcdBySkuUsage(self._Pcds)

@@ -1191,7 +1192,34 @@ class DscBuildData(PlatformBuildClassObject):
         return structure_pcd_data

 

     @staticmethod

-    def OverrideByFdfComm(StruPcds):

+    def OverrideByFdf(StruPcds,workspace):

+        if GlobalData.gFdfParser is None:

+            return StruPcds

+        StructurePcdInFdf = OrderedDict()

+        fdfpcd = GlobalData.gFdfParser.Profile.PcdDict

+        fdfpcdlocation = GlobalData.gFdfParser.Profile.PcdLocalDict

+        for item in fdfpcd :

+            if len(item[2]) and (item[0],item[1]) in StruPcds:

+                StructurePcdInFdf[(item[1],item[0],item[2] )] = fdfpcd[item]

+        GlobalPcds = {(item[0],item[1]) for item in StructurePcdInFdf}

+        for Pcd in StruPcds.values():

+            if (Pcd.TokenSpaceGuidCName,Pcd.TokenCName) not in GlobalPcds:

+                continue

+            FieldValues = OrderedDict()

+            for item in StructurePcdInFdf:

+                if (Pcd.TokenSpaceGuidCName,Pcd.TokenCName) == (item[0],item[1]) and item[2]:

+                    FieldValues[item[2]] = StructurePcdInFdf[item]

+            for field in FieldValues:

+                if field not in Pcd.PcdFieldValueFromFdf:

+                    Pcd.PcdFieldValueFromFdf[field] = ["","",""]

+                Pcd.PcdFieldValueFromFdf[field][0] = FieldValues[field]

+                Pcd.PcdFieldValueFromFdf[field][1] = os.path.relpath(fdfpcdlocation[(Pcd.TokenCName,Pcd.TokenSpaceGuidCName,field)][0],workspace)

+                Pcd.PcdFieldValueFromFdf[field][2] = fdfpcdlocation[(Pcd.TokenCName,Pcd.TokenSpaceGuidCName,field)][1]

+

+        return StruPcds

+

+    @staticmethod

+    def OverrideByComm(StruPcds):

         StructurePcdInCom = OrderedDict()

         for item in GlobalData.BuildOptionPcd:

             if len(item) == 5 and (item[1], item[0]) in StruPcds:

@@ -1212,7 +1240,8 @@ class DscBuildData(PlatformBuildClassObject):
                 Pcd.PcdFieldValueFromComm[field][2] = FieldValues[field][1][1]

         return StruPcds

 

-    def OverrideByFdfCommOverAll(self, AllPcds):

+

+    def OverrideByCommOverAll(self,AllPcds):

         def CheckStructureInComm(commpcds):

             if not commpcds:

                 return False

@@ -1259,6 +1288,50 @@ class DscBuildData(PlatformBuildClassObject):
                         self.Pcds[Name, Guid] = copy.deepcopy(PcdInDec)

                         self.Pcds[Name, Guid].DefaultValue = NoFiledValues[( Guid, Name)][0]

         return AllPcds

+

+    def OverrideByFdfOverAll(self,AllPcds):

+

+        if GlobalData.gFdfParser is None:

+            return AllPcds

+        NoFiledValues = GlobalData.gFdfParser.Profile.PcdDict

+        for Guid,Name,Field in NoFiledValues:

+            if len(Field):

+                continue

+            Value = NoFiledValues[(Guid,Name,Field)]

+            if (Name,Guid) in AllPcds:

+                Pcd = AllPcds.get((Name,Guid))

+                if isinstance(self._DecPcds.get((Pcd.TokenCName,Pcd.TokenSpaceGuidCName), None),StructurePcd):

+                    self._DecPcds.get((Pcd.TokenCName,Pcd.TokenSpaceGuidCName)).PcdValueFromComm = Value

+                else:

+                    Pcd.PcdValueFromComm = Value

+                    Pcd.DefaultValue = Value

+                    for sku in Pcd.SkuInfoList:

+                        SkuInfo = Pcd.SkuInfoList[sku]

+                        if SkuInfo.DefaultValue:

+                            SkuInfo.DefaultValue = Value

+                        else:

+                            SkuInfo.HiiDefaultValue = Value

+                            for defaultstore in SkuInfo.DefaultStoreDict:

+                                SkuInfo.DefaultStoreDict[defaultstore] = Value

+                    if Pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII]]:

+                        if Pcd.DatumType == TAB_VOID:

+                            if not Pcd.MaxDatumSize:

+                                Pcd.MaxDatumSize = '0'

+                            CurrentSize = int(Pcd.MaxDatumSize,16) if Pcd.MaxDatumSize.upper().startswith("0X") else int(Pcd.MaxDatumSize)

+                            OptionSize = len((StringToArray(Pcd.PcdValueFromComm)).split(","))

+                            MaxSize = max(CurrentSize, OptionSize)

+                            Pcd.MaxDatumSize = str(MaxSize)

+            else:

+                PcdInDec = self.DecPcds.get((Name,Guid))

+                if PcdInDec:

+                    PcdInDec.PcdValueFromComm = Value

+                    if PcdInDec.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],

+                                        self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE],

+                                        self._PCD_TYPE_STRING_[MODEL_PCD_FEATURE_FLAG]]:

+                        self.Pcds[Name, Guid] = copy.deepcopy(PcdInDec)

+                        self.Pcds[Name, Guid].DefaultValue = Value

+        return AllPcds

+

     def UpdateStructuredPcds(self, TypeList, AllPcds):

 

         DynamicPcdType = [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_DEFAULT],

@@ -1368,7 +1441,8 @@ class DscBuildData(PlatformBuildClassObject):
                         if defaultstoreid not in stru_pcd.SkuOverrideValues[skuid]:

                             stru_pcd.SkuOverrideValues[skuid][defaultstoreid] = copy.deepcopy(stru_pcd.SkuOverrideValues[nextskuid][mindefaultstorename])

                             stru_pcd.ValueChain.add((skuid, defaultstoreid))

-        S_pcd_set = DscBuildData.OverrideByFdfComm(S_pcd_set)

+        S_pcd_set = DscBuildData.OverrideByFdf(S_pcd_set,self.WorkspaceDir)

+        S_pcd_set = DscBuildData.OverrideByComm(S_pcd_set)

         Str_Pcd_Values = self.GenerateByteArrayValue(S_pcd_set)

         if Str_Pcd_Values:

             for (skuname, StoreName, PcdGuid, PcdName, PcdValue) in Str_Pcd_Values:

@@ -1594,6 +1668,30 @@ class DscBuildData(PlatformBuildClassObject):
                             while '[' in FieldName:

                                 FieldName = FieldName.rsplit('[', 1)[0]

                                 CApp = CApp + '  __FLEXIBLE_SIZE(*Size, %s, %s, %d); // From %s Line %d Value %s \n' % (Pcd.DatumType, FieldName.strip("."), ArrayIndex + 1, FieldList[FieldName_ori][1], FieldList[FieldName_ori][2], FieldList[FieldName_ori][0])

+        if Pcd.PcdFieldValueFromFdf:

+            CApp = CApp + "// From fdf \n"

+        for FieldName in Pcd.PcdFieldValueFromFdf:

+            FieldName = "." + FieldName

+            IsArray = IsFieldValueAnArray(Pcd.PcdFieldValueFromFdf[FieldName.strip(".")][0])

+            if IsArray and not (Pcd.PcdFieldValueFromFdf[FieldName.strip(".")][0].startswith('{GUID') and Pcd.PcdFieldValueFromFdf[FieldName.strip(".")][0].endswith('}')):

+                try:

+                    Value = ValueExpressionEx(Pcd.PcdFieldValueFromFdf[FieldName.strip(".")][0], TAB_VOID, self._GuidDict)(True)

+                except BadExpression:

+                    EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %

+                                    (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName.strip('.'))), Pcd.PcdFieldValueFromFdf[FieldName.strip(".")][1], Pcd.PcdFieldValueFromFdf[FieldName.strip(".")][2]))

+                Value, ValueSize = ParseFieldValue(Value)

+                CApp = CApp + '  __FLEXIBLE_SIZE(*Size, %s, %s, %d / __ARRAY_ELEMENT_SIZE(%s, %s) + ((%d %% __ARRAY_ELEMENT_SIZE(%s, %s)) ? 1 : 0)); // From %s Line %d Value %s\n' % (Pcd.DatumType, FieldName.strip("."), ValueSize, Pcd.DatumType, FieldName.strip("."), ValueSize, Pcd.DatumType, FieldName.strip("."), Pcd.PcdFieldValueFromFdf[FieldName.strip(".")][1], Pcd.PcdFieldValueFromFdf[FieldName.strip(".")][2], Pcd.PcdFieldValueFromFdf[FieldName.strip(".")][0]);

+            else:

+                NewFieldName = ''

+                FieldName_ori = FieldName.strip('.')

+                while '[' in  FieldName:

+                    NewFieldName = NewFieldName + FieldName.split('[', 1)[0] + '[0]'

+                    ArrayIndex = int(FieldName.split('[', 1)[1].split(']', 1)[0])

+                    FieldName = FieldName.split(']', 1)[1]

+                FieldName = NewFieldName + FieldName

+                while '[' in FieldName:

+                    FieldName = FieldName.rsplit('[', 1)[0]

+                    CApp = CApp + '  __FLEXIBLE_SIZE(*Size, %s, %s, %d); // From %s Line %s Value %s \n' % (Pcd.DatumType, FieldName.strip("."), ArrayIndex + 1, Pcd.PcdFieldValueFromFdf[FieldName_ori][1], Pcd.PcdFieldValueFromFdf[FieldName_ori][2], Pcd.PcdFieldValueFromFdf[FieldName_ori][0])

         if Pcd.PcdFieldValueFromComm:

             CApp = CApp + "// From Command Line \n"

         for FieldName in Pcd.PcdFieldValueFromComm:

@@ -1835,6 +1933,70 @@ class DscBuildData(PlatformBuildClassObject):
     def GenerateCommandLineValueStatement(Pcd):

         CApp = '  Assign_%s_%s_CommandLine_Value(Pcd);\n' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName)

         return CApp

+    def GenerateFdfValue(self,Pcd):

+        CApp = "// Value in Fdf\n"

+        CApp = CApp + "void Assign_%s_%s_Fdf_Value(%s *Pcd){\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName,Pcd.DatumType)

+        CApp = CApp + '  UINT32  FieldSize;\n'

+        CApp = CApp + '  CHAR8   *Value;\n'

+

+        pcddefaultvalue = Pcd.PcdValueFromFdf

+        for FieldList in [pcddefaultvalue,Pcd.PcdFieldValueFromFdf]:

+            if not FieldList:

+                continue

+            if pcddefaultvalue and FieldList == pcddefaultvalue:

+                IsArray = IsFieldValueAnArray(FieldList)

+                if IsArray:

+                    try:

+                        FieldList = ValueExpressionEx(FieldList, TAB_VOID)(True)

+                    except BadExpression:

+                        EdkLogger.error("Build", FORMAT_INVALID, "Invalid value format for %s.%s, from Fdf: %s" %

+                                        (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldList))

+                Value, ValueSize = ParseFieldValue (FieldList)

+

+                if isinstance(Value, str):

+                    CApp = CApp + '  Pcd = %s; // From Fdf \n' % (Value)

+                elif IsArray:

+                #

+                # Use memcpy() to copy value into field

+                #

+                    CApp = CApp + '  Value     = %s; // From Fdf .\n' % (DscBuildData.IntToCString(Value, ValueSize))

+                    CApp = CApp + '  memcpy (Pcd, Value, %d);\n' % (ValueSize)

+                continue

+            for FieldName in FieldList:

+                IsArray = IsFieldValueAnArray(FieldList[FieldName][0])

+                if IsArray:

+                    try:

+                        FieldList[FieldName][0] = ValueExpressionEx(FieldList[FieldName][0], TAB_VOID, self._GuidDict)(True)

+                    except BadExpression:

+                        EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %

+                                        (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName)), FieldList[FieldName][1], FieldList[FieldName][2]))

+                    except:

+                        print("error")

+                try:

+                    Value, ValueSize = ParseFieldValue (FieldList[FieldName][0])

+                except Exception:

+                    EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " % (".".join((Pcd.TokenSpaceGuidCName,Pcd.TokenCName,FieldName)),FieldList[FieldName][1], FieldList[FieldName][2]))

+                if isinstance(Value, str):

+                    CApp = CApp + '  Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])

+                elif IsArray:

+                #

+                # Use memcpy() to copy value into field

+                #

+                    CApp = CApp + '  FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd.DatumType, FieldName)

+                    CApp = CApp + '  Value     = %s; // From %s Line %d Value %s\n' % (DscBuildData.IntToCString(Value, ValueSize), FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])

+                    CApp = CApp + '  memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName, ValueSize, ValueSize)

+                else:

+                    if ValueSize > 4:

+                        CApp = CApp + '  Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])

+                    else:

+                        CApp = CApp + '  Pcd->%s = %d; // From %s Line %s Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])

+        CApp = CApp + "}\n"

+        return CApp

+

+    @staticmethod

+    def GenerateFdfValueStatement(Pcd):

+        CApp = '  Assign_%s_%s_Fdf_Value(Pcd);\n' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName)

+        return CApp

 

     def GenerateInitializeFunc(self, SkuName, DefaultStore, Pcd, InitByteValue, CApp):

         OverrideValues = {DefaultStore:""}

@@ -1907,6 +2069,7 @@ class DscBuildData(PlatformBuildClassObject):
             else:

                 CApp = CApp + "// SkuName: %s,  DefaultStoreName: STANDARD \n" % self.SkuIdMgr.SystemSkuId

                 CApp = CApp + DscBuildData.GenerateInitValueStatement(Pcd, self.SkuIdMgr.SystemSkuId, TAB_DEFAULT_STORES_DEFAULT)

+            CApp = CApp + DscBuildData.GenerateFdfValueStatement(Pcd)

             CApp = CApp + DscBuildData.GenerateCommandLineValueStatement(Pcd)

             #

             # Set new PCD value and size

@@ -1943,6 +2106,7 @@ class DscBuildData(PlatformBuildClassObject):
             Pcd = StructuredPcds[PcdName]

             CApp = CApp + self.GenerateSizeFunction(Pcd)

             CApp = CApp + self.GenerateDefaultValueAssignFunction(Pcd)

+            CApp = CApp + self.GenerateFdfValue(Pcd)

             CApp = CApp + self.GenerateCommandLineValue(Pcd)

             if not Pcd.SkuOverrideValues or Pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],

                         self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:

diff --git a/BaseTools/Source/Python/build/BuildReport.py b/BaseTools/Source/Python/build/BuildReport.py
index 1555ec3c21..273e7d41b8 100644
--- a/BaseTools/Source/Python/build/BuildReport.py
+++ b/BaseTools/Source/Python/build/BuildReport.py
@@ -1331,6 +1331,9 @@ class PcdReport(object):
             for Key, Values in OverrideStruct.items():

                 if Values[1] and Values[1].endswith('.dsc'):

                     OverrideFieldStruct[Key] = Values

+        if Pcd.PcdFieldValueFromFdf:

+            for Key, Values in Pcd.PcdFieldValueFromFdf.items():

+                OverrideFieldStruct[Key] = Values

         if Pcd.PcdFieldValueFromComm:

             for Key, Values in Pcd.PcdFieldValueFromComm.items():

                 OverrideFieldStruct[Key] = Values