Enhance VfrCompiler to parse following case:
1. EFI VarStore can contain bit fields in their structure.
2. For question Oneof/Checkbox/numeric, their storage can be
   bit fields of an EFI VarStore.

Cc: Eric Dong <eric.d...@intel.com>
Cc: Liming Gao <liming....@intel.com>
Cc: Dandan Bi <dandan...@intel.com>
Contributed-under: TianoCore Contribution Agreement 1.0
Signed-off-by: Dandan Bi <dandan...@intel.com>
---
 BaseTools/Source/C/VfrCompile/VfrFormPkg.h      |  14 +-
 BaseTools/Source/C/VfrCompile/VfrSyntax.g       | 505 +++++++++++++++++++-----
 BaseTools/Source/C/VfrCompile/VfrUtilityLib.cpp | 406 ++++++++++++++++++-
 BaseTools/Source/C/VfrCompile/VfrUtilityLib.h   |  25 +-
 4 files changed, 825 insertions(+), 125 deletions(-)

diff --git a/BaseTools/Source/C/VfrCompile/VfrFormPkg.h 
b/BaseTools/Source/C/VfrCompile/VfrFormPkg.h
index 17ab14c..18c2afb 100644
--- a/BaseTools/Source/C/VfrCompile/VfrFormPkg.h
+++ b/BaseTools/Source/C/VfrCompile/VfrFormPkg.h
@@ -1,10 +1,10 @@
 /** @file
   
   The definition of CFormPkg's member function
 
-Copyright (c) 2004 - 2016, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2017, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials                          
 are licensed and made available under the terms and conditions of the BSD 
License         
 which accompanies this distribution.  The full text of the license may be 
found at        
 http://opensource.org/licenses/bsd-license.php                                 
           
                                                                                
           
@@ -565,12 +565,16 @@ public:
       }
     }
     mMinMaxStepData->u8.Step = Step;
   }
 
-  UINT64 GetMinData (UINT8 VarType) {
+  UINT64 GetMinData (UINT8 VarType, BOOLEAN IsBitVar) {
     UINT64 MinValue = 0;
+    if (IsBitVar) {
+      MinValue = mMinMaxStepData->u32.MinValue;
+      return MinValue;
+    }
     switch (VarType) {
     case EFI_IFR_TYPE_NUM_SIZE_64:
       MinValue = mMinMaxStepData->u64.MinValue;
       break;
     case EFI_IFR_TYPE_NUM_SIZE_32:
@@ -586,12 +590,16 @@ public:
       break;
     }
     return MinValue;
   }
 
-  UINT64 GetMaxData (UINT8 VarType) {
+  UINT64 GetMaxData (UINT8 VarType, BOOLEAN IsBitVar) {
     UINT64 MaxValue = 0;
+    if (IsBitVar) {
+      MaxValue = mMinMaxStepData->u32.MaxValue;
+      return MaxValue;
+    }
     switch (VarType) {
     case EFI_IFR_TYPE_NUM_SIZE_64:
       MaxValue = mMinMaxStepData->u64.MaxValue;
       break;
     case EFI_IFR_TYPE_NUM_SIZE_32:
diff --git a/BaseTools/Source/C/VfrCompile/VfrSyntax.g 
b/BaseTools/Source/C/VfrCompile/VfrSyntax.g
index 406dbc5..b13b6d0 100644
--- a/BaseTools/Source/C/VfrCompile/VfrSyntax.g
+++ b/BaseTools/Source/C/VfrCompile/VfrSyntax.g
@@ -344,11 +344,15 @@ vfrDataStructFields :
      dataStructFieldBool   |
      dataStructFieldString |
      dataStructFieldDate   |
      dataStructFieldTime   |
      dataStructFieldRef    |
-     dataStructFieldUser
+     dataStructFieldUser   |
+     vfr64BitsStructField  |
+     vfr32BitsStructField  |
+     vfr16BitsStructField  |
+     vfr8BitsStructField
   )*
   ;
 
 dataStructField64 :
   << UINT32 ArrayNum = 0; >>
@@ -450,10 +454,50 @@ dataStructFieldUser :
     OpenBracket I:Number CloseBracket               << ArrayNum = 
_STOU32(I->getText(), I->getLine()); >>
   }
   ";"                                               << 
_PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), T->getText(), 
ArrayNum), T); >>
   ;
 
+vfr64BitsStructField:
+  << UINT32 Width = 0;>>
+  D:"UINT64"
+  N:StringIdentifier
+  {
+    ":" I:Number              << Width = _STOU32(I->getText(), I->getLine());>>
+  }
+  ";"                         << 
_PCATCH(gCVfrVarDataTypeDB.DataTypeAddBitField (N->getText(), D->getText(), 
Width), N); >>
+  ;
+
+vfr32BitsStructField:
+  << UINT32 Width = 0;>>
+  D:"UINT32"
+  N:StringIdentifier
+  {
+    ":" I:Number              << Width = _STOU32(I->getText(), I->getLine());>>
+  }
+  ";"                         << 
_PCATCH(gCVfrVarDataTypeDB.DataTypeAddBitField (N->getText(), D->getText(),  
Width), N); >>
+  ;
+
+vfr16BitsStructField:
+  << UINT32 Width = 0;>>
+  D:"UINT16"
+  N:StringIdentifier
+  {
+    ":" I:Number              << Width = _STOU32(I->getText(), I->getLine());>>
+  }
+  ";"                         << 
_PCATCH(gCVfrVarDataTypeDB.DataTypeAddBitField (N->getText(), D->getText(),  
Width), N); >>
+  ;
+
+vfr8BitsStructField:
+  << UINT32 Width = 0;>>
+  D:"UINT8"
+  N:StringIdentifier
+  {
+    ":" I:Number              << Width = _STOU32(I->getText(), I->getLine());>>
+  }
+  ";"                         << 
_PCATCH(gCVfrVarDataTypeDB.DataTypeAddBitField (N->getText(), D->getText(), 
Width), N); >>
+  ;
+
 //*****************************************************************************
 //
 // the syntax of GUID definition
 //
 guidSubDefinition [EFI_GUID &Guid] :
@@ -921,10 +965,11 @@ vfrStatementVarStoreEfi :
      UINT32          Size;
      CHAR8           *TypeName;
      UINT32          LineNum;
      CHAR8           *StoreName = NULL;
      BOOLEAN         CustomizedName = FALSE;
+     BOOLEAN         IsBitVarStore = FALSE;
   >>
   E:Efivarstore                                     << 
VSEObj.SetLineNo(E->getLine()); >>
   (
       TN:StringIdentifier ","                       << TypeName = 
TN->getText(); LineNum = TN->getLine(); CustomizedName = TRUE; >>
     | U8:"UINT8" ","                                << TypeName = 
U8->getText(); LineNum = U8->getLine(); >>
@@ -934,10 +979,11 @@ vfrStatementVarStoreEfi :
     | U64:"UINT64" ","                              << TypeName = 
U64->getText(); LineNum = U64->getLine(); >>
     | D:"EFI_HII_DATE" ","                          << TypeName = 
D->getText(); LineNum = D->getLine(); >>
     | T:"EFI_HII_TIME" ","                          << TypeName = 
T->getText(); LineNum = T->getLine(); >>
     | R:"EFI_HII_REF" ","                           << TypeName = 
R->getText(); LineNum = R->getLine(); >>    
   )
+  << IsBitVarStore = gCVfrVarDataTypeDB.DataTypeHasBitField (TN->getText());>>
   {
     VarId "=" ID:Number ","                         <<
                                                        _PCATCH(
                                                          (INTN)(VarStoreId = 
_STOU16(ID->getText(), ID->getLine())) != 0,
                                                          (INTN)TRUE,
@@ -984,17 +1030,27 @@ vfrStatementVarStoreEfi :
                                                     >>
   )
 
   Uuid "=" guidDefinition[Guid]                     << 
                                                        if 
(IsUEFI23EfiVarstore) {
-                                                       
_PCATCH(gCVfrDataStorage.DeclareBufferVarStore (
-                                                                               
   StoreName,
-                                                                               
   &Guid,
-                                                                               
   &gCVfrVarDataTypeDB,
-                                                                               
   TypeName,
-                                                                               
   VarStoreId
-                                                                               
   ), LineNum);                                                        
+                                                        if (IsBitVarStore) {
+                                                          
_PCATCH(gCVfrDataStorage.DeclareBitsBufferVarStore (
+                                                                               
     StoreName,
+                                                                               
     &Guid,
+                                                                               
     &gCVfrVarDataTypeDB,
+                                                                               
     TypeName,
+                                                                               
     VarStoreId
+                                                                               
     ), LineNum);
+                                                        } else {
+                                                          
_PCATCH(gCVfrDataStorage.DeclareBufferVarStore (
+                                                                               
     StoreName,
+                                                                               
     &Guid,
+                                                                               
     &gCVfrVarDataTypeDB,
+                                                                               
     TypeName,
+                                                                               
     VarStoreId
+                                                                               
     ), LineNum);
+                                                        }
                                                          
_PCATCH(gCVfrDataStorage.GetVarStoreId(StoreName, &VarStoreId, &Guid), SN);
                                                          
_PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize(TypeName, &Size), LineNum);
                                                        } else {
                                                         
_PCATCH(gCVfrDataStorage.DeclareBufferVarStore (
                                                                                
   TN->getText(),
@@ -1129,10 +1185,11 @@ vfrQuestionHeader[CIfrQuestionHeader & QHObj, 
EFI_QUESION_TYPE QType = QUESTION_
      EFI_VARSTORE_INFO Info;
      Info.mVarType               = EFI_IFR_TYPE_OTHER;
      Info.mVarTotalSize          = 0;
      Info.mInfo.mVarOffset       = EFI_VAROFFSET_INVALID;
      Info.mVarStoreId            = EFI_VARSTORE_ID_INVALID;
+     Info.mIsBitVar              = FALSE;
      EFI_QUESTION_ID   QId       = EFI_QUESTION_ID_INVALID;
      CHAR8             *QName    = NULL;
      CHAR8             *VarIdStr = NULL;
      mUsedDefaultCount           = 0;
   >>
@@ -1185,10 +1242,62 @@ vfrQuestionHeader[CIfrQuestionHeader & QHObj, 
EFI_QUESION_TYPE QType = QUESTION_
                                                        }
                                                        _SAVE_CURRQEST_VARINFO 
(Info);
                                                     >>
   ;
 
+ vfrQuestionBaseInfo[EFI_VARSTORE_INFO & Info, EFI_QUESTION_ID & 
QId,EFI_QUESION_TYPE QType = QUESTION_NORMAL]:
+  <<
+     CHAR8             *QName    = NULL;
+     CHAR8             *VarIdStr = NULL;
+     mUsedDefaultCount           = 0;
+  >>
+  {
+    Name "=" QN:StringIdentifier ","                <<
+                                                       QName = QN->getText();
+                                                       
_PCATCH(mCVfrQuestionDB.FindQuestion (QName), VFR_RETURN_UNDEFINED, QN, "has 
already been used please used anther name");
+                                                    >>
+  }
+  { V:VarId "=" vfrStorageVarId[Info, VarIdStr] "," }
+  {
+    QuestionId "=" ID:Number ","                    <<
+                                                       QId = 
_STOQID(ID->getText(), ID->getLine());
+                                                       
_PCATCH(mCVfrQuestionDB.FindQuestion (QId), VFR_RETURN_UNDEFINED, ID, "has 
already been used please assign another number");
+                                                    >>
+  }
+                                                    <<
+                                                       switch (QType) {
+                                                       case QUESTION_NORMAL:
+                                                         
mCVfrQuestionDB.RegisterQuestion (QName, VarIdStr, QId);
+                                                         break;
+                                                       case QUESTION_DATE:
+                                                         
mCVfrQuestionDB.RegisterNewDateQuestion (QName, VarIdStr, QId);
+                                                         break;
+                                                       case QUESTION_TIME:
+                                                         
mCVfrQuestionDB.RegisterNewTimeQuestion (QName, VarIdStr, QId);
+                                                         break;
+                                                       case QUESTION_REF:
+                                                         //
+                                                         // VarIdStr != NULL 
stand for question with storagae.
+                                                         //
+                                                         if (VarIdStr != NULL) 
{
+                                                           
mCVfrQuestionDB.RegisterRefQuestion (QName, VarIdStr, QId);
+                                                         } else {
+                                                           
mCVfrQuestionDB.RegisterQuestion (QName, NULL, QId);
+                                                         }
+                                                         break;
+                                                       default:
+                                                       
_PCATCH(VFR_RETURN_FATAL_ERROR);
+                                                       }
+                                                    >>
+                                                    << 
+                                                       if (VarIdStr != NULL) {
+                                                         delete VarIdStr; 
+                                                       }
+                                                       _SAVE_CURRQEST_VARINFO 
(Info);
+                                                    >>
+  ;
+
 questionheaderFlagsField[UINT8 & Flags] :
     ReadOnlyFlag                                    << $Flags |= 0x01; >>
   | InteractiveFlag                                 << $Flags |= 0x04; >>
   | ResetRequiredFlag                               << $Flags |= 0x10; >>
   | ReconnectRequiredFlag                           << $Flags |= 0x40; >>
@@ -1233,10 +1342,11 @@ vfrStorageVarId[EFI_VARSTORE_INFO & Info, CHAR8 
*&QuestVarIdStr, BOOLEAN CheckFl
      CHAR8                 *SName       = NULL;
      CHAR8                 *TName       = NULL;
      EFI_VFR_RETURN_CODE   VfrReturnCode = VFR_RETURN_SUCCESS;
      EFI_IFR_TYPE_VALUE    Dummy        = gZeroEfiIfrTypeValue;
      EFI_GUID              *VarGuid     = NULL;
+     gNestStructureIsBitVar = FALSE;
   >>
   (
     SN1:StringIdentifier                            << SName = SN1->getText(); 
_STRCAT(&VarIdStr, SN1->getText()); >>
     OpenBracket I1:Number CloseBracket              <<
                                                        Idx = 
_STOU32(I1->getText(), I1->getLine());
@@ -1282,21 +1392,21 @@ vfrStorageVarId[EFI_VARSTORE_INFO & Info, CHAR8 
*&QuestVarIdStr, BOOLEAN CheckFl
                                                           VfrReturnCode = 
gCVfrDataStorage.GetVarStoreId(SName, &$Info.mVarStoreId, &mFormsetGuid);
                                                        }
                                                        if (CheckFlag || 
VfrReturnCode == VFR_RETURN_SUCCESS) {
                                                          
_PCATCH(VfrReturnCode, SN2);
                                                          VarStoreType = 
gCVfrDataStorage.GetVarStoreType ($Info.mVarStoreId);
-                                                         if (VarStoreType == 
EFI_VFR_VARSTORE_BUFFER) {
+                                                         if (VarStoreType == 
EFI_VFR_VARSTORE_BUFFER || VarStoreType == EFI_VFR_VARSTORE_BUFFER_BITS) {
                                                            
_PCATCH(gCVfrDataStorage.GetBufferVarStoreDataTypeName(Info.mVarStoreId, 
&TName), SN2);
                                                            _STRCAT(&VarStr, 
TName);
                                                          }
                                                        }
                                                     >>
 
     (
       "."                                           <<
                                                        if (CheckFlag || 
VfrReturnCode == VFR_RETURN_SUCCESS) {
-                                                         
_PCATCH(((VarStoreType != EFI_VFR_VARSTORE_BUFFER) ? 
VFR_RETURN_EFIVARSTORE_USE_ERROR : VFR_RETURN_SUCCESS), SN2);
+                                                         
_PCATCH((((VarStoreType != EFI_VFR_VARSTORE_BUFFER)&& (VarStoreType != 
EFI_VFR_VARSTORE_BUFFER_BITS))? VFR_RETURN_EFIVARSTORE_USE_ERROR : 
VFR_RETURN_SUCCESS), SN2);
                                                        }
                                                        _STRCAT(&VarIdStr, 
"."); _STRCAT(&VarStr, ".");
                                                     >>
       SF:StringIdentifier                           << _STRCAT(&VarIdStr, 
SF->getText()); _STRCAT(&VarStr, SF->getText()); >>
       {
@@ -1321,11 +1431,31 @@ vfrStorageVarId[EFI_VARSTORE_INFO & Info, CHAR8 
*&QuestVarIdStr, BOOLEAN CheckFl
                                                        switch (VarStoreType) {
                                                        case 
EFI_VFR_VARSTORE_EFI:
                                                          
_PCATCH(gCVfrDataStorage.GetEfiVarStoreInfo (&$Info), SN2);
                                                          break;
                                                        case 
EFI_VFR_VARSTORE_BUFFER:
-                                                         
_PCATCH(gCVfrVarDataTypeDB.GetDataFieldInfo (VarStr, $Info.mInfo.mVarOffset, 
$Info.mVarType, $Info.mVarTotalSize), SN2->getLine(), VarStr);
+                                                         
_PCATCH(gCVfrVarDataTypeDB.GetDataFieldInfo (VarStr, $Info.mInfo.mVarOffset, 
$Info.mVarType, $Info.mVarTotalSize, FALSE), SN2->getLine(), VarStr);
+                                                         VarGuid = 
gCVfrDataStorage.GetVarStoreGuid($Info.mVarStoreId);
+                                                         
_PCATCH((EFI_VFR_RETURN_CODE)gCVfrBufferConfig.Register (
+                                                                    SName,
+                                                                    VarGuid,
+                                                                    NULL),
+                                                                 
SN2->getLine());
+                                                         
_PCATCH((EFI_VFR_RETURN_CODE)gCVfrBufferConfig.Write (
+                                                                    'a',
+                                                                    SName,
+                                                                    VarGuid,
+                                                                    NULL,
+                                                                    
$Info.mVarType,
+                                                                    
$Info.mInfo.mVarOffset,
+                                                                    
$Info.mVarTotalSize,
+                                                                    Dummy),
+                                                                 
SN2->getLine());
+                                                         
_PCATCH(gCVfrDataStorage.AddBufferVarStoreFieldInfo(&$Info),SN2->getLine());
+                                                         break;
+                                                       case 
EFI_VFR_VARSTORE_BUFFER_BITS:
+                                                         
_PCATCH(gCVfrVarDataTypeDB.GetDataFieldInfo (VarStr, $Info.mInfo.mVarOffset, 
$Info.mVarType, $Info.mVarTotalSize, TRUE), SN2->getLine(), VarStr);
                                                          VarGuid = 
gCVfrDataStorage.GetVarStoreGuid($Info.mVarStoreId);
                                                          
_PCATCH((EFI_VFR_RETURN_CODE)gCVfrBufferConfig.Register (
                                                                     SName,
                                                                     VarGuid,
                                                                     NULL),
@@ -1338,11 +1468,12 @@ vfrStorageVarId[EFI_VARSTORE_INFO & Info, CHAR8 
*&QuestVarIdStr, BOOLEAN CheckFl
                                                                     
$Info.mVarType,
                                                                     
$Info.mInfo.mVarOffset,
                                                                     
$Info.mVarTotalSize,
                                                                     Dummy),
                                                                  
SN2->getLine());
-                                                         
_PCATCH(gCVfrDataStorage.AddBufferVarStoreFieldInfo(&$Info ),SN2->getLine());
+                                                         
_PCATCH(gCVfrDataStorage.AddBufferVarStoreFieldInfo(&$Info),SN2->getLine());
+                                                         Info.mIsBitVar = TRUE;
                                                          break;
                                                        case 
EFI_VFR_VARSTORE_NAME:
                                                        default: break;
                                                        }
 
@@ -1419,10 +1550,13 @@ vfrConstantValueField[UINT8 Type, EFI_IFR_TYPE_VALUE 
&Value, BOOLEAN &ListType]
   >>
     {
       "\-"                                          << Negative = TRUE;  >>
     }
     N1:Number                                       <<
+                                                       if 
(_GET_CURRQEST_VARTINFO().mIsBitVar) {
+                                                         $Value.u32    = 
_STOU32(N1->getText(), N1->getLine());
+                                                       } else {
                                                        switch ($Type) {
                                                        case 
EFI_IFR_TYPE_NUM_SIZE_8 :
                                                          $Value.u8 = 
_STOU8(N1->getText(), N1->getLine());
                                                          if (IntDecStyle) {
                                                            if (Negative) {
@@ -1500,10 +1634,11 @@ vfrConstantValueField[UINT8 Type, EFI_IFR_TYPE_VALUE 
&Value, BOOLEAN &ListType]
                                                        case EFI_IFR_TYPE_DATE :
                                                        case EFI_IFR_TYPE_REF  :
                                                        default :
                                                        break;
                                                        }
+                                                       }
                                                     >>
   | B1:True                                         << $Value.b      = TRUE; >>
   | B2:False                                        << $Value.b      = FALSE; 
>>
   | O1:One                                          << $Value.u8     = 
_STOU8(O1->getText(), O1->getLine()); >>
   | O2:Ones                                         << $Value.u64    = 
_STOU64(O2->getText(), O2->getLine()); >>
@@ -1672,42 +1807,48 @@ vfrStatementDefault :
       "=" vfrConstantValueField[_GET_CURRQEST_DATATYPE(), *Val, ArrayType] "," 
 
                                                     << 
                                                         if (gCurrentMinMaxData 
!= NULL && gCurrentMinMaxData->IsNumericOpcode()) {
                                                           //check default 
value is valid for Numeric Opcode
                                                           NumericQst = 
(CIfrNumeric *) gCurrentQuestion;
-                                                          if 
((NumericQst->GetNumericFlags() & EFI_IFR_DISPLAY) == 0) {
+                                                          if 
((NumericQst->GetNumericFlags() & EFI_IFR_DISPLAY) == 0 && 
!(_GET_CURRQEST_VARTINFO().mIsBitVar)) {
                                                             switch 
(_GET_CURRQEST_DATATYPE()) {
                                                             case 
EFI_IFR_TYPE_NUM_SIZE_8:
-                                                              if (((INT8) 
Val->u8 < (INT8) gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE())) || 
-                                                                  ((INT8) 
Val->u8 > (INT8) gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE()))) {
+                                                              if (((INT8) 
Val->u8 < (INT8) gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE(), 
FALSE)) || 
+                                                                  ((INT8) 
Val->u8 > (INT8) gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE(), 
FALSE))) {
                                                                 _PCATCH 
(VFR_RETURN_INVALID_PARAMETER, D->getLine(), "Numeric default value must be 
between MinValue and MaxValue.");
                                                               }
                                                               break;
                                                             case 
EFI_IFR_TYPE_NUM_SIZE_16:
-                                                              if (((INT16) 
Val->u16 < (INT16) gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE())) || 
-                                                                  ((INT16) 
Val->u16 > (INT16) gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE()))) {
+                                                              if (((INT16) 
Val->u16 < (INT16) gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE(), 
FALSE)) || 
+                                                                  ((INT16) 
Val->u16 > (INT16) gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE(), 
FALSE))) {
                                                                 _PCATCH 
(VFR_RETURN_INVALID_PARAMETER, D->getLine(), "Numeric default value must be 
between MinValue and MaxValue.");
                                                               }
                                                               break;
                                                             case 
EFI_IFR_TYPE_NUM_SIZE_32:
-                                                              if (((INT32) 
Val->u32 < (INT32) gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE())) || 
-                                                                  ((INT32) 
Val->u32 > (INT32) gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE()))) {
+                                                              if (((INT32) 
Val->u32 < (INT32) gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE(), 
FALSE)) || 
+                                                                  ((INT32) 
Val->u32 > (INT32) gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE(), 
FALSE))) {
                                                                 _PCATCH 
(VFR_RETURN_INVALID_PARAMETER, D->getLine(), "Numeric default value must be 
between MinValue and MaxValue.");
                                                               }
                                                               break;
                                                             case 
EFI_IFR_TYPE_NUM_SIZE_64:
-                                                              if (((INT64) 
Val->u64 < (INT64) gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE())) || 
-                                                                  ((INT64) 
Val->u64 > (INT64) gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE()))) {
+                                                              if (((INT64) 
Val->u64 < (INT64) gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE(), 
FALSE)) || 
+                                                                  ((INT64) 
Val->u64 > (INT64) gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE(), 
FALSE))) {
                                                                 _PCATCH 
(VFR_RETURN_INVALID_PARAMETER, D->getLine(), "Numeric default value must be 
between MinValue and MaxValue.");
                                                               }
                                                               break;
                                                             default:
                                                               break;
                                                             }
                                                           } else {
-                                                            if (Val->u64 < 
gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE()) || Val->u64 > 
gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE())) {
+                                                            if 
(_GET_CURRQEST_VARTINFO().mIsBitVar) {
+                                                              if (Val->u32 < 
gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE(), TRUE) || Val->u32 > 
gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE(), TRUE)) {
                                                               _PCATCH 
(VFR_RETURN_INVALID_PARAMETER, D->getLine(), "Numeric default value must be 
between MinValue and MaxValue.");
+                                                              }
+                                                            } else {
+                                                              if (Val->u64 < 
gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE(), FALSE) || Val->u64 > 
gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE(), FALSE)) {
+                                                                _PCATCH 
(VFR_RETURN_INVALID_PARAMETER, D->getLine(), "Numeric default value must be 
between MinValue and MaxValue.");
+                                                              }
                                                             }
                                                           }
                                                         }
                                                         if 
(_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) {
                                                           _PCATCH 
(VFR_RETURN_FATAL_ERROR, D->getLine(), "Default data type error.");
@@ -1742,21 +1883,29 @@ vfrStatementDefault :
 
                                                             default:
                                                               break;
                                                           }
                                                         } else {
-                                                          _PCATCH 
(gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &Size), 
D->getLine());
+                                                          if 
(_GET_CURRQEST_VARTINFO().mIsBitVar) {
+                                                            Size = sizeof 
(UINT32);
+                                                          } else {
+                                                            _PCATCH 
(gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &Size), 
D->getLine());
+                                                          }
                                                         }
                                                         Size += OFFSET_OF 
(EFI_IFR_DEFAULT, Value);
                                                         DObj = new CIfrDefault 
((UINT8)Size);
                                                         
DObj->SetLineNo(D->getLine());
                                                         if (ArrayType) {
                                                           DObj->SetType 
(EFI_IFR_TYPE_BUFFER);
                                                         } else if 
(gIsStringOp) {
                                                           DObj->SetType 
(EFI_IFR_TYPE_STRING);
                                                         } else {
-                                                          DObj->SetType 
(_GET_CURRQEST_DATATYPE());
+                                                          if 
(_GET_CURRQEST_VARTINFO().mIsBitVar) {
+                                                            DObj->SetType 
(EFI_IFR_TYPE_NUM_SIZE_32);
+                                                          } else {
+                                                            DObj->SetType 
(_GET_CURRQEST_DATATYPE());
+                                                          }
                                                         }
                                                         DObj->SetValue(*Val);
                                                     >>
       |                                             << IsExp = TRUE; DObj2 = 
new CIfrDefault2; DObj2->SetLineNo(D->getLine()); DObj2->SetScope (1); >>
         vfrStatementValue ","                       << CIfrEnd EndObj1; 
EndObj1.SetLineNo(D->getLine()); >>
@@ -2159,39 +2308,70 @@ vfrStatementBooleanType :
 //     default value = TRUE, defaultstore = MyDefaultStore,
 //   endcheckbox;
 //
 vfrStatementCheckBox :
   <<
-     CIfrCheckBox       CBObj;
+     CIfrCheckBox       *CBObj = NULL;
      EFI_IFR_TYPE_VALUE Val = gZeroEfiIfrTypeValue;
      CHAR8              *VarStoreName = NULL;
      UINT32             DataTypeSize;
      EFI_GUID           *VarStoreGuid = NULL;
+     CIfrGuid           *GuidObj = NULL;
+     EFI_QUESTION_ID   QId = EFI_QUESTION_ID_INVALID;;
+     EFI_VARSTORE_INFO Info;
+     Info.mVarType               = EFI_IFR_TYPE_OTHER;
+     Info.mVarTotalSize          = 0;
+     Info.mInfo.mVarOffset       = EFI_VAROFFSET_INVALID;
+     Info.mVarStoreId            = EFI_VARSTORE_ID_INVALID;
+     Info.mIsBitVar              = FALSE;
   >>
-  L:CheckBox                                           << 
CBObj.SetLineNo(L->getLine()); >>
-  vfrQuestionHeader[CBObj] ","                         << //check data type
+  L:CheckBox
+  vfrQuestionBaseInfo[Info, QId]                       <<
+                                                         if 
(_GET_CURRQEST_VARTINFO().mIsBitVar || gNestStructureIsBitVar) {
+                                                           GuidObj = new 
CIfrGuid(0);
+                                                           GuidObj->SetGuid 
(&gBitVarstoreGuid);
+                                                           
GuidObj->SetLineNo(L->getLine());
+                                                         }
+                                                         CBObj = new 
CIfrCheckBox;
+                                                         
CBObj->SetLineNo(L->getLine());
+                                                         CBObj->SetQuestionId 
(QId);
+                                                         
CBObj->SetVarStoreInfo (&Info);
+                                                        >>
+  vfrStatementHeader[CBObj]","                           << //check data type
                                                           if 
(_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) {
                                                             
_GET_CURRQEST_VARTINFO().mVarType = EFI_IFR_TYPE_BOOLEAN;
                                                           }
                                                           if 
(_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) {
-                                                            _PCATCH 
(gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize), 
L->getLine(), "CheckBox varid is not the valid data type");
-                                                            if (DataTypeSize 
!= 0 && DataTypeSize != _GET_CURRQEST_VARSIZE()) {
-                                                              _PCATCH 
(VFR_RETURN_INVALID_PARAMETER, L->getLine(), "CheckBox varid doesn't support 
array");
-                                                            } else if 
((gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId) == 
EFI_VFR_VARSTORE_BUFFER) &&
-                                                                      
(_GET_CURRQEST_VARSIZE() != sizeof (BOOLEAN))) {
-                                                              _PCATCH 
(VFR_RETURN_INVALID_PARAMETER, L->getLine(), "CheckBox varid only support 
BOOLEAN data type");
+                                                            //
+                                                            // Check whether 
the question refers to a bit field, if yes. create a Guid to
+                                                            // indicate the 
question refers to a bit field.
+                                                            //
+                                                            if 
(_GET_CURRQEST_VARTINFO ().mIsBitVar || gNestStructureIsBitVar) {
+                                                              _PCATCH 
(gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize), 
L->getLine(), "CheckBox varid is not the valid data type");
+                                                               if 
((gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId) == 
EFI_VFR_VARSTORE_BUFFER_BITS) &&
+                                                                        
(_GET_CURRQEST_VARSIZE() != 1)) {
+                                                                _PCATCH 
(VFR_RETURN_INVALID_PARAMETER, L->getLine(), "CheckBox varid only occupy 1 bit 
in Bit Varstore");
+                                                              }
+                                                            } else {
+                                                              _PCATCH 
(gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize), 
L->getLine(), "CheckBox varid is not the valid data type");
+                                                              if (DataTypeSize 
!= 0 && DataTypeSize != _GET_CURRQEST_VARSIZE()) {
+                                                                _PCATCH 
(VFR_RETURN_INVALID_PARAMETER, L->getLine(), "CheckBox varid doesn't support 
array");
+                                                              } else if 
((gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId) == 
EFI_VFR_VARSTORE_BUFFER) &&
+                                                                        
(_GET_CURRQEST_VARSIZE() != sizeof (BOOLEAN))) {
+                                                                _PCATCH 
(VFR_RETURN_INVALID_PARAMETER, L->getLine(), "CheckBox varid only support 
BOOLEAN data type");
+                                                              }
                                                             }
                                                           }
                                                        >>
   {
-    F:FLAGS "=" vfrCheckBoxFlags[CBObj, F->getLine()] ","
+    F:FLAGS "=" vfrCheckBoxFlags[*CBObj, F->getLine()] ","
                                                        <<
                                                          if 
(_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) {
                                                             
_PCATCH(gCVfrDataStorage.GetVarStoreName (_GET_CURRQEST_VARTINFO().mVarStoreId, 
&VarStoreName), VFR_RETURN_SUCCESS, L, "Failed to retrieve varstore name");
                                                             VarStoreGuid = 
gCVfrDataStorage.GetVarStoreGuid(_GET_CURRQEST_VARTINFO().mVarStoreId);
                                                             Val.b = TRUE;
-                                                            if (CBObj.GetFlags 
() & 0x01) {
+                                                            if 
(CBObj->GetFlags () & 0x01) {
                                                               
CheckDuplicateDefaultValue (EFI_HII_DEFAULT_CLASS_STANDARD, F);
                                                               _PCATCH(
                                                                 
gCVfrDefaultStore.BufferVarStoreAltConfigAdd (
                                                                                
     EFI_HII_DEFAULT_CLASS_STANDARD,
                                                                                
     _GET_CURRQEST_VARTINFO(),
@@ -2203,11 +2383,11 @@ vfrStatementCheckBox :
                                                                 
VFR_RETURN_SUCCESS,
                                                                 L,
                                                                 "No standard 
default storage found"
                                                                 );
                                                             }
-                                                            if (CBObj.GetFlags 
() & 0x02) {
+                                                            if 
(CBObj->GetFlags () & 0x02) {
                                                               
CheckDuplicateDefaultValue (EFI_HII_DEFAULT_CLASS_MANUFACTURING, F);
                                                               _PCATCH(
                                                                 
gCVfrDefaultStore.BufferVarStoreAltConfigAdd (
                                                                                
     EFI_HII_DEFAULT_CLASS_MANUFACTURING,
                                                                                
     _GET_CURRQEST_VARTINFO(),
@@ -2223,14 +2403,21 @@ vfrStatementCheckBox :
                                                             }
                                                           }
                                                         >>
   }
   {
-    Key "=" KN:Number  ","                             << AssignQuestionKey 
(CBObj, KN); >>
+    Key "=" KN:Number  ","                             << AssignQuestionKey 
(*CBObj, KN); >>
   }
   vfrStatementQuestionOptionList
-  E:EndCheckBox                                        << CRT_END_OP (E); >>
+  E:EndCheckBox                                        << CRT_END_OP (E);
+                                                          if (GuidObj != NULL) 
{
+                                                            
GuidObj->SetScope(1);
+                                                            CRT_END_OP (E);
+                                                            delete GuidObj;
+                                                          }
+                                                          if (CBObj != NULL) 
delete CBObj;
+                                                       >>
   ";"
   ;
 
 vfrCheckBoxFlags [CIfrCheckBox & CBObj, UINT32 LineNum] :
   <<
@@ -2436,10 +2623,13 @@ vfrSetMinMaxStep[CIfrMinMaxStepData & MMSDObj] :
   }
   I:Number ","                                         <<
                                                           if (!IntDecStyle &&  
MinNegative) {
                                                             _PCATCH 
(VFR_RETURN_INVALID_PARAMETER, I->getLine(), "\"-\" can't be used when not in 
int decimal type. ");
                                                           }
+                                                          if 
(_GET_CURRQEST_VARTINFO().mIsBitVar) {
+                                                            MinU4 = 
_STOU32(I->getText(), I->getLine());
+                                                          } else {
                                                           switch 
(_GET_CURRQEST_DATATYPE()) {
                                                           case 
EFI_IFR_TYPE_NUM_SIZE_64 :
                                                             MinU8 = 
_STOU64(I->getText(), I->getLine());
                                                             if (IntDecStyle) {
                                                               if (MinNegative) 
{ 
@@ -2506,20 +2696,23 @@ vfrSetMinMaxStep[CIfrMinMaxStepData & MMSDObj] :
                                                             if (MinNegative) {
                                                               MinU1 = ~MinU1 + 
1;
                                                             }
                                                             break;
                                                           }
+                                                          }
                                                        >>
   Maximum   "=" 
   { 
     "\-"                                               << MaxNegative = TRUE; 
>>
   }
   A:Number ","                                         <<
                                                           if (!IntDecStyle && 
MaxNegative) {
                                                             _PCATCH 
(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "\"-\" can't be used when not in 
int decimal type. ");
                                                           }
-
+                                                          if 
(_GET_CURRQEST_VARTINFO().mIsBitVar) {
+                                                            MaxU4 = 
_STOU32(A->getText(), A->getLine());
+                                                          }  else {
                                                           switch 
(_GET_CURRQEST_DATATYPE()) {
                                                           case 
EFI_IFR_TYPE_NUM_SIZE_64 : 
                                                             MaxU8 = 
_STOU64(A->getText(), A->getLine()); 
                                                             if (IntDecStyle) {
                                                               if (MaxNegative) 
{
@@ -2622,75 +2815,122 @@ vfrSetMinMaxStep[CIfrMinMaxStepData & MMSDObj] :
                                                                 _PCATCH 
(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less than 
Minimum");
                                                               }
                                                             }
                                                             break;
                                                           }
+                                                          }
                                                        >>
   {
     STEP    "=" S:Number ","
                                                        <<
+                                                          if 
(_GET_CURRQEST_VARTINFO().mIsBitVar) {
+                                                            StepU4 = 
_STOU32(S->getText(), S->getLine());
+                                                          }  else {
                                                           switch 
(_GET_CURRQEST_DATATYPE()) {
                                                           case 
EFI_IFR_TYPE_NUM_SIZE_64 : StepU8 = _STOU64(S->getText(), S->getLine()); break;
                                                           case 
EFI_IFR_TYPE_NUM_SIZE_32 : StepU4 = _STOU32(S->getText(), S->getLine()); break;
                                                           case 
EFI_IFR_TYPE_NUM_SIZE_16 : StepU2 = _STOU16(S->getText(), S->getLine()); break;
                                                           case 
EFI_IFR_TYPE_NUM_SIZE_8 :  StepU1 = _STOU8(S->getText(), S->getLine());  break;
                                                           }
+                                                          }
                                                        >>
   }
                                                        <<
+                                                         if 
(_GET_CURRQEST_VARTINFO().mIsBitVar) {
+                                                            
$MMSDObj.SetMinMaxStepData (MinU4, MaxU4, StepU4);
+                                                          }  else {
                                                           switch 
(_GET_CURRQEST_DATATYPE()) {
                                                           case 
EFI_IFR_TYPE_NUM_SIZE_64 : $MMSDObj.SetMinMaxStepData (MinU8, MaxU8, StepU8); 
break;
                                                           case 
EFI_IFR_TYPE_NUM_SIZE_32 : $MMSDObj.SetMinMaxStepData (MinU4, MaxU4, StepU4); 
break;
                                                           case 
EFI_IFR_TYPE_NUM_SIZE_16 : $MMSDObj.SetMinMaxStepData (MinU2, MaxU2, StepU2); 
break;
                                                           case 
EFI_IFR_TYPE_NUM_SIZE_8 :  $MMSDObj.SetMinMaxStepData (MinU1, MaxU1, StepU1);  
break;
                                                           }
+                                                          }
                                                        >>
   ;
 
 vfrStatementNumeric :
   <<
-     CIfrNumeric NObj;
+     CIfrNumeric *NObj = NULL;
      UINT32      DataTypeSize;
      BOOLEAN     IsSupported = TRUE;
      UINT8       ShrinkSize  = 0;
+     CIfrGuid    *GuidObj = NULL;
+     UINT8       LFlags = _GET_CURRQEST_DATATYPE() & EFI_IFR_NUMERIC_SIZE;
+     EFI_QUESTION_ID   QId = EFI_QUESTION_ID_INVALID;;
+     EFI_VARSTORE_INFO Info;
+     Info.mVarType               = EFI_IFR_TYPE_OTHER;
+     Info.mVarTotalSize          = 0;
+     Info.mInfo.mVarOffset       = EFI_VAROFFSET_INVALID;
+     Info.mVarStoreId            = EFI_VARSTORE_ID_INVALID;
+     Info.mIsBitVar              = FALSE;
   >>
-  L:Numeric                                            << 
NObj.SetLineNo(L->getLine()); >>
-  vfrQuestionHeader[NObj] ","                          << // check data type
+  L:Numeric                                            <<  >>
+  vfrQuestionBaseInfo[Info, QId]                       <<
+                                                         if 
(_GET_CURRQEST_VARTINFO().mIsBitVar || gNestStructureIsBitVar) {
+                                                           GuidObj = new 
CIfrGuid(0);
+                                                           GuidObj->SetGuid 
(&gBitVarstoreGuid);
+                                                           
GuidObj->SetLineNo(L->getLine());
+                                                         }
+                                                         NObj = new 
CIfrNumeric;
+                                                         
NObj->SetLineNo(L->getLine());
+                                                         NObj->SetQuestionId 
(QId);
+                                                         NObj->SetVarStoreInfo 
(&Info);
+                                                        >>
+  vfrStatementHeader[NObj]","
+                                                         <<
+                                                          // check data type
                                                           if 
(_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) {
-                                                            _PCATCH 
(gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize), 
L->getLine(), "Numeric varid is not the valid data type");
-                                                            if (DataTypeSize 
!= 0 && DataTypeSize != _GET_CURRQEST_VARSIZE()) {
-                                                              _PCATCH 
(VFR_RETURN_INVALID_PARAMETER, L->getLine(), "Numeric varid doesn't support 
array");
+                                                            if 
(_GET_CURRQEST_VARTINFO().mIsBitVar || gNestStructureIsBitVar) {
+                                                               LFlags|= (0X0F 
& (_GET_CURRQEST_VARSIZE()));
+                                                              
_PCATCH(NObj->SetFlags (NObj->FLAGS(), LFlags), L->getLine());
+                                                            } else {
+                                                              _PCATCH 
(gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize), 
L->getLine(), "Numeric varid is not the valid data type");
+                                                              if (DataTypeSize 
!= 0 && DataTypeSize != _GET_CURRQEST_VARSIZE()) {
+                                                                _PCATCH 
(VFR_RETURN_INVALID_PARAMETER, L->getLine(), "Numeric varid doesn't support 
array");
+                                                              }
+                                                              
_PCATCH(NObj->SetFlags (NObj->FLAGS(), _GET_CURRQEST_DATATYPE()), L->getLine());
                                                             }
-                                                            
_PCATCH(NObj.SetFlags (NObj.FLAGS(), _GET_CURRQEST_DATATYPE()), L->getLine());
                                                           }
                                                        >>
-  { F:FLAGS "=" vfrNumericFlags[NObj, F->getLine()] "," }
+  { F:FLAGS "=" vfrNumericFlags[*NObj, F->getLine()] "," }
   {
-    Key   "=" KN:Number ","                            << AssignQuestionKey 
(NObj, KN); >>
+    Key   "=" KN:Number ","                            << AssignQuestionKey 
(*NObj, KN); >>
   }
-  vfrSetMinMaxStep[NObj]                               <<
-                                                          switch 
(_GET_CURRQEST_DATATYPE()) {
-                                                            //
-                                                            // Base on the 
type to know the actual used size,shrink the buffer 
-                                                            // size allocate 
before.
-                                                            //
-                                                            case 
EFI_IFR_TYPE_NUM_SIZE_8: ShrinkSize = 21;break;
-                                                            case 
EFI_IFR_TYPE_NUM_SIZE_16:ShrinkSize = 18;break;
-                                                            case 
EFI_IFR_TYPE_NUM_SIZE_32:ShrinkSize = 12;break;
-                                                            case 
EFI_IFR_TYPE_NUM_SIZE_64:break;
-                                                            default: 
-                                                              IsSupported = 
FALSE;
-                                                              break;
+  vfrSetMinMaxStep[*NObj]                               <<
+                                                          if 
(!_GET_CURRQEST_VARTINFO().mIsBitVar && !gNestStructureIsBitVar) {
+                                                            switch 
(_GET_CURRQEST_DATATYPE()) {
+                                                              //
+                                                              // Base on the 
type to know the actual used size,shrink the buffer 
+                                                              // size allocate 
before.
+                                                              //
+                                                              case 
EFI_IFR_TYPE_NUM_SIZE_8: ShrinkSize = 21;break;
+                                                              case 
EFI_IFR_TYPE_NUM_SIZE_16:ShrinkSize = 18;break;
+                                                              case 
EFI_IFR_TYPE_NUM_SIZE_32:ShrinkSize = 12;break;
+                                                              case 
EFI_IFR_TYPE_NUM_SIZE_64:break;
+                                                              default: 
+                                                                IsSupported = 
FALSE;
+                                                                break;
+                                                            }
+                                                          } else {
+                                                            ShrinkSize = 0;
                                                           }
-                                                          NObj.ShrinkBinSize 
(ShrinkSize);
+                                                          NObj->ShrinkBinSize 
(ShrinkSize);
+
                                                           if (!IsSupported) {
                                                             _PCATCH 
(VFR_RETURN_INVALID_PARAMETER, L->getLine(), "Numeric question only support 
UINT8, UINT16, UINT32 and UINT64 data type.");
                                                           }
                                                        >>
   vfrStatementQuestionOptionList
   E:EndNumeric                                         << 
-                                                          CRT_END_OP (E); 
+                                                          CRT_END_OP (E);
+                                                          if (GuidObj != NULL) 
{
+                                                            
GuidObj->SetScope(1);
+                                                            CRT_END_OP (E);
+                                                            delete GuidObj;
+                                                          }
+                                                          if (NObj != NULL) 
delete NObj;
                                                        >>
   ";"
   ;
 
 vfrNumericFlags [CIfrNumeric & NObj, UINT32 LineNum] :
@@ -2702,25 +2942,34 @@ vfrNumericFlags [CIfrNumeric & NObj, UINT32 LineNum] :
      BOOLEAN IsDisplaySpecified = FALSE;
   >>
   numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified] ( "\|" 
numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified ] )*
                                                        <<
                                                           //check data type 
flag
-                                                          if 
(_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) {
-                                                            VarStoreType = 
gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId);
-                                                            if (VarStoreType 
== EFI_VFR_VARSTORE_BUFFER || VarStoreType == EFI_VFR_VARSTORE_EFI) {
-                                                              if 
(_GET_CURRQEST_DATATYPE() != (LFlags & EFI_IFR_NUMERIC_SIZE)) {
-                                                                
_PCATCH(VFR_RETURN_INVALID_PARAMETER, LineNum, "Numeric Flag is not same to 
Numeric VarData type");
+                                                          if 
(!_GET_CURRQEST_VARTINFO().mIsBitVar && !gNestStructureIsBitVar) {
+                                                            if 
(_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) {
+                                                              VarStoreType = 
gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId);
+                                                              if (VarStoreType 
== EFI_VFR_VARSTORE_BUFFER || VarStoreType == EFI_VFR_VARSTORE_EFI) {
+                                                                if 
(_GET_CURRQEST_DATATYPE() != (LFlags & EFI_IFR_NUMERIC_SIZE)) {
+                                                                  
_PCATCH(VFR_RETURN_INVALID_PARAMETER, LineNum, "Numeric Flag is not same to 
Numeric VarData type");
+                                                                }
+                                                              } else {
+                                                                // update data 
type for name/value store
+                                                                UINT32 
DataTypeSize;
+                                                                
_GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE;
+                                                                
gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize);
+                                                                
_GET_CURRQEST_VARTINFO().mVarTotalSize = DataTypeSize;
                                                               }
-                                                            } else {
-                                                              // update data 
type for name/value store
-                                                              UINT32 
DataTypeSize;
+                                                            } else if 
(IsSetType){
                                                               
_GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE;
-                                                              
gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize);
-                                                              
_GET_CURRQEST_VARTINFO().mVarTotalSize = DataTypeSize;
                                                             }
-                                                          } else if 
(IsSetType){
-                                                            
_GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE;
+                                                          } else {
+                                                            if 
(_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) {
+                                                              VarStoreType = 
gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId);
+                                                              if (VarStoreType 
== EFI_VFR_VARSTORE_BUFFER_BITS) {
+                                                                LFlags|= (0X0F 
& (_GET_CURRQEST_VARSIZE()));
+                                                              }
+                                                            }
                                                           }
                                                           
_PCATCH(NObj.SetFlags (HFlags, LFlags, IsDisplaySpecified), LineNum);
                                                        >>
   ;
 
@@ -2736,30 +2985,57 @@ numericFlagsField [UINT8 & HFlags, UINT8 & LFlags, 
BOOLEAN & IsSetType, BOOLEAN
   | questionheaderFlagsField[HFlags]
   ;
 
 vfrStatementOneOf :
   <<
-     CIfrOneOf OObj;
+     CIfrOneOf *OObj = NULL;
      UINT32    DataTypeSize;
      BOOLEAN   IsSupported = TRUE;
      UINT8     ShrinkSize  = 0;
+     CIfrGuid  *GuidObj = NULL;
+     UINT8 LFlags = _GET_CURRQEST_DATATYPE() & EFI_IFR_NUMERIC_SIZE;
+     EFI_QUESTION_ID   QId = EFI_QUESTION_ID_INVALID;;
+     EFI_VARSTORE_INFO Info;
+     Info.mVarType               = EFI_IFR_TYPE_OTHER;
+     Info.mVarTotalSize          = 0;
+     Info.mInfo.mVarOffset       = EFI_VAROFFSET_INVALID;
+     Info.mVarStoreId            = EFI_VARSTORE_ID_INVALID;
+     Info.mIsBitVar              = FALSE;
   >>
-  L:OneOf                                              << 
OObj.SetLineNo(L->getLine()); >>
-  vfrQuestionHeader[OObj] ","                          << //check data type
+  L:OneOf
+  vfrQuestionBaseInfo[Info, QId]                       <<
+                                                         if 
(_GET_CURRQEST_VARTINFO().mIsBitVar || gNestStructureIsBitVar) {
+                                                           GuidObj = new 
CIfrGuid(0);
+                                                           GuidObj->SetGuid 
(&gBitVarstoreGuid);
+                                                           
GuidObj->SetLineNo(L->getLine());
+                                                         }
+                                                         OObj = new CIfrOneOf;
+                                                         
OObj->SetLineNo(L->getLine());
+                                                         OObj->SetQuestionId 
(QId);
+                                                         OObj->SetVarStoreInfo 
(&Info);
+                                                        >>
+  vfrStatementHeader[OObj]","
+                                                        << //check data type
                                                           if 
(_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) {
-                                                            _PCATCH 
(gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize), 
L->getLine(), "OneOf varid is not the valid data type");
-                                                            if (DataTypeSize 
!= 0 && DataTypeSize != _GET_CURRQEST_VARSIZE()) {
-                                                              _PCATCH 
(VFR_RETURN_INVALID_PARAMETER, L->getLine(), "OneOf varid doesn't support 
array");
+                                                            if 
(_GET_CURRQEST_VARTINFO().mIsBitVar || gNestStructureIsBitVar) {
+                                                               LFlags|= (0X0F 
& (_GET_CURRQEST_VARSIZE()));
+                                                              
_PCATCH(OObj->SetFlags (OObj->FLAGS(), LFlags), L->getLine());
+                                                            } else {
+                                                              _PCATCH 
(gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize), 
L->getLine(), "OneOf varid is not the valid data type");
+                                                              if (DataTypeSize 
!= 0 && DataTypeSize != _GET_CURRQEST_VARSIZE()) {
+                                                                _PCATCH 
(VFR_RETURN_INVALID_PARAMETER, L->getLine(), "OneOf varid doesn't support 
array");
+                                                              }
+                                                              
_PCATCH(OObj->SetFlags (OObj->FLAGS(), _GET_CURRQEST_DATATYPE()), L->getLine());
                                                             }
-                                                            
_PCATCH(OObj.SetFlags (OObj.FLAGS(), _GET_CURRQEST_DATATYPE()), L->getLine());
                                                           }
                                                        >>
-  { F:FLAGS "=" vfrOneofFlagsField[OObj, F->getLine()] "," }
+  { F:FLAGS "=" vfrOneofFlagsField[*OObj, F->getLine()] "," }
   {
-    vfrSetMinMaxStep[OObj]
+    vfrSetMinMaxStep[*OObj]
   }
                                                        <<
+                                                          if 
(!_GET_CURRQEST_VARTINFO().mIsBitVar && !gNestStructureIsBitVar) {
                                                           switch 
(_GET_CURRQEST_DATATYPE()) {
                                                             //
                                                             // Base on the 
type to know the actual used size,shrink the buffer 
                                                             // size allocate 
before.
                                                             //
@@ -2769,18 +3045,28 @@ vfrStatementOneOf :
                                                             case 
EFI_IFR_TYPE_NUM_SIZE_64:break;
                                                             default:
                                                               IsSupported = 
FALSE;
                                                               break;
                                                           }
-                                                          OObj.ShrinkBinSize 
(ShrinkSize);
+                                                         } else {
+                                                         ShrinkSize = 0;
+                                                         }
+                                                          OObj->ShrinkBinSize 
(ShrinkSize);
+
                                                           if (!IsSupported) {
                                                             _PCATCH 
(VFR_RETURN_INVALID_PARAMETER, L->getLine(), "OneOf question only support 
UINT8, UINT16, UINT32 and UINT64 data type.");
                                                           }
                                                        >>
   vfrStatementQuestionOptionList
   E:EndOneOf                                           <<
-                                                          CRT_END_OP (E); 
+                                                          CRT_END_OP (E);
+                                                        if (GuidObj != NULL) {
+                                                            
GuidObj->SetScope(1);
+                                                            CRT_END_OP (E);
+                                                            delete GuidObj;
+                                                          }
+                                                          if (OObj != NULL) 
delete OObj;
                                                        >>
   ";"
   ;
 
 vfrOneofFlagsField [CIfrOneOf & OObj, UINT32 LineNum] :
@@ -2792,25 +3078,34 @@ vfrOneofFlagsField [CIfrOneOf & OObj, UINT32 LineNum] :
      BOOLEAN IsDisplaySpecified = FALSE;
   >>
   numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified] ( "\|" 
numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified] )*
                                                        <<
                                                           //check data type 
flag
-                                                          if 
(_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) {
-                                                            VarStoreType = 
gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId);
-                                                            if (VarStoreType 
== EFI_VFR_VARSTORE_BUFFER || VarStoreType == EFI_VFR_VARSTORE_EFI) {
-                                                              if 
(_GET_CURRQEST_DATATYPE() != (LFlags & EFI_IFR_NUMERIC_SIZE)) {
-                                                                
_PCATCH(VFR_RETURN_INVALID_PARAMETER, LineNum, "Numeric Flag is not same to 
Numeric VarData type");
+                                                          if 
(!_GET_CURRQEST_VARTINFO().mIsBitVar && !gNestStructureIsBitVar) {
+                                                            if 
(_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) {
+                                                               VarStoreType = 
gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId);
+                                                              if (VarStoreType 
== EFI_VFR_VARSTORE_BUFFER || VarStoreType == EFI_VFR_VARSTORE_EFI) {
+                                                                if 
(_GET_CURRQEST_DATATYPE() != (LFlags & EFI_IFR_NUMERIC_SIZE)) {
+                                                                 
_PCATCH(VFR_RETURN_INVALID_PARAMETER, LineNum, "Numeric Flag is not same to 
Numeric VarData type");
+                                                                }
+                                                              } else {
+                                                                // update data 
type for Name/Value store
+                                                                UINT32 
DataTypeSize;
+                                                                
_GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE;
+                                                                
gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize);
+                                                                
_GET_CURRQEST_VARTINFO().mVarTotalSize = DataTypeSize;
                                                               }
-                                                            } else {
-                                                              // update data 
type for Name/Value store
-                                                              UINT32 
DataTypeSize;
+                                                            } else if 
(IsSetType){
                                                               
_GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE;
-                                                              
gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize);
-                                                              
_GET_CURRQEST_VARTINFO().mVarTotalSize = DataTypeSize;
                                                             }
-                                                          } else if 
(IsSetType){
-                                                            
_GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE;
+                                                          } else {
+                                                            if 
(_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) {
+                                                              VarStoreType = 
gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId);
+                                                              if (VarStoreType 
== EFI_VFR_VARSTORE_BUFFER_BITS) {
+                                                                LFlags|= (0X0F 
& (_GET_CURRQEST_VARSIZE()));
+                                                              }
+                                                            }
                                                           }
                                                           
_PCATCH(OObj.SetFlags (HFlags, LFlags), LineNum);
                                                        >>
   ;
 
@@ -3363,10 +3658,13 @@ vfrStatementOneOfOption :
   Value "=" vfrConstantValueField[_GET_CURRQEST_DATATYPE(), *Val, ArrayType] 
","
                                                        << 
                                                           if 
(gCurrentMinMaxData != NULL) {
                                                             //set min/max 
value for oneof opcode
                                                             UINT64 Step = 
gCurrentMinMaxData->GetStepData(_GET_CURRQEST_DATATYPE());
+                                                            if 
(_GET_CURRQEST_VARTINFO().mIsBitVar) {
+                                                              
gCurrentMinMaxData->SetMinMaxStepData(Val->u32, Val->u32, (UINT32) Step);
+                                                            } else {
                                                             switch 
(_GET_CURRQEST_DATATYPE()) {
                                                             case 
EFI_IFR_TYPE_NUM_SIZE_64:
                                                               
gCurrentMinMaxData->SetMinMaxStepData(Val->u64, Val->u64, Step);
                                                               break;
                                                             case 
EFI_IFR_TYPE_NUM_SIZE_32:
@@ -3379,10 +3677,11 @@ vfrStatementOneOfOption :
                                                               
gCurrentMinMaxData->SetMinMaxStepData(Val->u8, Val->u8, (UINT8) Step);
                                                               break;
                                                             default:
                                                               break;
                                                             }
+                                                           }
                                                           }
                                                           if 
(_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) {
                                                             Size = sizeof 
(EFI_IFR_TYPE_VALUE);
                                                           } else if 
(ArrayType) {
                                                             switch 
(_GET_CURRQEST_DATATYPE()) {
@@ -3411,11 +3710,15 @@ vfrStatementOneOfOption :
                                                                break;
                                                              default:
                                                                break;
                                                             }
                                                           } else {
-                                                            ReturnCode = 
gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &Size);
+                                                            if 
(_GET_CURRQEST_VARTINFO().mIsBitVar) {
+                                                              Size = sizeof 
(UINT32);
+                                                            } else {
+                                                              ReturnCode = 
gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &Size);
+                                                            }
                                                           }
                                                           if (ReturnCode != 
VFR_RETURN_SUCCESS) {
                                                             _PCATCH 
(ReturnCode, L->getLine());
                                                           }
 
@@ -3424,11 +3727,15 @@ vfrStatementOneOfOption :
                                                           
OOOObj->SetLineNo(L->getLine());
                                                           OOOObj->SetOption 
(_STOSID(S->getText(), S->getLine())); 
                                                           if (ArrayType) {
                                                             OOOObj->SetType 
(EFI_IFR_TYPE_BUFFER); 
                                                           } else {
+                                                            if 
(_GET_CURRQEST_VARTINFO().mIsBitVar) {
+                                                               OOOObj->SetType 
( EFI_IFR_TYPE_NUM_SIZE_32);
+                                                            } else {
                                                             OOOObj->SetType 
(_GET_CURRQEST_DATATYPE()); 
+                                                              }
                                                           }
                                                           OOOObj->SetValue 
(*Val); 
                                                        >>
   F:FLAGS "=" vfrOneOfOptionFlags[*OOOObj, F->getLine()]
                                                        <<
diff --git a/BaseTools/Source/C/VfrCompile/VfrUtilityLib.cpp 
b/BaseTools/Source/C/VfrCompile/VfrUtilityLib.cpp
index 2f97975..d0b7d6c 100644
--- a/BaseTools/Source/C/VfrCompile/VfrUtilityLib.cpp
+++ b/BaseTools/Source/C/VfrCompile/VfrUtilityLib.cpp
@@ -1,10 +1,10 @@
 /** @file
   
   Vfr common library functions.
 
-Copyright (c) 2004 - 2016, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2017, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials                          
 are licensed and made available under the terms and conditions of the BSD 
License         
 which accompanies this distribution.  The full text of the license may be 
found at        
 http://opensource.org/licenses/bsd-license.php                                 
           
                                                                                
           
@@ -575,10 +575,19 @@ CVfrVarDataTypeDB::RegisterNewType (
 {
   New->mNext               = mDataTypeList;
   mDataTypeList            = New;
 }
 
+VOID
+CVfrVarDataTypeDB::RegisterNewBitsType (
+  IN SVfrDataType  *New
+  )
+{
+  New->mNext               = mBitsTypeList;
+  mBitsTypeList            = New;
+}
+
 EFI_VFR_RETURN_CODE
 CVfrVarDataTypeDB::ExtractStructTypeName (
   IN  CHAR8 *&VarStr,
   OUT CHAR8 *TName
   )
@@ -598,10 +607,28 @@ CVfrVarDataTypeDB::ExtractStructTypeName (
   }
 
   return VFR_RETURN_SUCCESS;
 }
 
+BOOLEAN
+CVfrVarDataTypeDB::DataTypeHasBitField (
+  IN  CHAR8         *TypeName
+  )
+{
+  SVfrDataType        *pType  = NULL;
+  SVfrDataField       *pTmp;
+
+  GetDataType (TypeName, &pType);
+  for (pTmp = pType->mMembers; pTmp!= NULL; pTmp = pTmp->mNext) {
+    if (pTmp->mIsBitField) {
+       return TRUE;
+    }
+  }
+  return FALSE;
+}
+
+
 EFI_VFR_RETURN_CODE
 CVfrVarDataTypeDB::ExtractFieldNameAndArrary (
   IN  CHAR8   *&VarStr,
   IN  CHAR8   *FName,
   OUT UINT32 &ArrayIdx
@@ -695,11 +722,12 @@ CVfrVarDataTypeDB::GetTypeField (
 
 EFI_VFR_RETURN_CODE
 CVfrVarDataTypeDB::GetFieldOffset (
   IN  SVfrDataField *Field,
   IN  UINT32        ArrayIdx,
-  OUT UINT32        &Offset
+  OUT UINT32        &Offset,
+  IN  BOOLEAN       IsBitField
   )
 {
   if (Field == NULL) {
     return VFR_RETURN_FATAL_ERROR;
   }
@@ -727,12 +755,15 @@ CVfrVarDataTypeDB::GetFieldOffset (
   //
   // if ((ArrayIdx == INVALID_ARRAY_INDEX) && (Field->mArrayNum > 0)) {
   //   return VFR_RETURN_ERROR_ARRARY_NUM;
   // }
   //
-
-  Offset = Field->mOffset + Field->mFieldType->mTotalSize * ((ArrayIdx == 
INVALID_ARRAY_INDEX) ? 0 : ArrayIdx);
+  if (IsBitField) {
+    Offset = Field->mOffset + Field->mFieldType->mTotalSize * ((ArrayIdx == 
INVALID_ARRAY_INDEX) ? 0 : ArrayIdx) * 8;
+  } else {
+    Offset = Field->mOffset + Field->mFieldType->mTotalSize * ((ArrayIdx == 
INVALID_ARRAY_INDEX) ? 0 : ArrayIdx);
+  }
   return VFR_RETURN_SUCCESS;
 }
 
 UINT8
 CVfrVarDataTypeDB::GetFieldWidth (
@@ -747,21 +778,26 @@ CVfrVarDataTypeDB::GetFieldWidth (
 }
 
 UINT32
 CVfrVarDataTypeDB::GetFieldSize (
   IN SVfrDataField *Field,
-  IN UINT32       ArrayIdx
+  IN UINT32       ArrayIdx,
+  IN BOOLEAN      IsBitField
   )
 {
   if (Field == NULL) {
     return VFR_RETURN_FATAL_ERROR;
   }
 
   if ((ArrayIdx == INVALID_ARRAY_INDEX) && (Field->mArrayNum != 0)) {
-    return Field->mFieldType->mTotalSize * Field->mArrayNum;
+      return Field->mFieldType->mTotalSize * Field->mArrayNum;
   } else {
-    return Field->mFieldType->mTotalSize;
+    if (IsBitField) {
+      return Field->mBitWidth;
+    } else {
+      return Field->mFieldType->mTotalSize;
+    }
   }
 }
 
 VOID
 CVfrVarDataTypeDB::InternalTypesListInit (
@@ -786,22 +822,25 @@ CVfrVarDataTypeDB::InternalTypesListInit (
         strcpy (pYearField->mFieldName, "Year");
         GetDataType ((CHAR8 *)"UINT16", &pYearField->mFieldType);
         pYearField->mOffset      = 0;
         pYearField->mNext        = pMonthField;
         pYearField->mArrayNum    = 0;
+        pYearField->mIsBitField = FALSE;
 
         strcpy (pMonthField->mFieldName, "Month");
         GetDataType ((CHAR8 *)"UINT8", &pMonthField->mFieldType);
         pMonthField->mOffset     = 2;
         pMonthField->mNext       = pDayField;
         pMonthField->mArrayNum   = 0;
+        pMonthField->mIsBitField = FALSE;
 
         strcpy (pDayField->mFieldName, "Day");
         GetDataType ((CHAR8 *)"UINT8", &pDayField->mFieldType);
         pDayField->mOffset       = 3;
         pDayField->mNext         = NULL;
         pDayField->mArrayNum     = 0;
+        pDayField->mIsBitField = FALSE;
 
         New->mMembers            = pYearField;
       } else if (strcmp (gInternalTypesTable[Index].mTypeName, "EFI_HII_TIME") 
== 0) {
         SVfrDataField *pHoursField   = new SVfrDataField;
         SVfrDataField *pMinutesField = new SVfrDataField;
@@ -810,22 +849,25 @@ CVfrVarDataTypeDB::InternalTypesListInit (
         strcpy (pHoursField->mFieldName, "Hours");
         GetDataType ((CHAR8 *)"UINT8", &pHoursField->mFieldType);
         pHoursField->mOffset     = 0;
         pHoursField->mNext       = pMinutesField;
         pHoursField->mArrayNum   = 0;
+        pHoursField->mIsBitField = FALSE;
 
         strcpy (pMinutesField->mFieldName, "Minutes");
         GetDataType ((CHAR8 *)"UINT8", &pMinutesField->mFieldType);
         pMinutesField->mOffset   = 1;
         pMinutesField->mNext     = pSecondsField;
         pMinutesField->mArrayNum = 0;
+        pMinutesField->mIsBitField = FALSE;
 
         strcpy (pSecondsField->mFieldName, "Seconds");
         GetDataType ((CHAR8 *)"UINT8", &pSecondsField->mFieldType);
         pSecondsField->mOffset   = 2;
         pSecondsField->mNext     = NULL;
         pSecondsField->mArrayNum = 0;
+        pSecondsField->mIsBitField = FALSE;
 
         New->mMembers            = pHoursField;
       } else if (strcmp (gInternalTypesTable[Index].mTypeName, "EFI_HII_REF") 
== 0) {
         SVfrDataField *pQuestionIdField   = new SVfrDataField;
         SVfrDataField *pFormIdField       = new SVfrDataField;
@@ -835,28 +877,32 @@ CVfrVarDataTypeDB::InternalTypesListInit (
         strcpy (pQuestionIdField->mFieldName, "QuestionId");
         GetDataType ((CHAR8 *)"UINT16", &pQuestionIdField->mFieldType);
         pQuestionIdField->mOffset     = 0;
         pQuestionIdField->mNext       = pFormIdField;
         pQuestionIdField->mArrayNum   = 0;
+        pQuestionIdField->mIsBitField = FALSE;
 
         strcpy (pFormIdField->mFieldName, "FormId");
         GetDataType ((CHAR8 *)"UINT16", &pFormIdField->mFieldType);
         pFormIdField->mOffset   = 2;
         pFormIdField->mNext     = pFormSetGuidField;
         pFormIdField->mArrayNum = 0;
+        pFormIdField->mIsBitField = FALSE;
 
         strcpy (pFormSetGuidField->mFieldName, "FormSetGuid");
         GetDataType ((CHAR8 *)"EFI_GUID", &pFormSetGuidField->mFieldType);
         pFormSetGuidField->mOffset   = 4;
         pFormSetGuidField->mNext     = pDevicePathField;
         pFormSetGuidField->mArrayNum = 0;
+        pFormSetGuidField->mIsBitField = FALSE;
 
         strcpy (pDevicePathField->mFieldName, "DevicePath");
         GetDataType ((CHAR8 *)"EFI_STRING_ID", &pDevicePathField->mFieldType);
         pDevicePathField->mOffset   = 20;
         pDevicePathField->mNext     = NULL;
         pDevicePathField->mArrayNum = 0;
+        pDevicePathField->mIsBitField = FALSE;
 
         New->mMembers            = pQuestionIdField;
       } else {
         New->mMembers            = NULL;
       }
@@ -870,10 +916,11 @@ CVfrVarDataTypeDB::InternalTypesListInit (
 CVfrVarDataTypeDB::CVfrVarDataTypeDB (
   VOID
   )
 {
   mDataTypeList  = NULL;
+  mBitsTypeList  = NULL;
   mNewDataType   = NULL;
   mCurrDataField = NULL;
   mPackAlign     = DEFAULT_PACK_ALIGN;
   mPackStack     = NULL;
   mFirstNewDataTypeName = NULL;
@@ -899,11 +946,22 @@ CVfrVarDataTypeDB::~CVfrVarDataTypeDB (
     while(pType->mMembers != NULL) {
       pField = pType->mMembers;
       pType->mMembers = pType->mMembers->mNext;
       delete pField;
     }
-       delete pType;
+    delete pType;
+  }
+
+  while (mBitsTypeList != NULL) {
+    pType = mBitsTypeList;
+    mBitsTypeList = mBitsTypeList->mNext;
+    while(pType->mMembers != NULL) {
+      pField = pType->mMembers;
+      pType->mMembers = pType->mMembers->mNext;
+      delete pField;
+    }
+    delete pType;
   }
 
   while (mPackStack != NULL) {
     pPack = mPackStack;
     mPackStack = mPackStack->mNext;
@@ -976,10 +1034,11 @@ CVfrVarDataTypeDB::DeclareDataTypeBegin (
   pNewType->mType        = EFI_IFR_TYPE_OTHER;
   pNewType->mAlign       = DEFAULT_ALIGN;
   pNewType->mTotalSize   = 0;
   pNewType->mMembers     = NULL;
   pNewType->mNext        = NULL;
+  pNewType->mHasBitField = FALSE;
 
   mNewDataType           = pNewType;
 }
 
 EFI_VFR_RETURN_CODE
@@ -1008,10 +1067,61 @@ CVfrVarDataTypeDB::SetNewTypeName (
   strcpy(mNewDataType->mTypeName, TypeName);
   return VFR_RETURN_SUCCESS;
 }
 
 EFI_VFR_RETURN_CODE
+CVfrVarDataTypeDB::DataTypeAddBitField (
+  IN CHAR8   *FieldName,
+  IN CHAR8   *TypeName,
+  IN UINT8   Width
+  )
+{
+  SVfrDataField       *pNewField  = NULL;
+  SVfrDataType        *pFieldType = NULL;
+  SVfrDataField       *pTmp;
+  UINT32              Align;
+
+  CHECK_ERROR_RETURN (GetDataType (TypeName, &pFieldType), VFR_RETURN_SUCCESS);
+
+  if (strlen (FieldName) >= MAX_NAME_LEN) {
+   return VFR_RETURN_INVALID_PARAMETER;
+  }
+
+  for (pTmp = mNewDataType->mMembers; pTmp != NULL; pTmp = pTmp->mNext) {
+    if (strcmp (pTmp->mFieldName, FieldName) == 0) {
+      return VFR_RETURN_REDEFINED;
+    }
+  }
+
+  if ((pNewField = new SVfrDataField) == NULL) {
+    return VFR_RETURN_OUT_FOR_RESOURCES;
+  }
+
+  strcpy (pNewField->mFieldName, FieldName);
+  pNewField->mFieldType    = pFieldType;
+  pNewField->mIsBitField   = TRUE;
+  pNewField->mBitWidth     = Width;
+
+  if (mNewDataType->mMembers == NULL) {
+    mNewDataType->mMembers = pNewField;
+    pNewField->mNext       = NULL;
+    pNewField->mOffset = 0;
+  } else {
+    for (pTmp = mNewDataType->mMembers; pTmp->mNext != NULL; pTmp = 
pTmp->mNext)
+      ;
+    pTmp->mNext            = pNewField;
+    pNewField->mNext       = NULL;
+  }
+
+  mNewDataType->mAlign     = MIN (mPackAlign, MAX (pFieldType->mAlign, 
mNewDataType->mAlign));
+
+  mNewDataType->mHasBitField = TRUE;
+
+  return VFR_RETURN_SUCCESS;
+}
+
+EFI_VFR_RETURN_CODE
 CVfrVarDataTypeDB::DataTypeAddField (
   IN CHAR8   *FieldName,
   IN CHAR8   *TypeName,
   IN UINT32 ArrayNum
   )
@@ -1039,10 +1149,11 @@ CVfrVarDataTypeDB::DataTypeAddField (
     return VFR_RETURN_OUT_FOR_RESOURCES;
   }
   strcpy (pNewField->mFieldName, FieldName);
   pNewField->mFieldType    = pFieldType;
   pNewField->mArrayNum     = ArrayNum;
+  pNewField->mIsBitField   = FALSE;
   if ((mNewDataType->mTotalSize % Align) == 0) {
     pNewField->mOffset     = mNewDataType->mTotalSize;
   } else {
     pNewField->mOffset     = mNewDataType->mTotalSize + 
ALIGN_STUFF(mNewDataType->mTotalSize, Align);
   }
@@ -1061,20 +1172,117 @@ CVfrVarDataTypeDB::DataTypeAddField (
 
   return VFR_RETURN_SUCCESS;
 }
 
 VOID
+CVfrVarDataTypeDB::ChangeFieldToBitRepresentation(
+   IN SVfrDataType  *DataType
+  )
+{
+  
+  SVfrDataField   *pTmp;
+  SVfrDataField   *pSTmp;
+  UINT32          Offset;
+  UINT8           Width;
+  UINT32          TotalSize;
+
+  Offset     = 0;
+  Width      = 0;
+  TotalSize  = 0;
+
+
+  for (pTmp = DataType->mMembers; pTmp!= NULL; pTmp = pTmp->mNext) {
+    pTmp->mOffset = 0;
+  }
+
+  for (pTmp = DataType->mMembers; pTmp != NULL; pTmp = pTmp->mNext) {
+    if (pTmp->mIsBitField) {
+      pSTmp = pTmp;
+      while (pSTmp != NULL && pSTmp->mIsBitField) {
+        pSTmp->mOffset += Offset;
+        pTmp = pSTmp;
+        if ((pSTmp->mNext != NULL) &&!(pSTmp->mNext->mIsBitField)) {
+          //
+          // Currect field is bit field, but next field is not bit field
+          //
+          if (Width > 0){
+            TotalSize += pSTmp->mFieldType->mTotalSize;
+            Width += pSTmp->mBitWidth;
+            if (Width > pSTmp->mFieldType->mTotalSize * 8) {
+              Offset += pSTmp->mFieldType->mTotalSize * 8;
+              pSTmp->mOffset += Offset;
+            } else {
+              pSTmp->mOffset += (Width - pSTmp->mBitWidth);
+            }
+            Width = 0;
+            break;
+          }
+          Offset += pSTmp->mFieldType->mTotalSize * 8;
+          TotalSize += pSTmp->mFieldType->mTotalSize;
+          break;
+        } else if ((pSTmp->mNext != NULL) && strcmp 
(pSTmp->mFieldType->mTypeName,pSTmp->mNext->mFieldType->mTypeName) !=0) {
+          //
+          // Currect field is bit field, and next field is also bit field,
+          // but they have different type name.
+          //
+          if (Width > 0){
+            Width += pSTmp->mBitWidth;
+            if (Width > pSTmp->mFieldType->mTotalSize * 8) {
+              Offset += pSTmp->mFieldType->mTotalSize * 8;
+              pSTmp->mOffset += Offset;
+            } else {
+              pSTmp->mOffset += (Width - pSTmp->mBitWidth);
+            }
+            Width = 0;
+          }
+          Offset += pSTmp->mFieldType->mTotalSize * 8;
+          TotalSize += pSTmp->mFieldType->mTotalSize;
+          break;
+        }else {
+          pSTmp->mOffset += Width;
+          Width += pSTmp->mBitWidth;
+          if (Width > pSTmp->mFieldType->mTotalSize * 8) {
+            Offset += pSTmp->mFieldType->mTotalSize * 8;
+            TotalSize += pSTmp->mFieldType->mTotalSize;
+            Width = 0;
+            break;
+          }
+        }
+       if (pSTmp->mNext == NULL) {
+          Offset += pSTmp->mFieldType->mTotalSize * 8;
+          TotalSize += pSTmp->mFieldType->mTotalSize;
+          Width = 0;
+          break;
+        }
+        pSTmp = pSTmp->mNext;
+      }
+    } else {
+      pTmp->mOffset += Offset;
+      pTmp->mBitWidth = pTmp->mFieldType->mTotalSize * 8;
+      Offset += pTmp->mFieldType->mTotalSize * 8;
+      TotalSize += pTmp->mFieldType->mTotalSize;
+    }
+  }
+
+  DataType->mTotalSize = TotalSize;
+}
+
+VOID
 CVfrVarDataTypeDB::DeclareDataTypeEnd (
   VOID
   )
 {
   if (mNewDataType->mTypeName[0] == '\0') {
     return;
   }
 
-  if ((mNewDataType->mTotalSize % mNewDataType->mAlign) !=0) {
-    mNewDataType->mTotalSize += ALIGN_STUFF (mNewDataType->mTotalSize, 
mNewDataType->mAlign);
+  if (mNewDataType->mHasBitField) {
+    ChangeFieldToBitRepresentation (mNewDataType);
+  } else {
+    if ((mNewDataType->mTotalSize % mNewDataType->mAlign) !=0) {
+      mNewDataType->mTotalSize += ALIGN_STUFF (mNewDataType->mTotalSize, 
mNewDataType->mAlign);
+    }
   }
 
   RegisterNewType (mNewDataType);
   if (mFirstNewDataTypeName == NULL) {
     mFirstNewDataTypeName = mNewDataType->mTypeName;
@@ -1170,43 +1378,104 @@ CVfrVarDataTypeDB::GetDataTypeSize (
 EFI_VFR_RETURN_CODE
 CVfrVarDataTypeDB::GetDataFieldInfo (
   IN  CHAR8     *VarStr,
   OUT UINT16   &Offset,
   OUT UINT8    &Type,
+  OUT UINT32   &Size,
+  IN  BOOLEAN  IsBitField
+  )
+{
+  CHAR8               TName[MAX_NAME_LEN], FName[MAX_NAME_LEN];
+  UINT32              ArrayIdx, Tmp;
+  SVfrDataType        *pType  = NULL;
+  SVfrDataField       *pField = NULL;
+  BOOLEAN             IsNestBitField;
+
+  Offset = 0;
+  Type   = EFI_IFR_TYPE_OTHER;
+  Size   = 0;
+
+  CHECK_ERROR_RETURN (ExtractStructTypeName (VarStr, TName), 
VFR_RETURN_SUCCESS);
+  CHECK_ERROR_RETURN (GetDataType (TName, &pType), VFR_RETURN_SUCCESS);
+
+  //
+  // if it is not struct data type
+  //
+  Type  = pType->mType;
+  Size  = pType->mTotalSize;
+
+  while (*VarStr != '\0') {
+    CHECK_ERROR_RETURN(ExtractFieldNameAndArrary(VarStr, FName, ArrayIdx), 
VFR_RETURN_SUCCESS);
+    CHECK_ERROR_RETURN(GetTypeField (FName, pType, pField), 
VFR_RETURN_SUCCESS);
+    pType  = pField->mFieldType;
+    IsNestBitField = pField->mIsBitField;
+    gNestStructureIsBitVar = IsNestBitField;
+    if (!IsBitField && IsNestBitField) {
+      CHECK_ERROR_RETURN(GetFieldOffset (pField, ArrayIdx, Tmp, 
IsNestBitField), VFR_RETURN_SUCCESS);
+      Offset = (UINT16) (Offset * 8 + Tmp);
+      Size   = GetFieldSize (pField, ArrayIdx, IsNestBitField);
+    } else {
+      CHECK_ERROR_RETURN(GetFieldOffset (pField, ArrayIdx, Tmp, IsBitField), 
VFR_RETURN_SUCCESS);
+      Offset = (UINT16) (Offset + Tmp);
+      Size   = GetFieldSize (pField, ArrayIdx, IsBitField);
+    }
+    Type   = GetFieldWidth (pField);
+  }
+  return VFR_RETURN_SUCCESS;
+}
+
+EFI_VFR_RETURN_CODE
+CVfrVarDataTypeDB::GetDataFieldInfo (
+  IN  CHAR8     *VarStr,
+  OUT UINT16   &Offset,
+  OUT UINT8    &Type,
   OUT UINT32   &Size
   )
 {
   CHAR8               TName[MAX_NAME_LEN], FName[MAX_NAME_LEN];
   UINT32              ArrayIdx, Tmp;
   SVfrDataType        *pType  = NULL;
   SVfrDataField       *pField = NULL;
+  BOOLEAN             IsNestBitField;
+  BOOLEAN             IsBitField;
 
   Offset = 0;
   Type   = EFI_IFR_TYPE_OTHER;
   Size   = 0;
 
   CHECK_ERROR_RETURN (ExtractStructTypeName (VarStr, TName), 
VFR_RETURN_SUCCESS);
   CHECK_ERROR_RETURN (GetDataType (TName, &pType), VFR_RETURN_SUCCESS);
 
+  IsBitField = DataTypeHasBitField (TName);
+
   //
   // if it is not struct data type
   //
   Type  = pType->mType;
   Size  = pType->mTotalSize;
 
   while (*VarStr != '\0') {
-       CHECK_ERROR_RETURN(ExtractFieldNameAndArrary(VarStr, FName, ArrayIdx), 
VFR_RETURN_SUCCESS);
+    CHECK_ERROR_RETURN(ExtractFieldNameAndArrary(VarStr, FName, ArrayIdx), 
VFR_RETURN_SUCCESS);
     CHECK_ERROR_RETURN(GetTypeField (FName, pType, pField), 
VFR_RETURN_SUCCESS);
     pType  = pField->mFieldType;
-    CHECK_ERROR_RETURN(GetFieldOffset (pField, ArrayIdx, Tmp), 
VFR_RETURN_SUCCESS);
-    Offset = (UINT16) (Offset + Tmp);
+    IsNestBitField = pField->mIsBitField;
+    gNestStructureIsBitVar = IsNestBitField;
+    if (!IsBitField && IsNestBitField) {
+      CHECK_ERROR_RETURN(GetFieldOffset (pField, ArrayIdx, Tmp, 
IsNestBitField), VFR_RETURN_SUCCESS);
+      Offset = (UINT16) (Offset * 8 + Tmp);
+      Size   = GetFieldSize (pField, ArrayIdx, IsNestBitField);
+    } else {
+      CHECK_ERROR_RETURN(GetFieldOffset (pField, ArrayIdx, Tmp, IsBitField), 
VFR_RETURN_SUCCESS);
+      Offset = (UINT16) (Offset + Tmp);
+      Size   = GetFieldSize (pField, ArrayIdx, IsBitField);
+    }
     Type   = GetFieldWidth (pField);
-    Size   = GetFieldSize (pField, ArrayIdx);
   }
   return VFR_RETURN_SUCCESS;
 }
 
+
 EFI_VFR_RETURN_CODE
 CVfrVarDataTypeDB::GetUserDefinedTypeNameList  (
   OUT CHAR8      ***NameList,
   OUT UINT32    *ListSize
   )
@@ -1347,10 +1616,11 @@ SVfrVarStorageNode::SVfrVarStorageNode (
 SVfrVarStorageNode::SVfrVarStorageNode (
   IN EFI_GUID              *Guid,
   IN CHAR8                 *StoreName,
   IN EFI_VARSTORE_ID       VarStoreId,
   IN SVfrDataType          *DataType,
+  IN BOOLEAN               BitsVarstore,
   IN BOOLEAN               Flag
   )
 {
   if (Guid != NULL) {
     mGuid = *Guid;
@@ -1363,11 +1633,15 @@ SVfrVarStorageNode::SVfrVarStorageNode (
   } else {
     mVarStoreName = NULL;
   }
   mNext                    = NULL;
   mVarStoreId              = VarStoreId;
-  mVarStoreType            = EFI_VFR_VARSTORE_BUFFER;
+  if (BitsVarstore) {
+    mVarStoreType            = EFI_VFR_VARSTORE_BUFFER_BITS;
+  } else {
+    mVarStoreType            = EFI_VFR_VARSTORE_BUFFER;
+  }
   mStorageInfo.mDataType   = DataType;
   mAssignedFlag            = Flag;
 }
 
 SVfrVarStorageNode::SVfrVarStorageNode (
@@ -1415,10 +1689,11 @@ CVfrDataStorage::CVfrDataStorage (
   mFreeVarStoreIdBitMap[0] = 0x80000000;
 
   mBufferVarStoreList      = NULL;
   mEfiVarStoreList         = NULL;
   mNameVarStoreList        = NULL;
+  mBitsBufferStoreList     = NULL;
   mCurrVarStorageNode      = NULL;
   mNewVarStorageNode       = NULL;
   mBufferFieldInfoListHead = NULL;
   mBufferFieldInfoListTail = NULL;
 }
@@ -1442,10 +1717,15 @@ CVfrDataStorage::~CVfrDataStorage (
   while (mNameVarStoreList != NULL) {
     pNode = mNameVarStoreList;
     mNameVarStoreList = mNameVarStoreList->mNext;
     delete pNode;
   }
+  while ( mBitsBufferStoreList != NULL) {
+    pNode =  mBitsBufferStoreList;
+    mBitsBufferStoreList =  mBitsBufferStoreList->mNext;
+    delete pNode;
+  }
   if (mNewVarStorageNode != NULL) {
     delete mNewVarStorageNode;
   }
 }
 
@@ -1661,11 +1941,11 @@ CVfrDataStorage::DeclareBufferVarStore (
       return VFR_RETURN_VARSTOREID_REDEFINED;
     }
     MarkVarStoreIdUsed (VarStoreId);
   }
 
-  if ((pNew = new SVfrVarStorageNode (Guid, StoreName, VarStoreId, pDataType, 
Flag)) == NULL) {
+  if ((pNew = new SVfrVarStorageNode (Guid, StoreName, VarStoreId, pDataType, 
FALSE, Flag)) == NULL) {
     return VFR_RETURN_OUT_FOR_RESOURCES;
   }
 
   pNew->mNext         = mBufferVarStoreList;
   mBufferVarStoreList = pNew;
@@ -1676,10 +1956,57 @@ CVfrDataStorage::DeclareBufferVarStore (
 
   return VFR_RETURN_SUCCESS;
 }
 
 EFI_VFR_RETURN_CODE 
+CVfrDataStorage::DeclareBitsBufferVarStore (
+  IN CHAR8             *StoreName, 
+  IN EFI_GUID          *Guid, 
+  IN CVfrVarDataTypeDB *DataTypeDB,
+  IN CHAR8             *TypeName,
+  IN EFI_VARSTORE_ID   VarStoreId,
+  IN BOOLEAN           Flag
+  )
+{
+  SVfrVarStorageNode   *pNew = NULL;
+  SVfrDataType         *pDataType = NULL;
+  EFI_VARSTORE_ID      TempVarStoreId;
+
+  if ((StoreName == NULL) || (Guid == NULL) || (DataTypeDB == NULL)) {
+    return VFR_RETURN_FATAL_ERROR;
+  }
+
+  if (GetVarStoreId (StoreName, &TempVarStoreId, Guid) == VFR_RETURN_SUCCESS) {
+    return VFR_RETURN_REDEFINED;
+  }
+
+  CHECK_ERROR_RETURN(DataTypeDB->GetDataType (TypeName, &pDataType), 
VFR_RETURN_SUCCESS);
+
+  if (VarStoreId == EFI_VARSTORE_ID_INVALID) {
+    VarStoreId = GetFreeVarStoreId (EFI_VFR_VARSTORE_BUFFER);
+  } else {
+    if (ChekVarStoreIdFree (VarStoreId) == FALSE) {
+      return VFR_RETURN_VARSTOREID_REDEFINED;
+    }
+    MarkVarStoreIdUsed (VarStoreId);
+  }
+
+  if ((pNew = new SVfrVarStorageNode (Guid, StoreName, VarStoreId, pDataType, 
TRUE, Flag)) == NULL) {
+    return VFR_RETURN_OUT_FOR_RESOURCES;
+  }
+
+  pNew->mNext         = mBitsBufferStoreList;
+  mBitsBufferStoreList = pNew;
+
+  if (gCVfrBufferConfig.Register(StoreName, Guid) != 0) {
+    return VFR_RETURN_FATAL_ERROR;
+  }
+
+  return VFR_RETURN_SUCCESS;
+}
+
+EFI_VFR_RETURN_CODE 
 CVfrDataStorage::GetVarStoreByDataType (
   IN  CHAR8              *DataTypeName,
   OUT SVfrVarStorageNode **VarNode,
   IN  EFI_GUID           *VarGuid
   )
@@ -1813,10 +2140,18 @@ CVfrDataStorage::GetVarStoreId (
         *VarStoreId = mCurrVarStorageNode->mVarStoreId;
         return ReturnCode;
       }
     }
   }
+  for (pNode = mBitsBufferStoreList; pNode != NULL; pNode = pNode->mNext) {
+    if (strcmp (pNode->mVarStoreName, StoreName) == 0) {
+      if (CheckGuidField(pNode, StoreGuid, &HasFoundOne, &ReturnCode)) {
+        *VarStoreId = mCurrVarStorageNode->mVarStoreId;
+        return ReturnCode;
+      }
+    }
+  }
 
   if (HasFoundOne) {
     *VarStoreId = mCurrVarStorageNode->mVarStoreId;
     return VFR_RETURN_SUCCESS;
   }
@@ -1852,10 +2187,17 @@ CVfrDataStorage::GetBufferVarStoreDataTypeName (
       *DataTypeName = pNode->mStorageInfo.mDataType->mTypeName;
       return VFR_RETURN_SUCCESS;
     }
   }
 
+  for (pNode = mBitsBufferStoreList; pNode != NULL; pNode = pNode->mNext) {
+    if (pNode->mVarStoreId == VarStoreId) {
+      *DataTypeName = pNode->mStorageInfo.mDataType->mTypeName;
+       return VFR_RETURN_SUCCESS;
+    }
+  }
+
   return VFR_RETURN_UNDEFINED;
 }
 
 EFI_VFR_VARSTORE_TYPE
 CVfrDataStorage::GetVarStoreType (
@@ -1890,10 +2232,17 @@ CVfrDataStorage::GetVarStoreType (
       VarStoreType = pNode->mVarStoreType;
       return VarStoreType;
     }
   }
 
+  for (pNode = mBitsBufferStoreList; pNode != NULL; pNode = pNode->mNext) {
+    if (pNode->mVarStoreId == VarStoreId) {
+      VarStoreType = pNode->mVarStoreType;
+      return VarStoreType;
+    }
+  }
+
   return VarStoreType;
 }
 
 EFI_GUID *
 CVfrDataStorage::GetVarStoreGuid (
@@ -1928,10 +2277,17 @@ CVfrDataStorage::GetVarStoreGuid (
       VarGuid = &pNode->mGuid;
       return VarGuid;
     }
   }
 
+  for (pNode = mBitsBufferStoreList; pNode != NULL; pNode = pNode->mNext) {
+    if (pNode->mVarStoreId == VarStoreId) {
+      VarGuid = &pNode->mGuid;
+      return VarGuid;
+    }
+  }
+
   return VarGuid;
 }
 
 EFI_VFR_RETURN_CODE
 CVfrDataStorage::GetVarStoreName (
@@ -1964,10 +2320,18 @@ CVfrDataStorage::GetVarStoreName (
       *VarStoreName = pNode->mVarStoreName;
       return VFR_RETURN_SUCCESS;
     }
   }
 
+  for (pNode = mBitsBufferStoreList; pNode != NULL; pNode = pNode->mNext) {
+    if (pNode->mVarStoreId == VarStoreId) {
+      *VarStoreName = pNode->mVarStoreName;
+      return VFR_RETURN_SUCCESS;
+    }
+  }
+
+
   *VarStoreName = NULL;
   return VFR_RETURN_UNDEFINED;
 }
 
 EFI_VFR_RETURN_CODE
@@ -2375,10 +2739,11 @@ EFI_VARSTORE_INFO::EFI_VARSTORE_INFO (
   mVarStoreId      = EFI_VARSTORE_ID_INVALID;
   mInfo.mVarName   = EFI_STRING_ID_INVALID;
   mInfo.mVarOffset = EFI_VAROFFSET_INVALID;
   mVarType         = EFI_IFR_TYPE_OTHER;
   mVarTotalSize    = 0;
+  mIsBitVar        = FALSE;
 }
 
 EFI_VARSTORE_INFO::EFI_VARSTORE_INFO (
   IN EFI_VARSTORE_INFO &Info
   )
@@ -2386,10 +2751,11 @@ EFI_VARSTORE_INFO::EFI_VARSTORE_INFO (
   mVarStoreId      = Info.mVarStoreId;
   mInfo.mVarName   = Info.mInfo.mVarName;
   mInfo.mVarOffset = Info.mInfo.mVarOffset;
   mVarType         = Info.mVarType;
   mVarTotalSize    = Info.mVarTotalSize;
+  mIsBitVar        = Info.mIsBitVar;
 }
 
 EFI_VARSTORE_INFO&
 EFI_VARSTORE_INFO::operator= (
   IN CONST EFI_VARSTORE_INFO &Info
@@ -2399,10 +2765,11 @@ EFI_VARSTORE_INFO::operator= (
     mVarStoreId      = Info.mVarStoreId;
     mInfo.mVarName   = Info.mInfo.mVarName;
     mInfo.mVarOffset = Info.mInfo.mVarOffset;
     mVarType         = Info.mVarType;
     mVarTotalSize    = Info.mVarTotalSize;
+    mIsBitVar        = Info.mIsBitVar;
   }
 
   return *this;
 }
 
@@ -2413,11 +2780,12 @@ EFI_VARSTORE_INFO::operator == (
 {
   if ((mVarStoreId == Info->mVarStoreId) &&
          (mInfo.mVarName == Info->mInfo.mVarName) &&
       (mInfo.mVarOffset == Info->mInfo.mVarOffset) &&
       (mVarType == Info->mVarType) &&
-      (mVarTotalSize == Info->mVarTotalSize)) {
+      (mVarTotalSize == Info->mVarTotalSize) &&
+      (mIsBitVar == Info->mIsBitVar)) {
     return TRUE;
   }
 
   return FALSE;
 }
@@ -3715,11 +4083,13 @@ CVfrStringDB::GetUnicodeStringTextSize (
   }
 
   return StringSize;
 }
 
-BOOLEAN  VfrCompatibleMode = FALSE;
+BOOLEAN  VfrCompatibleMode      = FALSE;
+BOOLEAN  gNestStructureIsBitVar = FALSE;
+EFI_GUID gBitVarstoreGuid  = {0x82DDD68B, 0x9163, 0x4187, {0x9B, 0x27, 0x20, 
0xA8, 0xFD, 0x60 ,0xA7 , 0x1D}};
 
 CVfrVarDataTypeDB gCVfrVarDataTypeDB;
 CVfrDefaultStore  gCVfrDefaultStore;
 CVfrDataStorage  gCVfrDataStorage;
 
diff --git a/BaseTools/Source/C/VfrCompile/VfrUtilityLib.h 
b/BaseTools/Source/C/VfrCompile/VfrUtilityLib.h
index 59509c3..2adfba7 100644
--- a/BaseTools/Source/C/VfrCompile/VfrUtilityLib.h
+++ b/BaseTools/Source/C/VfrCompile/VfrUtilityLib.h
@@ -1,10 +1,10 @@
 /** @file
   
   Vfr common library functions.
 
-Copyright (c) 2004 - 2016, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2004 - 2017, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials                          
 are licensed and made available under the terms and conditions of the BSD 
License         
 which accompanies this distribution.  The full text of the license may be 
found at        
 http://opensource.org/licenses/bsd-license.php                                 
           
                                                                                
           
@@ -20,10 +20,12 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER 
EXPRESS OR IMPLIED.
 #include "Common/UefiBaseTypes.h"
 #include "EfiVfr.h"
 #include "VfrError.h"
 
 extern BOOLEAN  VfrCompatibleMode;
+extern EFI_GUID gBitVarstoreGuid;
+extern BOOLEAN  gNestStructureIsBitVar;
 
 #define MAX_NAME_LEN                       64
 #define MAX_STRING_LEN                     0x100
 #define DEFAULT_ALIGN                      1
 #define DEFAULT_PACK_ALIGN                 0x8
@@ -114,18 +116,21 @@ struct SVfrDataType;
 struct SVfrDataField {
   CHAR8                     mFieldName[MAX_NAME_LEN];
   SVfrDataType              *mFieldType;
   UINT32                    mOffset;
   UINT32                    mArrayNum;
+  BOOLEAN                   mIsBitField;
+  UINT8                     mBitWidth;
   SVfrDataField             *mNext;
 };
 
 struct SVfrDataType {
   CHAR8                     mTypeName[MAX_NAME_LEN];
   UINT8                     mType;
   UINT32                    mAlign;
   UINT32                    mTotalSize;
+  BOOLEAN                   mHasBitField;
   SVfrDataField             *mMembers;
   SVfrDataType              *mNext;
 };
 
 #define VFR_PACK_ASSIGN     0x01
@@ -183,40 +188,46 @@ private:
 public:
   EFI_VFR_RETURN_CODE       Pack (IN UINT32, IN UINT8, IN CHAR8 *Identifier = 
NULL, IN UINT32 Number = DEFAULT_PACK_ALIGN);
 
 private:
   SVfrDataType              *mDataTypeList;
+  SVfrDataType              *mBitsTypeList;
 
   SVfrDataType              *mNewDataType;
   SVfrDataType              *mCurrDataType;
   SVfrDataField             *mCurrDataField;
 
   VOID InternalTypesListInit (VOID);
   VOID RegisterNewType (IN SVfrDataType *);
+  VOID RegisterNewBitsType (IN SVfrDataType *);
 
   EFI_VFR_RETURN_CODE ExtractStructTypeName (IN CHAR8 *&, OUT CHAR8 *);
   EFI_VFR_RETURN_CODE GetTypeField (IN CONST CHAR8 *, IN SVfrDataType *, IN 
SVfrDataField *&);
-  EFI_VFR_RETURN_CODE GetFieldOffset (IN SVfrDataField *, IN UINT32, OUT 
UINT32 &);
+  EFI_VFR_RETURN_CODE GetFieldOffset (IN SVfrDataField *, IN UINT32, OUT 
UINT32 &, IN  BOOLEAN);
   UINT8               GetFieldWidth (IN SVfrDataField *);
-  UINT32              GetFieldSize (IN SVfrDataField *, IN UINT32);
+  UINT32              GetFieldSize (IN SVfrDataField *, IN UINT32, IN BOOLEAN);
 
 public:
   CVfrVarDataTypeDB (VOID);
   ~CVfrVarDataTypeDB (VOID);
 
   VOID                DeclareDataTypeBegin (VOID);
   EFI_VFR_RETURN_CODE SetNewTypeName (IN CHAR8 *);
   EFI_VFR_RETURN_CODE DataTypeAddField (IN CHAR8 *, IN CHAR8 *, IN UINT32);
+  EFI_VFR_RETURN_CODE DataTypeAddBitField (IN CHAR8 *, IN CHAR8 *, IN UINT8);
   VOID                DeclareDataTypeEnd (VOID);
+  VOID                ChangeFieldToBitRepresentation( IN SVfrDataType *);
 
   EFI_VFR_RETURN_CODE GetDataType (IN CHAR8 *, OUT SVfrDataType **);
   EFI_VFR_RETURN_CODE GetDataTypeSize (IN CHAR8 *, OUT UINT32 *);
   EFI_VFR_RETURN_CODE GetDataTypeSize (IN UINT8, OUT UINT32 *);
+  EFI_VFR_RETURN_CODE GetDataFieldInfo (IN CHAR8 *, OUT UINT16 &, OUT UINT8 &, 
OUT UINT32 &, IN  BOOLEAN);
   EFI_VFR_RETURN_CODE GetDataFieldInfo (IN CHAR8 *, OUT UINT16 &, OUT UINT8 &, 
OUT UINT32 &);
 
   EFI_VFR_RETURN_CODE GetUserDefinedTypeNameList (OUT CHAR8 ***, OUT UINT32 *);
   EFI_VFR_RETURN_CODE ExtractFieldNameAndArrary (IN CHAR8 *&, OUT CHAR8 *, OUT 
UINT32 &);
+  BOOLEAN             DataTypeHasBitField (IN  CHAR8 *);
 
   BOOLEAN             IsTypeNameDefined (IN CHAR8 *);
 
   VOID                Dump(IN FILE *);
   //
@@ -236,11 +247,12 @@ extern CVfrVarDataTypeDB  gCVfrVarDataTypeDB;
 
 typedef enum {
   EFI_VFR_VARSTORE_INVALID,
   EFI_VFR_VARSTORE_BUFFER,
   EFI_VFR_VARSTORE_EFI,
-  EFI_VFR_VARSTORE_NAME
+  EFI_VFR_VARSTORE_NAME,
+  EFI_VFR_VARSTORE_BUFFER_BITS
 } EFI_VFR_VARSTORE_TYPE;
 
 struct SVfrVarStorageNode {
   EFI_GUID                  mGuid;
   CHAR8                     *mVarStoreName;
@@ -266,11 +278,11 @@ struct SVfrVarStorageNode {
     } mNameSpace;
   } mStorageInfo;
 
 public:
   SVfrVarStorageNode (IN EFI_GUID *, IN CHAR8 *, IN EFI_VARSTORE_ID, IN 
EFI_STRING_ID, IN UINT32, IN BOOLEAN Flag = TRUE);
-  SVfrVarStorageNode (IN EFI_GUID *, IN CHAR8 *, IN EFI_VARSTORE_ID, IN 
SVfrDataType *, IN BOOLEAN Flag = TRUE);
+  SVfrVarStorageNode (IN EFI_GUID *, IN CHAR8 *, IN EFI_VARSTORE_ID, IN 
SVfrDataType *,IN BOOLEAN, IN BOOLEAN Flag = TRUE);
   SVfrVarStorageNode (IN CHAR8 *, IN EFI_VARSTORE_ID);
   ~SVfrVarStorageNode (VOID);
 
 private:
   SVfrVarStorageNode (IN CONST SVfrVarStorageNode&);             // Prevent 
copy-construction
@@ -283,10 +295,11 @@ struct EFI_VARSTORE_INFO {
     EFI_STRING_ID           mVarName;
     UINT16                  mVarOffset;
   } mInfo;
   UINT8                     mVarType;
   UINT32                    mVarTotalSize;
+  BOOLEAN                   mIsBitVar;
 
   EFI_VARSTORE_INFO (VOID);
   EFI_VARSTORE_INFO (IN EFI_VARSTORE_INFO &);
   EFI_VARSTORE_INFO& operator=(IN CONST EFI_VARSTORE_INFO &);
   BOOLEAN operator == (IN EFI_VARSTORE_INFO *);
@@ -308,10 +321,11 @@ private:
   UINT32                    
mFreeVarStoreIdBitMap[EFI_FREE_VARSTORE_ID_BITMAP_SIZE];
 
   struct SVfrVarStorageNode *mBufferVarStoreList;
   struct SVfrVarStorageNode *mEfiVarStoreList;
   struct SVfrVarStorageNode *mNameVarStoreList;
+  struct SVfrVarStorageNode *mBitsBufferStoreList;
 
   struct SVfrVarStorageNode *mCurrVarStorageNode;
   struct SVfrVarStorageNode *mNewVarStorageNode;
   BufferVarStoreFieldInfoNode    *mBufferFieldInfoListHead;
   BufferVarStoreFieldInfoNode    *mBufferFieldInfoListTail;
@@ -342,10 +356,11 @@ public:
   EFI_VFR_RETURN_CODE DeclareNameVarStoreEnd (EFI_GUID *);
 
   EFI_VFR_RETURN_CODE DeclareEfiVarStore (IN CHAR8 *, IN EFI_GUID *, IN 
EFI_STRING_ID, IN UINT32, IN BOOLEAN Flag = TRUE);
 
   EFI_VFR_RETURN_CODE DeclareBufferVarStore (IN CHAR8 *, IN EFI_GUID *, IN 
CVfrVarDataTypeDB *, IN CHAR8 *, IN EFI_VARSTORE_ID, IN BOOLEAN Flag = TRUE);
+  EFI_VFR_RETURN_CODE DeclareBitsBufferVarStore (IN CHAR8 *, IN EFI_GUID *, IN 
CVfrVarDataTypeDB *, IN CHAR8 *, IN EFI_VARSTORE_ID, IN BOOLEAN Flag = TRUE);
 
   EFI_VFR_RETURN_CODE GetVarStoreId (IN CHAR8 *, OUT EFI_VARSTORE_ID *, IN 
EFI_GUID *VarGuid = NULL);
   EFI_VFR_VARSTORE_TYPE GetVarStoreType (IN EFI_VARSTORE_ID);
   EFI_GUID *          GetVarStoreGuid (IN  EFI_VARSTORE_ID);
   EFI_VFR_RETURN_CODE GetVarStoreName (IN EFI_VARSTORE_ID, OUT CHAR8 **);
-- 
1.9.5.msysgit.1

_______________________________________________
edk2-devel mailing list
edk2-devel@lists.01.org
https://lists.01.org/mailman/listinfo/edk2-devel

Reply via email to