BaseTools: resolve initialization order errors in VfrFormPkg.h
authorzenith432 <zenith432@users.sourceforge.net>
Wed, 6 Dec 2017 16:46:37 +0000 (16:46 +0000)
committerLiming Gao <liming.gao@intel.com>
Tue, 2 Jan 2018 12:37:38 +0000 (20:37 +0800)
clang generates many warnings
warning: field 'XXX' is uninitialized when used here [-Wuninitialized]
for VfrFormPkg.h.

VfrFormPkg.h defines many classes derived from CIfrObj (along with other
base classes.)
Each of these derived classes defines a non-static member field that serves
as a duplicate pointer to an original pointer defined in the CIfrObj base
class, but cast to a different pointer type.
The derived class constructor passes the duplicate pointer to base class
constructors:
1) Once passes the address of the duplicate pointer to the CIfrObj
   constructor to have it initialized.
2) Then passes the duplicate pointer to one or more subsequent base class
   constructors to be used.
Both 1) and 2) constitute undefined behavior in C++.  C++ prescribes that
base classes are initialized before non-static members when initializing a
derived class.  So when base class constructors are executing, it is not
permitted to assume any non-static members of the derived class exist (even
to the stage of having their storage allocated.)

clang does not issue warnings for 1), but issues warnings -Wuninitialized
for 2).

This coding methodology is resolved as follows:
a) The CIfrObj object accessor method for retrieving the original pointer
   is revised to a template member function that returns the original
   pointer cast to a desired target type.
b) The call to CIfrObj constructor is no longer used to initialize the
   duplicate pointer in the derived class.
c) Any subsequent calls to a base class constructor that need to use the
   pointer, retrieve it from the CIfrObj base class using the template
   accessor method.
d) If the derived class makes no further use of the pointer, then the
   duplicate pointer defined in it is eliminated.
e) If the derived class needs the duplicate pointer for other use, the
   duplicate pointer remains in the derived class and is initialized in
   proper order from the original pointer in CIfrObj.
f) Existing source code that previously used the CIfrObj pointer accessor
   method is revised to use the template method.

Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Zenith432 <zenith432@users.sourceforge.net>
Reviewed-by: Liming Gao <liming.gao@intel.com>
BaseTools/Source/C/VfrCompile/VfrFormPkg.cpp
BaseTools/Source/C/VfrCompile/VfrFormPkg.h
BaseTools/Source/C/VfrCompile/VfrSyntax.g

index 0f0efd4c6d0b42912deefeed555fdf1c6f6a1b5e..090ee13ef9da2e1b2402294d4d1908d50e5f8999 100644 (file)
@@ -844,7 +844,7 @@ CFormPkg::DeclarePendingQuestion (
   // DisableIf\r
   CIfrDisableIf DIObj;\r
   DIObj.SetLineNo (LineNo);\r
-  *InsertOpcodeAddr = DIObj.GetObjBinAddr ();\r
+  *InsertOpcodeAddr = DIObj.GetObjBinAddr<CHAR8>();\r
   \r
   //TrueOpcode\r
   CIfrTrue TObj (LineNo);\r
@@ -1925,7 +1925,7 @@ CIfrRecordInfoDB::IfrCreateDefaultForQuestion (
           Obj = new CIfrObj (pOpHead->OpCode, NULL, pSNode->mBinBufLen, FALSE);\r
           assert (Obj != NULL);\r
           Obj->SetLineNo (pSNode->mLineNo);\r
-          ObjBinBuf = Obj->GetObjBinAddr();\r
+          ObjBinBuf = Obj->GetObjBinAddr<CHAR8>();\r
           memcpy (ObjBinBuf, pSNode->mIfrBinBuf, (UINTN)pSNode->mBinBufLen);\r
           delete Obj;\r
           pSNode = pSNode->mNext;\r
index 8a22cb24e4b7be97f85b6f94b7e765a20f5175aa..822f861983f8c77a1fc4969032dfcd452645ba81 100644 (file)
@@ -278,8 +278,9 @@ public:
     mLineNo = LineNo;\r
   }\r
 \r
-  inline CHAR8 * GetObjBinAddr (VOID) {\r
-    return mObjBinBuf;\r
+  template<typename T>\r
+  inline T * GetObjBinAddr (VOID) {\r
+    return reinterpret_cast<T *>(mObjBinBuf);\r
   }\r
 \r
   inline UINT32 GetObjBinOffset (VOID) {\r
@@ -665,8 +666,8 @@ private:
   EFI_GUID *mClassGuid;\r
 \r
 public:\r
-  CIfrFormSet (UINT8 Size) : CIfrObj (EFI_IFR_FORM_SET_OP, (CHAR8 **)&mFormSet, Size),\r
-                   CIfrOpHeader (EFI_IFR_FORM_SET_OP, &mFormSet->Header, Size) {\r
+  CIfrFormSet (UINT8 Size) : CIfrObj (EFI_IFR_FORM_SET_OP, (CHAR8 **)NULL, Size),\r
+                   CIfrOpHeader (EFI_IFR_FORM_SET_OP, &(GetObjBinAddr<EFI_IFR_FORM_SET>())->Header, Size), mFormSet(GetObjBinAddr<EFI_IFR_FORM_SET>()) {\r
     mFormSet->Help         = EFI_STRING_ID_INVALID;\r
     mFormSet->FormSetTitle = EFI_STRING_ID_INVALID;\r
     mFormSet->Flags        = 0;\r
@@ -696,12 +697,9 @@ public:
 };\r
 \r
 class CIfrEnd : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_END  *mEnd;\r
-\r
 public:\r
-  CIfrEnd () : CIfrObj (EFI_IFR_END_OP, (CHAR8 **)&mEnd),\r
-               CIfrOpHeader (EFI_IFR_END_OP, &mEnd->Header) {}\r
+  CIfrEnd () : CIfrObj (EFI_IFR_END_OP),\r
+               CIfrOpHeader (EFI_IFR_END_OP, &(GetObjBinAddr<EFI_IFR_END>())->Header) {}\r
 };\r
 \r
 class CIfrDefaultStore : public CIfrObj, public CIfrOpHeader {\r
@@ -709,8 +707,8 @@ private:
   EFI_IFR_DEFAULTSTORE *mDefaultStore;\r
 \r
 public:\r
-  CIfrDefaultStore () : CIfrObj (EFI_IFR_DEFAULTSTORE_OP, (CHAR8 **)&mDefaultStore),\r
-                       CIfrOpHeader (EFI_IFR_DEFAULTSTORE_OP, &mDefaultStore->Header) {\r
+  CIfrDefaultStore () : CIfrObj (EFI_IFR_DEFAULTSTORE_OP),\r
+                       CIfrOpHeader (EFI_IFR_DEFAULTSTORE_OP, &(GetObjBinAddr<EFI_IFR_DEFAULTSTORE>())->Header), mDefaultStore(GetObjBinAddr<EFI_IFR_DEFAULTSTORE>()) {\r
     mDefaultStore->DefaultId   = EFI_VARSTORE_ID_INVALID;\r
     mDefaultStore->DefaultName = EFI_STRING_ID_INVALID;\r
   }\r
@@ -751,8 +749,8 @@ private:
   EFI_IFR_FORM  *mForm;\r
 \r
 public:\r
-  CIfrForm () : CIfrObj (EFI_IFR_FORM_OP, (CHAR8 **)&mForm), \r
-                CIfrOpHeader (EFI_IFR_FORM_OP, &mForm->Header) {\r
+  CIfrForm () : CIfrObj (EFI_IFR_FORM_OP),\r
+                CIfrOpHeader (EFI_IFR_FORM_OP, &(GetObjBinAddr<EFI_IFR_FORM>())->Header), mForm(GetObjBinAddr<EFI_IFR_FORM>()) {\r
     mForm->FormId    = 0;\r
     mForm->FormTitle = EFI_STRING_ID_INVALID;\r
   }\r
@@ -783,8 +781,8 @@ private:
   EFI_IFR_FORM_MAP_METHOD *mMethodMap;\r
 \r
 public:\r
-  CIfrFormMap () : CIfrObj (EFI_IFR_FORM_MAP_OP, (CHAR8 **)&mFormMap, sizeof (EFI_IFR_FORM_MAP), TRUE), \r
-                   CIfrOpHeader (EFI_IFR_FORM_MAP_OP, &mFormMap->Header) {\r
+  CIfrFormMap () : CIfrObj (EFI_IFR_FORM_MAP_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_FORM_MAP), TRUE),\r
+                   CIfrOpHeader (EFI_IFR_FORM_MAP_OP, &(GetObjBinAddr<EFI_IFR_FORM_MAP>())->Header), mFormMap(GetObjBinAddr<EFI_IFR_FORM_MAP>()) {\r
     mFormMap->FormId = 0;\r
     mMethodMap       = (EFI_IFR_FORM_MAP_METHOD *) (mFormMap + 1);\r
   }\r
@@ -820,8 +818,8 @@ private:
   EFI_IFR_VARSTORE *mVarStore;\r
 \r
 public:\r
-  CIfrVarStore () : CIfrObj (EFI_IFR_VARSTORE_OP, (CHAR8 **)&mVarStore, sizeof (EFI_IFR_VARSTORE), TRUE), \r
-                   CIfrOpHeader (EFI_IFR_VARSTORE_OP, &mVarStore->Header) {\r
+  CIfrVarStore () : CIfrObj (EFI_IFR_VARSTORE_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_VARSTORE), TRUE),\r
+                   CIfrOpHeader (EFI_IFR_VARSTORE_OP, &(GetObjBinAddr<EFI_IFR_VARSTORE>())->Header), mVarStore(GetObjBinAddr<EFI_IFR_VARSTORE>()) {\r
     mVarStore->VarStoreId = EFI_VARSTORE_ID_INVALID;\r
     mVarStore->Size       = 0;\r
     memset (&mVarStore->Guid, 0, sizeof (EFI_GUID));\r
@@ -860,8 +858,8 @@ private:
   EFI_IFR_VARSTORE_EFI *mVarStoreEfi;\r
 \r
 public:\r
-  CIfrVarStoreEfi () : CIfrObj (EFI_IFR_VARSTORE_EFI_OP, (CHAR8 **)&mVarStoreEfi, sizeof (EFI_IFR_VARSTORE_EFI), TRUE),\r
-                      CIfrOpHeader (EFI_IFR_VARSTORE_EFI_OP, &mVarStoreEfi->Header) {\r
+  CIfrVarStoreEfi () : CIfrObj (EFI_IFR_VARSTORE_EFI_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_VARSTORE_EFI), TRUE),\r
+                      CIfrOpHeader (EFI_IFR_VARSTORE_EFI_OP, &(GetObjBinAddr<EFI_IFR_VARSTORE_EFI>())->Header), mVarStoreEfi(GetObjBinAddr<EFI_IFR_VARSTORE_EFI>()) {\r
     mVarStoreEfi->VarStoreId = EFI_VAROFFSET_INVALID;\r
     mVarStoreEfi->Size       = 0;\r
     memset (&mVarStoreEfi->Guid, 0, sizeof (EFI_GUID));\r
@@ -916,8 +914,8 @@ private:
   EFI_IFR_VARSTORE_NAME_VALUE *mVarStoreNameValue;\r
 \r
 public:\r
-  CIfrVarStoreNameValue () : CIfrObj (EFI_IFR_VARSTORE_NAME_VALUE_OP, (CHAR8 **)&mVarStoreNameValue), \r
-                              CIfrOpHeader (EFI_IFR_VARSTORE_NAME_VALUE_OP, &mVarStoreNameValue->Header) {\r
+  CIfrVarStoreNameValue () : CIfrObj (EFI_IFR_VARSTORE_NAME_VALUE_OP),\r
+                              CIfrOpHeader (EFI_IFR_VARSTORE_NAME_VALUE_OP, &(GetObjBinAddr<EFI_IFR_VARSTORE_NAME_VALUE>())->Header), mVarStoreNameValue(GetObjBinAddr<EFI_IFR_VARSTORE_NAME_VALUE>()) {\r
     mVarStoreNameValue->VarStoreId = EFI_VAROFFSET_INVALID;\r
     memset (&mVarStoreNameValue->Guid, 0, sizeof (EFI_GUID));\r
   }\r
@@ -936,8 +934,8 @@ private:
   EFI_IFR_IMAGE *mImage;\r
 \r
 public:\r
-  CIfrImage () : CIfrObj (EFI_IFR_IMAGE_OP, (CHAR8 **)&mImage),\r
-                 CIfrOpHeader (EFI_IFR_IMAGE_OP, &mImage->Header) {\r
+  CIfrImage () : CIfrObj (EFI_IFR_IMAGE_OP),\r
+                 CIfrOpHeader (EFI_IFR_IMAGE_OP, &(GetObjBinAddr<EFI_IFR_IMAGE>())->Header), mImage(GetObjBinAddr<EFI_IFR_IMAGE>()) {\r
     mImage->Id = EFI_IMAGE_ID_INVALID;\r
   }\r
 \r
@@ -947,23 +945,17 @@ public:
 };\r
 \r
 class CIfrModal : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_MODAL_TAG *mModal;\r
-\r
 public:\r
-  CIfrModal () : CIfrObj (EFI_IFR_MODAL_TAG_OP, (CHAR8 **)&mModal),\r
-                 CIfrOpHeader (EFI_IFR_MODAL_TAG_OP, &mModal->Header) {\r
+  CIfrModal () : CIfrObj (EFI_IFR_MODAL_TAG_OP),\r
+                 CIfrOpHeader (EFI_IFR_MODAL_TAG_OP, &(GetObjBinAddr<EFI_IFR_MODAL_TAG>())->Header) {\r
   }\r
 };\r
 \r
 \r
 class CIfrLocked : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_LOCKED *mLocked;\r
-\r
 public:\r
-  CIfrLocked () : CIfrObj (EFI_IFR_LOCKED_OP, (CHAR8 **)&mLocked),\r
-                  CIfrOpHeader (EFI_IFR_LOCKED_OP, &mLocked->Header) {}\r
+  CIfrLocked () : CIfrObj (EFI_IFR_LOCKED_OP),\r
+                  CIfrOpHeader (EFI_IFR_LOCKED_OP, &(GetObjBinAddr<EFI_IFR_LOCKED>())->Header) {}\r
 };\r
 \r
 class CIfrRule : public CIfrObj, public CIfrOpHeader {\r
@@ -971,9 +963,8 @@ private:
   EFI_IFR_RULE *mRule;\r
 \r
 public:\r
-  CIfrRule () : CIfrObj (EFI_IFR_RULE_OP, (CHAR8 **)&mRule),\r
-                mRule ((EFI_IFR_RULE *)GetObjBinAddr()),\r
-                CIfrOpHeader (EFI_IFR_RULE_OP, &mRule->Header) {\r
+  CIfrRule () : CIfrObj (EFI_IFR_RULE_OP),\r
+                CIfrOpHeader (EFI_IFR_RULE_OP, &(GetObjBinAddr<EFI_IFR_RULE>())->Header), mRule(GetObjBinAddr<EFI_IFR_RULE>()) {\r
     mRule->RuleId = EFI_RULE_ID_INVALID;\r
   }\r
 \r
@@ -994,8 +985,8 @@ public:
     IN UINT16             DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD,\r
     IN UINT8              Type      = EFI_IFR_TYPE_OTHER,\r
     IN EFI_IFR_TYPE_VALUE Value     = gZeroEfiIfrTypeValue\r
-    ) : CIfrObj (EFI_IFR_DEFAULT_OP, (CHAR8 **)&mDefault, Size),\r
-        CIfrOpHeader (EFI_IFR_DEFAULT_OP, &mDefault->Header, Size) {\r
+    ) : CIfrObj (EFI_IFR_DEFAULT_OP, (CHAR8 **)NULL, Size),\r
+        CIfrOpHeader (EFI_IFR_DEFAULT_OP, &(GetObjBinAddr<EFI_IFR_DEFAULT>())->Header, Size), mDefault(GetObjBinAddr<EFI_IFR_DEFAULT>()) {\r
     mDefault->Type      = Type;\r
     mDefault->DefaultId = DefaultId;\r
     memmove (&(mDefault->Value), &Value, Size - OFFSET_OF (EFI_IFR_DEFAULT, Value));\r
@@ -1022,8 +1013,8 @@ public:
   CIfrDefault2 (\r
     IN UINT16             DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD,\r
     IN UINT8              Type      = EFI_IFR_TYPE_OTHER\r
-    ) : CIfrObj (EFI_IFR_DEFAULT_OP, (CHAR8 **)&mDefault, sizeof (EFI_IFR_DEFAULT_2)),\r
-        CIfrOpHeader (EFI_IFR_DEFAULT_OP, &mDefault->Header, sizeof (EFI_IFR_DEFAULT_2)) {\r
+    ) : CIfrObj (EFI_IFR_DEFAULT_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_DEFAULT_2)),\r
+        CIfrOpHeader (EFI_IFR_DEFAULT_OP, &(GetObjBinAddr<EFI_IFR_DEFAULT_2>())->Header, sizeof (EFI_IFR_DEFAULT_2)), mDefault(GetObjBinAddr<EFI_IFR_DEFAULT_2>()) {\r
     mDefault->Type      = Type;\r
     mDefault->DefaultId = DefaultId;\r
   }\r
@@ -1038,32 +1029,23 @@ public:
 };\r
 \r
 class CIfrValue : public CIfrObj, public CIfrOpHeader{\r
-private:\r
-  EFI_IFR_VALUE *mValue;\r
-\r
 public:\r
-  CIfrValue () : CIfrObj (EFI_IFR_VALUE_OP, (CHAR8 **)&mValue),\r
-                CIfrOpHeader (EFI_IFR_VALUE_OP, &mValue->Header) {}\r
+  CIfrValue () : CIfrObj (EFI_IFR_VALUE_OP),\r
+                CIfrOpHeader (EFI_IFR_VALUE_OP, &(GetObjBinAddr<EFI_IFR_VALUE>())->Header) {}\r
 \r
 };\r
 \r
 class CIfrRead : public CIfrObj, public CIfrOpHeader{\r
-private:\r
-  EFI_IFR_READ *mRead;\r
-\r
 public:\r
-  CIfrRead () : CIfrObj (EFI_IFR_READ_OP, (CHAR8 **)&mRead),\r
-                CIfrOpHeader (EFI_IFR_READ_OP, &mRead->Header) {}\r
+  CIfrRead () : CIfrObj (EFI_IFR_READ_OP),\r
+                CIfrOpHeader (EFI_IFR_READ_OP, &(GetObjBinAddr<EFI_IFR_READ>())->Header) {}\r
 \r
 };\r
 \r
 class CIfrWrite : public CIfrObj, public CIfrOpHeader{\r
-private:\r
-  EFI_IFR_WRITE *mWrite;\r
-\r
 public:\r
-  CIfrWrite () : CIfrObj (EFI_IFR_WRITE_OP, (CHAR8 **)&mWrite),\r
-                CIfrOpHeader (EFI_IFR_WRITE_OP, &mWrite->Header) {}\r
+  CIfrWrite () : CIfrObj (EFI_IFR_WRITE_OP),\r
+                CIfrOpHeader (EFI_IFR_WRITE_OP, &(GetObjBinAddr<EFI_IFR_WRITE>())->Header) {}\r
 \r
 };\r
 \r
@@ -1074,8 +1056,8 @@ private:
 public:\r
   CIfrGet (\r
   IN UINT32 LineNo  \r
-  ) : CIfrObj (EFI_IFR_GET_OP, (CHAR8 **)&mGet),\r
-      CIfrOpHeader (EFI_IFR_GET_OP, &mGet->Header) {\r
+  ) : CIfrObj (EFI_IFR_GET_OP),\r
+      CIfrOpHeader (EFI_IFR_GET_OP, &(GetObjBinAddr<EFI_IFR_GET>())->Header), mGet(GetObjBinAddr<EFI_IFR_GET>()) {\r
     SetLineNo (LineNo);\r
   }\r
 \r
@@ -1094,8 +1076,8 @@ private:
 public:\r
   CIfrSet (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_SET_OP, (CHAR8 **)&mSet),\r
-      CIfrOpHeader (EFI_IFR_SET_OP, &mSet->Header) {\r
+  ) : CIfrObj (EFI_IFR_SET_OP),\r
+      CIfrOpHeader (EFI_IFR_SET_OP, &(GetObjBinAddr<EFI_IFR_SET>())->Header), mSet(GetObjBinAddr<EFI_IFR_SET>()) {\r
     SetLineNo (LineNo);\r
   }\r
 \r
@@ -1112,9 +1094,9 @@ private:
   EFI_IFR_SUBTITLE   *mSubtitle;\r
 \r
 public:\r
-  CIfrSubtitle () : CIfrObj (EFI_IFR_SUBTITLE_OP, (CHAR8 **)&mSubtitle),\r
-                  CIfrOpHeader (EFI_IFR_SUBTITLE_OP, &mSubtitle->Header),\r
-  CIfrStatementHeader (&mSubtitle->Statement) {\r
+  CIfrSubtitle () : CIfrObj (EFI_IFR_SUBTITLE_OP),\r
+                  CIfrOpHeader (EFI_IFR_SUBTITLE_OP, &(GetObjBinAddr<EFI_IFR_SUBTITLE>())->Header),\r
+  CIfrStatementHeader (&(GetObjBinAddr<EFI_IFR_SUBTITLE>())->Statement), mSubtitle(GetObjBinAddr<EFI_IFR_SUBTITLE>()) {\r
     mSubtitle->Flags = 0;\r
   }\r
 \r
@@ -1132,9 +1114,9 @@ private:
   EFI_IFR_TEXT *mText;\r
 \r
 public:\r
-  CIfrText () : CIfrObj (EFI_IFR_TEXT_OP, (CHAR8 **)&mText),\r
-               CIfrOpHeader (EFI_IFR_TEXT_OP, &mText->Header), \r
-               CIfrStatementHeader (&mText->Statement) {\r
+  CIfrText () : CIfrObj (EFI_IFR_TEXT_OP),\r
+               CIfrOpHeader (EFI_IFR_TEXT_OP, &(GetObjBinAddr<EFI_IFR_TEXT>())->Header),\r
+               CIfrStatementHeader (&(GetObjBinAddr<EFI_IFR_TEXT>())->Statement), mText(GetObjBinAddr<EFI_IFR_TEXT>()) {\r
     mText->TextTwo = EFI_STRING_ID_INVALID;\r
   }\r
 \r
@@ -1148,9 +1130,9 @@ private:
   EFI_IFR_REF *mRef;\r
 \r
 public:\r
-  CIfrRef () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef),\r
-              CIfrOpHeader (EFI_IFR_REF_OP, &mRef->Header), \r
-              CIfrQuestionHeader (&mRef->Question) {\r
+  CIfrRef () : CIfrObj (EFI_IFR_REF_OP),\r
+              CIfrOpHeader (EFI_IFR_REF_OP, &(GetObjBinAddr<EFI_IFR_REF>())->Header),\r
+              CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_REF>())->Question), mRef(GetObjBinAddr<EFI_IFR_REF>()) {\r
     mRef->FormId = 0;\r
   }\r
 \r
@@ -1164,9 +1146,9 @@ private:
   EFI_IFR_REF2 *mRef2;\r
 \r
 public:\r
-  CIfrRef2 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef2, sizeof (EFI_IFR_REF2)),\r
-               CIfrOpHeader (EFI_IFR_REF_OP, &mRef2->Header, sizeof (EFI_IFR_REF2)), \r
-               CIfrQuestionHeader (&mRef2->Question) {\r
+  CIfrRef2 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_REF2)),\r
+               CIfrOpHeader (EFI_IFR_REF_OP, &(GetObjBinAddr<EFI_IFR_REF2>())->Header, sizeof (EFI_IFR_REF2)),\r
+               CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_REF2>())->Question), mRef2(GetObjBinAddr<EFI_IFR_REF2>()) {\r
     mRef2->FormId     = 0;\r
     mRef2->QuestionId = EFI_QUESTION_ID_INVALID;\r
   }\r
@@ -1185,9 +1167,9 @@ private:
   EFI_IFR_REF3 *mRef3;\r
 \r
 public:\r
-  CIfrRef3 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef3, sizeof(EFI_IFR_REF3)),\r
-               CIfrOpHeader (EFI_IFR_REF_OP, &mRef3->Header, sizeof (EFI_IFR_REF3)), \r
-               CIfrQuestionHeader (&mRef3->Question) {\r
+  CIfrRef3 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)NULL, sizeof(EFI_IFR_REF3)),\r
+               CIfrOpHeader (EFI_IFR_REF_OP, &(GetObjBinAddr<EFI_IFR_REF3>())->Header, sizeof (EFI_IFR_REF3)),\r
+               CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_REF3>())->Question), mRef3(GetObjBinAddr<EFI_IFR_REF3>()) {\r
     mRef3->FormId     = 0;\r
     mRef3->QuestionId = EFI_QUESTION_ID_INVALID;\r
     memset (&mRef3->FormSetId, 0, sizeof (EFI_GUID));\r
@@ -1211,9 +1193,9 @@ private:
   EFI_IFR_REF4 *mRef4;\r
 \r
 public:\r
-  CIfrRef4 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef4, sizeof(EFI_IFR_REF4)),\r
-               CIfrOpHeader (EFI_IFR_REF_OP, &mRef4->Header, sizeof(EFI_IFR_REF4)), \r
-               CIfrQuestionHeader (&mRef4->Question) {\r
+  CIfrRef4 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)NULL, sizeof(EFI_IFR_REF4)),\r
+               CIfrOpHeader (EFI_IFR_REF_OP, &(GetObjBinAddr<EFI_IFR_REF4>())->Header, sizeof(EFI_IFR_REF4)),\r
+               CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_REF4>())->Question), mRef4(GetObjBinAddr<EFI_IFR_REF4>()) {\r
     mRef4->FormId     = 0;\r
     mRef4->QuestionId = EFI_QUESTION_ID_INVALID;\r
     memset (&mRef4->FormSetId, 0, sizeof (EFI_GUID));\r
@@ -1238,13 +1220,10 @@ public:
 };\r
 \r
 class CIfrRef5 : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
-private:\r
-  EFI_IFR_REF5 *mRef5;\r
-\r
 public:\r
-  CIfrRef5 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef5, sizeof (EFI_IFR_REF5)),\r
-              CIfrOpHeader (EFI_IFR_REF_OP, &mRef5->Header, sizeof (EFI_IFR_REF5)), \r
-              CIfrQuestionHeader (&mRef5->Question) {\r
+  CIfrRef5 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_REF5)),\r
+              CIfrOpHeader (EFI_IFR_REF_OP, &(GetObjBinAddr<EFI_IFR_REF5>())->Header, sizeof (EFI_IFR_REF5)),\r
+              CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_REF5>())->Question) {\r
   }\r
 };\r
 \r
@@ -1253,9 +1232,9 @@ private:
   EFI_IFR_RESET_BUTTON *mResetButton;\r
 \r
 public:\r
-  CIfrResetButton () : CIfrObj (EFI_IFR_RESET_BUTTON_OP, (CHAR8 **)&mResetButton),\r
-                       CIfrOpHeader (EFI_IFR_RESET_BUTTON_OP, &mResetButton->Header), \r
-  CIfrStatementHeader (&mResetButton->Statement) {\r
+  CIfrResetButton () : CIfrObj (EFI_IFR_RESET_BUTTON_OP),\r
+                       CIfrOpHeader (EFI_IFR_RESET_BUTTON_OP, &(GetObjBinAddr<EFI_IFR_RESET_BUTTON>())->Header),\r
+  CIfrStatementHeader (&(GetObjBinAddr<EFI_IFR_RESET_BUTTON>())->Statement), mResetButton(GetObjBinAddr<EFI_IFR_RESET_BUTTON>()) {\r
     mResetButton->DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD;\r
   }\r
 \r
@@ -1269,9 +1248,9 @@ private:
   EFI_IFR_CHECKBOX *mCheckBox;\r
 \r
 public:\r
-  CIfrCheckBox () : CIfrObj (EFI_IFR_CHECKBOX_OP, (CHAR8 **)&mCheckBox),\r
-                     CIfrOpHeader (EFI_IFR_CHECKBOX_OP, &mCheckBox->Header), \r
-                     CIfrQuestionHeader (&mCheckBox->Question) {\r
+  CIfrCheckBox () : CIfrObj (EFI_IFR_CHECKBOX_OP),\r
+                     CIfrOpHeader (EFI_IFR_CHECKBOX_OP, &(GetObjBinAddr<EFI_IFR_CHECKBOX>())->Header),\r
+                     CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_CHECKBOX>())->Question), mCheckBox(GetObjBinAddr<EFI_IFR_CHECKBOX>()) {\r
     mCheckBox->Flags = 0;\r
     gCurrentQuestion  = this;\r
   }\r
@@ -1309,9 +1288,9 @@ private:
   EFI_IFR_ACTION *mAction;\r
 \r
 public:\r
-  CIfrAction () : CIfrObj (EFI_IFR_ACTION_OP, (CHAR8 **)&mAction),\r
-                 CIfrOpHeader (EFI_IFR_ACTION_OP, &mAction->Header), \r
-                 CIfrQuestionHeader (&mAction->Question) {\r
+  CIfrAction () : CIfrObj (EFI_IFR_ACTION_OP),\r
+                 CIfrOpHeader (EFI_IFR_ACTION_OP, &(GetObjBinAddr<EFI_IFR_ACTION>())->Header),\r
+                 CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_ACTION>())->Question), mAction(GetObjBinAddr<EFI_IFR_ACTION>()) {\r
     mAction->QuestionConfig = EFI_STRING_ID_INVALID;\r
   }\r
 \r
@@ -1325,9 +1304,9 @@ private:
   EFI_IFR_DATE *mDate;\r
 \r
 public:\r
-  CIfrDate () : CIfrObj (EFI_IFR_DATE_OP, (CHAR8 **)&mDate),\r
-               CIfrOpHeader (EFI_IFR_DATE_OP, &mDate->Header),\r
-               CIfrQuestionHeader (&mDate->Question) {\r
+  CIfrDate () : CIfrObj (EFI_IFR_DATE_OP),\r
+               CIfrOpHeader (EFI_IFR_DATE_OP, &(GetObjBinAddr<EFI_IFR_DATE>())->Header),\r
+               CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_DATE>())->Question), mDate(GetObjBinAddr<EFI_IFR_DATE>()) {\r
     mDate->Flags = 0;\r
   }\r
 \r
@@ -1368,10 +1347,10 @@ private:
   EFI_IFR_NUMERIC *mNumeric;\r
 \r
 public:\r
-  CIfrNumeric () : CIfrObj (EFI_IFR_NUMERIC_OP, (CHAR8 **)&mNumeric, sizeof (EFI_IFR_NUMERIC), TRUE),\r
-                   CIfrOpHeader (EFI_IFR_NUMERIC_OP, &mNumeric->Header),\r
-                   CIfrQuestionHeader (&mNumeric->Question),\r
-                   CIfrMinMaxStepData (&mNumeric->data, TRUE) {\r
+  CIfrNumeric () : CIfrObj (EFI_IFR_NUMERIC_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_NUMERIC), TRUE),\r
+                   CIfrOpHeader (EFI_IFR_NUMERIC_OP, &(GetObjBinAddr<EFI_IFR_NUMERIC>())->Header),\r
+                   CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_NUMERIC>())->Question),\r
+                   CIfrMinMaxStepData (&(GetObjBinAddr<EFI_IFR_NUMERIC>())->data, TRUE), mNumeric(GetObjBinAddr<EFI_IFR_NUMERIC>()) {\r
     mNumeric->Flags  = EFI_IFR_NUMERIC_SIZE_1 | EFI_IFR_DISPLAY_UINT_DEC;\r
     gCurrentQuestion   = this;\r
     gCurrentMinMaxData = this;\r
@@ -1397,7 +1376,7 @@ public:
     //\r
     // Update the buffer pointer used by other class.\r
     //\r
-    mNumeric = (EFI_IFR_NUMERIC *) GetObjBinAddr();\r
+    mNumeric = GetObjBinAddr<EFI_IFR_NUMERIC>();\r
     UpdateHeader (&mNumeric->Header);\r
     UpdateCIfrQuestionHeader(&mNumeric->Question);\r
     UpdateCIfrMinMaxStepData(&mNumeric->data);\r
@@ -1445,10 +1424,10 @@ private:
   EFI_IFR_ONE_OF *mOneOf;\r
 \r
 public:\r
-  CIfrOneOf () : CIfrObj (EFI_IFR_ONE_OF_OP, (CHAR8 **)&mOneOf, sizeof (EFI_IFR_ONE_OF), TRUE),\r
-                 CIfrOpHeader (EFI_IFR_ONE_OF_OP, &mOneOf->Header),\r
-                 CIfrQuestionHeader (&mOneOf->Question),\r
-                 CIfrMinMaxStepData (&mOneOf->data) {\r
+  CIfrOneOf () : CIfrObj (EFI_IFR_ONE_OF_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_ONE_OF), TRUE),\r
+                 CIfrOpHeader (EFI_IFR_ONE_OF_OP, &(GetObjBinAddr<EFI_IFR_ONE_OF>())->Header),\r
+                 CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_ONE_OF>())->Question),\r
+                 CIfrMinMaxStepData (&(GetObjBinAddr<EFI_IFR_ONE_OF>())->data), mOneOf(GetObjBinAddr<EFI_IFR_ONE_OF>()) {\r
     mOneOf->Flags    = 0;\r
     gCurrentQuestion   = this;\r
     gCurrentMinMaxData = this;\r
@@ -1506,7 +1485,7 @@ public:
     //\r
     // Update the buffer pointer used by other class.\r
     //\r
-    mOneOf = (EFI_IFR_ONE_OF *) GetObjBinAddr();\r
+    mOneOf = GetObjBinAddr<EFI_IFR_ONE_OF>();\r
     UpdateHeader (&mOneOf->Header);\r
     UpdateCIfrQuestionHeader(&mOneOf->Question);\r
     UpdateCIfrMinMaxStepData(&mOneOf->data);\r
@@ -1518,9 +1497,9 @@ private:
   EFI_IFR_STRING *mString;\r
 \r
 public:\r
-  CIfrString () : CIfrObj (EFI_IFR_STRING_OP, (CHAR8 **)&mString),\r
-                 CIfrOpHeader (EFI_IFR_STRING_OP, &mString->Header),\r
-                 CIfrQuestionHeader (&mString->Question) {\r
+  CIfrString () : CIfrObj (EFI_IFR_STRING_OP),\r
+                 CIfrOpHeader (EFI_IFR_STRING_OP, &(GetObjBinAddr<EFI_IFR_STRING>())->Header),\r
+                 CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_STRING>())->Question), mString(GetObjBinAddr<EFI_IFR_STRING>()) {\r
     mString->Flags   = 0;\r
     mString->MinSize = 0;\r
     mString->MaxSize = 0;\r
@@ -1560,9 +1539,9 @@ private:
   EFI_IFR_PASSWORD *mPassword;\r
 \r
 public:\r
-  CIfrPassword () : CIfrObj (EFI_IFR_PASSWORD_OP, (CHAR8 **)&mPassword),\r
-                    CIfrOpHeader (EFI_IFR_PASSWORD_OP, &mPassword->Header),\r
-                    CIfrQuestionHeader (&mPassword->Question) {\r
+  CIfrPassword () : CIfrObj (EFI_IFR_PASSWORD_OP),\r
+                    CIfrOpHeader (EFI_IFR_PASSWORD_OP, &(GetObjBinAddr<EFI_IFR_PASSWORD>())->Header),\r
+                    CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_PASSWORD>())->Question), mPassword(GetObjBinAddr<EFI_IFR_PASSWORD>()) {\r
     mPassword->MinSize = 0;\r
     mPassword->MaxSize = 0;\r
     gCurrentQuestion   = this;\r
@@ -1586,9 +1565,9 @@ private:
   EFI_IFR_ORDERED_LIST *mOrderedList;\r
 \r
 public:\r
-  CIfrOrderedList () : CIfrObj (EFI_IFR_ORDERED_LIST_OP, (CHAR8 **)&mOrderedList),\r
-                      CIfrOpHeader (EFI_IFR_ORDERED_LIST_OP, &mOrderedList->Header),\r
-                      CIfrQuestionHeader (&mOrderedList->Question) {\r
+  CIfrOrderedList () : CIfrObj (EFI_IFR_ORDERED_LIST_OP),\r
+                      CIfrOpHeader (EFI_IFR_ORDERED_LIST_OP, &(GetObjBinAddr<EFI_IFR_ORDERED_LIST>())->Header),\r
+                      CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_ORDERED_LIST>())->Question), mOrderedList(GetObjBinAddr<EFI_IFR_ORDERED_LIST>()) {\r
     mOrderedList->MaxContainers = 0;\r
     mOrderedList->Flags         = 0;\r
     gCurrentQuestion            = this;\r
@@ -1627,9 +1606,9 @@ private:
   EFI_IFR_TIME *mTime;\r
 \r
 public:\r
-  CIfrTime () : CIfrObj (EFI_IFR_TIME_OP, (CHAR8 **)&mTime),\r
-                CIfrOpHeader (EFI_IFR_TIME_OP, &mTime->Header),\r
-                CIfrQuestionHeader (&mTime->Question) {\r
+  CIfrTime () : CIfrObj (EFI_IFR_TIME_OP),\r
+                CIfrOpHeader (EFI_IFR_TIME_OP, &(GetObjBinAddr<EFI_IFR_TIME>())->Header),\r
+                CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_TIME>())->Question), mTime(GetObjBinAddr<EFI_IFR_TIME>()) {\r
     mTime->Flags = 0;\r
   }\r
 \r
@@ -1666,31 +1645,21 @@ public:
 };\r
 \r
 class CIfrDisableIf : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_DISABLE_IF *mDisableIf;\r
-\r
 public:\r
-  CIfrDisableIf () : CIfrObj (EFI_IFR_DISABLE_IF_OP, (CHAR8 **)&mDisableIf),\r
-                   mDisableIf ((EFI_IFR_DISABLE_IF *) GetObjBinAddr()),\r
-                   CIfrOpHeader (EFI_IFR_DISABLE_IF_OP, &mDisableIf->Header) {}\r
+  CIfrDisableIf () : CIfrObj (EFI_IFR_DISABLE_IF_OP),\r
+                   CIfrOpHeader (EFI_IFR_DISABLE_IF_OP, &(GetObjBinAddr<EFI_IFR_DISABLE_IF>())->Header) {}\r
 };\r
 \r
 class CIfrSuppressIf : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_SUPPRESS_IF *mSuppressIf;\r
-\r
 public:\r
-  CIfrSuppressIf () : CIfrObj (EFI_IFR_SUPPRESS_IF_OP, (CHAR8 **)&mSuppressIf),\r
-                     CIfrOpHeader (EFI_IFR_SUPPRESS_IF_OP, &mSuppressIf->Header) {}\r
+  CIfrSuppressIf () : CIfrObj (EFI_IFR_SUPPRESS_IF_OP),\r
+                     CIfrOpHeader (EFI_IFR_SUPPRESS_IF_OP, &(GetObjBinAddr<EFI_IFR_SUPPRESS_IF>())->Header) {}\r
 };\r
 \r
 class CIfrGrayOutIf : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_GRAY_OUT_IF *mGrayOutIf;\r
-\r
 public:\r
-  CIfrGrayOutIf () : CIfrObj (EFI_IFR_GRAY_OUT_IF_OP, (CHAR8 **)&mGrayOutIf),\r
-                    CIfrOpHeader (EFI_IFR_GRAY_OUT_IF_OP, &mGrayOutIf->Header) {}\r
+  CIfrGrayOutIf () : CIfrObj (EFI_IFR_GRAY_OUT_IF_OP),\r
+                    CIfrOpHeader (EFI_IFR_GRAY_OUT_IF_OP, &(GetObjBinAddr<EFI_IFR_GRAY_OUT_IF>())->Header) {}\r
 };\r
 \r
 class CIfrInconsistentIf : public CIfrObj, public CIfrOpHeader {\r
@@ -1698,8 +1667,8 @@ private:
   EFI_IFR_INCONSISTENT_IF *mInconsistentIf;\r
 \r
 public:\r
-  CIfrInconsistentIf () : CIfrObj (EFI_IFR_INCONSISTENT_IF_OP, (CHAR8 **)&mInconsistentIf),\r
-                        CIfrOpHeader (EFI_IFR_INCONSISTENT_IF_OP, &mInconsistentIf->Header) {\r
+  CIfrInconsistentIf () : CIfrObj (EFI_IFR_INCONSISTENT_IF_OP),\r
+                        CIfrOpHeader (EFI_IFR_INCONSISTENT_IF_OP, &(GetObjBinAddr<EFI_IFR_INCONSISTENT_IF>())->Header), mInconsistentIf(GetObjBinAddr<EFI_IFR_INCONSISTENT_IF>()) {\r
     mInconsistentIf->Error = EFI_STRING_ID_INVALID;\r
   }\r
 \r
@@ -1713,8 +1682,8 @@ private:
   EFI_IFR_WARNING_IF *mWarningIf;\r
 \r
 public:\r
-  CIfrWarningIf () : CIfrObj (EFI_IFR_WARNING_IF_OP, (CHAR8 **)&mWarningIf),\r
-                        CIfrOpHeader (EFI_IFR_WARNING_IF_OP, &mWarningIf->Header) {\r
+  CIfrWarningIf () : CIfrObj (EFI_IFR_WARNING_IF_OP),\r
+                        CIfrOpHeader (EFI_IFR_WARNING_IF_OP, &(GetObjBinAddr<EFI_IFR_WARNING_IF>())->Header), mWarningIf(GetObjBinAddr<EFI_IFR_WARNING_IF>()) {\r
     mWarningIf->Warning = EFI_STRING_ID_INVALID;\r
     mWarningIf->TimeOut = 0;\r
   }\r
@@ -1733,8 +1702,8 @@ private:
   EFI_IFR_NO_SUBMIT_IF *mNoSubmitIf;\r
 \r
 public:\r
-  CIfrNoSubmitIf () : CIfrObj (EFI_IFR_NO_SUBMIT_IF_OP, (CHAR8 **)&mNoSubmitIf),\r
-                     CIfrOpHeader (EFI_IFR_NO_SUBMIT_IF_OP, &mNoSubmitIf->Header) {\r
+  CIfrNoSubmitIf () : CIfrObj (EFI_IFR_NO_SUBMIT_IF_OP),\r
+                     CIfrOpHeader (EFI_IFR_NO_SUBMIT_IF_OP, &(GetObjBinAddr<EFI_IFR_NO_SUBMIT_IF>())->Header), mNoSubmitIf(GetObjBinAddr<EFI_IFR_NO_SUBMIT_IF>()) {\r
     mNoSubmitIf->Error = EFI_STRING_ID_INVALID;\r
   }\r
 \r
@@ -1748,8 +1717,8 @@ private:
   EFI_IFR_REFRESH *mRefresh;\r
 \r
 public:\r
-  CIfrRefresh () : CIfrObj (EFI_IFR_REFRESH_OP, (CHAR8 **)&mRefresh),\r
-                  CIfrOpHeader (EFI_IFR_REFRESH_OP, &mRefresh->Header) {\r
+  CIfrRefresh () : CIfrObj (EFI_IFR_REFRESH_OP),\r
+                  CIfrOpHeader (EFI_IFR_REFRESH_OP, &(GetObjBinAddr<EFI_IFR_REFRESH>())->Header), mRefresh(GetObjBinAddr<EFI_IFR_REFRESH>()) {\r
     mRefresh->RefreshInterval = 0;\r
   }\r
 \r
@@ -1763,8 +1732,8 @@ private:
   EFI_IFR_REFRESH_ID *mRefreshId;\r
 \r
 public:\r
-  CIfrRefreshId () : CIfrObj (EFI_IFR_REFRESH_ID_OP, (CHAR8 **)&mRefreshId),\r
-      CIfrOpHeader (EFI_IFR_REFRESH_ID_OP, &mRefreshId->Header) {\r
+  CIfrRefreshId () : CIfrObj (EFI_IFR_REFRESH_ID_OP),\r
+      CIfrOpHeader (EFI_IFR_REFRESH_ID_OP, &(GetObjBinAddr<EFI_IFR_REFRESH_ID>())->Header), mRefreshId(GetObjBinAddr<EFI_IFR_REFRESH_ID>()) {\r
     memset (&mRefreshId->RefreshEventGroupId, 0, sizeof (EFI_GUID));\r
   }\r
 \r
@@ -1778,8 +1747,8 @@ private:
   EFI_IFR_VARSTORE_DEVICE *mVarStoreDevice;\r
 \r
 public:\r
-  CIfrVarStoreDevice () : CIfrObj (EFI_IFR_VARSTORE_DEVICE_OP, (CHAR8 **)&mVarStoreDevice),\r
-                          CIfrOpHeader (EFI_IFR_VARSTORE_DEVICE_OP, &mVarStoreDevice->Header) {\r
+  CIfrVarStoreDevice () : CIfrObj (EFI_IFR_VARSTORE_DEVICE_OP),\r
+                          CIfrOpHeader (EFI_IFR_VARSTORE_DEVICE_OP, &(GetObjBinAddr<EFI_IFR_VARSTORE_DEVICE>())->Header), mVarStoreDevice(GetObjBinAddr<EFI_IFR_VARSTORE_DEVICE>()) {\r
     mVarStoreDevice->DevicePath = EFI_STRING_ID_INVALID;\r
   }\r
 \r
@@ -1793,8 +1762,8 @@ private:
   EFI_IFR_ONE_OF_OPTION *mOneOfOption;\r
 \r
 public:\r
-  CIfrOneOfOption (UINT8 Size) : CIfrObj (EFI_IFR_ONE_OF_OPTION_OP, (CHAR8 **)&mOneOfOption, Size),\r
-                       CIfrOpHeader (EFI_IFR_ONE_OF_OPTION_OP, &mOneOfOption->Header, Size) {\r
+  CIfrOneOfOption (UINT8 Size) : CIfrObj (EFI_IFR_ONE_OF_OPTION_OP, (CHAR8 **)NULL, Size),\r
+                       CIfrOpHeader (EFI_IFR_ONE_OF_OPTION_OP, &(GetObjBinAddr<EFI_IFR_ONE_OF_OPTION>())->Header, Size), mOneOfOption(GetObjBinAddr<EFI_IFR_ONE_OF_OPTION>()) {\r
     mOneOfOption->Flags  = 0;\r
     mOneOfOption->Option = EFI_STRING_ID_INVALID;\r
     mOneOfOption->Type   = EFI_IFR_TYPE_OTHER;\r
@@ -1868,8 +1837,8 @@ private:
   EFI_IFR_GUID_CLASS *mClass;\r
 \r
 public:\r
-  CIfrClass () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mClass, sizeof (EFI_IFR_GUID_CLASS)),\r
-                CIfrOpHeader (EFI_IFR_GUID_OP, &mClass->Header, sizeof (EFI_IFR_GUID_CLASS)) {\r
+  CIfrClass () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID_CLASS)),\r
+                CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr<EFI_IFR_GUID_CLASS>())->Header, sizeof (EFI_IFR_GUID_CLASS)), mClass(GetObjBinAddr<EFI_IFR_GUID_CLASS>()) {\r
     mClass->ExtendOpCode = EFI_IFR_EXTEND_OP_CLASS;\r
     mClass->Guid         = IfrTianoGuid;\r
     mClass->Class        = EFI_NON_DEVICE_CLASS;\r
@@ -1885,8 +1854,8 @@ private:
   EFI_IFR_GUID_SUBCLASS *mSubClass;\r
 \r
 public:\r
-  CIfrSubClass () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mSubClass, sizeof (EFI_IFR_GUID_SUBCLASS)),\r
-                    CIfrOpHeader (EFI_IFR_GUID_OP, &mSubClass->Header, sizeof (EFI_IFR_GUID_SUBCLASS)) {\r
+  CIfrSubClass () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID_SUBCLASS)),\r
+                    CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr<EFI_IFR_GUID_SUBCLASS>())->Header, sizeof (EFI_IFR_GUID_SUBCLASS)), mSubClass(GetObjBinAddr<EFI_IFR_GUID_SUBCLASS>()) {\r
     mSubClass->ExtendOpCode = EFI_IFR_EXTEND_OP_SUBCLASS;\r
     mSubClass->Guid         = IfrTianoGuid;\r
     mSubClass->SubClass     = EFI_SETUP_APPLICATION_SUBCLASS;\r
@@ -1902,8 +1871,8 @@ private:
   EFI_IFR_GUID_LABEL *mLabel;\r
 \r
 public:\r
-  CIfrLabel () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mLabel, sizeof (EFI_IFR_GUID_LABEL)),\r
-                CIfrOpHeader (EFI_IFR_GUID_OP, &mLabel->Header, sizeof (EFI_IFR_GUID_LABEL)) {\r
+  CIfrLabel () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID_LABEL)),\r
+                CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr<EFI_IFR_GUID_LABEL>())->Header, sizeof (EFI_IFR_GUID_LABEL)), mLabel(GetObjBinAddr<EFI_IFR_GUID_LABEL>()) {\r
     mLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
     mLabel->Guid         = IfrTianoGuid;\r
   }\r
@@ -1918,8 +1887,8 @@ private:
   EFI_IFR_GUID_BANNER *mBanner;\r
 \r
 public:\r
-  CIfrBanner () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mBanner, sizeof (EFI_IFR_GUID_BANNER)),\r
-                  CIfrOpHeader (EFI_IFR_GUID_OP, &mBanner->Header, sizeof (EFI_IFR_GUID_BANNER)) {\r
+  CIfrBanner () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID_BANNER)),\r
+                  CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr<EFI_IFR_GUID_BANNER>())->Header, sizeof (EFI_IFR_GUID_BANNER)), mBanner(GetObjBinAddr<EFI_IFR_GUID_BANNER>()) {\r
     mBanner->ExtendOpCode = EFI_IFR_EXTEND_OP_BANNER;\r
     mBanner->Guid         = IfrTianoGuid;\r
   }\r
@@ -1946,8 +1915,8 @@ public:
     IN EFI_QUESTION_ID QuestionId,\r
     IN EFI_IFR_TYPE_VALUE &OptionValue,\r
     IN EFI_QUESTION_ID KeyValue\r
-  ) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mOptionKey, sizeof (EFI_IFR_GUID_OPTIONKEY)),\r
-      CIfrOpHeader (EFI_IFR_GUID_OP, &mOptionKey->Header, sizeof (EFI_IFR_GUID_OPTIONKEY)) {\r
+  ) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID_OPTIONKEY)),\r
+      CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr<EFI_IFR_GUID_OPTIONKEY>())->Header, sizeof (EFI_IFR_GUID_OPTIONKEY)), mOptionKey(GetObjBinAddr<EFI_IFR_GUID_OPTIONKEY>()) {\r
     mOptionKey->ExtendOpCode = EFI_IFR_EXTEND_OP_OPTIONKEY;\r
     mOptionKey->Guid         = IfrFrameworkGuid;\r
     mOptionKey->QuestionId   = QuestionId;\r
@@ -1964,8 +1933,8 @@ public:
   CIfrVarEqName (\r
     IN EFI_QUESTION_ID QuestionId,\r
     IN EFI_STRING_ID   NameId\r
-  ) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mVarEqName, sizeof (EFI_IFR_GUID_VAREQNAME)),\r
-      CIfrOpHeader (EFI_IFR_GUID_OP, &mVarEqName->Header, sizeof (EFI_IFR_GUID_VAREQNAME)) {\r
+  ) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID_VAREQNAME)),\r
+      CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr<EFI_IFR_GUID_VAREQNAME>())->Header, sizeof (EFI_IFR_GUID_VAREQNAME)), mVarEqName(GetObjBinAddr<EFI_IFR_GUID_VAREQNAME>()) {\r
     mVarEqName->ExtendOpCode = EFI_IFR_EXTEND_OP_VAREQNAME;\r
     mVarEqName->Guid         = IfrFrameworkGuid;\r
     mVarEqName->QuestionId   = QuestionId;\r
@@ -1978,8 +1947,8 @@ private:
   EFI_IFR_GUID_TIMEOUT *mTimeout;\r
 \r
 public:\r
-  CIfrTimeout (IN UINT16 Timeout = 0) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mTimeout, sizeof (EFI_IFR_GUID_TIMEOUT)),\r
-                                        CIfrOpHeader (EFI_IFR_GUID_OP, &mTimeout->Header, sizeof (EFI_IFR_GUID_TIMEOUT)) {\r
+  CIfrTimeout (IN UINT16 Timeout = 0) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID_TIMEOUT)),\r
+                                        CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr<EFI_IFR_GUID_TIMEOUT>())->Header, sizeof (EFI_IFR_GUID_TIMEOUT)), mTimeout(GetObjBinAddr<EFI_IFR_GUID_TIMEOUT>()) {\r
     mTimeout->ExtendOpCode = EFI_IFR_EXTEND_OP_TIMEOUT;\r
     mTimeout->Guid         = IfrTianoGuid;\r
     mTimeout->TimeOut      = Timeout;\r
@@ -1995,8 +1964,8 @@ private:
   EFI_IFR_GUID *mGuid;\r
 \r
 public:\r
-  CIfrGuid (UINT8 Size) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mGuid, sizeof (EFI_IFR_GUID)+Size),\r
-                  CIfrOpHeader (EFI_IFR_GUID_OP, &mGuid->Header, sizeof (EFI_IFR_GUID)+Size) {\r
+  CIfrGuid (UINT8 Size) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID)+Size),\r
+                  CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr<EFI_IFR_GUID>())->Header, sizeof (EFI_IFR_GUID)+Size), mGuid(GetObjBinAddr<EFI_IFR_GUID>()) {\r
     memset (&mGuid->Guid, 0, sizeof (EFI_GUID));\r
   }\r
 \r
@@ -2010,14 +1979,11 @@ public:
 };\r
 \r
 class CIfrDup : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_DUP *mDup;\r
-\r
 public:\r
   CIfrDup (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_DUP_OP, (CHAR8 **)&mDup),\r
-      CIfrOpHeader (EFI_IFR_DUP_OP, &mDup->Header) {\r
+  ) : CIfrObj (EFI_IFR_DUP_OP),\r
+      CIfrOpHeader (EFI_IFR_DUP_OP, &(GetObjBinAddr<EFI_IFR_DUP>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
@@ -2029,8 +1995,8 @@ private:
 public:\r
   CIfrEqIdId (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_EQ_ID_ID_OP, (CHAR8 **)&mEqIdId),\r
-                 CIfrOpHeader (EFI_IFR_EQ_ID_ID_OP, &mEqIdId->Header) {\r
+  ) : CIfrObj (EFI_IFR_EQ_ID_ID_OP),\r
+                 CIfrOpHeader (EFI_IFR_EQ_ID_ID_OP, &(GetObjBinAddr<EFI_IFR_EQ_ID_ID>())->Header), mEqIdId(GetObjBinAddr<EFI_IFR_EQ_ID_ID>()) {\r
     SetLineNo (LineNo);\r
     mEqIdId->QuestionId1 = EFI_QUESTION_ID_INVALID;\r
     mEqIdId->QuestionId2 = EFI_QUESTION_ID_INVALID;\r
@@ -2068,8 +2034,8 @@ private:
 public:\r
   CIfrEqIdVal (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_EQ_ID_VAL_OP, (CHAR8 **)&mEqIdVal),\r
-      CIfrOpHeader (EFI_IFR_EQ_ID_VAL_OP, &mEqIdVal->Header) {\r
+  ) : CIfrObj (EFI_IFR_EQ_ID_VAL_OP),\r
+      CIfrOpHeader (EFI_IFR_EQ_ID_VAL_OP, &(GetObjBinAddr<EFI_IFR_EQ_ID_VAL>())->Header), mEqIdVal(GetObjBinAddr<EFI_IFR_EQ_ID_VAL>()) {\r
     SetLineNo (LineNo);\r
     mEqIdVal->QuestionId = EFI_QUESTION_ID_INVALID;\r
   }\r
@@ -2098,8 +2064,8 @@ private:
 public:\r
   CIfrEqIdList (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_EQ_ID_VAL_LIST_OP, (CHAR8 **)&mEqIdVList, sizeof (EFI_IFR_EQ_ID_VAL_LIST), TRUE),\r
-                   CIfrOpHeader (EFI_IFR_EQ_ID_VAL_LIST_OP, &mEqIdVList->Header) {\r
+  ) : CIfrObj (EFI_IFR_EQ_ID_VAL_LIST_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_EQ_ID_VAL_LIST), TRUE),\r
+                   CIfrOpHeader (EFI_IFR_EQ_ID_VAL_LIST_OP, &(GetObjBinAddr<EFI_IFR_EQ_ID_VAL_LIST>())->Header), mEqIdVList(GetObjBinAddr<EFI_IFR_EQ_ID_VAL_LIST>()) {\r
     SetLineNo (LineNo);\r
     mEqIdVList->QuestionId   = EFI_QUESTION_ID_INVALID;\r
     mEqIdVList->ListLength   = 0;\r
@@ -2109,7 +2075,7 @@ public:
   VOID UpdateIfrBuffer ( \r
   ) {\r
     _EMIT_PENDING_OBJ();\r
-    mEqIdVList = (EFI_IFR_EQ_ID_VAL_LIST *) GetObjBinAddr();\r
+    mEqIdVList = GetObjBinAddr<EFI_IFR_EQ_ID_VAL_LIST>();\r
     UpdateHeader (&mEqIdVList->Header);\r
   }\r
 \r
@@ -2149,8 +2115,8 @@ private:
 public:\r
   CIfrQuestionRef1 (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_QUESTION_REF1_OP, (CHAR8 **)&mQuestionRef1),\r
-      CIfrOpHeader (EFI_IFR_QUESTION_REF1_OP, &mQuestionRef1->Header) {\r
+  ) : CIfrObj (EFI_IFR_QUESTION_REF1_OP),\r
+      CIfrOpHeader (EFI_IFR_QUESTION_REF1_OP, &(GetObjBinAddr<EFI_IFR_QUESTION_REF1>())->Header), mQuestionRef1(GetObjBinAddr<EFI_IFR_QUESTION_REF1>()) {\r
     SetLineNo (LineNo);\r
     mQuestionRef1->QuestionId = EFI_QUESTION_ID_INVALID;\r
   }\r
@@ -2169,27 +2135,21 @@ public:
 };\r
 \r
 class CIfrQuestionRef2 : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_QUESTION_REF2 *mQuestionRef2;\r
-\r
 public:\r
   CIfrQuestionRef2 (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_QUESTION_REF2_OP, (CHAR8 **)&mQuestionRef2),\r
-      CIfrOpHeader (EFI_IFR_QUESTION_REF2_OP, &mQuestionRef2->Header) {\r
+  ) : CIfrObj (EFI_IFR_QUESTION_REF2_OP),\r
+      CIfrOpHeader (EFI_IFR_QUESTION_REF2_OP, &(GetObjBinAddr<EFI_IFR_QUESTION_REF2>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrQuestionRef3 : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_QUESTION_REF3 *mQuestionRef3;\r
-\r
 public:\r
   CIfrQuestionRef3 (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)&mQuestionRef3),\r
-      CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &mQuestionRef3->Header) {\r
+  ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP),\r
+      CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &(GetObjBinAddr<EFI_IFR_QUESTION_REF3>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
@@ -2201,8 +2161,8 @@ private:
 public:\r
   CIfrQuestionRef3_2 (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)&mQuestionRef3_2, sizeof (EFI_IFR_QUESTION_REF3_2)),\r
-      CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &mQuestionRef3_2->Header, sizeof (EFI_IFR_QUESTION_REF3_2)) {\r
+  ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_QUESTION_REF3_2)),\r
+      CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &(GetObjBinAddr<EFI_IFR_QUESTION_REF3_2>())->Header, sizeof (EFI_IFR_QUESTION_REF3_2)), mQuestionRef3_2(GetObjBinAddr<EFI_IFR_QUESTION_REF3_2>()) {\r
     SetLineNo (LineNo);\r
     mQuestionRef3_2->DevicePath = EFI_STRING_ID_INVALID;\r
   }\r
@@ -2219,8 +2179,8 @@ private:
 public:\r
   CIfrQuestionRef3_3 (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)&mQuestionRef3_3, sizeof (EFI_IFR_QUESTION_REF3_3)),\r
-      CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &mQuestionRef3_3->Header, sizeof (EFI_IFR_QUESTION_REF3_3)) {\r
+  ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_QUESTION_REF3_3)),\r
+      CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &(GetObjBinAddr<EFI_IFR_QUESTION_REF3_3>())->Header, sizeof (EFI_IFR_QUESTION_REF3_3)), mQuestionRef3_3(GetObjBinAddr<EFI_IFR_QUESTION_REF3_3>()) {\r
     SetLineNo (LineNo);\r
     mQuestionRef3_3->DevicePath = EFI_STRING_ID_INVALID;\r
     memset (&mQuestionRef3_3->Guid, 0, sizeof (EFI_GUID));\r
@@ -2242,8 +2202,8 @@ private:
 public:\r
   CIfrRuleRef (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_RULE_REF_OP, (CHAR8 **)&mRuleRef),\r
-      CIfrOpHeader (EFI_IFR_RULE_REF_OP, &mRuleRef->Header) {\r
+  ) : CIfrObj (EFI_IFR_RULE_REF_OP),\r
+      CIfrOpHeader (EFI_IFR_RULE_REF_OP, &(GetObjBinAddr<EFI_IFR_RULE_REF>())->Header), mRuleRef(GetObjBinAddr<EFI_IFR_RULE_REF>()) {\r
     SetLineNo (LineNo);\r
     mRuleRef->RuleId = EFI_RULE_ID_INVALID;\r
   }\r
@@ -2260,8 +2220,8 @@ private:
 public:\r
   CIfrStringRef1 (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_STRING_REF1_OP, (CHAR8 **)&mStringRef1),\r
-      CIfrOpHeader (EFI_IFR_STRING_REF1_OP, &mStringRef1->Header) {\r
+  ) : CIfrObj (EFI_IFR_STRING_REF1_OP),\r
+      CIfrOpHeader (EFI_IFR_STRING_REF1_OP, &(GetObjBinAddr<EFI_IFR_STRING_REF1>())->Header), mStringRef1(GetObjBinAddr<EFI_IFR_STRING_REF1>()) {\r
     SetLineNo (LineNo);\r
     mStringRef1->StringId = EFI_STRING_ID_INVALID;\r
   }\r
@@ -2272,27 +2232,21 @@ public:
 };\r
 \r
 class CIfrStringRef2 : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_STRING_REF2 *mStringRef2;\r
-\r
 public:\r
   CIfrStringRef2 (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_STRING_REF2_OP, (CHAR8 **)&mStringRef2),\r
-      CIfrOpHeader (EFI_IFR_STRING_REF2_OP, &mStringRef2->Header) {\r
+  ) : CIfrObj (EFI_IFR_STRING_REF2_OP),\r
+      CIfrOpHeader (EFI_IFR_STRING_REF2_OP, &(GetObjBinAddr<EFI_IFR_STRING_REF2>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrThis : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_THIS *mThis;\r
-\r
 public:\r
   CIfrThis (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_THIS_OP, (CHAR8 **)&mThis),\r
-      CIfrOpHeader (EFI_IFR_THIS_OP, &mThis->Header) {\r
+  ) : CIfrObj (EFI_IFR_THIS_OP),\r
+      CIfrOpHeader (EFI_IFR_THIS_OP, &(GetObjBinAddr<EFI_IFR_THIS>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
@@ -2304,8 +2258,8 @@ private:
 public:\r
   CIfrSecurity (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_SECURITY_OP, (CHAR8 **)&mSecurity),\r
-      CIfrOpHeader (EFI_IFR_SECURITY_OP, &mSecurity->Header) {\r
+  ) : CIfrObj (EFI_IFR_SECURITY_OP),\r
+      CIfrOpHeader (EFI_IFR_SECURITY_OP, &(GetObjBinAddr<EFI_IFR_SECURITY>())->Header), mSecurity(GetObjBinAddr<EFI_IFR_SECURITY>()) {\r
     SetLineNo (LineNo);\r
     memset (&mSecurity->Permissions, 0, sizeof (EFI_GUID));\r
   }\r
@@ -2322,8 +2276,8 @@ private:
 public:\r
   CIfrUint8 (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_UINT8_OP, (CHAR8 **)&mUint8),\r
-      CIfrOpHeader (EFI_IFR_UINT8_OP, &mUint8->Header) {\r
+  ) : CIfrObj (EFI_IFR_UINT8_OP),\r
+      CIfrOpHeader (EFI_IFR_UINT8_OP, &(GetObjBinAddr<EFI_IFR_UINT8>())->Header), mUint8(GetObjBinAddr<EFI_IFR_UINT8>()) {\r
     SetLineNo (LineNo);\r
   }\r
 \r
@@ -2339,8 +2293,8 @@ private:
 public:\r
   CIfrUint16 (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_UINT16_OP, (CHAR8 **)&mUint16),\r
-      CIfrOpHeader (EFI_IFR_UINT16_OP, &mUint16->Header) {\r
+  ) : CIfrObj (EFI_IFR_UINT16_OP),\r
+      CIfrOpHeader (EFI_IFR_UINT16_OP, &(GetObjBinAddr<EFI_IFR_UINT16>())->Header), mUint16(GetObjBinAddr<EFI_IFR_UINT16>()) {\r
     SetLineNo (LineNo);\r
   }\r
 \r
@@ -2356,8 +2310,8 @@ private:
 public:\r
   CIfrUint32 (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_UINT32_OP, (CHAR8 **)&mUint32),\r
-      CIfrOpHeader (EFI_IFR_UINT32_OP, &mUint32->Header) {\r
+  ) : CIfrObj (EFI_IFR_UINT32_OP),\r
+      CIfrOpHeader (EFI_IFR_UINT32_OP, &(GetObjBinAddr<EFI_IFR_UINT32>())->Header), mUint32(GetObjBinAddr<EFI_IFR_UINT32>()) {\r
     SetLineNo (LineNo);\r
   }\r
 \r
@@ -2373,8 +2327,8 @@ private:
 public:\r
   CIfrUint64 (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_UINT64_OP, (CHAR8 **)&mUint64),\r
-      CIfrOpHeader (EFI_IFR_UINT64_OP, &mUint64->Header) {\r
+  ) : CIfrObj (EFI_IFR_UINT64_OP),\r
+      CIfrOpHeader (EFI_IFR_UINT64_OP, &(GetObjBinAddr<EFI_IFR_UINT64>())->Header), mUint64(GetObjBinAddr<EFI_IFR_UINT64>()) {\r
     SetLineNo (LineNo);\r
   }\r
 \r
@@ -2384,144 +2338,111 @@ public:
 };\r
 \r
 class CIfrTrue : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_TRUE *mTrue;\r
-\r
 public:\r
   CIfrTrue (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_TRUE_OP, (CHAR8 **)&mTrue),\r
-      CIfrOpHeader (EFI_IFR_TRUE_OP, &mTrue->Header) {\r
+  ) : CIfrObj (EFI_IFR_TRUE_OP),\r
+      CIfrOpHeader (EFI_IFR_TRUE_OP, &(GetObjBinAddr<EFI_IFR_TRUE>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrFalse : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_FALSE *mFalse;\r
-\r
 public:\r
   CIfrFalse (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_FALSE_OP, (CHAR8 **)&mFalse),\r
-      CIfrOpHeader (EFI_IFR_FALSE_OP, &mFalse->Header) {\r
+  ) : CIfrObj (EFI_IFR_FALSE_OP),\r
+      CIfrOpHeader (EFI_IFR_FALSE_OP, &(GetObjBinAddr<EFI_IFR_FALSE>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrOne : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_ONE *mOne;\r
-\r
 public:\r
   CIfrOne (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_ONE_OP, (CHAR8 **)&mOne),\r
-      CIfrOpHeader (EFI_IFR_ONE_OP, &mOne->Header) {\r
+  ) : CIfrObj (EFI_IFR_ONE_OP),\r
+      CIfrOpHeader (EFI_IFR_ONE_OP, &(GetObjBinAddr<EFI_IFR_ONE>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrOnes : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_ONES *mOnes;\r
-\r
 public:\r
   CIfrOnes (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_ONES_OP, (CHAR8 **)&mOnes),\r
-      CIfrOpHeader (EFI_IFR_ONES_OP, &mOnes->Header) {\r
+  ) : CIfrObj (EFI_IFR_ONES_OP),\r
+      CIfrOpHeader (EFI_IFR_ONES_OP, &(GetObjBinAddr<EFI_IFR_ONES>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrZero : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_ZERO *mZero;\r
-\r
 public:\r
   CIfrZero (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_ZERO_OP, (CHAR8 **)&mZero),\r
-      CIfrOpHeader (EFI_IFR_ZERO_OP, &mZero->Header) {\r
+  ) : CIfrObj (EFI_IFR_ZERO_OP),\r
+      CIfrOpHeader (EFI_IFR_ZERO_OP, &(GetObjBinAddr<EFI_IFR_ZERO>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrUndefined : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_UNDEFINED *mUndefined;\r
-\r
 public:\r
   CIfrUndefined (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_UNDEFINED_OP, (CHAR8 **)&mUndefined),\r
-      CIfrOpHeader (EFI_IFR_UNDEFINED_OP, &mUndefined->Header) {\r
+  ) : CIfrObj (EFI_IFR_UNDEFINED_OP),\r
+      CIfrOpHeader (EFI_IFR_UNDEFINED_OP, &(GetObjBinAddr<EFI_IFR_UNDEFINED>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrVersion : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_VERSION *mVersion;\r
-\r
 public:\r
   CIfrVersion (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_VERSION_OP, (CHAR8 **)&mVersion),\r
-      CIfrOpHeader (EFI_IFR_VERSION_OP, &mVersion->Header) {\r
+  ) : CIfrObj (EFI_IFR_VERSION_OP),\r
+      CIfrOpHeader (EFI_IFR_VERSION_OP, &(GetObjBinAddr<EFI_IFR_VERSION>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrLength : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_LENGTH *mLength;\r
-\r
 public:\r
   CIfrLength (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_LENGTH_OP, (CHAR8 **)&mLength),\r
-      CIfrOpHeader (EFI_IFR_LENGTH_OP, &mLength->Header) {\r
+  ) : CIfrObj (EFI_IFR_LENGTH_OP),\r
+      CIfrOpHeader (EFI_IFR_LENGTH_OP, &(GetObjBinAddr<EFI_IFR_LENGTH>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrNot : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_NOT *mNot;\r
-\r
 public:\r
   CIfrNot (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_NOT_OP, (CHAR8 **)&mNot),\r
-      CIfrOpHeader (EFI_IFR_NOT_OP, &mNot->Header) {\r
+  ) : CIfrObj (EFI_IFR_NOT_OP),\r
+      CIfrOpHeader (EFI_IFR_NOT_OP, &(GetObjBinAddr<EFI_IFR_NOT>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrBitWiseNot : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_BITWISE_NOT *mBitWise;\r
-\r
 public:\r
   CIfrBitWiseNot (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_BITWISE_NOT_OP, (CHAR8 **)&mBitWise),\r
-      CIfrOpHeader (EFI_IFR_BITWISE_NOT_OP, &mBitWise->Header) {\r
+  ) : CIfrObj (EFI_IFR_BITWISE_NOT_OP),\r
+      CIfrOpHeader (EFI_IFR_BITWISE_NOT_OP, &(GetObjBinAddr<EFI_IFR_BITWISE_NOT>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrToBoolean : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_TO_BOOLEAN *mToBoolean;\r
-\r
 public:\r
   CIfrToBoolean (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_TO_BOOLEAN_OP, (CHAR8 **)&mToBoolean),\r
-      CIfrOpHeader (EFI_IFR_TO_BOOLEAN_OP, &mToBoolean->Header) {\r
+  ) : CIfrObj (EFI_IFR_TO_BOOLEAN_OP),\r
+      CIfrOpHeader (EFI_IFR_TO_BOOLEAN_OP, &(GetObjBinAddr<EFI_IFR_TO_BOOLEAN>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
@@ -2533,8 +2454,8 @@ private:
 public:\r
   CIfrToString (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_TO_STRING_OP, (CHAR8 **)&mToString),\r
-      CIfrOpHeader (EFI_IFR_TO_STRING_OP, &mToString->Header) {\r
+  ) : CIfrObj (EFI_IFR_TO_STRING_OP),\r
+      CIfrOpHeader (EFI_IFR_TO_STRING_OP, &(GetObjBinAddr<EFI_IFR_TO_STRING>())->Header), mToString(GetObjBinAddr<EFI_IFR_TO_STRING>()) {\r
     SetLineNo (LineNo);\r
   }\r
 \r
@@ -2544,209 +2465,161 @@ public:
 };\r
 \r
 class CIfrToUint : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_TO_UINT *mToUint;\r
-\r
 public:\r
   CIfrToUint (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_TO_UINT_OP, (CHAR8 **)&mToUint),\r
-      CIfrOpHeader (EFI_IFR_TO_UINT_OP, &mToUint->Header) {\r
+  ) : CIfrObj (EFI_IFR_TO_UINT_OP),\r
+      CIfrOpHeader (EFI_IFR_TO_UINT_OP, &(GetObjBinAddr<EFI_IFR_TO_UINT>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrToUpper : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_TO_UPPER *mToUpper;\r
-\r
 public:\r
   CIfrToUpper (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_TO_UPPER_OP, (CHAR8 **)&mToUpper),\r
-      CIfrOpHeader (EFI_IFR_TO_UPPER_OP, &mToUpper->Header) {\r
+  ) : CIfrObj (EFI_IFR_TO_UPPER_OP),\r
+      CIfrOpHeader (EFI_IFR_TO_UPPER_OP, &(GetObjBinAddr<EFI_IFR_TO_UPPER>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrToLower : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_TO_LOWER *mToLower;\r
-\r
 public:\r
   CIfrToLower (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_TO_LOWER_OP, (CHAR8 **)&mToLower),\r
-      CIfrOpHeader (EFI_IFR_TO_LOWER_OP, &mToLower->Header) {\r
+  ) : CIfrObj (EFI_IFR_TO_LOWER_OP),\r
+      CIfrOpHeader (EFI_IFR_TO_LOWER_OP, &(GetObjBinAddr<EFI_IFR_TO_LOWER>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrAdd : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_ADD *mAdd;\r
-\r
 public:\r
   CIfrAdd (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_ADD_OP, (CHAR8 **)&mAdd),\r
-      CIfrOpHeader (EFI_IFR_ADD_OP, &mAdd->Header) {\r
+  ) : CIfrObj (EFI_IFR_ADD_OP),\r
+      CIfrOpHeader (EFI_IFR_ADD_OP, &(GetObjBinAddr<EFI_IFR_ADD>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrBitWiseAnd : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_BITWISE_AND *mBitWiseAnd;\r
-\r
 public:\r
   CIfrBitWiseAnd (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_BITWISE_AND_OP, (CHAR8 **)&mBitWiseAnd),\r
-      CIfrOpHeader (EFI_IFR_BITWISE_AND_OP, &mBitWiseAnd->Header) {\r
+  ) : CIfrObj (EFI_IFR_BITWISE_AND_OP),\r
+      CIfrOpHeader (EFI_IFR_BITWISE_AND_OP, &(GetObjBinAddr<EFI_IFR_BITWISE_AND>())->Header) {\r
     SetLineNo(LineNo);\r
   }\r
 };\r
 \r
 class CIfrBitWiseOr : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_BITWISE_OR *mBitWiseOr;\r
-\r
 public:\r
   CIfrBitWiseOr (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_BITWISE_OR_OP, (CHAR8 **)&mBitWiseOr),\r
-      CIfrOpHeader (EFI_IFR_BITWISE_OR_OP, &mBitWiseOr->Header) {\r
+  ) : CIfrObj (EFI_IFR_BITWISE_OR_OP),\r
+      CIfrOpHeader (EFI_IFR_BITWISE_OR_OP, &(GetObjBinAddr<EFI_IFR_BITWISE_OR>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrAnd : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_AND *mAnd;\r
-\r
 public:\r
   CIfrAnd (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_AND_OP, (CHAR8 **)&mAnd),\r
-      CIfrOpHeader (EFI_IFR_AND_OP, &mAnd->Header) {\r
+  ) : CIfrObj (EFI_IFR_AND_OP),\r
+      CIfrOpHeader (EFI_IFR_AND_OP, &(GetObjBinAddr<EFI_IFR_AND>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrCatenate : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_CATENATE *mCatenate;\r
-\r
 public:\r
   CIfrCatenate (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_CATENATE_OP, (CHAR8 **)&mCatenate),\r
-      CIfrOpHeader (EFI_IFR_CATENATE_OP, &mCatenate->Header) {\r
+  ) : CIfrObj (EFI_IFR_CATENATE_OP),\r
+      CIfrOpHeader (EFI_IFR_CATENATE_OP, &(GetObjBinAddr<EFI_IFR_CATENATE>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrDivide : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_DIVIDE *mDivide;\r
-\r
 public:\r
   CIfrDivide (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_DIVIDE_OP, (CHAR8 **)&mDivide),\r
-      CIfrOpHeader (EFI_IFR_DIVIDE_OP, &mDivide->Header) {\r
+  ) : CIfrObj (EFI_IFR_DIVIDE_OP),\r
+      CIfrOpHeader (EFI_IFR_DIVIDE_OP, &(GetObjBinAddr<EFI_IFR_DIVIDE>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrEqual : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_EQUAL *mEqual;\r
-\r
 public:\r
   CIfrEqual (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_EQUAL_OP, (CHAR8 **)&mEqual),\r
-      CIfrOpHeader (EFI_IFR_EQUAL_OP, &mEqual->Header) {\r
+  ) : CIfrObj (EFI_IFR_EQUAL_OP),\r
+      CIfrOpHeader (EFI_IFR_EQUAL_OP, &(GetObjBinAddr<EFI_IFR_EQUAL>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrGreaterEqual : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_GREATER_EQUAL *mGreaterEqual;\r
-\r
 public:\r
   CIfrGreaterEqual (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_GREATER_EQUAL_OP, (CHAR8 **)&mGreaterEqual),\r
-      CIfrOpHeader (EFI_IFR_GREATER_EQUAL_OP, &mGreaterEqual->Header) {\r
+  ) : CIfrObj (EFI_IFR_GREATER_EQUAL_OP),\r
+      CIfrOpHeader (EFI_IFR_GREATER_EQUAL_OP, &(GetObjBinAddr<EFI_IFR_GREATER_EQUAL>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrGreaterThan : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_GREATER_THAN *mGreaterThan;\r
-\r
 public:\r
   CIfrGreaterThan (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_GREATER_THAN_OP, (CHAR8 **)&mGreaterThan),\r
-      CIfrOpHeader (EFI_IFR_GREATER_THAN_OP, &mGreaterThan->Header) {\r
+  ) : CIfrObj (EFI_IFR_GREATER_THAN_OP),\r
+      CIfrOpHeader (EFI_IFR_GREATER_THAN_OP, &(GetObjBinAddr<EFI_IFR_GREATER_THAN>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrLessEqual : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_LESS_EQUAL *mLessEqual;\r
-\r
 public:\r
   CIfrLessEqual (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_LESS_EQUAL_OP, (CHAR8 **)&mLessEqual),\r
-      CIfrOpHeader (EFI_IFR_LESS_EQUAL_OP, &mLessEqual->Header) {\r
+  ) : CIfrObj (EFI_IFR_LESS_EQUAL_OP),\r
+      CIfrOpHeader (EFI_IFR_LESS_EQUAL_OP, &(GetObjBinAddr<EFI_IFR_LESS_EQUAL>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrLessThan : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_LESS_THAN *mLessThan;\r
-\r
 public:\r
   CIfrLessThan (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_LESS_THAN_OP, (CHAR8 **)&mLessThan),\r
-      CIfrOpHeader (EFI_IFR_LESS_THAN_OP, &mLessThan->Header) {\r
+  ) : CIfrObj (EFI_IFR_LESS_THAN_OP),\r
+      CIfrOpHeader (EFI_IFR_LESS_THAN_OP, &(GetObjBinAddr<EFI_IFR_LESS_THAN>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrMap : public CIfrObj, public CIfrOpHeader{\r
-private:\r
-  EFI_IFR_MAP *mMap;\r
-\r
 public:\r
   CIfrMap (\r
   IN UINT32 LineNo  \r
-  ) : CIfrObj (EFI_IFR_MAP_OP, (CHAR8 **)&mMap),\r
-      CIfrOpHeader (EFI_IFR_MAP_OP, &mMap->Header) {\r
+  ) : CIfrObj (EFI_IFR_MAP_OP),\r
+      CIfrOpHeader (EFI_IFR_MAP_OP, &(GetObjBinAddr<EFI_IFR_MAP>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrMatch : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_MATCH *mMatch;\r
-\r
 public:\r
   CIfrMatch (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_MATCH_OP, (CHAR8 **)&mMatch),\r
-      CIfrOpHeader (EFI_IFR_MATCH_OP, &mMatch->Header) {\r
+  ) : CIfrObj (EFI_IFR_MATCH_OP),\r
+      CIfrOpHeader (EFI_IFR_MATCH_OP, &(GetObjBinAddr<EFI_IFR_MATCH>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
@@ -2759,113 +2632,89 @@ public:
   CIfrMatch2 (\r
   IN UINT32   LineNo,\r
   IN EFI_GUID *Guid\r
-  ) : CIfrObj (EFI_IFR_MATCH2_OP, (CHAR8 **)&mMatch2),\r
-      CIfrOpHeader (EFI_IFR_MATCH2_OP, &mMatch2->Header) {\r
+  ) : CIfrObj (EFI_IFR_MATCH2_OP),\r
+      CIfrOpHeader (EFI_IFR_MATCH2_OP, &(GetObjBinAddr<EFI_IFR_MATCH2>())->Header), mMatch2(GetObjBinAddr<EFI_IFR_MATCH2>()) {\r
     SetLineNo (LineNo);\r
     memmove (&mMatch2->SyntaxType, Guid, sizeof (EFI_GUID));\r
   }\r
 };\r
 \r
 class CIfrMultiply : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_MULTIPLY *mMultiply;\r
-\r
 public:\r
   CIfrMultiply (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_MULTIPLY_OP, (CHAR8 **)&mMultiply),\r
-      CIfrOpHeader (EFI_IFR_MULTIPLY_OP, &mMultiply->Header) {\r
+  ) : CIfrObj (EFI_IFR_MULTIPLY_OP),\r
+      CIfrOpHeader (EFI_IFR_MULTIPLY_OP, &(GetObjBinAddr<EFI_IFR_MULTIPLY>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrModulo : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_MODULO *mModulo;\r
-\r
 public:\r
   CIfrModulo (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_MODULO_OP, (CHAR8 **)&mModulo),\r
-      CIfrOpHeader (EFI_IFR_MODULO_OP, &mModulo->Header) {\r
+  ) : CIfrObj (EFI_IFR_MODULO_OP),\r
+      CIfrOpHeader (EFI_IFR_MODULO_OP, &(GetObjBinAddr<EFI_IFR_MODULO>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrNotEqual : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_NOT_EQUAL *mNotEqual;\r
-\r
 public:\r
   CIfrNotEqual (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_NOT_EQUAL_OP, (CHAR8 **)&mNotEqual),\r
-      CIfrOpHeader (EFI_IFR_NOT_EQUAL_OP, &mNotEqual->Header) {\r
+  ) : CIfrObj (EFI_IFR_NOT_EQUAL_OP),\r
+      CIfrOpHeader (EFI_IFR_NOT_EQUAL_OP, &(GetObjBinAddr<EFI_IFR_NOT_EQUAL>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrOr : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_OR *mOr;\r
-\r
 public:\r
   CIfrOr (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_OR_OP, (CHAR8 **)&mOr),\r
-      CIfrOpHeader (EFI_IFR_OR_OP, &mOr->Header) {\r
+  ) : CIfrObj (EFI_IFR_OR_OP),\r
+      CIfrOpHeader (EFI_IFR_OR_OP, &(GetObjBinAddr<EFI_IFR_OR>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrShiftLeft : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_SHIFT_LEFT *mShiftLeft;\r
-\r
 public:\r
   CIfrShiftLeft (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_SHIFT_LEFT_OP, (CHAR8 **)&mShiftLeft),\r
-      CIfrOpHeader (EFI_IFR_SHIFT_LEFT_OP, &mShiftLeft->Header) {\r
+  ) : CIfrObj (EFI_IFR_SHIFT_LEFT_OP),\r
+      CIfrOpHeader (EFI_IFR_SHIFT_LEFT_OP, &(GetObjBinAddr<EFI_IFR_SHIFT_LEFT>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrShiftRight : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_SHIFT_RIGHT *mShiftRight;\r
-\r
 public:\r
   CIfrShiftRight (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_SHIFT_RIGHT_OP, (CHAR8 **)&mShiftRight),\r
-      CIfrOpHeader (EFI_IFR_SHIFT_RIGHT_OP, &mShiftRight->Header) {\r
+  ) : CIfrObj (EFI_IFR_SHIFT_RIGHT_OP),\r
+      CIfrOpHeader (EFI_IFR_SHIFT_RIGHT_OP, &(GetObjBinAddr<EFI_IFR_SHIFT_RIGHT>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrSubtract : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_SUBTRACT *mSubtract;\r
-\r
 public:\r
   CIfrSubtract (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_SUBTRACT_OP, (CHAR8 **)&mSubtract),\r
-      CIfrOpHeader (EFI_IFR_SUBTRACT_OP, &mSubtract->Header) {\r
+  ) : CIfrObj (EFI_IFR_SUBTRACT_OP),\r
+      CIfrOpHeader (EFI_IFR_SUBTRACT_OP, &(GetObjBinAddr<EFI_IFR_SUBTRACT>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrConditional : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_CONDITIONAL *mConditional;\r
-\r
 public:\r
   CIfrConditional (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_CONDITIONAL_OP, (CHAR8 **)&mConditional),\r
-      CIfrOpHeader (EFI_IFR_CONDITIONAL_OP, &mConditional->Header) {\r
+  ) : CIfrObj (EFI_IFR_CONDITIONAL_OP),\r
+      CIfrOpHeader (EFI_IFR_CONDITIONAL_OP, &(GetObjBinAddr<EFI_IFR_CONDITIONAL>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
@@ -2877,8 +2726,8 @@ private:
 public:\r
   CIfrFind (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_FIND_OP, (CHAR8 **)&mFind),\r
-      CIfrOpHeader (EFI_IFR_FIND_OP, &mFind->Header) {\r
+  ) : CIfrObj (EFI_IFR_FIND_OP),\r
+      CIfrOpHeader (EFI_IFR_FIND_OP, &(GetObjBinAddr<EFI_IFR_FIND>())->Header), mFind(GetObjBinAddr<EFI_IFR_FIND>()) {\r
     SetLineNo (LineNo);\r
   }\r
 \r
@@ -2888,27 +2737,21 @@ public:
 };\r
 \r
 class CIfrMid : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_MID *mMid;\r
-\r
 public:\r
   CIfrMid (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_MID_OP, (CHAR8 **)&mMid),\r
-      CIfrOpHeader (EFI_IFR_MID_OP, &mMid->Header) {\r
+  ) : CIfrObj (EFI_IFR_MID_OP),\r
+      CIfrOpHeader (EFI_IFR_MID_OP, &(GetObjBinAddr<EFI_IFR_MID>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
 \r
 class CIfrToken : public CIfrObj, public CIfrOpHeader {\r
-private:\r
-  EFI_IFR_TOKEN *mToken;\r
-\r
 public:\r
   CIfrToken (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_TOKEN_OP, (CHAR8 **)&mToken),\r
-      CIfrOpHeader (EFI_IFR_TOKEN_OP, &mToken->Header) {\r
+  ) : CIfrObj (EFI_IFR_TOKEN_OP),\r
+      CIfrOpHeader (EFI_IFR_TOKEN_OP, &(GetObjBinAddr<EFI_IFR_TOKEN>())->Header) {\r
     SetLineNo (LineNo);\r
   }\r
 };\r
@@ -2920,8 +2763,8 @@ private:
 public:\r
   CIfrSpan (\r
   IN UINT32 LineNo\r
-  ) : CIfrObj (EFI_IFR_SPAN_OP, (CHAR8 **)&mSpan),\r
-      CIfrOpHeader (EFI_IFR_SPAN_OP, &mSpan->Header) {\r
+  ) : CIfrObj (EFI_IFR_SPAN_OP),\r
+      CIfrOpHeader (EFI_IFR_SPAN_OP, &(GetObjBinAddr<EFI_IFR_SPAN>())->Header), mSpan(GetObjBinAddr<EFI_IFR_SPAN>()) {\r
     SetLineNo (LineNo);\r
     mSpan->Flags = EFI_IFR_FLAGS_FIRST_MATCHING;\r
   }\r
index a434eacff89c4bfd7d679faf576a820994df7422..4c7c6f28ff4fdfeb68100b93d84bbf5c1f73a2a6 100644 (file)
@@ -986,7 +986,7 @@ vfrStatementDefaultStore :
                                                     <<\r
                                                        if (gCVfrDefaultStore.DefaultIdRegistered (DefaultId) == FALSE) {\r
                                                          CIfrDefaultStore DSObj;\r
-                                                         _PCATCH(gCVfrDefaultStore.RegisterDefaultStore (DSObj.GetObjBinAddr(), N->getText(), _STOSID(S->getText(), S->getLine()), DefaultId)), D->getLine();\r
+                                                         _PCATCH(gCVfrDefaultStore.RegisterDefaultStore (DSObj.GetObjBinAddr<CHAR8>(), N->getText(), _STOSID(S->getText(), S->getLine()), DefaultId)), D->getLine();\r
                                                          DSObj.SetLineNo(D->getLine());\r
                                                          DSObj.SetDefaultName (_STOSID(S->getText(), S->getLine()));\r
                                                          DSObj.SetDefaultId (DefaultId);\r
@@ -1770,7 +1770,7 @@ vfrFormDefinition :
                                                         LObj3.SetNumber (0xffff);  //add end label for UEFI, label number hardcode 0xffff\r
                                                       }\r
 \r
-                                                      {CIfrEnd EObj; EObj.SetLineNo (E->getLine()); mLastFormEndAddr = EObj.GetObjBinAddr (); gAdjustOpcodeOffset = EObj.GetObjBinOffset ();}\r
+                                                      {CIfrEnd EObj; EObj.SetLineNo (E->getLine()); mLastFormEndAddr = EObj.GetObjBinAddr<CHAR8>(); gAdjustOpcodeOffset = EObj.GetObjBinOffset ();}\r
                                                     >>\r
   ";"\r
   ;\r
@@ -5675,7 +5675,7 @@ EfiVfrParser::_DeclareStandardDefaultStorage (
   //\r
   CIfrDefaultStore DSObj;\r
 \r
-  gCVfrDefaultStore.RegisterDefaultStore (DSObj.GetObjBinAddr(), (CHAR8 *) "Standard Defaults", EFI_STRING_ID_INVALID, EFI_HII_DEFAULT_CLASS_STANDARD);\r
+  gCVfrDefaultStore.RegisterDefaultStore (DSObj.GetObjBinAddr<CHAR8>(), (CHAR8 *) "Standard Defaults", EFI_STRING_ID_INVALID, EFI_HII_DEFAULT_CLASS_STANDARD);\r
   DSObj.SetLineNo (LineNo);\r
   DSObj.SetDefaultName (EFI_STRING_ID_INVALID);\r
   DSObj.SetDefaultId (EFI_HII_DEFAULT_CLASS_STANDARD);\r
@@ -5685,7 +5685,7 @@ EfiVfrParser::_DeclareStandardDefaultStorage (
   //\r
   CIfrDefaultStore DSObjMF;\r
 \r
-  gCVfrDefaultStore.RegisterDefaultStore (DSObjMF.GetObjBinAddr(), (CHAR8 *) "Standard ManuFacturing", EFI_STRING_ID_INVALID, EFI_HII_DEFAULT_CLASS_MANUFACTURING);\r
+  gCVfrDefaultStore.RegisterDefaultStore (DSObjMF.GetObjBinAddr<CHAR8>(), (CHAR8 *) "Standard ManuFacturing", EFI_STRING_ID_INVALID, EFI_HII_DEFAULT_CLASS_MANUFACTURING);\r
   DSObjMF.SetLineNo (LineNo);\r
   DSObjMF.SetDefaultName (EFI_STRING_ID_INVALID);\r
   DSObjMF.SetDefaultId (EFI_HII_DEFAULT_CLASS_MANUFACTURING);\r