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