BaseTools/Source/Python/AutoGen/GenC.py

   1 ## @file
   2 # Routines for generating AutoGen.h and AutoGen.c
   3 #
   4 # Copyright (c) 2007 - 2011, Intel Corporation. All rights reserved.<BR>
   5 # This program and the accompanying materials
   6 # are licensed and made available under the terms and conditions of the BSD License
   7 # which accompanies this distribution.  The full text of the license may be found at
   8 # http://opensource.org/licenses/bsd-license.php
   9 #
  10 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12 #
  13
  14 ## Import Modules
  15 #
  16 import string
  17
  18 from Common import EdkLogger
  19
  20 from Common.BuildToolError import *
  21 from Common.DataType import *
  22 from Common.Misc import *
  23 from Common.String import StringToArray
  24 from StrGather import *
  25
  26 ## PCD type string
  27 gItemTypeStringDatabase  = {
  28     TAB_PCDS_FEATURE_FLAG       :   'FixedAtBuild',
  29     TAB_PCDS_FIXED_AT_BUILD     :   'FixedAtBuild',
  30     TAB_PCDS_PATCHABLE_IN_MODULE:   'BinaryPatch',
  31     TAB_PCDS_DYNAMIC            :   '',
  32     TAB_PCDS_DYNAMIC_DEFAULT    :   '',
  33     TAB_PCDS_DYNAMIC_VPD        :   '',
  34     TAB_PCDS_DYNAMIC_HII        :   '',
  35     TAB_PCDS_DYNAMIC_EX         :   '',
  36     TAB_PCDS_DYNAMIC_EX_DEFAULT :   '',
  37     TAB_PCDS_DYNAMIC_EX_VPD     :   '',
  38     TAB_PCDS_DYNAMIC_EX_HII     :   '',
  39 }
  40
  41 ## Dynamic PCD types
  42 gDynamicPcd = [TAB_PCDS_DYNAMIC, TAB_PCDS_DYNAMIC_DEFAULT, TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_HII]
  43
  44 ## Dynamic-ex PCD types
  45 gDynamicExPcd = [TAB_PCDS_DYNAMIC_EX, TAB_PCDS_DYNAMIC_EX_DEFAULT, TAB_PCDS_DYNAMIC_EX_VPD, TAB_PCDS_DYNAMIC_EX_HII]
  46
  47 ## Datum size
  48 gDatumSizeStringDatabase = {'UINT8':'8','UINT16':'16','UINT32':'32','UINT64':'64','BOOLEAN':'BOOLEAN','VOID*':'8'}
  49 gDatumSizeStringDatabaseH = {'UINT8':'8','UINT16':'16','UINT32':'32','UINT64':'64','BOOLEAN':'BOOL','VOID*':'PTR'}
  50 gDatumSizeStringDatabaseLib = {'UINT8':'8','UINT16':'16','UINT32':'32','UINT64':'64','BOOLEAN':'Bool','VOID*':'Ptr'}
  51
  52 ## Mapping between PCD driver type and EFI phase
  53 gPcdPhaseMap = {
  54     "PEI_PCD_DRIVER"    :   "PEI",
  55     "DXE_PCD_DRIVER"    :   "DXE"
  56 }
  57
  58 gPcdDatabaseCommonAutoGenH = """
  59 //
  60 // The following definition will be generated by build tool
  61 //
  62
  63 //
  64 // Common definitions
  65 //
  66 typedef UINT8 SKU_ID;
  67
  68 #define PCD_TYPE_SHIFT        28
  69
  70 #define PCD_TYPE_DATA         (0x0 << PCD_TYPE_SHIFT)
  71 #define PCD_TYPE_HII          (0x8 << PCD_TYPE_SHIFT)
  72 #define PCD_TYPE_VPD          (0x4 << PCD_TYPE_SHIFT)
  73 #define PCD_TYPE_SKU_ENABLED  (0x2 << PCD_TYPE_SHIFT)
  74 #define PCD_TYPE_STRING       (0x1 << PCD_TYPE_SHIFT)
  75
  76 #define PCD_TYPE_ALL_SET      (PCD_TYPE_DATA | PCD_TYPE_HII | PCD_TYPE_VPD | PCD_TYPE_SKU_ENABLED | PCD_TYPE_STRING)
  77
  78 #define PCD_DATUM_TYPE_SHIFT  24
  79
  80 #define PCD_DATUM_TYPE_POINTER  (0x0 << PCD_DATUM_TYPE_SHIFT)
  81 #define PCD_DATUM_TYPE_UINT8    (0x1 << PCD_DATUM_TYPE_SHIFT)
  82 #define PCD_DATUM_TYPE_UINT16   (0x2 << PCD_DATUM_TYPE_SHIFT)
  83 #define PCD_DATUM_TYPE_UINT32   (0x4 << PCD_DATUM_TYPE_SHIFT)
  84 #define PCD_DATUM_TYPE_UINT64   (0x8 << PCD_DATUM_TYPE_SHIFT)
  85
  86 #define PCD_DATUM_TYPE_ALL_SET  (PCD_DATUM_TYPE_POINTER | \\
  87                                  PCD_DATUM_TYPE_UINT8   | \\
  88                                  PCD_DATUM_TYPE_UINT16  | \\
  89                                  PCD_DATUM_TYPE_UINT32  | \\
  90                                  PCD_DATUM_TYPE_UINT64)
  91
  92 #define PCD_DATABASE_OFFSET_MASK (~(PCD_TYPE_ALL_SET | PCD_DATUM_TYPE_ALL_SET))
  93
  94 typedef struct  {
  95   UINT32  ExTokenNumber;
  96   UINT16  LocalTokenNumber;   // PCD Number of this particular platform build
  97   UINT16  ExGuidIndex;        // Index of GuidTable
  98 } DYNAMICEX_MAPPING;
  99
 100 typedef struct {
 101   UINT32  SkuDataStartOffset; //We have to use offsetof MACRO as we don't know padding done by compiler
 102   UINT32  SkuIdTableOffset;   //Offset from the PCD_DB
 103 } SKU_HEAD;
 104
 105 typedef struct {
 106   UINT16  GuidTableIndex;     // Offset in Guid Table in units of GUID.
 107   UINT16  StringIndex;        // Offset in String Table in units of UINT16.
 108   UINT16  Offset;             // Offset in Variable
 109   UINT16  DefaultValueOffset; // Offset of the Default Value
 110 } VARIABLE_HEAD;
 111
 112 typedef  struct {
 113   UINT32  Offset;
 114 } VPD_HEAD;
 115
 116 typedef UINT16 STRING_HEAD;
 117
 118 typedef UINT16 SIZE_INFO;
 119
 120 #define offsetof(s,m)  (UINT32) (UINTN) &(((s *)0)->m)
 121
 122 """
 123
 124 gPcdDatabaseEpilogueAutoGenH = """
 125 typedef struct {
 126   PEI_PCD_DATABASE PeiDb;
 127   DXE_PCD_DATABASE DxeDb;
 128 } PCD_DATABASE;
 129
 130 #define PCD_TOTAL_TOKEN_NUMBER (PEI_LOCAL_TOKEN_NUMBER + DXE_LOCAL_TOKEN_NUMBER)
 131
 132 """
 133
 134 gPcdDatabaseAutoGenH = TemplateString("""
 135 #define ${PHASE}_GUID_TABLE_SIZE                ${GUID_TABLE_SIZE}
 136 #define ${PHASE}_STRING_TABLE_SIZE              ${STRING_TABLE_SIZE}
 137 #define ${PHASE}_SKUID_TABLE_SIZE               ${SKUID_TABLE_SIZE}
 138 #define ${PHASE}_LOCAL_TOKEN_NUMBER_TABLE_SIZE  ${LOCAL_TOKEN_NUMBER_TABLE_SIZE}
 139 #define ${PHASE}_LOCAL_TOKEN_NUMBER             ${LOCAL_TOKEN_NUMBER}
 140 #define ${PHASE}_EXMAPPING_TABLE_SIZE           ${EXMAPPING_TABLE_SIZE}
 141 #define ${PHASE}_EX_TOKEN_NUMBER                ${EX_TOKEN_NUMBER}
 142 #define ${PHASE}_SIZE_TABLE_SIZE                ${SIZE_TABLE_SIZE}
 143 #define ${PHASE}_GUID_TABLE_EMPTY               ${GUID_TABLE_EMPTY}
 144 #define ${PHASE}_STRING_TABLE_EMPTY             ${STRING_TABLE_EMPTY}
 145 #define ${PHASE}_SKUID_TABLE_EMPTY              ${SKUID_TABLE_EMPTY}
 146 #define ${PHASE}_DATABASE_EMPTY                 ${DATABASE_EMPTY}
 147 #define ${PHASE}_EXMAP_TABLE_EMPTY              ${EXMAP_TABLE_EMPTY}
 148
 149 typedef struct {
 150 ${BEGIN}  UINT64             ${INIT_CNAME_DECL_UINT64}_${INIT_GUID_DECL_UINT64}[${INIT_NUMSKUS_DECL_UINT64}];
 151 ${END}
 152 ${BEGIN}  UINT64             ${VARDEF_CNAME_UINT64}_${VARDEF_GUID_UINT64}_VariableDefault_${VARDEF_SKUID_UINT64};
 153 ${END}
 154 ${BEGIN}  UINT32             ${INIT_CNAME_DECL_UINT32}_${INIT_GUID_DECL_UINT32}[${INIT_NUMSKUS_DECL_UINT32}];
 155 ${END}
 156 ${BEGIN}  UINT32             ${VARDEF_CNAME_UINT32}_${VARDEF_GUID_UINT32}_VariableDefault_${VARDEF_SKUID_UINT32};
 157 ${END}
 158 ${BEGIN}  VPD_HEAD           ${VPD_HEAD_CNAME_DECL}_${VPD_HEAD_GUID_DECL}[${VPD_HEAD_NUMSKUS_DECL}];
 159 ${END}
 160   DYNAMICEX_MAPPING  ExMapTable[${PHASE}_EXMAPPING_TABLE_SIZE];
 161   UINT32             LocalTokenNumberTable[${PHASE}_LOCAL_TOKEN_NUMBER_TABLE_SIZE];
 162   GUID               GuidTable[${PHASE}_GUID_TABLE_SIZE];
 163 ${BEGIN}  STRING_HEAD        ${STRING_HEAD_CNAME_DECL}_${STRING_HEAD_GUID_DECL}[${STRING_HEAD_NUMSKUS_DECL}];
 164 ${END}
 165 ${BEGIN}  VARIABLE_HEAD      ${VARIABLE_HEAD_CNAME_DECL}_${VARIABLE_HEAD_GUID_DECL}_Variable_Header[${VARIABLE_HEAD_NUMSKUS_DECL}];
 166 ${END}
 167 ${BEGIN}  UINT8              StringTable${STRING_TABLE_INDEX}[${STRING_TABLE_LENGTH}]; /* ${STRING_TABLE_CNAME}_${STRING_TABLE_GUID} */
 168 ${END}
 169   SIZE_INFO          SizeTable[${PHASE}_SIZE_TABLE_SIZE];
 170 ${BEGIN}  UINT16             ${INIT_CNAME_DECL_UINT16}_${INIT_GUID_DECL_UINT16}[${INIT_NUMSKUS_DECL_UINT16}];
 171 ${END}
 172 ${BEGIN}  UINT16             ${VARDEF_CNAME_UINT16}_${VARDEF_GUID_UINT16}_VariableDefault_${VARDEF_SKUID_UINT16};
 173 ${END}
 174 ${BEGIN}  UINT8              ${INIT_CNAME_DECL_UINT8}_${INIT_GUID_DECL_UINT8}[${INIT_NUMSKUS_DECL_UINT8}];
 175 ${END}
 176 ${BEGIN}  UINT8              ${VARDEF_CNAME_UINT8}_${VARDEF_GUID_UINT8}_VariableDefault_${VARDEF_SKUID_UINT8};
 177 ${END}
 178 ${BEGIN}  BOOLEAN            ${INIT_CNAME_DECL_BOOLEAN}_${INIT_GUID_DECL_BOOLEAN}[${INIT_NUMSKUS_DECL_BOOLEAN}];
 179 ${END}
 180 ${BEGIN}  BOOLEAN            ${VARDEF_CNAME_BOOLEAN}_${VARDEF_GUID_BOOLEAN}_VariableDefault_${VARDEF_SKUID_BOOLEAN};
 181 ${END}
 182   UINT8              SkuIdTable[${PHASE}_SKUID_TABLE_SIZE];
 183 ${SYSTEM_SKU_ID}
 184 } ${PHASE}_PCD_DATABASE_INIT;
 185
 186 typedef struct {
 187 ${PCD_DATABASE_UNINIT_EMPTY}
 188 ${BEGIN}  UINT64   ${UNINIT_CNAME_DECL_UINT64}_${UNINIT_GUID_DECL_UINT64}[${UNINIT_NUMSKUS_DECL_UINT64}];
 189 ${END}
 190 ${BEGIN}  UINT32   ${UNINIT_CNAME_DECL_UINT32}_${UNINIT_GUID_DECL_UINT32}[${UNINIT_NUMSKUS_DECL_UINT32}];
 191 ${END}
 192 ${BEGIN}  UINT16   ${UNINIT_CNAME_DECL_UINT16}_${UNINIT_GUID_DECL_UINT16}[${UNINIT_NUMSKUS_DECL_UINT16}];
 193 ${END}
 194 ${BEGIN}  UINT8    ${UNINIT_CNAME_DECL_UINT8}_${UNINIT_GUID_DECL_UINT8}[${UNINIT_NUMSKUS_DECL_UINT8}];
 195 ${END}
 196 ${BEGIN}  BOOLEAN  ${UNINIT_CNAME_DECL_BOOLEAN}_${UNINIT_GUID_DECL_BOOLEAN}[${UNINIT_NUMSKUS_DECL_BOOLEAN}];
 197 ${END}
 198 } ${PHASE}_PCD_DATABASE_UNINIT;
 199
 200 #define PCD_${PHASE}_SERVICE_DRIVER_VERSION         2
 201
 202 typedef struct {
 203   ${PHASE}_PCD_DATABASE_INIT    Init;
 204   ${PHASE}_PCD_DATABASE_UNINIT  Uninit;
 205 } ${PHASE}_PCD_DATABASE;
 206
 207 #define ${PHASE}_NEX_TOKEN_NUMBER (${PHASE}_LOCAL_TOKEN_NUMBER - ${PHASE}_EX_TOKEN_NUMBER)
 208 """)
 209
 210 gEmptyPcdDatabaseAutoGenC = TemplateString("""
 211 ${PHASE}_PCD_DATABASE_INIT g${PHASE}PcdDbInit = {
 212   /* ExMapTable */
 213   {
 214     {0, 0, 0}
 215   },
 216   /* LocalTokenNumberTable */
 217   {
 218     0
 219   },
 220   /* GuidTable */
 221   {
 222     {0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}
 223   },
 224   /* StringTable */
 225   { 0 },
 226   /* SizeTable */
 227   {
 228     0, 0
 229   },
 230   /* SkuIdTable */
 231   { 0 },
 232   ${SYSTEM_SKU_ID_VALUE}
 233 };
 234 """)
 235
 236 gPcdDatabaseAutoGenC = TemplateString("""
 237 ${PHASE}_PCD_DATABASE_INIT g${PHASE}PcdDbInit = {
 238 ${BEGIN}  { ${INIT_VALUE_UINT64} }, /*  ${INIT_CNAME_DECL_UINT64}_${INIT_GUID_DECL_UINT64}[${INIT_NUMSKUS_DECL_UINT64}] */
 239 ${END}
 240 ${BEGIN}  ${VARDEF_VALUE_UINT64}, /* ${VARDEF_CNAME_UINT64}_${VARDEF_GUID_UINT64}_VariableDefault_${VARDEF_SKUID_UINT64} */
 241 ${END}
 242 ${BEGIN}  { ${INIT_VALUE_UINT32} }, /*  ${INIT_CNAME_DECL_UINT32}_${INIT_GUID_DECL_UINT32}[${INIT_NUMSKUS_DECL_UINT32}] */
 243 ${END}
 244 ${BEGIN}  ${VARDEF_VALUE_UINT32}, /* ${VARDEF_CNAME_UINT32}_${VARDEF_GUID_UINT32}_VariableDefault_${VARDEF_SKUID_UINT32} */
 245 ${END}
 246   /* VPD */
 247 ${BEGIN}  { ${VPD_HEAD_VALUE} }, /* ${VPD_HEAD_CNAME_DECL}_${VPD_HEAD_GUID_DECL}[${VPD_HEAD_NUMSKUS_DECL}] */
 248 ${END}
 249   /* ExMapTable */
 250   {
 251 ${BEGIN}    { ${EXMAPPING_TABLE_EXTOKEN}, ${EXMAPPING_TABLE_LOCAL_TOKEN}, ${EXMAPPING_TABLE_GUID_INDEX} },
 252 ${END}
 253   },
 254   /* LocalTokenNumberTable */
 255   {
 256 ${BEGIN}    offsetof(${PHASE}_PCD_DATABASE, ${TOKEN_INIT}.${TOKEN_CNAME}_${TOKEN_GUID}${VARDEF_HEADER}) | ${TOKEN_TYPE},
 257 ${END}
 258   },
 259   /* GuidTable */
 260   {
 261 ${BEGIN}    ${GUID_STRUCTURE},
 262 ${END}
 263   },
 264 ${BEGIN}  { ${STRING_HEAD_VALUE} }, /* ${STRING_HEAD_CNAME_DECL}_${STRING_HEAD_GUID_DECL}[${STRING_HEAD_NUMSKUS_DECL}] */
 265 ${END}
 266 ${BEGIN}  /* ${VARIABLE_HEAD_CNAME_DECL}_${VARIABLE_HEAD_GUID_DECL}_Variable_Header[${VARIABLE_HEAD_NUMSKUS_DECL}] */
 267   {
 268     ${VARIABLE_HEAD_VALUE}
 269   },
 270 ${END}
 271  /* StringTable */
 272 ${BEGIN}  ${STRING_TABLE_VALUE}, /* ${STRING_TABLE_CNAME}_${STRING_TABLE_GUID} */
 273 ${END}
 274   /* SizeTable */
 275   {
 276 ${BEGIN}    ${SIZE_TABLE_MAXIMUM_LENGTH}, ${SIZE_TABLE_CURRENT_LENGTH}, /* ${SIZE_TABLE_CNAME}_${SIZE_TABLE_GUID} */
 277 ${END}
 278   },
 279 ${BEGIN}  { ${INIT_VALUE_UINT16} }, /*  ${INIT_CNAME_DECL_UINT16}_${INIT_GUID_DECL_UINT16}[${INIT_NUMSKUS_DECL_UINT16}] */
 280 ${END}
 281 ${BEGIN}  ${VARDEF_VALUE_UINT16}, /* ${VARDEF_CNAME_UINT16}_${VARDEF_GUID_UINT16}_VariableDefault_${VARDEF_SKUID_UINT16} */
 282 ${END}
 283 ${BEGIN}  { ${INIT_VALUE_UINT8} }, /*  ${INIT_CNAME_DECL_UINT8}_${INIT_GUID_DECL_UINT8}[${INIT_NUMSKUS_DECL_UINT8}] */
 284 ${END}
 285 ${BEGIN}  ${VARDEF_VALUE_UINT8}, /* ${VARDEF_CNAME_UINT8}_${VARDEF_GUID_UINT8}_VariableDefault_${VARDEF_SKUID_UINT8} */
 286 ${END}
 287 ${BEGIN}  { ${INIT_VALUE_BOOLEAN} }, /*  ${INIT_CNAME_DECL_BOOLEAN}_${INIT_GUID_DECL_BOOLEAN}[${INIT_NUMSKUS_DECL_BOOLEAN}] */
 288 ${END}
 289 ${BEGIN}  ${VARDEF_VALUE_BOOLEAN}, /* ${VARDEF_CNAME_BOOLEAN}_${VARDEF_GUID_BOOLEAN}_VariableDefault_${VARDEF_SKUID_BOOLEAN} */
 290 ${END}
 291   /* SkuIdTable */
 292   { ${BEGIN}${SKUID_VALUE}, ${END} },
 293   ${SYSTEM_SKU_ID_VALUE}
 294 };
 295 """)
 296
 297
 298 ## AutoGen File Header Templates
 299 gAutoGenHeaderString = TemplateString("""\
 300 /**
 301   DO NOT EDIT
 302   FILE auto-generated
 303   Module name:
 304     ${FileName}
 305   Abstract:       Auto-generated ${FileName} for building module or library.
 306 **/
 307 """)
 308
 309 gAutoGenHPrologueString = TemplateString("""
 310 #ifndef _${File}_${Guid}
 311 #define _${File}_${Guid}
 312
 313 """)
 314
 315 gAutoGenHEpilogueString = """
 316 #endif
 317 """
 318
 319 ## PEI Core Entry Point Templates
 320 gPeiCoreEntryPointPrototype = TemplateString("""
 321 ${BEGIN}
 322 VOID
 323 EFIAPI
 324 ${Function} (
 325   IN CONST  EFI_SEC_PEI_HAND_OFF    *SecCoreData,
 326   IN CONST  EFI_PEI_PPI_DESCRIPTOR  *PpiList,
 327   IN VOID                           *Context
 328   );
 329 ${END}
 330 """)
 331
 332 gPeiCoreEntryPointString = TemplateString("""
 333 ${BEGIN}
 334 VOID
 335 EFIAPI
 336 ProcessModuleEntryPointList (
 337   IN CONST  EFI_SEC_PEI_HAND_OFF    *SecCoreData,
 338   IN CONST  EFI_PEI_PPI_DESCRIPTOR  *PpiList,
 339   IN VOID                           *Context
 340   )
 341
 342 {
 343   ${Function} (SecCoreData, PpiList, Context);
 344 }
 345 ${END}
 346 """)
 347
 348
 349 ## DXE Core Entry Point Templates
 350 gDxeCoreEntryPointPrototype = TemplateString("""
 351 ${BEGIN}
 352 VOID
 353 EFIAPI
 354 ${Function} (
 355   IN VOID  *HobStart
 356   );
 357 ${END}
 358 """)
 359
 360 gDxeCoreEntryPointString = TemplateString("""
 361 ${BEGIN}
 362 VOID
 363 EFIAPI
 364 ProcessModuleEntryPointList (
 365   IN VOID  *HobStart
 366   )
 367
 368 {
 369   ${Function} (HobStart);
 370 }
 371 ${END}
 372 """)
 373
 374 ## PEIM Entry Point Templates
 375 gPeimEntryPointPrototype = TemplateString("""
 376 ${BEGIN}
 377 EFI_STATUS
 378 EFIAPI
 379 ${Function} (
 380   IN       EFI_PEI_FILE_HANDLE  FileHandle,
 381   IN CONST EFI_PEI_SERVICES     **PeiServices
 382   );
 383 ${END}
 384 """)
 385
 386 gPeimEntryPointString = [
 387 TemplateString("""
 388 GLOBAL_REMOVE_IF_UNREFERENCED const UINT32 _gPeimRevision = ${PiSpecVersion};
 389
 390 EFI_STATUS
 391 EFIAPI
 392 ProcessModuleEntryPointList (
 393   IN       EFI_PEI_FILE_HANDLE  FileHandle,
 394   IN CONST EFI_PEI_SERVICES     **PeiServices
 395   )
 396
 397 {
 398   return EFI_SUCCESS;
 399 }
 400 """),
 401 TemplateString("""
 402 GLOBAL_REMOVE_IF_UNREFERENCED const UINT32 _gPeimRevision = ${PiSpecVersion};
 403 ${BEGIN}
 404 EFI_STATUS
 405 EFIAPI
 406 ProcessModuleEntryPointList (
 407   IN       EFI_PEI_FILE_HANDLE  FileHandle,
 408   IN CONST EFI_PEI_SERVICES     **PeiServices
 409   )
 410
 411 {
 412   return ${Function} (FileHandle, PeiServices);
 413 }
 414 ${END}
 415 """),
 416 TemplateString("""
 417 GLOBAL_REMOVE_IF_UNREFERENCED const UINT32 _gPeimRevision = ${PiSpecVersion};
 418
 419 EFI_STATUS
 420 EFIAPI
 421 ProcessModuleEntryPointList (
 422   IN       EFI_PEI_FILE_HANDLE  FileHandle,
 423   IN CONST EFI_PEI_SERVICES     **PeiServices
 424   )
 425
 426 {
 427   EFI_STATUS  Status;
 428   EFI_STATUS  CombinedStatus;
 429
 430   CombinedStatus = EFI_LOAD_ERROR;
 431 ${BEGIN}
 432   Status = ${Function} (FileHandle, PeiServices);
 433   if (!EFI_ERROR (Status) || EFI_ERROR (CombinedStatus)) {
 434     CombinedStatus = Status;
 435   }
 436 ${END}
 437   return CombinedStatus;
 438 }
 439 """)
 440 ]
 441
 442 ## SMM_CORE Entry Point Templates
 443 gSmmCoreEntryPointPrototype = TemplateString("""
 444 ${BEGIN}
 445 EFI_STATUS
 446 EFIAPI
 447 ${Function} (
 448   IN EFI_HANDLE         ImageHandle,
 449   IN EFI_SYSTEM_TABLE   *SystemTable
 450   );
 451 ${END}
 452 """)
 453
 454 gSmmCoreEntryPointString = TemplateString("""
 455 ${BEGIN}
 456 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 457 const UINT32 _gDxeRevision = ${PiSpecVersion};
 458
 459 EFI_STATUS
 460 EFIAPI
 461 ProcessModuleEntryPointList (
 462   IN EFI_HANDLE         ImageHandle,
 463   IN EFI_SYSTEM_TABLE   *SystemTable
 464   )
 465 {
 466   return ${Function} (ImageHandle, SystemTable);
 467 }
 468 ${END}
 469 """)
 470
 471 ## DXE SMM Entry Point Templates
 472 gDxeSmmEntryPointPrototype = TemplateString("""
 473 ${BEGIN}
 474 EFI_STATUS
 475 EFIAPI
 476 ${Function} (
 477   IN EFI_HANDLE        ImageHandle,
 478   IN EFI_SYSTEM_TABLE  *SystemTable
 479   );
 480 ${END}
 481 """)
 482
 483 gDxeSmmEntryPointString = [
 484 TemplateString("""
 485 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 486 const UINT32 _gDxeRevision = ${PiSpecVersion};
 487
 488 EFI_STATUS
 489 EFIAPI
 490 ProcessModuleEntryPointList (
 491   IN EFI_HANDLE        ImageHandle,
 492   IN EFI_SYSTEM_TABLE  *SystemTable
 493   )
 494
 495 {
 496   return EFI_SUCCESS;
 497 }
 498 """),
 499 TemplateString("""
 500 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 501 const UINT32 _gDxeRevision = ${PiSpecVersion};
 502
 503 static BASE_LIBRARY_JUMP_BUFFER  mJumpContext;
 504 static EFI_STATUS  mDriverEntryPointStatus;
 505
 506 VOID
 507 EFIAPI
 508 ExitDriver (
 509   IN EFI_STATUS  Status
 510   )
 511 {
 512   if (!EFI_ERROR (Status) || EFI_ERROR (mDriverEntryPointStatus)) {
 513     mDriverEntryPointStatus = Status;
 514   }
 515   LongJump (&mJumpContext, (UINTN)-1);
 516   ASSERT (FALSE);
 517 }
 518
 519 EFI_STATUS
 520 EFIAPI
 521 ProcessModuleEntryPointList (
 522   IN EFI_HANDLE        ImageHandle,
 523   IN EFI_SYSTEM_TABLE  *SystemTable
 524   )
 525 {
 526   mDriverEntryPointStatus = EFI_LOAD_ERROR;
 527
 528 ${BEGIN}
 529   if (SetJump (&mJumpContext) == 0) {
 530     ExitDriver (${Function} (ImageHandle, SystemTable));
 531     ASSERT (FALSE);
 532   }
 533 ${END}
 534
 535   return mDriverEntryPointStatus;
 536 }
 537 """)
 538 ]
 539
 540 ## UEFI Driver Entry Point Templates
 541 gUefiDriverEntryPointPrototype = TemplateString("""
 542 ${BEGIN}
 543 EFI_STATUS
 544 EFIAPI
 545 ${Function} (
 546   IN EFI_HANDLE        ImageHandle,
 547   IN EFI_SYSTEM_TABLE  *SystemTable
 548   );
 549 ${END}
 550 """)
 551
 552 gUefiDriverEntryPointString = [
 553 TemplateString("""
 554 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 555 const UINT32 _gDxeRevision = ${PiSpecVersion};
 556
 557 EFI_STATUS
 558 EFIAPI
 559 ProcessModuleEntryPointList (
 560   IN EFI_HANDLE        ImageHandle,
 561   IN EFI_SYSTEM_TABLE  *SystemTable
 562   )
 563 {
 564   return EFI_SUCCESS;
 565 }
 566 """),
 567 TemplateString("""
 568 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 569 const UINT32 _gDxeRevision = ${PiSpecVersion};
 570
 571 ${BEGIN}
 572 EFI_STATUS
 573 EFIAPI
 574 ProcessModuleEntryPointList (
 575   IN EFI_HANDLE        ImageHandle,
 576   IN EFI_SYSTEM_TABLE  *SystemTable
 577   )
 578
 579 {
 580   return ${Function} (ImageHandle, SystemTable);
 581 }
 582 ${END}
 583 VOID
 584 EFIAPI
 585 ExitDriver (
 586   IN EFI_STATUS  Status
 587   )
 588 {
 589   if (EFI_ERROR (Status)) {
 590     ProcessLibraryDestructorList (gImageHandle, gST);
 591   }
 592   gBS->Exit (gImageHandle, Status, 0, NULL);
 593 }
 594 """),
 595 TemplateString("""
 596 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 597 const UINT32 _gDxeRevision = ${PiSpecVersion};
 598
 599 static BASE_LIBRARY_JUMP_BUFFER  mJumpContext;
 600 static EFI_STATUS  mDriverEntryPointStatus;
 601
 602 EFI_STATUS
 603 EFIAPI
 604 ProcessModuleEntryPointList (
 605   IN EFI_HANDLE        ImageHandle,
 606   IN EFI_SYSTEM_TABLE  *SystemTable
 607   )
 608 {
 609   mDriverEntryPointStatus = EFI_LOAD_ERROR;
 610   ${BEGIN}
 611   if (SetJump (&mJumpContext) == 0) {
 612     ExitDriver (${Function} (ImageHandle, SystemTable));
 613     ASSERT (FALSE);
 614   }
 615   ${END}
 616   return mDriverEntryPointStatus;
 617 }
 618
 619 VOID
 620 EFIAPI
 621 ExitDriver (
 622   IN EFI_STATUS  Status
 623   )
 624 {
 625   if (!EFI_ERROR (Status) || EFI_ERROR (mDriverEntryPointStatus)) {
 626     mDriverEntryPointStatus = Status;
 627   }
 628   LongJump (&mJumpContext, (UINTN)-1);
 629   ASSERT (FALSE);
 630 }
 631 """)
 632 ]
 633
 634
 635 ## UEFI Application Entry Point Templates
 636 gUefiApplicationEntryPointPrototype = TemplateString("""
 637 ${BEGIN}
 638 EFI_STATUS
 639 EFIAPI
 640 ${Function} (
 641   IN EFI_HANDLE        ImageHandle,
 642   IN EFI_SYSTEM_TABLE  *SystemTable
 643   );
 644 ${END}
 645 """)
 646
 647 gUefiApplicationEntryPointString = [
 648 TemplateString("""
 649 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 650
 651 EFI_STATUS
 652 EFIAPI
 653 ProcessModuleEntryPointList (
 654   IN EFI_HANDLE        ImageHandle,
 655   IN EFI_SYSTEM_TABLE  *SystemTable
 656   )
 657 {
 658   return EFI_SUCCESS;
 659 }
 660 """),
 661 TemplateString("""
 662 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 663
 664 ${BEGIN}
 665 EFI_STATUS
 666 EFIAPI
 667 ProcessModuleEntryPointList (
 668   IN EFI_HANDLE        ImageHandle,
 669   IN EFI_SYSTEM_TABLE  *SystemTable
 670   )
 671
 672 {
 673   return ${Function} (ImageHandle, SystemTable);
 674 }
 675 ${END}
 676 VOID
 677 EFIAPI
 678 ExitDriver (
 679   IN EFI_STATUS  Status
 680   )
 681 {
 682   if (EFI_ERROR (Status)) {
 683     ProcessLibraryDestructorList (gImageHandle, gST);
 684   }
 685   gBS->Exit (gImageHandle, Status, 0, NULL);
 686 }
 687 """),
 688 TemplateString("""
 689 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 690
 691 EFI_STATUS
 692 EFIAPI
 693 ProcessModuleEntryPointList (
 694   IN EFI_HANDLE        ImageHandle,
 695   IN EFI_SYSTEM_TABLE  *SystemTable
 696   )
 697
 698 {
 699   ${BEGIN}
 700   if (SetJump (&mJumpContext) == 0) {
 701     ExitDriver (${Function} (ImageHandle, SystemTable));
 702     ASSERT (FALSE);
 703   }
 704   ${END}
 705   return mDriverEntryPointStatus;
 706 }
 707
 708 static BASE_LIBRARY_JUMP_BUFFER  mJumpContext;
 709 static EFI_STATUS  mDriverEntryPointStatus = EFI_LOAD_ERROR;
 710
 711 VOID
 712 EFIAPI
 713 ExitDriver (
 714   IN EFI_STATUS  Status
 715   )
 716 {
 717   if (!EFI_ERROR (Status) || EFI_ERROR (mDriverEntryPointStatus)) {
 718     mDriverEntryPointStatus = Status;
 719   }
 720   LongJump (&mJumpContext, (UINTN)-1);
 721   ASSERT (FALSE);
 722 }
 723 """)
 724 ]
 725
 726 ## UEFI Unload Image Templates
 727 gUefiUnloadImagePrototype = TemplateString("""
 728 ${BEGIN}
 729 EFI_STATUS
 730 EFIAPI
 731 ${Function} (
 732   IN EFI_HANDLE        ImageHandle
 733   );
 734 ${END}
 735 """)
 736
 737 gUefiUnloadImageString = [
 738 TemplateString("""
 739 GLOBAL_REMOVE_IF_UNREFERENCED const UINT8 _gDriverUnloadImageCount = ${Count};
 740
 741 EFI_STATUS
 742 EFIAPI
 743 ProcessModuleUnloadList (
 744   IN EFI_HANDLE        ImageHandle
 745   )
 746 {
 747   return EFI_SUCCESS;
 748 }
 749 """),
 750 TemplateString("""
 751 GLOBAL_REMOVE_IF_UNREFERENCED const UINT8 _gDriverUnloadImageCount = ${Count};
 752
 753 ${BEGIN}
 754 EFI_STATUS
 755 EFIAPI
 756 ProcessModuleUnloadList (
 757   IN EFI_HANDLE        ImageHandle
 758   )
 759 {
 760   return ${Function} (ImageHandle);
 761 }
 762 ${END}
 763 """),
 764 TemplateString("""
 765 GLOBAL_REMOVE_IF_UNREFERENCED const UINT8 _gDriverUnloadImageCount = ${Count};
 766
 767 EFI_STATUS
 768 EFIAPI
 769 ProcessModuleUnloadList (
 770   IN EFI_HANDLE        ImageHandle
 771   )
 772 {
 773   EFI_STATUS  Status;
 774
 775   Status = EFI_SUCCESS;
 776 ${BEGIN}
 777   if (EFI_ERROR (Status)) {
 778     ${Function} (ImageHandle);
 779   } else {
 780     Status = ${Function} (ImageHandle);
 781   }
 782 ${END}
 783   return Status;
 784 }
 785 """)
 786 ]
 787
 788 gLibraryStructorPrototype = {
 789 'BASE'  : TemplateString("""${BEGIN}
 790 RETURN_STATUS
 791 EFIAPI
 792 ${Function} (
 793   VOID
 794   );${END}
 795 """),
 796
 797 'PEI'   : TemplateString("""${BEGIN}
 798 EFI_STATUS
 799 EFIAPI
 800 ${Function} (
 801   IN       EFI_PEI_FILE_HANDLE       FileHandle,
 802   IN CONST EFI_PEI_SERVICES          **PeiServices
 803   );${END}
 804 """),
 805
 806 'DXE'   : TemplateString("""${BEGIN}
 807 EFI_STATUS
 808 EFIAPI
 809 ${Function} (
 810   IN EFI_HANDLE        ImageHandle,
 811   IN EFI_SYSTEM_TABLE  *SystemTable
 812   );${END}
 813 """),
 814 }
 815
 816 gLibraryStructorCall = {
 817 'BASE'  : TemplateString("""${BEGIN}
 818   Status = ${Function} ();
 819   ASSERT_EFI_ERROR (Status);${END}
 820 """),
 821
 822 'PEI'   : TemplateString("""${BEGIN}
 823   Status = ${Function} (FileHandle, PeiServices);
 824   ASSERT_EFI_ERROR (Status);${END}
 825 """),
 826
 827 'DXE'   : TemplateString("""${BEGIN}
 828   Status = ${Function} (ImageHandle, SystemTable);
 829   ASSERT_EFI_ERROR (Status);${END}
 830 """),
 831 }
 832
 833 ## Library Constructor and Destructor Templates
 834 gLibraryString = {
 835 'BASE'  :   TemplateString("""
 836 ${BEGIN}${FunctionPrototype}${END}
 837
 838 VOID
 839 EFIAPI
 840 ProcessLibrary${Type}List (
 841   VOID
 842   )
 843 {
 844 ${BEGIN}  EFI_STATUS  Status;
 845 ${FunctionCall}${END}
 846 }
 847 """),
 848
 849 'PEI'   :   TemplateString("""
 850 ${BEGIN}${FunctionPrototype}${END}
 851
 852 VOID
 853 EFIAPI
 854 ProcessLibrary${Type}List (
 855   IN       EFI_PEI_FILE_HANDLE       FileHandle,
 856   IN CONST EFI_PEI_SERVICES          **PeiServices
 857   )
 858 {
 859 ${BEGIN}  EFI_STATUS  Status;
 860 ${FunctionCall}${END}
 861 }
 862 """),
 863
 864 'DXE'   :   TemplateString("""
 865 ${BEGIN}${FunctionPrototype}${END}
 866
 867 VOID
 868 EFIAPI
 869 ProcessLibrary${Type}List (
 870   IN EFI_HANDLE        ImageHandle,
 871   IN EFI_SYSTEM_TABLE  *SystemTable
 872   )
 873 {
 874 ${BEGIN}  EFI_STATUS  Status;
 875 ${FunctionCall}${END}
 876 }
 877 """),
 878 }
 879
 880 gBasicHeaderFile = "Base.h"
 881
 882 gModuleTypeHeaderFile = {
 883     "BASE"              :   [gBasicHeaderFile],
 884     "SEC"               :   ["PiPei.h", "Library/DebugLib.h"],
 885     "PEI_CORE"          :   ["PiPei.h", "Library/DebugLib.h", "Library/PeiCoreEntryPoint.h"],
 886     "PEIM"              :   ["PiPei.h", "Library/DebugLib.h", "Library/PeimEntryPoint.h"],
 887     "DXE_CORE"          :   ["PiDxe.h", "Library/DebugLib.h", "Library/DxeCoreEntryPoint.h"],
 888     "DXE_DRIVER"        :   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h", "Library/UefiDriverEntryPoint.h"],
 889     "DXE_SMM_DRIVER"    :   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h", "Library/UefiDriverEntryPoint.h"],
 890     "DXE_RUNTIME_DRIVER":   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h", "Library/UefiDriverEntryPoint.h"],
 891     "DXE_SAL_DRIVER"    :   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h", "Library/UefiDriverEntryPoint.h"],
 892     "UEFI_DRIVER"       :   ["Uefi.h",  "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h", "Library/UefiDriverEntryPoint.h"],
 893     "UEFI_APPLICATION"  :   ["Uefi.h",  "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h", "Library/UefiApplicationEntryPoint.h"],
 894     "SMM_CORE"          :   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiDriverEntryPoint.h"],
 895     "USER_DEFINED"      :   [gBasicHeaderFile]
 896 }
 897
 898 ## Create code for module PCDs
 899 #
 900 #   @param      Info        The ModuleAutoGen object
 901 #   @param      AutoGenC    The TemplateString object for C code
 902 #   @param      AutoGenH    The TemplateString object for header file
 903 #   @param      Pcd         The PCD object
 904 #
 905 def CreateModulePcdCode(Info, AutoGenC, AutoGenH, Pcd):
 906     TokenSpaceGuidValue = Pcd.TokenSpaceGuidValue   #Info.GuidList[Pcd.TokenSpaceGuidCName]
 907     PcdTokenNumber = Info.PlatformInfo.PcdTokenNumber
 908     #
 909     # Write PCDs
 910     #
 911     PcdTokenName = '_PCD_TOKEN_' + Pcd.TokenCName
 912     if Pcd.Type in gDynamicExPcd:
 913         TokenNumber = int(Pcd.TokenValue, 0)
 914     else:
 915         if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in PcdTokenNumber:
 916             EdkLogger.error("build", AUTOGEN_ERROR,
 917                             "No generated token number for %s.%s\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 918                             ExtraData="[%s]" % str(Info))
 919         TokenNumber = PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName]
 920     AutoGenH.Append('\n#define %s  %d\n' % (PcdTokenName, TokenNumber))
 921
 922     EdkLogger.debug(EdkLogger.DEBUG_3, "Creating code for " + Pcd.TokenCName + "." + Pcd.TokenSpaceGuidCName)
 923     if Pcd.Type not in gItemTypeStringDatabase:
 924         EdkLogger.error("build", AUTOGEN_ERROR,
 925                         "Unknown PCD type [%s] of PCD %s.%s" % (Pcd.Type, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 926                         ExtraData="[%s]" % str(Info))
 927     if Pcd.DatumType not in gDatumSizeStringDatabase:
 928         EdkLogger.error("build", AUTOGEN_ERROR,
 929                         "Unknown datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 930                         ExtraData="[%s]" % str(Info))
 931
 932     DatumSize = gDatumSizeStringDatabase[Pcd.DatumType]
 933     DatumSizeLib = gDatumSizeStringDatabaseLib[Pcd.DatumType]
 934     GetModeName = '_PCD_GET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + Pcd.TokenCName
 935     SetModeName = '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + Pcd.TokenCName
 936
 937     if Pcd.Type in gDynamicExPcd:
 938         AutoGenH.Append('#define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 939         if Pcd.DatumType == 'VOID*':
 940             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 941         else:
 942             AutoGenH.Append('#define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 943     elif Pcd.Type in gDynamicPcd:
 944         AutoGenH.Append('#define %s  LibPcdGet%s(%s)\n' % (GetModeName, DatumSizeLib, PcdTokenName))
 945         if Pcd.DatumType == 'VOID*':
 946             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSet%s(%s, (SizeOfBuffer), (Buffer))\n' %(SetModeName, DatumSizeLib, PcdTokenName))
 947         else:
 948             AutoGenH.Append('#define %s(Value)  LibPcdSet%s(%s, (Value))\n' % (SetModeName, DatumSizeLib, PcdTokenName))
 949     else:
 950         PcdVariableName = '_gPcd_' + gItemTypeStringDatabase[Pcd.Type] + '_' + Pcd.TokenCName
 951         Const = 'const'
 952         if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
 953             Const = ''
 954         Type = ''
 955         Array = ''
 956         Value = Pcd.DefaultValue
 957         Unicode = False
 958         ValueNumber = 0
 959         if Pcd.DatumType in ['UINT64', 'UINT32', 'UINT16', 'UINT8']:
 960             try:
 961                 if Value.upper().startswith('0X'):
 962                     ValueNumber = int (Value, 16)
 963                 else:
 964                     ValueNumber = int (Value)
 965             except:
 966                 EdkLogger.error("build", AUTOGEN_ERROR,
 967                                 "PCD value is not valid dec or hex number for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 968                                 ExtraData="[%s]" % str(Info))
 969             if Pcd.DatumType == 'UINT64':
 970                 if ValueNumber < 0:
 971                     EdkLogger.error("build", AUTOGEN_ERROR,
 972                                     "PCD can't be set to negative value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 973                                     ExtraData="[%s]" % str(Info))
 974                 elif ValueNumber >= 0x10000000000000000:
 975                     EdkLogger.error("build", AUTOGEN_ERROR,
 976                                     "Too large PCD value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 977                                     ExtraData="[%s]" % str(Info))
 978                 if not Value.endswith('ULL'):
 979                     Value += 'ULL'
 980             elif Pcd.DatumType == 'UINT32':
 981                 if ValueNumber < 0:
 982                     EdkLogger.error("build", AUTOGEN_ERROR,
 983                                     "PCD can't be set to negative value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 984                                     ExtraData="[%s]" % str(Info))
 985                 elif ValueNumber >= 0x100000000:
 986                     EdkLogger.error("build", AUTOGEN_ERROR,
 987                                     "Too large PCD value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 988                                     ExtraData="[%s]" % str(Info))
 989             elif Pcd.DatumType == 'UINT16':
 990                 if ValueNumber < 0:
 991                     EdkLogger.error("build", AUTOGEN_ERROR,
 992                                     "PCD can't be set to negative value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 993                                     ExtraData="[%s]" % str(Info))
 994                 elif ValueNumber >= 0x10000:
 995                     EdkLogger.error("build", AUTOGEN_ERROR,
 996                                     "Too large PCD value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 997                                     ExtraData="[%s]" % str(Info))
 998             elif Pcd.DatumType == 'UINT8':
 999                 if ValueNumber < 0:
1000                     EdkLogger.error("build", AUTOGEN_ERROR,
1001                                     "PCD can't be set to negative value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
1002                                     ExtraData="[%s]" % str(Info))
1003                 elif ValueNumber >= 0x100:
1004                     EdkLogger.error("build", AUTOGEN_ERROR,
1005                                     "Too large PCD value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
1006                                     ExtraData="[%s]" % str(Info))
1007         if Pcd.DatumType == 'VOID*':
1008             if Pcd.MaxDatumSize == None or Pcd.MaxDatumSize == '':
1009                 EdkLogger.error("build", AUTOGEN_ERROR,
1010                                 "Unknown [MaxDatumSize] of PCD [%s.%s]" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
1011                                 ExtraData="[%s]" % str(Info))
1012
1013             ArraySize = int(Pcd.MaxDatumSize, 0)
1014             if Value[0] == '{':
1015                 Type = '(VOID *)'
1016             else:
1017                 if Value[0] == 'L':
1018                     Unicode = True
1019                 Value = Value.lstrip('L')   #.strip('"')
1020                 Value = eval(Value)         # translate escape character
1021                 NewValue = '{'
1022                 for Index in range(0,len(Value)):
1023                     if Unicode:
1024                         NewValue = NewValue + str(ord(Value[Index]) % 0x10000) + ', '
1025                     else:
1026                         NewValue = NewValue + str(ord(Value[Index]) % 0x100) + ', '
1027                 if Unicode:
1028                     ArraySize = ArraySize / 2;
1029
1030                 if ArraySize < (len(Value) + 1):
1031                     EdkLogger.error("build", AUTOGEN_ERROR,
1032                                     "The maximum size of VOID* type PCD '%s.%s' is less than its actual size occupied." % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
1033                                     ExtraData="[%s]" % str(Info))
1034                 Value = NewValue + '0 }'
1035             Array = '[%d]' % ArraySize
1036         #
1037         # skip casting for fixed at build since it breaks ARM assembly.
1038         # Long term we need PCD macros that work in assembly
1039         #
1040         elif Pcd.Type != TAB_PCDS_FIXED_AT_BUILD:
1041             Value = "((%s)%s)" % (Pcd.DatumType, Value)
1042
1043         if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
1044             PcdValueName = '_PCD_PATCHABLE_VALUE_' + Pcd.TokenCName
1045         else:
1046             PcdValueName = '_PCD_VALUE_' + Pcd.TokenCName
1047
1048         if Pcd.DatumType == 'VOID*':
1049             #
1050             # For unicode, UINT16 array will be generated, so the alignment of unicode is guaranteed.
1051             #
1052             if Unicode:
1053                 AutoGenH.Append('#define _PCD_PATCHABLE_%s_SIZE %s\n' % (Pcd.TokenCName, Pcd.MaxDatumSize))
1054                 AutoGenH.Append('#define %s  %s%s\n' %(PcdValueName, Type, PcdVariableName))
1055                 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s UINT16 %s%s = %s;\n' % (Const, PcdVariableName, Array, Value))
1056                 AutoGenH.Append('extern %s UINT16 %s%s;\n' %(Const, PcdVariableName, Array))
1057                 AutoGenH.Append('#define %s  %s%s\n' %(GetModeName, Type, PcdVariableName))
1058             else:
1059                 AutoGenH.Append('#define _PCD_PATCHABLE_%s_SIZE %s\n' % (Pcd.TokenCName, Pcd.MaxDatumSize))
1060                 AutoGenH.Append('#define %s  %s%s\n' %(PcdValueName, Type, PcdVariableName))
1061                 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s UINT8 %s%s = %s;\n' % (Const, PcdVariableName, Array, Value))
1062                 AutoGenH.Append('extern %s UINT8 %s%s;\n' %(Const, PcdVariableName, Array))
1063                 AutoGenH.Append('#define %s  %s%s\n' %(GetModeName, Type, PcdVariableName))
1064         elif Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
1065             AutoGenH.Append('#define %s  %s\n' %(PcdValueName, Value))
1066             AutoGenC.Append('volatile %s %s %s = %s;\n' %(Const, Pcd.DatumType, PcdVariableName, PcdValueName))
1067             AutoGenH.Append('extern volatile %s  %s  %s%s;\n' % (Const, Pcd.DatumType, PcdVariableName, Array))
1068             AutoGenH.Append('#define %s  %s%s\n' % (GetModeName, Type, PcdVariableName))
1069         else:
1070             AutoGenH.Append('#define %s  %s\n' %(PcdValueName, Value))
1071             AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s %s = %s;\n' %(Const, Pcd.DatumType, PcdVariableName, PcdValueName))
1072             AutoGenH.Append('extern %s  %s  %s%s;\n' % (Const, Pcd.DatumType, PcdVariableName, Array))
1073             AutoGenH.Append('#define %s  %s%s\n' % (GetModeName, Type, PcdVariableName))
1074
1075         if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
1076             if Pcd.DatumType == 'VOID*':
1077                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPatchPcdSetPtr(_gPcd_BinaryPatch_%s, (UINTN)_PCD_PATCHABLE_%s_SIZE, (SizeOfBuffer), (Buffer))\n' % (SetModeName, Pcd.TokenCName, Pcd.TokenCName))
1078             else:
1079                 AutoGenH.Append('#define %s(Value)  (%s = (Value))\n' % (SetModeName, PcdVariableName))
1080         else:
1081             AutoGenH.Append('//#define %s  ASSERT(FALSE)  // It is not allowed to set value for a FIXED_AT_BUILD PCD\n' % SetModeName)
1082
1083 ## Create code for library module PCDs
1084 #
1085 #   @param      Info        The ModuleAutoGen object
1086 #   @param      AutoGenC    The TemplateString object for C code
1087 #   @param      AutoGenH    The TemplateString object for header file
1088 #   @param      Pcd         The PCD object
1089 #
1090 def CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd):
1091     PcdTokenNumber = Info.PlatformInfo.PcdTokenNumber
1092     TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName
1093     TokenCName  = Pcd.TokenCName
1094     TokenSpaceGuidValue = Pcd.TokenSpaceGuidValue   #Info.GuidList[TokenSpaceGuidCName]
1095     if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in PcdTokenNumber:
1096         EdkLogger.error("build", AUTOGEN_ERROR,
1097                         "No generated token number for %s.%s\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
1098                         ExtraData="[%s]" % str(Info))
1099     TokenNumber = PcdTokenNumber[TokenCName, TokenSpaceGuidCName]
1100
1101     # If PCD is DynamicEx, then use TokenNumber declared in DEC file
1102     if Pcd.Type in gDynamicExPcd:
1103         TokenNumber = int(Pcd.TokenValue, 0)
1104
1105     if Pcd.Type not in gItemTypeStringDatabase:
1106         EdkLogger.error("build", AUTOGEN_ERROR,
1107                         "Unknown PCD type [%s] of PCD %s.%s" % (Pcd.Type, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
1108                         ExtraData="[%s]" % str(Info))
1109     if Pcd.DatumType not in gDatumSizeStringDatabase:
1110         EdkLogger.error("build", AUTOGEN_ERROR,
1111                         "Unknown datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
1112                         ExtraData="[%s]" % str(Info))
1113
1114     DatumType   = Pcd.DatumType
1115     DatumSize   = gDatumSizeStringDatabaseH[DatumType]
1116     DatumSizeLib= gDatumSizeStringDatabaseLib[DatumType]
1117     GetModeName = '_PCD_GET_MODE_' + DatumSize + '_' + TokenCName
1118     SetModeName = '_PCD_SET_MODE_' + DatumSize + '_' + TokenCName
1119
1120     Type = ''
1121     Array = ''
1122     if Pcd.DatumType == 'VOID*':
1123         Type = '(VOID *)'
1124         Array = '[]'
1125
1126     AutoGenH.Append('#define _PCD_TOKEN_%s  %d\n' % (TokenCName, TokenNumber))
1127
1128     PcdItemType = Pcd.Type
1129     #if PcdItemType in gDynamicPcd:
1130     #    PcdItemType = TAB_PCDS_FIXED_AT_BUILD
1131     #    if (TokenCName, TokenSpaceGuidCName) in Info.PlatformInfo.Platform.Pcds:
1132     #        PcdItemType  = Info.PlatformInfo.Platform.Pcds[TokenCName, TokenSpaceGuidCName].Type
1133     if PcdItemType in gDynamicExPcd:
1134         PcdTokenName = '_PCD_TOKEN_' + TokenCName
1135         AutoGenH.Append('#define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, TokenSpaceGuidCName, PcdTokenName))
1136         if DatumType == 'VOID*':
1137             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName,DatumSizeLib, TokenSpaceGuidCName, PcdTokenName))
1138         else:
1139             AutoGenH.Append('#define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, TokenSpaceGuidCName, PcdTokenName))
1140     if PcdItemType in gDynamicPcd:
1141         PcdTokenName = '_PCD_TOKEN_' + TokenCName
1142         AutoGenH.Append('#define %s  LibPcdGet%s(%s)\n' % (GetModeName, DatumSizeLib, PcdTokenName))
1143         if DatumType == 'VOID*':
1144             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSet%s(%s, (SizeOfBuffer), (Buffer))\n' %(SetModeName, DatumSizeLib, PcdTokenName))
1145         else:
1146             AutoGenH.Append('#define %s(Value)  LibPcdSet%s(%s, (Value))\n' % (SetModeName, DatumSizeLib, PcdTokenName))
1147     if PcdItemType == TAB_PCDS_PATCHABLE_IN_MODULE:
1148         PcdVariableName = '_gPcd_' + gItemTypeStringDatabase[TAB_PCDS_PATCHABLE_IN_MODULE] + '_' + TokenCName
1149         AutoGenH.Append('extern %s _gPcd_BinaryPatch_%s%s;\n' %(DatumType, TokenCName, Array) )
1150         AutoGenH.Append('#define %s  %s_gPcd_BinaryPatch_%s\n' %(GetModeName, Type, TokenCName))
1151         AutoGenH.Append('#define %s(Value)  (%s = (Value))\n' % (SetModeName, PcdVariableName))
1152     if PcdItemType == TAB_PCDS_FIXED_AT_BUILD or PcdItemType == TAB_PCDS_FEATURE_FLAG:
1153         AutoGenH.Append('extern const %s _gPcd_FixedAtBuild_%s%s;\n' %(DatumType, TokenCName, Array))
1154         #AutoGenH.Append('#define _PCD_VALUE_%s  _gPcd_FixedAtBuild_%s\n' %(TokenCName, TokenCName))
1155         AutoGenH.Append('#define %s  %s_gPcd_FixedAtBuild_%s\n' %(GetModeName, Type, TokenCName))
1156         AutoGenH.Append('//#define %s  ASSERT(FALSE)  // It is not allowed to set value for a FIXED_AT_BUILD PCD\n' % SetModeName)
1157
1158 ## Create code for PCD database in DXE or PEI phase
1159 #
1160 #   @param      Platform    The platform object
1161 #   @retval     tuple       Two TemplateString objects for C code and header file,
1162 #                           respectively
1163 #
1164 def CreatePcdDatabasePhaseSpecificAutoGen (Platform, Phase):
1165     AutoGenC = TemplateString()
1166     AutoGenH = TemplateString()
1167
1168     Dict = {
1169         'PHASE'                         : Phase,
1170         'GUID_TABLE_SIZE'               : '1',
1171         'STRING_TABLE_SIZE'             : '1',
1172         'SKUID_TABLE_SIZE'              : '1',
1173         'LOCAL_TOKEN_NUMBER_TABLE_SIZE' : '1',
1174         'LOCAL_TOKEN_NUMBER'            : '0',
1175         'EXMAPPING_TABLE_SIZE'          : '1',
1176         'EX_TOKEN_NUMBER'               : '0',
1177         'SIZE_TABLE_SIZE'               : '2',
1178         'GUID_TABLE_EMPTY'              : 'TRUE',
1179         'STRING_TABLE_EMPTY'            : 'TRUE',
1180         'SKUID_TABLE_EMPTY'             : 'TRUE',
1181         'DATABASE_EMPTY'                : 'TRUE',
1182         'EXMAP_TABLE_EMPTY'             : 'TRUE',
1183         'PCD_DATABASE_UNINIT_EMPTY'     : '  UINT8  dummy; /* PCD_DATABASE_UNINIT is emptry */',
1184         'SYSTEM_SKU_ID'                 : '  SKU_ID             SystemSkuId;',
1185         'SYSTEM_SKU_ID_VALUE'           : '0'
1186     }
1187
1188     for DatumType in ['UINT64','UINT32','UINT16','UINT8','BOOLEAN', "VOID*"]:
1189         Dict['VARDEF_CNAME_' + DatumType] = []
1190         Dict['VARDEF_GUID_' + DatumType]  = []
1191         Dict['VARDEF_SKUID_' + DatumType] = []
1192         Dict['VARDEF_VALUE_' + DatumType] = []
1193         for Init in ['INIT','UNINIT']:
1194             Dict[Init+'_CNAME_DECL_' + DatumType]   = []
1195             Dict[Init+'_GUID_DECL_' + DatumType]    = []
1196             Dict[Init+'_NUMSKUS_DECL_' + DatumType] = []
1197             Dict[Init+'_VALUE_' + DatumType]        = []
1198
1199     for Type in ['STRING_HEAD','VPD_HEAD','VARIABLE_HEAD']:
1200         Dict[Type + '_CNAME_DECL']   = []
1201         Dict[Type + '_GUID_DECL']    = []
1202         Dict[Type + '_NUMSKUS_DECL'] = []
1203         Dict[Type + '_VALUE'] = []
1204
1205     Dict['STRING_TABLE_INDEX'] = []
1206     Dict['STRING_TABLE_LENGTH']  = []
1207     Dict['STRING_TABLE_CNAME'] = []
1208     Dict['STRING_TABLE_GUID']  = []
1209     Dict['STRING_TABLE_VALUE'] = []
1210
1211     Dict['SIZE_TABLE_CNAME'] = []
1212     Dict['SIZE_TABLE_GUID']  = []
1213     Dict['SIZE_TABLE_CURRENT_LENGTH']  = []
1214     Dict['SIZE_TABLE_MAXIMUM_LENGTH']  = []
1215
1216     Dict['EXMAPPING_TABLE_EXTOKEN'] = []
1217     Dict['EXMAPPING_TABLE_LOCAL_TOKEN'] = []
1218     Dict['EXMAPPING_TABLE_GUID_INDEX'] = []
1219
1220     Dict['GUID_STRUCTURE'] = []
1221
1222     Dict['SKUID_VALUE'] = []
1223     Dict['VARDEF_HEADER'] = []
1224     if Phase == 'DXE':
1225         Dict['SYSTEM_SKU_ID'] = ''
1226         Dict['SYSTEM_SKU_ID_VALUE'] = ''
1227
1228     StringTableIndex = 0
1229     StringTableSize = 0
1230     NumberOfLocalTokens = 0
1231     NumberOfPeiLocalTokens = 0
1232     NumberOfDxeLocalTokens = 0
1233     NumberOfExTokens = 0
1234     NumberOfSizeItems = 0
1235     GuidList = []
1236
1237     for Pcd in Platform.DynamicPcdList:
1238         CName = Pcd.TokenCName
1239         TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName
1240
1241         EdkLogger.debug(EdkLogger.DEBUG_3, "PCD: %s %s (%s : %s)" % (CName, TokenSpaceGuidCName, Pcd.Phase, Phase))
1242         if Pcd.DatumType not in gDatumSizeStringDatabase:
1243             EdkLogger.error("build", AUTOGEN_ERROR,
1244                             "Unknown datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
1245                             ExtraData="[%s]" % str(Platform))
1246
1247         if Pcd.Phase == 'PEI':
1248             NumberOfPeiLocalTokens += 1
1249         if Pcd.Phase == 'DXE':
1250             NumberOfDxeLocalTokens += 1
1251         if Pcd.Phase != Phase:
1252             continue
1253
1254         #
1255         # TODO: need GetGuidValue() definition
1256         #
1257         TokenSpaceGuidStructure = Pcd.TokenSpaceGuidValue
1258         TokenSpaceGuid = GuidStructureStringToGuidValueName(TokenSpaceGuidStructure)
1259         if Pcd.Type in gDynamicExPcd:
1260             if TokenSpaceGuid not in GuidList:
1261                 GuidList += [TokenSpaceGuid]
1262                 Dict['GUID_STRUCTURE'].append(TokenSpaceGuidStructure)
1263             NumberOfExTokens += 1
1264
1265         ValueList = []
1266         StringHeadOffsetList = []
1267         VpdHeadOffsetList = []
1268         VariableHeadValueList = []
1269         Pcd.InitString = 'UNINIT'
1270
1271         if Pcd.DatumType == 'VOID*':
1272             if Pcd.Type not in ["DynamicVpd", "DynamicExVpd"]:
1273                 Pcd.TokenTypeList = ['PCD_TYPE_STRING']
1274             else:
1275                 Pcd.TokenTypeList = []
1276         elif Pcd.DatumType == 'BOOLEAN':
1277             Pcd.TokenTypeList = ['PCD_DATUM_TYPE_UINT8']
1278         else:
1279             Pcd.TokenTypeList = ['PCD_DATUM_TYPE_' + Pcd.DatumType]
1280
1281         if len(Pcd.SkuInfoList) > 1:
1282             Pcd.TokenTypeList += ['PCD_TYPE_SKU_ENABLED']
1283
1284         for SkuName in Pcd.SkuInfoList:
1285             Sku = Pcd.SkuInfoList[SkuName]
1286             SkuId = Sku.SkuId
1287             if SkuId == None or SkuId == '':
1288                 continue
1289
1290             if SkuId not in Dict['SKUID_VALUE']:
1291                 Dict['SKUID_VALUE'].append(SkuId)
1292
1293             SkuIdIndex =   Dict['SKUID_VALUE'].index(SkuId)
1294             if len(Sku.VariableName) > 0:
1295                 Pcd.TokenTypeList += ['PCD_TYPE_HII']
1296                 Pcd.InitString = 'INIT'
1297                 VariableNameStructure = StringToArray(Sku.VariableName)
1298                 if VariableNameStructure not in Dict['STRING_TABLE_VALUE']:
1299                     Dict['STRING_TABLE_CNAME'].append(CName)
1300                     Dict['STRING_TABLE_GUID'].append(TokenSpaceGuid)
1301                     if StringTableIndex == 0:
1302                         Dict['STRING_TABLE_INDEX'].append('')
1303                     else:
1304                         Dict['STRING_TABLE_INDEX'].append('_%d' % StringTableIndex)
1305
1306                     Dict['STRING_TABLE_LENGTH'].append((len(Sku.VariableName) - 3 + 1) * 2)
1307                     Dict['STRING_TABLE_VALUE'].append(VariableNameStructure)
1308                     StringTableIndex += 1
1309                     StringTableSize += (len(Sku.VariableName) - 3 + 1) * 2
1310
1311                 VariableHeadStringIndex = 0
1312                 for Index in range(Dict['STRING_TABLE_VALUE'].index(VariableNameStructure)):
1313                     VariableHeadStringIndex += Dict['STRING_TABLE_LENGTH'][Index]
1314
1315                 VariableGuidStructure = Sku.VariableGuidValue
1316                 VariableGuid = GuidStructureStringToGuidValueName(VariableGuidStructure)
1317                 if VariableGuid not in GuidList:
1318                     GuidList += [VariableGuid]
1319                     Dict['GUID_STRUCTURE'].append(VariableGuidStructure)
1320                 VariableHeadGuidIndex = GuidList.index(VariableGuid)
1321
1322                 if "PCD_TYPE_STRING" in Pcd.TokenTypeList:
1323                     VariableHeadValueList.append('%d, %d, %s, offsetof(%s_PCD_DATABASE, Init.%s_%s)' %
1324                                                  (VariableHeadGuidIndex, VariableHeadStringIndex, Sku.VariableOffset,
1325                                                   Phase, CName, TokenSpaceGuid))
1326                 else:
1327                     VariableHeadValueList.append('%d, %d, %s, offsetof(%s_PCD_DATABASE, Init.%s_%s_VariableDefault_%s)' %
1328                                                  (VariableHeadGuidIndex, VariableHeadStringIndex, Sku.VariableOffset,
1329                                                   Phase, CName, TokenSpaceGuid, SkuIdIndex))
1330                 Dict['VARDEF_CNAME_'+Pcd.DatumType].append(CName)
1331                 Dict['VARDEF_GUID_'+Pcd.DatumType].append(TokenSpaceGuid)
1332                 Dict['VARDEF_SKUID_'+Pcd.DatumType].append(SkuIdIndex)
1333                 if "PCD_TYPE_STRING" in  Pcd.TokenTypeList:
1334                     Dict['VARDEF_VALUE_' + Pcd.DatumType].append("%s_%s[%d]" % (Pcd.TokenCName, TokenSpaceGuid, SkuIdIndex))
1335                 else:
1336                     Dict['VARDEF_VALUE_'+Pcd.DatumType].append(Sku.HiiDefaultValue)
1337             elif Sku.VpdOffset != '':
1338                 Pcd.TokenTypeList += ['PCD_TYPE_VPD']
1339                 Pcd.InitString = 'INIT'
1340                 VpdHeadOffsetList.append(Sku.VpdOffset)
1341                 continue
1342
1343             if Pcd.DatumType == 'VOID*':
1344                 Pcd.TokenTypeList += ['PCD_TYPE_STRING']
1345                 Pcd.InitString = 'INIT'
1346                 if Sku.HiiDefaultValue != '' and Sku.DefaultValue == '':
1347                     Sku.DefaultValue = Sku.HiiDefaultValue
1348                 if Sku.DefaultValue != '':
1349                     NumberOfSizeItems += 1
1350                     Dict['STRING_TABLE_CNAME'].append(CName)
1351                     Dict['STRING_TABLE_GUID'].append(TokenSpaceGuid)
1352
1353                     if StringTableIndex == 0:
1354                         Dict['STRING_TABLE_INDEX'].append('')
1355                     else:
1356                         Dict['STRING_TABLE_INDEX'].append('_%d' % StringTableIndex)
1357                     if Sku.DefaultValue[0] == 'L':
1358                         Size = (len(Sku.DefaultValue) - 3 + 1) * 2
1359                         Dict['STRING_TABLE_VALUE'].append(StringToArray(Sku.DefaultValue))
1360                     elif Sku.DefaultValue[0] == '"':
1361                         Size = len(Sku.DefaultValue) - 2 + 1
1362                         Dict['STRING_TABLE_VALUE'].append(StringToArray(Sku.DefaultValue))
1363                     elif Sku.DefaultValue[0] == '{':
1364                         Size = len(Sku.DefaultValue.replace(',',' ').split())
1365                         Dict['STRING_TABLE_VALUE'].append(Sku.DefaultValue)
1366
1367                     StringHeadOffsetList.append(str(StringTableSize))
1368                     Dict['SIZE_TABLE_CNAME'].append(CName)
1369                     Dict['SIZE_TABLE_GUID'].append(TokenSpaceGuid)
1370                     Dict['SIZE_TABLE_CURRENT_LENGTH'].append(Size)
1371                     Dict['SIZE_TABLE_MAXIMUM_LENGTH'].append(Pcd.MaxDatumSize)
1372                     if Pcd.MaxDatumSize != '':
1373                         MaxDatumSize = int(Pcd.MaxDatumSize, 0)
1374                         if MaxDatumSize < Size:
1375                             EdkLogger.error("build", AUTOGEN_ERROR,
1376                                             "The maximum size of VOID* type PCD '%s.%s' is less than its actual size occupied." % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
1377                                             ExtraData="[%s]" % str(Platform))
1378                         Size = MaxDatumSize
1379                     Dict['STRING_TABLE_LENGTH'].append(Size)
1380                     StringTableIndex += 1
1381                     StringTableSize += (Size)
1382             else:
1383                 if "PCD_TYPE_HII" not in Pcd.TokenTypeList:
1384                     Pcd.TokenTypeList += ['PCD_TYPE_DATA']
1385                     if Sku.DefaultValue == 'TRUE':
1386                         Pcd.InitString = 'INIT'
1387                     else:
1388                         try:
1389                             if int(Sku.DefaultValue, 0) != 0:
1390                                 Pcd.InitString = 'INIT'
1391                         except:
1392                             pass
1393
1394                 #
1395                 # For UNIT64 type PCD's value, ULL should be append to avoid
1396                 # warning under linux building environment.
1397                 #
1398                 if Pcd.DatumType == "UINT64":
1399                     ValueList.append(Sku.DefaultValue + "ULL")
1400                 else:
1401                     ValueList.append(Sku.DefaultValue)
1402
1403         Pcd.TokenTypeList = list(set(Pcd.TokenTypeList))
1404
1405
1406         if 'PCD_TYPE_HII' in Pcd.TokenTypeList:
1407             Dict['VARIABLE_HEAD_CNAME_DECL'].append(CName)
1408             Dict['VARIABLE_HEAD_GUID_DECL'].append(TokenSpaceGuid)
1409             Dict['VARIABLE_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))
1410             Dict['VARIABLE_HEAD_VALUE'].append('{ %s }\n' % ' },\n    { '.join(VariableHeadValueList))
1411             Dict['VARDEF_HEADER'].append('_Variable_Header')
1412         else:
1413             Dict['VARDEF_HEADER'].append('')
1414         if 'PCD_TYPE_VPD' in Pcd.TokenTypeList:
1415             Dict['VPD_HEAD_CNAME_DECL'].append(CName)
1416             Dict['VPD_HEAD_GUID_DECL'].append(TokenSpaceGuid)
1417             Dict['VPD_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))
1418             Dict['VPD_HEAD_VALUE'].append('{ %s }' % ' }, { '.join(VpdHeadOffsetList))
1419         if 'PCD_TYPE_STRING' in Pcd.TokenTypeList:
1420             Dict['STRING_HEAD_CNAME_DECL'].append(CName)
1421             Dict['STRING_HEAD_GUID_DECL'].append(TokenSpaceGuid)
1422             Dict['STRING_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))
1423             Dict['STRING_HEAD_VALUE'].append(', '.join(StringHeadOffsetList))
1424         if 'PCD_TYPE_DATA' in Pcd.TokenTypeList:
1425             Dict[Pcd.InitString+'_CNAME_DECL_'+Pcd.DatumType].append(CName)
1426             Dict[Pcd.InitString+'_GUID_DECL_'+Pcd.DatumType].append(TokenSpaceGuid)
1427             Dict[Pcd.InitString+'_NUMSKUS_DECL_'+Pcd.DatumType].append(len(Pcd.SkuInfoList))
1428             if Pcd.InitString == 'UNINIT':
1429                 Dict['PCD_DATABASE_UNINIT_EMPTY'] = ''
1430             else:
1431                 Dict[Pcd.InitString+'_VALUE_'+Pcd.DatumType].append(', '.join(ValueList))
1432
1433     if Phase == 'PEI':
1434         NumberOfLocalTokens = NumberOfPeiLocalTokens
1435     if Phase == 'DXE':
1436         NumberOfLocalTokens = NumberOfDxeLocalTokens
1437
1438     Dict['TOKEN_INIT']       = ['' for x in range(NumberOfLocalTokens)]
1439     Dict['TOKEN_CNAME']      = ['' for x in range(NumberOfLocalTokens)]
1440     Dict['TOKEN_GUID']       = ['' for x in range(NumberOfLocalTokens)]
1441     Dict['TOKEN_TYPE']       = ['' for x in range(NumberOfLocalTokens)]
1442
1443     for Pcd in Platform.DynamicPcdList:
1444         CName = Pcd.TokenCName
1445         TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName
1446         if Pcd.Phase != Phase:
1447             continue
1448
1449         TokenSpaceGuid = GuidStructureStringToGuidValueName(Pcd.TokenSpaceGuidValue) #(Platform.PackageList, TokenSpaceGuidCName))
1450         GeneratedTokenNumber = Platform.PcdTokenNumber[CName, TokenSpaceGuidCName] - 1
1451         if Phase == 'DXE':
1452             GeneratedTokenNumber -= NumberOfPeiLocalTokens
1453
1454         EdkLogger.debug(EdkLogger.DEBUG_1, "PCD = %s.%s" % (CName, TokenSpaceGuidCName))
1455         EdkLogger.debug(EdkLogger.DEBUG_1, "phase = %s" % Phase)
1456         EdkLogger.debug(EdkLogger.DEBUG_1, "GeneratedTokenNumber = %s" % str(GeneratedTokenNumber))
1457
1458         Dict['TOKEN_INIT'][GeneratedTokenNumber] = 'Init'
1459         if Pcd.InitString == 'UNINIT':
1460             Dict['TOKEN_INIT'][GeneratedTokenNumber] = 'Uninit'
1461         Dict['TOKEN_CNAME'][GeneratedTokenNumber] = CName
1462         Dict['TOKEN_GUID'][GeneratedTokenNumber] = TokenSpaceGuid
1463         Dict['TOKEN_TYPE'][GeneratedTokenNumber] = ' | '.join(Pcd.TokenTypeList)
1464         if Pcd.Type in gDynamicExPcd:
1465             Dict['EXMAPPING_TABLE_EXTOKEN'].append(Pcd.TokenValue)
1466             if Phase == 'DXE':
1467                 GeneratedTokenNumber += NumberOfPeiLocalTokens
1468             #
1469             # Per, PCD architecture specification, PCD Token Number is 1 based and 0 is defined as invalid token number.
1470             # For each EX type PCD, a PCD Token Number is assigned. When the
1471             # PCD Driver/PEIM map EX_GUID and EX_TOKEN_NUMBER to the PCD Token Number,
1472             # the non-EX Protocol/PPI interface can be called to get/set the value. This assumption is made by
1473             # Pcd Driver/PEIM in MdeModulePkg.
1474             # Therefore, 1 is added to GeneratedTokenNumber to generate a PCD Token Number before being inserted
1475             # to the EXMAPPING_TABLE.
1476             #
1477             Dict['EXMAPPING_TABLE_LOCAL_TOKEN'].append(GeneratedTokenNumber + 1)
1478             Dict['EXMAPPING_TABLE_GUID_INDEX'].append(GuidList.index(TokenSpaceGuid))
1479
1480     if GuidList != []:
1481         Dict['GUID_TABLE_EMPTY'] = 'FALSE'
1482         Dict['GUID_TABLE_SIZE'] = len(GuidList)
1483     else:
1484         Dict['GUID_STRUCTURE'] = [GuidStringToGuidStructureString('00000000-0000-0000-0000-000000000000')]
1485
1486     if StringTableIndex == 0:
1487         Dict['STRING_TABLE_INDEX'].append('')
1488         Dict['STRING_TABLE_LENGTH'].append(1)
1489         Dict['STRING_TABLE_CNAME'].append('')
1490         Dict['STRING_TABLE_GUID'].append('')
1491         Dict['STRING_TABLE_VALUE'].append('{ 0 }')
1492     else:
1493         Dict['STRING_TABLE_EMPTY'] = 'FALSE'
1494         Dict['STRING_TABLE_SIZE'] = StringTableSize
1495
1496     if Dict['SIZE_TABLE_CNAME'] == []:
1497         Dict['SIZE_TABLE_CNAME'].append('')
1498         Dict['SIZE_TABLE_GUID'].append('')
1499         Dict['SIZE_TABLE_CURRENT_LENGTH'].append(0)
1500         Dict['SIZE_TABLE_MAXIMUM_LENGTH'].append(0)
1501
1502     if NumberOfLocalTokens != 0:
1503         Dict['DATABASE_EMPTY']                = 'FALSE'
1504         Dict['LOCAL_TOKEN_NUMBER_TABLE_SIZE'] = NumberOfLocalTokens
1505         Dict['LOCAL_TOKEN_NUMBER']            = NumberOfLocalTokens
1506
1507     if NumberOfExTokens != 0:
1508         Dict['EXMAP_TABLE_EMPTY']    = 'FALSE'
1509         Dict['EXMAPPING_TABLE_SIZE'] = NumberOfExTokens
1510         Dict['EX_TOKEN_NUMBER']      = NumberOfExTokens
1511     else:
1512         Dict['EXMAPPING_TABLE_EXTOKEN'].append(0)
1513         Dict['EXMAPPING_TABLE_LOCAL_TOKEN'].append(0)
1514         Dict['EXMAPPING_TABLE_GUID_INDEX'].append(0)
1515
1516     if NumberOfSizeItems != 0:
1517         Dict['SIZE_TABLE_SIZE'] = NumberOfSizeItems * 2
1518
1519     AutoGenH.Append(gPcdDatabaseAutoGenH.Replace(Dict))
1520     if NumberOfLocalTokens == 0:
1521         AutoGenC.Append(gEmptyPcdDatabaseAutoGenC.Replace(Dict))
1522     else:
1523         AutoGenC.Append(gPcdDatabaseAutoGenC.Replace(Dict))
1524
1525     return AutoGenH, AutoGenC
1526
1527 ## Create code for PCD database
1528 #
1529 #   @param      Info        The ModuleAutoGen object
1530 #   @param      AutoGenC    The TemplateString object for C code
1531 #   @param      AutoGenH    The TemplateString object for header file
1532 #
1533 def CreatePcdDatabaseCode (Info, AutoGenC, AutoGenH):
1534     if Info.PcdIsDriver == "":
1535         return
1536     if Info.PcdIsDriver not in gPcdPhaseMap:
1537         EdkLogger.error("build", AUTOGEN_ERROR, "Not supported PcdIsDriver type:%s" % Info.PcdIsDriver,
1538                         ExtraData="[%s]" % str(Info))
1539
1540     AutoGenH.Append(gPcdDatabaseCommonAutoGenH)
1541     AdditionalAutoGenH, AdditionalAutoGenC = CreatePcdDatabasePhaseSpecificAutoGen (Info.PlatformInfo, 'PEI')
1542     AutoGenH.Append(AdditionalAutoGenH.String)
1543
1544     Phase = gPcdPhaseMap[Info.PcdIsDriver]
1545     if Phase == 'PEI':
1546         AutoGenC.Append(AdditionalAutoGenC.String)
1547
1548     if Phase == 'DXE':
1549         AdditionalAutoGenH, AdditionalAutoGenC = CreatePcdDatabasePhaseSpecificAutoGen (Info.PlatformInfo, Phase)
1550         AutoGenH.Append(AdditionalAutoGenH.String)
1551         AutoGenC.Append(AdditionalAutoGenC.String)
1552         AutoGenH.Append(gPcdDatabaseEpilogueAutoGenH)
1553
1554 ## Create code for library constructor
1555 #
1556 #   @param      Info        The ModuleAutoGen object
1557 #   @param      AutoGenC    The TemplateString object for C code
1558 #   @param      AutoGenH    The TemplateString object for header file
1559 #
1560 def CreateLibraryConstructorCode(Info, AutoGenC, AutoGenH):
1561     #
1562     # Library Constructors
1563     #
1564     ConstructorPrototypeString = TemplateString()
1565     ConstructorCallingString = TemplateString()
1566     if Info.IsLibrary:
1567         DependentLibraryList = [Info.Module]
1568     else:
1569         DependentLibraryList = Info.DependentLibraryList
1570     for Lib in DependentLibraryList:
1571         if len(Lib.ConstructorList) <= 0:
1572             continue
1573         Dict = {'Function':Lib.ConstructorList}
1574         if Lib.ModuleType in ['BASE', 'SEC']:
1575             ConstructorPrototypeString.Append(gLibraryStructorPrototype['BASE'].Replace(Dict))
1576             ConstructorCallingString.Append(gLibraryStructorCall['BASE'].Replace(Dict))
1577         elif Lib.ModuleType in ['PEI_CORE','PEIM']:
1578             ConstructorPrototypeString.Append(gLibraryStructorPrototype['PEI'].Replace(Dict))
1579             ConstructorCallingString.Append(gLibraryStructorCall['PEI'].Replace(Dict))
1580         elif Lib.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER',
1581                                 'DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION','SMM_CORE']:
1582             ConstructorPrototypeString.Append(gLibraryStructorPrototype['DXE'].Replace(Dict))
1583             ConstructorCallingString.Append(gLibraryStructorCall['DXE'].Replace(Dict))
1584
1585     if str(ConstructorPrototypeString) == '':
1586         ConstructorPrototypeList = []
1587     else:
1588         ConstructorPrototypeList = [str(ConstructorPrototypeString)]
1589     if str(ConstructorCallingString) == '':
1590         ConstructorCallingList = []
1591     else:
1592         ConstructorCallingList = [str(ConstructorCallingString)]
1593
1594     Dict = {
1595         'Type'              :   'Constructor',
1596         'FunctionPrototype' :   ConstructorPrototypeList,
1597         'FunctionCall'      :   ConstructorCallingList
1598     }
1599     if Info.IsLibrary:
1600         AutoGenH.Append("${BEGIN}${FunctionPrototype}${END}", Dict)
1601     else:
1602         if Info.ModuleType in ['BASE', 'SEC']:
1603             AutoGenC.Append(gLibraryString['BASE'].Replace(Dict))
1604         elif Info.ModuleType in ['PEI_CORE','PEIM']:
1605             AutoGenC.Append(gLibraryString['PEI'].Replace(Dict))
1606         elif Info.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER',
1607                                  'DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION','SMM_CORE']:
1608             AutoGenC.Append(gLibraryString['DXE'].Replace(Dict))
1609
1610 ## Create code for library destructor
1611 #
1612 #   @param      Info        The ModuleAutoGen object
1613 #   @param      AutoGenC    The TemplateString object for C code
1614 #   @param      AutoGenH    The TemplateString object for header file
1615 #
1616 def CreateLibraryDestructorCode(Info, AutoGenC, AutoGenH):
1617     #
1618     # Library Destructors
1619     #
1620     DestructorPrototypeString = TemplateString()
1621     DestructorCallingString = TemplateString()
1622     if Info.IsLibrary:
1623         DependentLibraryList = [Info.Module]
1624     else:
1625         DependentLibraryList = Info.DependentLibraryList
1626     for Index in range(len(DependentLibraryList)-1, -1, -1):
1627         Lib = DependentLibraryList[Index]
1628         if len(Lib.DestructorList) <= 0:
1629             continue
1630         Dict = {'Function':Lib.DestructorList}
1631         if Lib.ModuleType in ['BASE', 'SEC']:
1632             DestructorPrototypeString.Append(gLibraryStructorPrototype['BASE'].Replace(Dict))
1633             DestructorCallingString.Append(gLibraryStructorCall['BASE'].Replace(Dict))
1634         elif Lib.ModuleType in ['PEI_CORE','PEIM']:
1635             DestructorPrototypeString.Append(gLibraryStructorPrototype['PEI'].Replace(Dict))
1636             DestructorCallingString.Append(gLibraryStructorCall['PEI'].Replace(Dict))
1637         elif Lib.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER',
1638                                 'DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION', 'SMM_CORE']:
1639             DestructorPrototypeString.Append(gLibraryStructorPrototype['DXE'].Replace(Dict))
1640             DestructorCallingString.Append(gLibraryStructorCall['DXE'].Replace(Dict))
1641
1642     if str(DestructorPrototypeString) == '':
1643         DestructorPrototypeList = []
1644     else:
1645         DestructorPrototypeList = [str(DestructorPrototypeString)]
1646     if str(DestructorCallingString) == '':
1647         DestructorCallingList = []
1648     else:
1649         DestructorCallingList = [str(DestructorCallingString)]
1650
1651     Dict = {
1652         'Type'              :   'Destructor',
1653         'FunctionPrototype' :   DestructorPrototypeList,
1654         'FunctionCall'      :   DestructorCallingList
1655     }
1656     if Info.IsLibrary:
1657         AutoGenH.Append("${BEGIN}${FunctionPrototype}${END}", Dict)
1658     else:
1659         if Info.ModuleType in ['BASE', 'SEC']:
1660             AutoGenC.Append(gLibraryString['BASE'].Replace(Dict))
1661         elif Info.ModuleType in ['PEI_CORE','PEIM']:
1662             AutoGenC.Append(gLibraryString['PEI'].Replace(Dict))
1663         elif Info.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER',
1664                                  'DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION','SMM_CORE']:
1665             AutoGenC.Append(gLibraryString['DXE'].Replace(Dict))
1666
1667
1668 ## Create code for ModuleEntryPoint
1669 #
1670 #   @param      Info        The ModuleAutoGen object
1671 #   @param      AutoGenC    The TemplateString object for C code
1672 #   @param      AutoGenH    The TemplateString object for header file
1673 #
1674 def CreateModuleEntryPointCode(Info, AutoGenC, AutoGenH):
1675     if Info.IsLibrary or Info.ModuleType in ['USER_DEFINED', 'SEC']:
1676         return
1677     #
1678     # Module Entry Points
1679     #
1680     NumEntryPoints = len(Info.Module.ModuleEntryPointList)
1681     if 'PI_SPECIFICATION_VERSION' in Info.Module.Specification:
1682         PiSpecVersion = Info.Module.Specification['PI_SPECIFICATION_VERSION']
1683     else:
1684         PiSpecVersion = '0x00000000'
1685     if 'UEFI_SPECIFICATION_VERSION' in Info.Module.Specification:
1686         UefiSpecVersion = Info.Module.Specification['UEFI_SPECIFICATION_VERSION']
1687     else:
1688         UefiSpecVersion = '0x00000000'
1689     Dict = {
1690         'Function'       :   Info.Module.ModuleEntryPointList,
1691         'PiSpecVersion'  :   PiSpecVersion,
1692         'UefiSpecVersion':   UefiSpecVersion
1693     }
1694
1695     if Info.ModuleType in ['PEI_CORE', 'DXE_CORE', 'SMM_CORE']:
1696         if Info.SourceFileList <> None and Info.SourceFileList <> []:
1697           if NumEntryPoints != 1:
1698               EdkLogger.error(
1699                   "build",
1700                   AUTOGEN_ERROR,
1701                   '%s must have exactly one entry point' % Info.ModuleType,
1702                   File=str(Info),
1703                   ExtraData= ", ".join(Info.Module.ModuleEntryPointList)
1704                   )
1705     if Info.ModuleType == 'PEI_CORE':
1706         AutoGenC.Append(gPeiCoreEntryPointString.Replace(Dict))
1707         AutoGenH.Append(gPeiCoreEntryPointPrototype.Replace(Dict))
1708     elif Info.ModuleType == 'DXE_CORE':
1709         AutoGenC.Append(gDxeCoreEntryPointString.Replace(Dict))
1710         AutoGenH.Append(gDxeCoreEntryPointPrototype.Replace(Dict))
1711     elif Info.ModuleType == 'SMM_CORE':
1712         AutoGenC.Append(gSmmCoreEntryPointString.Replace(Dict))
1713         AutoGenH.Append(gSmmCoreEntryPointPrototype.Replace(Dict))
1714     elif Info.ModuleType == 'PEIM':
1715         if NumEntryPoints < 2:
1716             AutoGenC.Append(gPeimEntryPointString[NumEntryPoints].Replace(Dict))
1717         else:
1718             AutoGenC.Append(gPeimEntryPointString[2].Replace(Dict))
1719         AutoGenH.Append(gPeimEntryPointPrototype.Replace(Dict))
1720     elif Info.ModuleType in ['DXE_RUNTIME_DRIVER','DXE_DRIVER','DXE_SAL_DRIVER','UEFI_DRIVER']:
1721         if NumEntryPoints < 2:
1722             AutoGenC.Append(gUefiDriverEntryPointString[NumEntryPoints].Replace(Dict))
1723         else:
1724             AutoGenC.Append(gUefiDriverEntryPointString[2].Replace(Dict))
1725         AutoGenH.Append(gUefiDriverEntryPointPrototype.Replace(Dict))
1726     elif Info.ModuleType == 'DXE_SMM_DRIVER':
1727         if NumEntryPoints == 0:
1728             AutoGenC.Append(gDxeSmmEntryPointString[0].Replace(Dict))
1729         else:
1730             AutoGenC.Append(gDxeSmmEntryPointString[1].Replace(Dict))
1731         AutoGenH.Append(gDxeSmmEntryPointPrototype.Replace(Dict))
1732     elif Info.ModuleType == 'UEFI_APPLICATION':
1733         if NumEntryPoints < 2:
1734             AutoGenC.Append(gUefiApplicationEntryPointString[NumEntryPoints].Replace(Dict))
1735         else:
1736             AutoGenC.Append(gUefiApplicationEntryPointString[2].Replace(Dict))
1737         AutoGenH.Append(gUefiApplicationEntryPointPrototype.Replace(Dict))
1738
1739 ## Create code for ModuleUnloadImage
1740 #
1741 #   @param      Info        The ModuleAutoGen object
1742 #   @param      AutoGenC    The TemplateString object for C code
1743 #   @param      AutoGenH    The TemplateString object for header file
1744 #
1745 def CreateModuleUnloadImageCode(Info, AutoGenC, AutoGenH):
1746     if Info.IsLibrary or Info.ModuleType in ['USER_DEFINED', 'SEC']:
1747         return
1748     #
1749     # Unload Image Handlers
1750     #
1751     NumUnloadImage = len(Info.Module.ModuleUnloadImageList)
1752     Dict = {'Count':NumUnloadImage, 'Function':Info.Module.ModuleUnloadImageList}
1753     if NumUnloadImage < 2:
1754         AutoGenC.Append(gUefiUnloadImageString[NumUnloadImage].Replace(Dict))
1755     else:
1756         AutoGenC.Append(gUefiUnloadImageString[2].Replace(Dict))
1757     AutoGenH.Append(gUefiUnloadImagePrototype.Replace(Dict))
1758
1759 ## Create code for GUID
1760 #
1761 #   @param      Info        The ModuleAutoGen object
1762 #   @param      AutoGenC    The TemplateString object for C code
1763 #   @param      AutoGenH    The TemplateString object for header file
1764 #
1765 def CreateGuidDefinitionCode(Info, AutoGenC, AutoGenH):
1766     if Info.IsLibrary:
1767         return
1768
1769     if Info.ModuleType in ["USER_DEFINED", "BASE"]:
1770         GuidType = "GUID"
1771     else:
1772         GuidType = "EFI_GUID"
1773
1774     if Info.GuidList:
1775         AutoGenC.Append("\n// Guids\n")
1776     #
1777     # GUIDs
1778     #
1779     for Key in Info.GuidList:
1780         AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.GuidList[Key]))
1781
1782 ## Create code for protocol
1783 #
1784 #   @param      Info        The ModuleAutoGen object
1785 #   @param      AutoGenC    The TemplateString object for C code
1786 #   @param      AutoGenH    The TemplateString object for header file
1787 #
1788 def CreateProtocolDefinitionCode(Info, AutoGenC, AutoGenH):
1789     if Info.IsLibrary:
1790         return
1791
1792     if Info.ModuleType in ["USER_DEFINED", "BASE"]:
1793         GuidType = "GUID"
1794     else:
1795         GuidType = "EFI_GUID"
1796
1797     if Info.ProtocolList:
1798         AutoGenC.Append("\n// Protocols\n")
1799     #
1800     # Protocol GUIDs
1801     #
1802     for Key in Info.ProtocolList:
1803         AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.ProtocolList[Key]))
1804
1805 ## Create code for PPI
1806 #
1807 #   @param      Info        The ModuleAutoGen object
1808 #   @param      AutoGenC    The TemplateString object for C code
1809 #   @param      AutoGenH    The TemplateString object for header file
1810 #
1811 def CreatePpiDefinitionCode(Info, AutoGenC, AutoGenH):
1812     if Info.IsLibrary:
1813         return
1814
1815     if Info.ModuleType in ["USER_DEFINED", "BASE"]:
1816         GuidType = "GUID"
1817     else:
1818         GuidType = "EFI_GUID"
1819
1820     if Info.PpiList:
1821         AutoGenC.Append("\n// PPIs\n")
1822     #
1823     # PPI GUIDs
1824     #
1825     for Key in Info.PpiList:
1826         AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.PpiList[Key]))
1827
1828 ## Create code for PCD
1829 #
1830 #   @param      Info        The ModuleAutoGen object
1831 #   @param      AutoGenC    The TemplateString object for C code
1832 #   @param      AutoGenH    The TemplateString object for header file
1833 #
1834 def CreatePcdCode(Info, AutoGenC, AutoGenH):
1835
1836     # Collect Token Space GUIDs used by DynamicEc PCDs
1837     TokenSpaceList = []
1838     for Pcd in Info.ModulePcdList:
1839        if Pcd.Type in gDynamicExPcd and Pcd.TokenSpaceGuidCName not in TokenSpaceList:
1840             TokenSpaceList += [Pcd.TokenSpaceGuidCName]
1841
1842     # Add extern declarations to AutoGen.h if one or more Token Space GUIDs were found
1843     if TokenSpaceList <> []:
1844         AutoGenH.Append("\n// Definition of PCD Token Space GUIDs used in this module\n\n")
1845         if Info.ModuleType in ["USER_DEFINED", "BASE"]:
1846             GuidType = "GUID"
1847         else:
1848             GuidType = "EFI_GUID"
1849         for Item in TokenSpaceList:
1850             AutoGenH.Append('extern %s %s;\n' % (GuidType, Item))
1851
1852     if Info.IsLibrary:
1853         if Info.ModulePcdList:
1854             AutoGenH.Append("\n// PCD definitions\n")
1855         for Pcd in Info.ModulePcdList:
1856             CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd)
1857     else:
1858         if Info.ModulePcdList:
1859             AutoGenH.Append("\n// Definition of PCDs used in this module\n")
1860             AutoGenC.Append("\n// Definition of PCDs used in this module\n")
1861         for Pcd in Info.ModulePcdList:
1862             CreateModulePcdCode(Info, AutoGenC, AutoGenH, Pcd)
1863
1864         if Info.LibraryPcdList:
1865             AutoGenH.Append("\n// Definition of PCDs used in libraries is in AutoGen.c\n")
1866             AutoGenC.Append("\n// Definition of PCDs used in libraries\n")
1867         for Pcd in Info.LibraryPcdList:
1868             CreateModulePcdCode(Info, AutoGenC, AutoGenC, Pcd)
1869     CreatePcdDatabaseCode(Info, AutoGenC, AutoGenH)
1870
1871 ## Create code for unicode string definition
1872 #
1873 #   @param      Info        The ModuleAutoGen object
1874 #   @param      AutoGenC    The TemplateString object for C code
1875 #   @param      AutoGenH    The TemplateString object for header file
1876 #   @param      UniGenCFlag     UniString is generated into AutoGen C file when it is set to True
1877 #   @param      UniGenBinBuffer Buffer to store uni string package data
1878 #
1879 def CreateUnicodeStringCode(Info, AutoGenC, AutoGenH, UniGenCFlag, UniGenBinBuffer):
1880     WorkingDir = os.getcwd()
1881     os.chdir(Info.WorkspaceDir)
1882
1883     IncList = [Info.MetaFile.Dir]
1884     # Get all files under [Sources] section in inf file for EDK-II module
1885     EDK2Module = True
1886     SrcList = [F for F in Info.SourceFileList]
1887     if Info.AutoGenVersion < 0x00010005:
1888         EDK2Module = False
1889         # Get all files under the module directory for EDK-I module
1890         Cwd = os.getcwd()
1891         os.chdir(Info.MetaFile.Dir)
1892         for Root, Dirs, Files in os.walk("."):
1893             if 'CVS' in Dirs:
1894                 Dirs.remove('CVS')
1895             if '.svn' in Dirs:
1896                 Dirs.remove('.svn')
1897             for File in Files:
1898                 File = PathClass(os.path.join(Root, File), Info.MetaFile.Dir)
1899                 if File in SrcList:
1900                     continue
1901                 SrcList.append(File)
1902         os.chdir(Cwd)
1903
1904     if 'BUILD' in Info.BuildOption and Info.BuildOption['BUILD']['FLAGS'].find('-c') > -1:
1905         CompatibleMode = True
1906     else:
1907         CompatibleMode = False
1908
1909     #
1910     # -s is a temporary option dedicated for building .UNI files with ISO 639-2 language codes of EDK Shell in EDK2
1911     #
1912     if 'BUILD' in Info.BuildOption and Info.BuildOption['BUILD']['FLAGS'].find('-s') > -1:
1913         if CompatibleMode:
1914             EdkLogger.error("build", AUTOGEN_ERROR,
1915                             "-c and -s build options should be used exclusively",
1916                             ExtraData="[%s]" % str(Info))
1917         ShellMode = True
1918     else:
1919         ShellMode = False
1920
1921     #RFC4646 is only for EDKII modules and ISO639-2 for EDK modules
1922     if EDK2Module:
1923         FilterInfo = [EDK2Module] + [Info.PlatformInfo.Platform.RFCLanguages]
1924     else:
1925         FilterInfo = [EDK2Module] + [Info.PlatformInfo.Platform.ISOLanguages]
1926     Header, Code = GetStringFiles(Info.UnicodeFileList, SrcList, IncList, Info.IncludePathList, ['.uni', '.inf'], Info.Name, CompatibleMode, ShellMode, UniGenCFlag, UniGenBinBuffer, FilterInfo)
1927     if CompatibleMode or UniGenCFlag:
1928         AutoGenC.Append("\n//\n//Unicode String Pack Definition\n//\n")
1929         AutoGenC.Append(Code)
1930         AutoGenC.Append("\n")
1931     AutoGenH.Append("\n//\n//Unicode String ID\n//\n")
1932     AutoGenH.Append(Header)
1933     if CompatibleMode or UniGenCFlag:
1934         AutoGenH.Append("\n#define STRING_ARRAY_NAME %sStrings\n" % Info.Name)
1935     os.chdir(WorkingDir)
1936
1937 ## Create common code
1938 #
1939 #   @param      Info        The ModuleAutoGen object
1940 #   @param      AutoGenC    The TemplateString object for C code
1941 #   @param      AutoGenH    The TemplateString object for header file
1942 #
1943 def CreateHeaderCode(Info, AutoGenC, AutoGenH):
1944     # file header
1945     AutoGenH.Append(gAutoGenHeaderString.Replace({'FileName':'AutoGen.h'}))
1946     # header file Prologue
1947     AutoGenH.Append(gAutoGenHPrologueString.Replace({'File':'AUTOGENH','Guid':Info.Guid.replace('-','_')}))
1948     if Info.AutoGenVersion >= 0x00010005:
1949         # header files includes
1950         AutoGenH.Append("#include <%s>\n" % gBasicHeaderFile)
1951         if Info.ModuleType in gModuleTypeHeaderFile \
1952            and gModuleTypeHeaderFile[Info.ModuleType][0] != gBasicHeaderFile:
1953             AutoGenH.Append("#include <%s>\n" % gModuleTypeHeaderFile[Info.ModuleType][0])
1954         AutoGenH.Append('\nextern GUID  gEfiCallerIdGuid;\n\n')
1955
1956         if Info.IsLibrary:
1957             return
1958
1959         AutoGenH.Append("#define EFI_CALLER_ID_GUID \\\n  %s\n" % GuidStringToGuidStructureString(Info.Guid))
1960
1961     if Info.IsLibrary:
1962         return
1963     # C file header
1964     AutoGenC.Append(gAutoGenHeaderString.Replace({'FileName':'AutoGen.c'}))
1965     if Info.AutoGenVersion >= 0x00010005:
1966         # C file header files includes
1967         if Info.ModuleType in gModuleTypeHeaderFile:
1968             for Inc in gModuleTypeHeaderFile[Info.ModuleType]:
1969                 AutoGenC.Append("#include <%s>\n" % Inc)
1970         else:
1971             AutoGenC.Append("#include <%s>\n" % gBasicHeaderFile)
1972
1973         #
1974         # Publish the CallerId Guid
1975         #
1976         AutoGenC.Append('\nGLOBAL_REMOVE_IF_UNREFERENCED GUID gEfiCallerIdGuid = %s;\n' % GuidStringToGuidStructureString(Info.Guid))
1977
1978 ## Create common code for header file
1979 #
1980 #   @param      Info        The ModuleAutoGen object
1981 #   @param      AutoGenC    The TemplateString object for C code
1982 #   @param      AutoGenH    The TemplateString object for header file
1983 #
1984 def CreateFooterCode(Info, AutoGenC, AutoGenH):
1985     AutoGenH.Append(gAutoGenHEpilogueString)
1986
1987 ## Create code for a module
1988 #
1989 #   @param      Info        The ModuleAutoGen object
1990 #   @param      AutoGenC    The TemplateString object for C code
1991 #   @param      AutoGenH    The TemplateString object for header file
1992 #   @param      UniGenCFlag     UniString is generated into AutoGen C file when it is set to True
1993 #   @param      UniGenBinBuffer Buffer to store uni string package data
1994 #
1995 def CreateCode(Info, AutoGenC, AutoGenH, StringH, UniGenCFlag, UniGenBinBuffer):
1996     CreateHeaderCode(Info, AutoGenC, AutoGenH)
1997
1998     if Info.AutoGenVersion >= 0x00010005:
1999         CreateGuidDefinitionCode(Info, AutoGenC, AutoGenH)
2000         CreateProtocolDefinitionCode(Info, AutoGenC, AutoGenH)
2001         CreatePpiDefinitionCode(Info, AutoGenC, AutoGenH)
2002         CreatePcdCode(Info, AutoGenC, AutoGenH)
2003         CreateLibraryConstructorCode(Info, AutoGenC, AutoGenH)
2004         CreateLibraryDestructorCode(Info, AutoGenC, AutoGenH)
2005         CreateModuleEntryPointCode(Info, AutoGenC, AutoGenH)
2006         CreateModuleUnloadImageCode(Info, AutoGenC, AutoGenH)
2007
2008     if Info.UnicodeFileList:
2009         FileName = "%sStrDefs.h" % Info.Name
2010         StringH.Append(gAutoGenHeaderString.Replace({'FileName':FileName}))
2011         StringH.Append(gAutoGenHPrologueString.Replace({'File':'STRDEFS', 'Guid':Info.Guid.replace('-','_')}))
2012         CreateUnicodeStringCode(Info, AutoGenC, StringH, UniGenCFlag, UniGenBinBuffer)
2013         StringH.Append("\n#endif\n")
2014         AutoGenH.Append('#include "%s"\n' % FileName)
2015
2016     CreateFooterCode(Info, AutoGenC, AutoGenH)
2017
2018     # no generation of AutoGen.c for R8 modules without unicode file
2019     if Info.AutoGenVersion < 0x00010005 and len(Info.UnicodeFileList) == 0:
2020         AutoGenC.String = ''
2021
2022 ## Create the code file
2023 #
2024 #   @param      FilePath     The path of code file
2025 #   @param      Content      The content of code file
2026 #   @param      IsBinaryFile The flag indicating if the file is binary file or not
2027 #
2028 #   @retval     True        If file content is changed or file doesn't exist
2029 #   @retval     False       If the file exists and the content is not changed
2030 #
2031 def Generate(FilePath, Content, IsBinaryFile):
2032     return SaveFileOnChange(FilePath, Content, IsBinaryFile)
2033