BaseTools/Source/Python/AutoGen/GenC.py

   1 ## @file
   2 # Routines for generating AutoGen.h and AutoGen.c
   3 #
   4 # Copyright (c) 2007 - 2016, 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 from GenPcdDb import CreatePcdDatabaseCode
  26
  27 ## PCD type string
  28 gItemTypeStringDatabase  = {
  29     TAB_PCDS_FEATURE_FLAG       :   'FixedAtBuild',
  30     TAB_PCDS_FIXED_AT_BUILD     :   'FixedAtBuild',
  31     TAB_PCDS_PATCHABLE_IN_MODULE:   'BinaryPatch',
  32     TAB_PCDS_DYNAMIC            :   '',
  33     TAB_PCDS_DYNAMIC_DEFAULT    :   '',
  34     TAB_PCDS_DYNAMIC_VPD        :   '',
  35     TAB_PCDS_DYNAMIC_HII        :   '',
  36     TAB_PCDS_DYNAMIC_EX         :   '',
  37     TAB_PCDS_DYNAMIC_EX_DEFAULT :   '',
  38     TAB_PCDS_DYNAMIC_EX_VPD     :   '',
  39     TAB_PCDS_DYNAMIC_EX_HII     :   '',
  40 }
  41
  42 ## Dynamic PCD types
  43 gDynamicPcd = [TAB_PCDS_DYNAMIC, TAB_PCDS_DYNAMIC_DEFAULT, TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_HII]
  44
  45 ## Dynamic-ex PCD types
  46 gDynamicExPcd = [TAB_PCDS_DYNAMIC_EX, TAB_PCDS_DYNAMIC_EX_DEFAULT, TAB_PCDS_DYNAMIC_EX_VPD, TAB_PCDS_DYNAMIC_EX_HII]
  47
  48 ## Datum size
  49 gDatumSizeStringDatabase = {'UINT8':'8','UINT16':'16','UINT32':'32','UINT64':'64','BOOLEAN':'BOOLEAN','VOID*':'8'}
  50 gDatumSizeStringDatabaseH = {'UINT8':'8','UINT16':'16','UINT32':'32','UINT64':'64','BOOLEAN':'BOOL','VOID*':'PTR'}
  51 gDatumSizeStringDatabaseLib = {'UINT8':'8','UINT16':'16','UINT32':'32','UINT64':'64','BOOLEAN':'Bool','VOID*':'Ptr'}
  52
  53 ## AutoGen File Header Templates
  54 gAutoGenHeaderString = TemplateString("""\
  55 /**
  56   DO NOT EDIT
  57   FILE auto-generated
  58   Module name:
  59     ${FileName}
  60   Abstract:       Auto-generated ${FileName} for building module or library.
  61 **/
  62 """)
  63
  64 gAutoGenHPrologueString = TemplateString("""
  65 #ifndef _${File}_${Guid}
  66 #define _${File}_${Guid}
  67
  68 """)
  69
  70 gAutoGenHCppPrologueString = """\
  71 #ifdef __cplusplus
  72 extern "C" {
  73 #endif
  74
  75 """
  76
  77 gAutoGenHEpilogueString = """
  78
  79 #ifdef __cplusplus
  80 }
  81 #endif
  82
  83 #endif
  84 """
  85
  86 ## PEI Core Entry Point Templates
  87 gPeiCoreEntryPointPrototype = TemplateString("""
  88 ${BEGIN}
  89 VOID
  90 EFIAPI
  91 ${Function} (
  92   IN CONST  EFI_SEC_PEI_HAND_OFF    *SecCoreData,
  93   IN CONST  EFI_PEI_PPI_DESCRIPTOR  *PpiList,
  94   IN VOID                           *Context
  95   );
  96 ${END}
  97 """)
  98
  99 gPeiCoreEntryPointString = TemplateString("""
 100 ${BEGIN}
 101 VOID
 102 EFIAPI
 103 ProcessModuleEntryPointList (
 104   IN CONST  EFI_SEC_PEI_HAND_OFF    *SecCoreData,
 105   IN CONST  EFI_PEI_PPI_DESCRIPTOR  *PpiList,
 106   IN VOID                           *Context
 107   )
 108
 109 {
 110   ${Function} (SecCoreData, PpiList, Context);
 111 }
 112 ${END}
 113 """)
 114
 115
 116 ## DXE Core Entry Point Templates
 117 gDxeCoreEntryPointPrototype = TemplateString("""
 118 ${BEGIN}
 119 VOID
 120 EFIAPI
 121 ${Function} (
 122   IN VOID  *HobStart
 123   );
 124 ${END}
 125 """)
 126
 127 gDxeCoreEntryPointString = TemplateString("""
 128 ${BEGIN}
 129 VOID
 130 EFIAPI
 131 ProcessModuleEntryPointList (
 132   IN VOID  *HobStart
 133   )
 134
 135 {
 136   ${Function} (HobStart);
 137 }
 138 ${END}
 139 """)
 140
 141 ## PEIM Entry Point Templates
 142 gPeimEntryPointPrototype = TemplateString("""
 143 ${BEGIN}
 144 EFI_STATUS
 145 EFIAPI
 146 ${Function} (
 147   IN       EFI_PEI_FILE_HANDLE  FileHandle,
 148   IN CONST EFI_PEI_SERVICES     **PeiServices
 149   );
 150 ${END}
 151 """)
 152
 153 gPeimEntryPointString = [
 154 TemplateString("""
 155 GLOBAL_REMOVE_IF_UNREFERENCED const UINT32 _gPeimRevision = ${PiSpecVersion};
 156
 157 EFI_STATUS
 158 EFIAPI
 159 ProcessModuleEntryPointList (
 160   IN       EFI_PEI_FILE_HANDLE  FileHandle,
 161   IN CONST EFI_PEI_SERVICES     **PeiServices
 162   )
 163
 164 {
 165   return EFI_SUCCESS;
 166 }
 167 """),
 168 TemplateString("""
 169 GLOBAL_REMOVE_IF_UNREFERENCED const UINT32 _gPeimRevision = ${PiSpecVersion};
 170 ${BEGIN}
 171 EFI_STATUS
 172 EFIAPI
 173 ProcessModuleEntryPointList (
 174   IN       EFI_PEI_FILE_HANDLE  FileHandle,
 175   IN CONST EFI_PEI_SERVICES     **PeiServices
 176   )
 177
 178 {
 179   return ${Function} (FileHandle, PeiServices);
 180 }
 181 ${END}
 182 """),
 183 TemplateString("""
 184 GLOBAL_REMOVE_IF_UNREFERENCED const UINT32 _gPeimRevision = ${PiSpecVersion};
 185
 186 EFI_STATUS
 187 EFIAPI
 188 ProcessModuleEntryPointList (
 189   IN       EFI_PEI_FILE_HANDLE  FileHandle,
 190   IN CONST EFI_PEI_SERVICES     **PeiServices
 191   )
 192
 193 {
 194   EFI_STATUS  Status;
 195   EFI_STATUS  CombinedStatus;
 196
 197   CombinedStatus = EFI_LOAD_ERROR;
 198 ${BEGIN}
 199   Status = ${Function} (FileHandle, PeiServices);
 200   if (!EFI_ERROR (Status) || EFI_ERROR (CombinedStatus)) {
 201     CombinedStatus = Status;
 202   }
 203 ${END}
 204   return CombinedStatus;
 205 }
 206 """)
 207 ]
 208
 209 ## SMM_CORE Entry Point Templates
 210 gSmmCoreEntryPointPrototype = TemplateString("""
 211 ${BEGIN}
 212 EFI_STATUS
 213 EFIAPI
 214 ${Function} (
 215   IN EFI_HANDLE         ImageHandle,
 216   IN EFI_SYSTEM_TABLE   *SystemTable
 217   );
 218 ${END}
 219 """)
 220
 221 gSmmCoreEntryPointString = TemplateString("""
 222 ${BEGIN}
 223 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 224 const UINT32 _gDxeRevision = ${PiSpecVersion};
 225
 226 EFI_STATUS
 227 EFIAPI
 228 ProcessModuleEntryPointList (
 229   IN EFI_HANDLE         ImageHandle,
 230   IN EFI_SYSTEM_TABLE   *SystemTable
 231   )
 232 {
 233   return ${Function} (ImageHandle, SystemTable);
 234 }
 235 ${END}
 236 """)
 237
 238 ## DXE SMM Entry Point Templates
 239 gDxeSmmEntryPointPrototype = TemplateString("""
 240 ${BEGIN}
 241 EFI_STATUS
 242 EFIAPI
 243 ${Function} (
 244   IN EFI_HANDLE        ImageHandle,
 245   IN EFI_SYSTEM_TABLE  *SystemTable
 246   );
 247 ${END}
 248 """)
 249
 250 gDxeSmmEntryPointString = [
 251 TemplateString("""
 252 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 253 const UINT32 _gDxeRevision = ${PiSpecVersion};
 254
 255 EFI_STATUS
 256 EFIAPI
 257 ProcessModuleEntryPointList (
 258   IN EFI_HANDLE        ImageHandle,
 259   IN EFI_SYSTEM_TABLE  *SystemTable
 260   )
 261
 262 {
 263   return EFI_SUCCESS;
 264 }
 265 """),
 266 TemplateString("""
 267 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 268 const UINT32 _gDxeRevision = ${PiSpecVersion};
 269
 270 static BASE_LIBRARY_JUMP_BUFFER  mJumpContext;
 271 static EFI_STATUS  mDriverEntryPointStatus;
 272
 273 VOID
 274 EFIAPI
 275 ExitDriver (
 276   IN EFI_STATUS  Status
 277   )
 278 {
 279   if (!EFI_ERROR (Status) || EFI_ERROR (mDriverEntryPointStatus)) {
 280     mDriverEntryPointStatus = Status;
 281   }
 282   LongJump (&mJumpContext, (UINTN)-1);
 283   ASSERT (FALSE);
 284 }
 285
 286 EFI_STATUS
 287 EFIAPI
 288 ProcessModuleEntryPointList (
 289   IN EFI_HANDLE        ImageHandle,
 290   IN EFI_SYSTEM_TABLE  *SystemTable
 291   )
 292 {
 293   mDriverEntryPointStatus = EFI_LOAD_ERROR;
 294
 295 ${BEGIN}
 296   if (SetJump (&mJumpContext) == 0) {
 297     ExitDriver (${Function} (ImageHandle, SystemTable));
 298     ASSERT (FALSE);
 299   }
 300 ${END}
 301
 302   return mDriverEntryPointStatus;
 303 }
 304 """)
 305 ]
 306
 307 ## UEFI Driver Entry Point Templates
 308 gUefiDriverEntryPointPrototype = TemplateString("""
 309 ${BEGIN}
 310 EFI_STATUS
 311 EFIAPI
 312 ${Function} (
 313   IN EFI_HANDLE        ImageHandle,
 314   IN EFI_SYSTEM_TABLE  *SystemTable
 315   );
 316 ${END}
 317 """)
 318
 319 gUefiDriverEntryPointString = [
 320 TemplateString("""
 321 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 322 const UINT32 _gDxeRevision = ${PiSpecVersion};
 323
 324 EFI_STATUS
 325 EFIAPI
 326 ProcessModuleEntryPointList (
 327   IN EFI_HANDLE        ImageHandle,
 328   IN EFI_SYSTEM_TABLE  *SystemTable
 329   )
 330 {
 331   return EFI_SUCCESS;
 332 }
 333 """),
 334 TemplateString("""
 335 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 336 const UINT32 _gDxeRevision = ${PiSpecVersion};
 337
 338 ${BEGIN}
 339 EFI_STATUS
 340 EFIAPI
 341 ProcessModuleEntryPointList (
 342   IN EFI_HANDLE        ImageHandle,
 343   IN EFI_SYSTEM_TABLE  *SystemTable
 344   )
 345
 346 {
 347   return ${Function} (ImageHandle, SystemTable);
 348 }
 349 ${END}
 350 VOID
 351 EFIAPI
 352 ExitDriver (
 353   IN EFI_STATUS  Status
 354   )
 355 {
 356   if (EFI_ERROR (Status)) {
 357     ProcessLibraryDestructorList (gImageHandle, gST);
 358   }
 359   gBS->Exit (gImageHandle, Status, 0, NULL);
 360 }
 361 """),
 362 TemplateString("""
 363 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 364 const UINT32 _gDxeRevision = ${PiSpecVersion};
 365
 366 static BASE_LIBRARY_JUMP_BUFFER  mJumpContext;
 367 static EFI_STATUS  mDriverEntryPointStatus;
 368
 369 EFI_STATUS
 370 EFIAPI
 371 ProcessModuleEntryPointList (
 372   IN EFI_HANDLE        ImageHandle,
 373   IN EFI_SYSTEM_TABLE  *SystemTable
 374   )
 375 {
 376   mDriverEntryPointStatus = EFI_LOAD_ERROR;
 377   ${BEGIN}
 378   if (SetJump (&mJumpContext) == 0) {
 379     ExitDriver (${Function} (ImageHandle, SystemTable));
 380     ASSERT (FALSE);
 381   }
 382   ${END}
 383   return mDriverEntryPointStatus;
 384 }
 385
 386 VOID
 387 EFIAPI
 388 ExitDriver (
 389   IN EFI_STATUS  Status
 390   )
 391 {
 392   if (!EFI_ERROR (Status) || EFI_ERROR (mDriverEntryPointStatus)) {
 393     mDriverEntryPointStatus = Status;
 394   }
 395   LongJump (&mJumpContext, (UINTN)-1);
 396   ASSERT (FALSE);
 397 }
 398 """)
 399 ]
 400
 401
 402 ## UEFI Application Entry Point Templates
 403 gUefiApplicationEntryPointPrototype = TemplateString("""
 404 ${BEGIN}
 405 EFI_STATUS
 406 EFIAPI
 407 ${Function} (
 408   IN EFI_HANDLE        ImageHandle,
 409   IN EFI_SYSTEM_TABLE  *SystemTable
 410   );
 411 ${END}
 412 """)
 413
 414 gUefiApplicationEntryPointString = [
 415 TemplateString("""
 416 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 417
 418 EFI_STATUS
 419 EFIAPI
 420 ProcessModuleEntryPointList (
 421   IN EFI_HANDLE        ImageHandle,
 422   IN EFI_SYSTEM_TABLE  *SystemTable
 423   )
 424 {
 425   return EFI_SUCCESS;
 426 }
 427 """),
 428 TemplateString("""
 429 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 430
 431 ${BEGIN}
 432 EFI_STATUS
 433 EFIAPI
 434 ProcessModuleEntryPointList (
 435   IN EFI_HANDLE        ImageHandle,
 436   IN EFI_SYSTEM_TABLE  *SystemTable
 437   )
 438
 439 {
 440   return ${Function} (ImageHandle, SystemTable);
 441 }
 442 ${END}
 443 VOID
 444 EFIAPI
 445 ExitDriver (
 446   IN EFI_STATUS  Status
 447   )
 448 {
 449   if (EFI_ERROR (Status)) {
 450     ProcessLibraryDestructorList (gImageHandle, gST);
 451   }
 452   gBS->Exit (gImageHandle, Status, 0, NULL);
 453 }
 454 """),
 455 TemplateString("""
 456 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 457
 458 EFI_STATUS
 459 EFIAPI
 460 ProcessModuleEntryPointList (
 461   IN EFI_HANDLE        ImageHandle,
 462   IN EFI_SYSTEM_TABLE  *SystemTable
 463   )
 464
 465 {
 466   ${BEGIN}
 467   if (SetJump (&mJumpContext) == 0) {
 468     ExitDriver (${Function} (ImageHandle, SystemTable));
 469     ASSERT (FALSE);
 470   }
 471   ${END}
 472   return mDriverEntryPointStatus;
 473 }
 474
 475 static BASE_LIBRARY_JUMP_BUFFER  mJumpContext;
 476 static EFI_STATUS  mDriverEntryPointStatus = EFI_LOAD_ERROR;
 477
 478 VOID
 479 EFIAPI
 480 ExitDriver (
 481   IN EFI_STATUS  Status
 482   )
 483 {
 484   if (!EFI_ERROR (Status) || EFI_ERROR (mDriverEntryPointStatus)) {
 485     mDriverEntryPointStatus = Status;
 486   }
 487   LongJump (&mJumpContext, (UINTN)-1);
 488   ASSERT (FALSE);
 489 }
 490 """)
 491 ]
 492
 493 ## UEFI Unload Image Templates
 494 gUefiUnloadImagePrototype = TemplateString("""
 495 ${BEGIN}
 496 EFI_STATUS
 497 EFIAPI
 498 ${Function} (
 499   IN EFI_HANDLE        ImageHandle
 500   );
 501 ${END}
 502 """)
 503
 504 gUefiUnloadImageString = [
 505 TemplateString("""
 506 GLOBAL_REMOVE_IF_UNREFERENCED const UINT8 _gDriverUnloadImageCount = ${Count};
 507
 508 EFI_STATUS
 509 EFIAPI
 510 ProcessModuleUnloadList (
 511   IN EFI_HANDLE        ImageHandle
 512   )
 513 {
 514   return EFI_SUCCESS;
 515 }
 516 """),
 517 TemplateString("""
 518 GLOBAL_REMOVE_IF_UNREFERENCED const UINT8 _gDriverUnloadImageCount = ${Count};
 519
 520 ${BEGIN}
 521 EFI_STATUS
 522 EFIAPI
 523 ProcessModuleUnloadList (
 524   IN EFI_HANDLE        ImageHandle
 525   )
 526 {
 527   return ${Function} (ImageHandle);
 528 }
 529 ${END}
 530 """),
 531 TemplateString("""
 532 GLOBAL_REMOVE_IF_UNREFERENCED const UINT8 _gDriverUnloadImageCount = ${Count};
 533
 534 EFI_STATUS
 535 EFIAPI
 536 ProcessModuleUnloadList (
 537   IN EFI_HANDLE        ImageHandle
 538   )
 539 {
 540   EFI_STATUS  Status;
 541
 542   Status = EFI_SUCCESS;
 543 ${BEGIN}
 544   if (EFI_ERROR (Status)) {
 545     ${Function} (ImageHandle);
 546   } else {
 547     Status = ${Function} (ImageHandle);
 548   }
 549 ${END}
 550   return Status;
 551 }
 552 """)
 553 ]
 554
 555 gLibraryStructorPrototype = {
 556 'BASE'  : TemplateString("""${BEGIN}
 557 RETURN_STATUS
 558 EFIAPI
 559 ${Function} (
 560   VOID
 561   );${END}
 562 """),
 563
 564 'PEI'   : TemplateString("""${BEGIN}
 565 EFI_STATUS
 566 EFIAPI
 567 ${Function} (
 568   IN       EFI_PEI_FILE_HANDLE       FileHandle,
 569   IN CONST EFI_PEI_SERVICES          **PeiServices
 570   );${END}
 571 """),
 572
 573 'DXE'   : TemplateString("""${BEGIN}
 574 EFI_STATUS
 575 EFIAPI
 576 ${Function} (
 577   IN EFI_HANDLE        ImageHandle,
 578   IN EFI_SYSTEM_TABLE  *SystemTable
 579   );${END}
 580 """),
 581 }
 582
 583 gLibraryStructorCall = {
 584 'BASE'  : TemplateString("""${BEGIN}
 585   Status = ${Function} ();
 586   ASSERT_EFI_ERROR (Status);${END}
 587 """),
 588
 589 'PEI'   : TemplateString("""${BEGIN}
 590   Status = ${Function} (FileHandle, PeiServices);
 591   ASSERT_EFI_ERROR (Status);${END}
 592 """),
 593
 594 'DXE'   : TemplateString("""${BEGIN}
 595   Status = ${Function} (ImageHandle, SystemTable);
 596   ASSERT_EFI_ERROR (Status);${END}
 597 """),
 598 }
 599
 600 ## Library Constructor and Destructor Templates
 601 gLibraryString = {
 602 'BASE'  :   TemplateString("""
 603 ${BEGIN}${FunctionPrototype}${END}
 604
 605 VOID
 606 EFIAPI
 607 ProcessLibrary${Type}List (
 608   VOID
 609   )
 610 {
 611 ${BEGIN}  EFI_STATUS  Status;
 612 ${FunctionCall}${END}
 613 }
 614 """),
 615
 616 'PEI'   :   TemplateString("""
 617 ${BEGIN}${FunctionPrototype}${END}
 618
 619 VOID
 620 EFIAPI
 621 ProcessLibrary${Type}List (
 622   IN       EFI_PEI_FILE_HANDLE       FileHandle,
 623   IN CONST EFI_PEI_SERVICES          **PeiServices
 624   )
 625 {
 626 ${BEGIN}  EFI_STATUS  Status;
 627 ${FunctionCall}${END}
 628 }
 629 """),
 630
 631 'DXE'   :   TemplateString("""
 632 ${BEGIN}${FunctionPrototype}${END}
 633
 634 VOID
 635 EFIAPI
 636 ProcessLibrary${Type}List (
 637   IN EFI_HANDLE        ImageHandle,
 638   IN EFI_SYSTEM_TABLE  *SystemTable
 639   )
 640 {
 641 ${BEGIN}  EFI_STATUS  Status;
 642 ${FunctionCall}${END}
 643 }
 644 """),
 645 }
 646
 647 gBasicHeaderFile = "Base.h"
 648
 649 gModuleTypeHeaderFile = {
 650     "BASE"              :   [gBasicHeaderFile],
 651     "SEC"               :   ["PiPei.h", "Library/DebugLib.h"],
 652     "PEI_CORE"          :   ["PiPei.h", "Library/DebugLib.h", "Library/PeiCoreEntryPoint.h"],
 653     "PEIM"              :   ["PiPei.h", "Library/DebugLib.h", "Library/PeimEntryPoint.h"],
 654     "DXE_CORE"          :   ["PiDxe.h", "Library/DebugLib.h", "Library/DxeCoreEntryPoint.h"],
 655     "DXE_DRIVER"        :   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h", "Library/UefiDriverEntryPoint.h"],
 656     "DXE_SMM_DRIVER"    :   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h", "Library/UefiDriverEntryPoint.h"],
 657     "DXE_RUNTIME_DRIVER":   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h", "Library/UefiDriverEntryPoint.h"],
 658     "DXE_SAL_DRIVER"    :   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h", "Library/UefiDriverEntryPoint.h"],
 659     "UEFI_DRIVER"       :   ["Uefi.h",  "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h", "Library/UefiDriverEntryPoint.h"],
 660     "UEFI_APPLICATION"  :   ["Uefi.h",  "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h", "Library/UefiApplicationEntryPoint.h"],
 661     "SMM_CORE"          :   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiDriverEntryPoint.h"],
 662     "USER_DEFINED"      :   [gBasicHeaderFile]
 663 }
 664
 665 ## Autogen internal worker macro to define DynamicEx PCD name includes both the TokenSpaceGuidName
 666 #  the TokenName and Guid comparison to avoid define name collisions.
 667 #
 668 #   @param      Info        The ModuleAutoGen object
 669 #   @param      AutoGenH    The TemplateString object for header file
 670 #
 671 #
 672 def DynExPcdTokenNumberMapping(Info, AutoGenH):
 673     ExTokenCNameList = []
 674     PcdExList        = []
 675     if Info.IsLibrary:
 676         PcdList = Info.LibraryPcdList
 677     else:
 678         PcdList = Info.ModulePcdList
 679     for Pcd in PcdList:
 680         if Pcd.Type in gDynamicExPcd:
 681             ExTokenCNameList.append(Pcd.TokenCName)
 682             PcdExList.append(Pcd)
 683     if len(ExTokenCNameList) == 0:
 684         return
 685     AutoGenH.Append('\n#define COMPAREGUID(Guid1, Guid2) (BOOLEAN)(*(CONST UINT64*)Guid1 == *(CONST UINT64*)Guid2 && *((CONST UINT64*)Guid1 + 1) == *((CONST UINT64*)Guid2 + 1))\n')
 686     # AutoGen for each PCD listed in a [PcdEx] section of a Module/Lib INF file.
 687     # Auto generate a macro for each TokenName that takes a Guid pointer as a parameter.
 688     # Use the Guid pointer to see if it matches any of the token space GUIDs.
 689     TokenCNameList = []
 690     for TokenCName in ExTokenCNameList:
 691         if TokenCName in TokenCNameList:
 692             continue
 693         Index = 0
 694         Count = ExTokenCNameList.count(TokenCName)
 695         for Pcd in PcdExList:
 696             if Pcd.TokenCName == TokenCName:
 697                 Index = Index + 1
 698                 if Index == 1:
 699                     AutoGenH.Append('\n#define __PCD_%s_ADDR_CMP(GuidPtr)  (' % (Pcd.TokenCName))
 700                     AutoGenH.Append('\\\n  (GuidPtr == &%s) ? _PCD_TOKEN_%s_%s:'
 701                                     % (Pcd.TokenSpaceGuidCName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
 702                 else:
 703                     AutoGenH.Append('\\\n  (GuidPtr == &%s) ? _PCD_TOKEN_%s_%s:'
 704                                     % (Pcd.TokenSpaceGuidCName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
 705                 if Index == Count:
 706                     AutoGenH.Append('0 \\\n  )\n')
 707                 TokenCNameList.append(TokenCName)
 708
 709     TokenCNameList = []
 710     for TokenCName in ExTokenCNameList:
 711         if TokenCName in TokenCNameList:
 712             continue
 713         Index = 0
 714         Count = ExTokenCNameList.count(TokenCName)
 715         for Pcd in PcdExList:
 716             if Pcd.Type in gDynamicExPcd and Pcd.TokenCName == TokenCName:
 717                 Index = Index + 1
 718                 if Index == 1:
 719                     AutoGenH.Append('\n#define __PCD_%s_VAL_CMP(GuidPtr)  (' % (Pcd.TokenCName))
 720                     AutoGenH.Append('\\\n  (GuidPtr == NULL) ? 0:')
 721                     AutoGenH.Append('\\\n  COMPAREGUID (GuidPtr, &%s) ? _PCD_TOKEN_%s_%s:'
 722                                     % (Pcd.TokenSpaceGuidCName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
 723                 else:
 724                     AutoGenH.Append('\\\n  COMPAREGUID (GuidPtr, &%s) ? _PCD_TOKEN_%s_%s:'
 725                                     % (Pcd.TokenSpaceGuidCName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
 726                 if Index == Count:
 727                     AutoGenH.Append('0 \\\n  )\n')
 728                     # Autogen internal worker macro to compare GUIDs.  Guid1 is a pointer to a GUID.
 729                     # Guid2 is a C name for a GUID. Compare pointers first because optimizing compiler
 730                     # can do this at build time on CONST GUID pointers and optimize away call to COMPAREGUID().
 731                     #  COMPAREGUID() will only be used if the Guid passed in is local to the module.
 732                     AutoGenH.Append('#define _PCD_TOKEN_EX_%s(GuidPtr)   __PCD_%s_ADDR_CMP(GuidPtr) ? __PCD_%s_ADDR_CMP(GuidPtr) : __PCD_%s_VAL_CMP(GuidPtr)  \n'
 733                                     % (Pcd.TokenCName, Pcd.TokenCName, Pcd.TokenCName, Pcd.TokenCName))
 734                 TokenCNameList.append(TokenCName)
 735
 736 def GetPcdSize(Pcd):
 737     if Pcd.DatumType == 'VOID*':
 738         Value = Pcd.DefaultValue
 739         if Value in [None, '']:
 740             return 1
 741         elif Value[0] == 'L':
 742             return (len(Value) - 2) * 2
 743         elif Value[0] == '{':
 744             return len(Value.split(','))
 745         else:
 746             return len(Value) - 1
 747     if Pcd.DatumType == 'UINT64':
 748         return 8
 749     if Pcd.DatumType == 'UINT32':
 750         return 4
 751     if Pcd.DatumType == 'UINT16':
 752         return 2
 753     if Pcd.DatumType == 'UINT8':
 754         return 1
 755     if Pcd.DatumType == 'BOOLEAN':
 756         return 1
 757
 758
 759 ## Create code for module PCDs
 760 #
 761 #   @param      Info        The ModuleAutoGen object
 762 #   @param      AutoGenC    The TemplateString object for C code
 763 #   @param      AutoGenH    The TemplateString object for header file
 764 #   @param      Pcd         The PCD object
 765 #
 766 def CreateModulePcdCode(Info, AutoGenC, AutoGenH, Pcd):
 767     TokenSpaceGuidValue = Pcd.TokenSpaceGuidValue   #Info.GuidList[Pcd.TokenSpaceGuidCName]
 768     PcdTokenNumber = Info.PlatformInfo.PcdTokenNumber
 769     #
 770     # Write PCDs
 771     #
 772     PcdTokenName = '_PCD_TOKEN_' + Pcd.TokenCName
 773     PatchPcdSizeTokenName = '_PCD_PATCHABLE_' + Pcd.TokenCName +'_SIZE'
 774     PatchPcdSizeVariableName = '_gPcd_BinaryPatch_Size_' + Pcd.TokenCName
 775     FixPcdSizeTokenName = '_PCD_SIZE_' + Pcd.TokenCName
 776
 777     if Pcd.Type in gDynamicExPcd:
 778         TokenNumber = int(Pcd.TokenValue, 0)
 779         # Add TokenSpaceGuidValue value to PcdTokenName to discriminate the DynamicEx PCDs with
 780         # different Guids but same TokenCName
 781         PcdExTokenName = '_PCD_TOKEN_' + Pcd.TokenSpaceGuidCName + '_' + Pcd.TokenCName
 782         AutoGenH.Append('\n#define %s  %dU\n' % (PcdExTokenName, TokenNumber))
 783     else:
 784         if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in PcdTokenNumber:
 785             # If one of the Source built modules listed in the DSC is not listed in FDF modules,
 786             # and the INF lists a PCD can only use the PcdsDynamic access method (it is only
 787             # listed in the DEC file that declares the PCD as PcdsDynamic), then build tool will
 788             # report warning message notify the PI that they are attempting to build a module
 789             # that must be included in a flash image in order to be functional. These Dynamic PCD
 790             # will not be added into the Database unless it is used by other modules that are
 791             # included in the FDF file.
 792             # In this case, just assign an invalid token number to make it pass build.
 793             if Pcd.Type in PCD_DYNAMIC_TYPE_LIST:
 794                 TokenNumber = 0
 795             else:
 796                 EdkLogger.error("build", AUTOGEN_ERROR,
 797                                 "No generated token number for %s.%s\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 798                                 ExtraData="[%s]" % str(Info))
 799         else:
 800             TokenNumber = PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName]
 801         AutoGenH.Append('\n#define %s  %dU\n' % (PcdTokenName, TokenNumber))
 802
 803     EdkLogger.debug(EdkLogger.DEBUG_3, "Creating code for " + Pcd.TokenCName + "." + Pcd.TokenSpaceGuidCName)
 804     if Pcd.Type not in gItemTypeStringDatabase:
 805         EdkLogger.error("build", AUTOGEN_ERROR,
 806                         "Unknown PCD type [%s] of PCD %s.%s" % (Pcd.Type, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 807                         ExtraData="[%s]" % str(Info))
 808     if Pcd.DatumType not in gDatumSizeStringDatabase:
 809         EdkLogger.error("build", AUTOGEN_ERROR,
 810                         "Unknown datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 811                         ExtraData="[%s]" % str(Info))
 812
 813     DatumSize = gDatumSizeStringDatabase[Pcd.DatumType]
 814     DatumSizeLib = gDatumSizeStringDatabaseLib[Pcd.DatumType]
 815     GetModeName = '_PCD_GET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + Pcd.TokenCName
 816     SetModeName = '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + Pcd.TokenCName
 817     SetModeStatusName = '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_S_' + Pcd.TokenCName
 818     GetModeSizeName = '_PCD_GET_MODE_SIZE' + '_' + Pcd.TokenCName
 819
 820     PcdExCNameList  = []
 821     if Pcd.Type in gDynamicExPcd:
 822         if Info.IsLibrary:
 823             PcdList = Info.LibraryPcdList
 824         else:
 825             PcdList = Info.ModulePcdList
 826         for PcdModule in PcdList:
 827             if PcdModule.Type in gDynamicExPcd:
 828                 PcdExCNameList.append(PcdModule.TokenCName)
 829         # Be compatible with the current code which using PcdToken and PcdGet/Set for DynamicEx Pcd.
 830         # If only PcdToken and PcdGet/Set used in all Pcds with different CName, it should succeed to build.
 831         # If PcdToken and PcdGet/Set used in the Pcds with different Guids but same CName, it should failed to build.
 832         if PcdExCNameList.count(Pcd.TokenCName) > 1:
 833             AutoGenH.Append('// Disabled the macros, as PcdToken and PcdGet/Set are not allowed in the case that more than one DynamicEx Pcds are different Guids but same CName.\n')
 834             AutoGenH.Append('// #define %s  %s\n' % (PcdTokenName, PcdExTokenName))
 835             AutoGenH.Append('// #define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 836             AutoGenH.Append('// #define %s  LibPcdGetExSize(&%s, %s)\n' % (GetModeSizeName,Pcd.TokenSpaceGuidCName, PcdTokenName))
 837             if Pcd.DatumType == 'VOID*':
 838                 AutoGenH.Append('// #define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 839                 AutoGenH.Append('// #define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%sS(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 840             else:
 841                 AutoGenH.Append('// #define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 842                 AutoGenH.Append('// #define %s(Value)  LibPcdSetEx%sS(&%s, %s, (Value))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 843         else:
 844             AutoGenH.Append('#define %s  %s\n' % (PcdTokenName, PcdExTokenName))
 845             AutoGenH.Append('#define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 846             AutoGenH.Append('#define %s LibPcdGetExSize(&%s, %s)\n' % (GetModeSizeName,Pcd.TokenSpaceGuidCName, PcdTokenName))
 847             if Pcd.DatumType == 'VOID*':
 848                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 849                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%sS(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 850             else:
 851                 AutoGenH.Append('#define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 852                 AutoGenH.Append('#define %s(Value)  LibPcdSetEx%sS(&%s, %s, (Value))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 853     elif Pcd.Type in gDynamicPcd:
 854         PcdList = []
 855         PcdCNameList = []
 856         PcdList.extend(Info.LibraryPcdList)
 857         PcdList.extend(Info.ModulePcdList)
 858         for PcdModule in PcdList:
 859             if PcdModule.Type in gDynamicPcd:
 860                 PcdCNameList.append(PcdModule.TokenCName)
 861         if PcdCNameList.count(Pcd.TokenCName) > 1:
 862             EdkLogger.error("build", AUTOGEN_ERROR, "More than one Dynamic Pcds [%s] are different Guids but same CName. They need to be changed to DynamicEx type to avoid the confliction.\n" % (Pcd.TokenCName), ExtraData="[%s]" % str(Info.MetaFile.Path))
 863         else:
 864             AutoGenH.Append('#define %s  LibPcdGet%s(%s)\n' % (GetModeName, DatumSizeLib, PcdTokenName))
 865             AutoGenH.Append('#define %s  LibPcdGetSize(%s)\n' % (GetModeSizeName, PcdTokenName))
 866             if Pcd.DatumType == 'VOID*':
 867                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSet%s(%s, (SizeOfBuffer), (Buffer))\n' %(SetModeName, DatumSizeLib, PcdTokenName))
 868                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSet%sS(%s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, DatumSizeLib, PcdTokenName))
 869             else:
 870                 AutoGenH.Append('#define %s(Value)  LibPcdSet%s(%s, (Value))\n' % (SetModeName, DatumSizeLib, PcdTokenName))
 871                 AutoGenH.Append('#define %s(Value)  LibPcdSet%sS(%s, (Value))\n' % (SetModeStatusName, DatumSizeLib, PcdTokenName))
 872     else:
 873         PcdVariableName = '_gPcd_' + gItemTypeStringDatabase[Pcd.Type] + '_' + Pcd.TokenCName
 874         Const = 'const'
 875         if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
 876             Const = ''
 877         Type = ''
 878         Array = ''
 879         Value = Pcd.DefaultValue
 880         Unicode = False
 881         ValueNumber = 0
 882
 883         if Pcd.DatumType == 'BOOLEAN':
 884             BoolValue = Value.upper()
 885             if BoolValue == 'TRUE' or BoolValue == '1':
 886                 Value = '1U'
 887             elif BoolValue == 'FALSE' or BoolValue == '0':
 888                 Value = '0U'
 889
 890         if Pcd.DatumType in ['UINT64', 'UINT32', 'UINT16', 'UINT8']:
 891             try:
 892                 if Value.upper().startswith('0X'):
 893                     ValueNumber = int (Value, 16)
 894                 else:
 895                     ValueNumber = int (Value)
 896             except:
 897                 EdkLogger.error("build", AUTOGEN_ERROR,
 898                                 "PCD value is not valid dec or hex number for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 899                                 ExtraData="[%s]" % str(Info))
 900             if Pcd.DatumType == 'UINT64':
 901                 if ValueNumber < 0:
 902                     EdkLogger.error("build", AUTOGEN_ERROR,
 903                                     "PCD can't be set to negative value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 904                                     ExtraData="[%s]" % str(Info))
 905                 elif ValueNumber >= 0x10000000000000000:
 906                     EdkLogger.error("build", AUTOGEN_ERROR,
 907                                     "Too large PCD value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 908                                     ExtraData="[%s]" % str(Info))
 909                 if not Value.endswith('ULL'):
 910                     Value += 'ULL'
 911             elif Pcd.DatumType == 'UINT32':
 912                 if ValueNumber < 0:
 913                     EdkLogger.error("build", AUTOGEN_ERROR,
 914                                     "PCD can't be set to negative value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 915                                     ExtraData="[%s]" % str(Info))
 916                 elif ValueNumber >= 0x100000000:
 917                     EdkLogger.error("build", AUTOGEN_ERROR,
 918                                     "Too large PCD value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 919                                     ExtraData="[%s]" % str(Info))
 920                 if not Value.endswith('U'):
 921                     Value += 'U'
 922             elif Pcd.DatumType == 'UINT16':
 923                 if ValueNumber < 0:
 924                     EdkLogger.error("build", AUTOGEN_ERROR,
 925                                     "PCD can't be set to negative value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 926                                     ExtraData="[%s]" % str(Info))
 927                 elif ValueNumber >= 0x10000:
 928                     EdkLogger.error("build", AUTOGEN_ERROR,
 929                                     "Too large PCD value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 930                                     ExtraData="[%s]" % str(Info))
 931                 if not Value.endswith('U'):
 932                     Value += 'U'
 933             elif Pcd.DatumType == 'UINT8':
 934                 if ValueNumber < 0:
 935                     EdkLogger.error("build", AUTOGEN_ERROR,
 936                                     "PCD can't be set to negative value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 937                                     ExtraData="[%s]" % str(Info))
 938                 elif ValueNumber >= 0x100:
 939                     EdkLogger.error("build", AUTOGEN_ERROR,
 940                                     "Too large PCD value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 941                                     ExtraData="[%s]" % str(Info))
 942                 if not Value.endswith('U'):
 943                     Value += 'U'
 944         if Pcd.DatumType == 'VOID*':
 945             if Pcd.MaxDatumSize == None or Pcd.MaxDatumSize == '':
 946                 EdkLogger.error("build", AUTOGEN_ERROR,
 947                                 "Unknown [MaxDatumSize] of PCD [%s.%s]" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 948                                 ExtraData="[%s]" % str(Info))
 949
 950             ArraySize = int(Pcd.MaxDatumSize, 0)
 951             if Value[0] == '{':
 952                 Type = '(VOID *)'
 953             else:
 954                 if Value[0] == 'L':
 955                     Unicode = True
 956                 Value = Value.lstrip('L')   #.strip('"')
 957                 Value = eval(Value)         # translate escape character
 958                 NewValue = '{'
 959                 for Index in range(0,len(Value)):
 960                     if Unicode:
 961                         NewValue = NewValue + str(ord(Value[Index]) % 0x10000) + ', '
 962                     else:
 963                         NewValue = NewValue + str(ord(Value[Index]) % 0x100) + ', '
 964                 if Unicode:
 965                     ArraySize = ArraySize / 2;
 966
 967                 if ArraySize < (len(Value) + 1):
 968                     EdkLogger.error("build", AUTOGEN_ERROR,
 969                                     "The maximum size of VOID* type PCD '%s.%s' is less than its actual size occupied." % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 970                                     ExtraData="[%s]" % str(Info))
 971                 Value = NewValue + '0 }'
 972             Array = '[%d]' % ArraySize
 973         #
 974         # skip casting for fixed at build since it breaks ARM assembly.
 975         # Long term we need PCD macros that work in assembly
 976         #
 977         elif Pcd.Type != TAB_PCDS_FIXED_AT_BUILD:
 978             Value = "((%s)%s)" % (Pcd.DatumType, Value)
 979
 980         if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
 981             PcdValueName = '_PCD_PATCHABLE_VALUE_' + Pcd.TokenCName
 982         else:
 983             PcdValueName = '_PCD_VALUE_' + Pcd.TokenCName
 984
 985         if Pcd.DatumType == 'VOID*':
 986             #
 987             # For unicode, UINT16 array will be generated, so the alignment of unicode is guaranteed.
 988             #
 989             if Unicode:
 990                 AutoGenH.Append('#define %s  %s%s\n' %(PcdValueName, Type, PcdVariableName))
 991                 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s UINT16 %s%s = %s;\n' % (Const, PcdVariableName, Array, Value))
 992                 AutoGenH.Append('extern %s UINT16 %s%s;\n' %(Const, PcdVariableName, Array))
 993                 AutoGenH.Append('#define %s  %s%s\n' %(GetModeName, Type, PcdVariableName))
 994             else:
 995                 AutoGenH.Append('#define %s  %s%s\n' %(PcdValueName, Type, PcdVariableName))
 996                 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s UINT8 %s%s = %s;\n' % (Const, PcdVariableName, Array, Value))
 997                 AutoGenH.Append('extern %s UINT8 %s%s;\n' %(Const, PcdVariableName, Array))
 998                 AutoGenH.Append('#define %s  %s%s\n' %(GetModeName, Type, PcdVariableName))
 999
1000             PcdDataSize = GetPcdSize(Pcd)
1001             if Pcd.Type == TAB_PCDS_FIXED_AT_BUILD:
1002                 AutoGenH.Append('#define %s %s\n' % (FixPcdSizeTokenName, PcdDataSize))
1003                 AutoGenH.Append('#define %s  %s \n' % (GetModeSizeName,FixPcdSizeTokenName))
1004
1005             if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
1006                 AutoGenH.Append('#define %s %s\n' % (PatchPcdSizeTokenName, Pcd.MaxDatumSize))
1007                 AutoGenH.Append('#define %s  %s \n' % (GetModeSizeName,PatchPcdSizeVariableName))
1008                 AutoGenH.Append('extern UINTN %s; \n' % PatchPcdSizeVariableName)
1009                 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED UINTN %s = %s;\n' % (PatchPcdSizeVariableName,PcdDataSize))
1010         elif Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
1011             AutoGenH.Append('#define %s  %s\n' %(PcdValueName, Value))
1012             AutoGenC.Append('volatile %s %s %s = %s;\n' %(Const, Pcd.DatumType, PcdVariableName, PcdValueName))
1013             AutoGenH.Append('extern volatile %s  %s  %s%s;\n' % (Const, Pcd.DatumType, PcdVariableName, Array))
1014             AutoGenH.Append('#define %s  %s%s\n' % (GetModeName, Type, PcdVariableName))
1015
1016             PcdDataSize = GetPcdSize(Pcd)
1017             AutoGenH.Append('#define %s %s\n' % (PatchPcdSizeTokenName, PcdDataSize))
1018
1019             AutoGenH.Append('#define %s  %s \n' % (GetModeSizeName,PatchPcdSizeVariableName))
1020             AutoGenH.Append('extern UINTN %s; \n' % PatchPcdSizeVariableName)
1021             AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED UINTN %s = %s;\n' % (PatchPcdSizeVariableName,PcdDataSize))
1022         else:
1023             PcdDataSize = GetPcdSize(Pcd)
1024             AutoGenH.Append('#define %s %s\n' % (FixPcdSizeTokenName, PcdDataSize))
1025             AutoGenH.Append('#define %s  %s \n' % (GetModeSizeName,FixPcdSizeTokenName))
1026
1027             AutoGenH.Append('#define %s  %s\n' %(PcdValueName, Value))
1028             AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s %s = %s;\n' %(Const, Pcd.DatumType, PcdVariableName, PcdValueName))
1029             AutoGenH.Append('extern %s  %s  %s%s;\n' % (Const, Pcd.DatumType, PcdVariableName, Array))
1030             AutoGenH.Append('#define %s  %s%s\n' % (GetModeName, Type, PcdVariableName))
1031
1032         if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
1033             if Pcd.DatumType == 'VOID*':
1034                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPatchPcdSetPtrAndSize((VOID *)_gPcd_BinaryPatch_%s, &_gPcd_BinaryPatch_Size_%s, (UINTN)_PCD_PATCHABLE_%s_SIZE, (SizeOfBuffer), (Buffer))\n' % (SetModeName, Pcd.TokenCName, Pcd.TokenCName, Pcd.TokenCName))
1035                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPatchPcdSetPtrAndSizeS((VOID *)_gPcd_BinaryPatch_%s, &_gPcd_BinaryPatch_Size_%s, (UINTN)_PCD_PATCHABLE_%s_SIZE, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, Pcd.TokenCName, Pcd.TokenCName, Pcd.TokenCName))
1036             else:
1037                 AutoGenH.Append('#define %s(Value)  (%s = (Value))\n' % (SetModeName, PcdVariableName))
1038                 AutoGenH.Append('#define %s(Value)  ((%s = (Value)), RETURN_SUCCESS) \n' % (SetModeStatusName, PcdVariableName))
1039         else:
1040             AutoGenH.Append('//#define %s  ASSERT(FALSE)  // It is not allowed to set value for a FIXED_AT_BUILD PCD\n' % SetModeName)
1041
1042 ## Create code for library module PCDs
1043 #
1044 #   @param      Info        The ModuleAutoGen object
1045 #   @param      AutoGenC    The TemplateString object for C code
1046 #   @param      AutoGenH    The TemplateString object for header file
1047 #   @param      Pcd         The PCD object
1048 #
1049 def CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd):
1050     PcdTokenNumber = Info.PlatformInfo.PcdTokenNumber
1051     TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName
1052     TokenCName  = Pcd.TokenCName
1053     PcdTokenName = '_PCD_TOKEN_' + TokenCName
1054     FixPcdSizeTokenName = '_PCD_SIZE_' + Pcd.TokenCName
1055     PatchPcdSizeTokenName = '_PCD_PATCHABLE_' + Pcd.TokenCName +'_SIZE'
1056     PatchPcdSizeVariableName = '_gPcd_BinaryPatch_Size_' + Pcd.TokenCName
1057
1058     #
1059     # Write PCDs
1060     #
1061     if Pcd.Type in gDynamicExPcd:
1062         TokenNumber = int(Pcd.TokenValue, 0)
1063     else:
1064         if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in PcdTokenNumber:
1065             # If one of the Source built modules listed in the DSC is not listed in FDF modules,
1066             # and the INF lists a PCD can only use the PcdsDynamic access method (it is only
1067             # listed in the DEC file that declares the PCD as PcdsDynamic), then build tool will
1068             # report warning message notify the PI that they are attempting to build a module
1069             # that must be included in a flash image in order to be functional. These Dynamic PCD
1070             # will not be added into the Database unless it is used by other modules that are
1071             # included in the FDF file.
1072             # In this case, just assign an invalid token number to make it pass build.
1073             if Pcd.Type in PCD_DYNAMIC_TYPE_LIST:
1074                 TokenNumber = 0
1075             else:
1076                 EdkLogger.error("build", AUTOGEN_ERROR,
1077                                 "No generated token number for %s.%s\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
1078                                 ExtraData="[%s]" % str(Info))
1079         else:
1080             TokenNumber = PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName]
1081
1082     if Pcd.Type not in gItemTypeStringDatabase:
1083         EdkLogger.error("build", AUTOGEN_ERROR,
1084                         "Unknown PCD type [%s] of PCD %s.%s" % (Pcd.Type, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
1085                         ExtraData="[%s]" % str(Info))
1086     if Pcd.DatumType not in gDatumSizeStringDatabase:
1087         EdkLogger.error("build", AUTOGEN_ERROR,
1088                         "Unknown datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
1089                         ExtraData="[%s]" % str(Info))
1090
1091     DatumType   = Pcd.DatumType
1092     DatumSize   = gDatumSizeStringDatabaseH[DatumType]
1093     DatumSizeLib= gDatumSizeStringDatabaseLib[DatumType]
1094     GetModeName = '_PCD_GET_MODE_' + DatumSize + '_' + TokenCName
1095     SetModeName = '_PCD_SET_MODE_' + DatumSize + '_' + TokenCName
1096     SetModeStatusName = '_PCD_SET_MODE_' + DatumSize + '_S_' + TokenCName
1097     GetModeSizeName = '_PCD_GET_MODE_SIZE' + '_' + Pcd.TokenCName
1098
1099     Type = ''
1100     Array = ''
1101     if Pcd.DatumType == 'VOID*':
1102         if Pcd.DefaultValue[0]== '{':
1103             Type = '(VOID *)'
1104         Array = '[]'
1105     PcdItemType = Pcd.Type
1106     PcdExCNameList  = []
1107     if PcdItemType in gDynamicExPcd:
1108         PcdExTokenName = '_PCD_TOKEN_' + TokenSpaceGuidCName + '_' + Pcd.TokenCName
1109         AutoGenH.Append('\n#define %s  %dU\n' % (PcdExTokenName, TokenNumber))
1110
1111         if Info.IsLibrary:
1112             PcdList = Info.LibraryPcdList
1113         else:
1114             PcdList = Info.ModulePcdList
1115         for PcdModule in PcdList:
1116             if PcdModule.Type in gDynamicExPcd:
1117                 PcdExCNameList.append(PcdModule.TokenCName)
1118         # Be compatible with the current code which using PcdGet/Set for DynamicEx Pcd.
1119         # If only PcdGet/Set used in all Pcds with different CName, it should succeed to build.
1120         # If PcdGet/Set used in the Pcds with different Guids but same CName, it should failed to build.
1121         if PcdExCNameList.count(Pcd.TokenCName) > 1:
1122             AutoGenH.Append('// Disabled the macros, as PcdToken and PcdGet/Set are not allowed in the case that more than one DynamicEx Pcds are different Guids but same CName.\n')
1123             AutoGenH.Append('// #define %s  %s\n' % (PcdTokenName, PcdExTokenName))
1124             AutoGenH.Append('// #define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1125             AutoGenH.Append('// #define %s  LibPcdGetExSize(&%s, %s \n' % (GetModeSizeName,Pcd.TokenSpaceGuidCName, PcdTokenName))
1126             if Pcd.DatumType == 'VOID*':
1127                 AutoGenH.Append('// #define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1128                 AutoGenH.Append('// #define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%sS(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1129             else:
1130                 AutoGenH.Append('// #define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1131                 AutoGenH.Append('// #define %s(Value)  LibPcdSetEx%sS(&%s, %s, (Value))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1132         else:
1133             AutoGenH.Append('#define %s  %s\n' % (PcdTokenName, PcdExTokenName))
1134             AutoGenH.Append('#define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1135             AutoGenH.Append('#define %s LibPcdGetExSize(&%s, %s)\n' % (GetModeSizeName,Pcd.TokenSpaceGuidCName, PcdTokenName))
1136             if Pcd.DatumType == 'VOID*':
1137                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1138                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%sS(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1139             else:
1140                 AutoGenH.Append('#define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1141                 AutoGenH.Append('#define %s(Value)  LibPcdSetEx%sS(&%s, %s, (Value))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1142     else:
1143         AutoGenH.Append('#define _PCD_TOKEN_%s  %dU\n' % (TokenCName, TokenNumber))
1144     if PcdItemType in gDynamicPcd:
1145         PcdList = []
1146         PcdCNameList = []
1147         PcdList.extend(Info.LibraryPcdList)
1148         PcdList.extend(Info.ModulePcdList)
1149         for PcdModule in PcdList:
1150             if PcdModule.Type in gDynamicPcd:
1151                 PcdCNameList.append(PcdModule.TokenCName)
1152         if PcdCNameList.count(Pcd.TokenCName) > 1:
1153             EdkLogger.error("build", AUTOGEN_ERROR, "More than one Dynamic Pcds [%s] are different Guids but same CName.They need to be changed to DynamicEx type to avoid the confliction.\n" % (Pcd.TokenCName), ExtraData="[%s]" % str(Info.MetaFile.Path))
1154         else:
1155             AutoGenH.Append('#define %s  LibPcdGet%s(%s)\n' % (GetModeName, DatumSizeLib, PcdTokenName))
1156             AutoGenH.Append('#define %s  LibPcdGetSize(%s)\n' % (GetModeSizeName, PcdTokenName))
1157             if DatumType == 'VOID*':
1158                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSet%s(%s, (SizeOfBuffer), (Buffer))\n' %(SetModeName, DatumSizeLib, PcdTokenName))
1159                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSet%sS(%s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, DatumSizeLib, PcdTokenName))
1160             else:
1161                 AutoGenH.Append('#define %s(Value)  LibPcdSet%s(%s, (Value))\n' % (SetModeName, DatumSizeLib, PcdTokenName))
1162                 AutoGenH.Append('#define %s(Value)  LibPcdSet%sS(%s, (Value))\n' % (SetModeStatusName, DatumSizeLib, PcdTokenName))
1163     if PcdItemType == TAB_PCDS_PATCHABLE_IN_MODULE:
1164         PcdVariableName = '_gPcd_' + gItemTypeStringDatabase[TAB_PCDS_PATCHABLE_IN_MODULE] + '_' + TokenCName
1165         if DatumType == 'VOID*':
1166             ArraySize = int(Pcd.MaxDatumSize, 0)
1167             if Pcd.DefaultValue[0] == 'L':
1168                 ArraySize = ArraySize / 2
1169             Array = '[%d]' % ArraySize
1170             DatumType = ['UINT8', 'UINT16'][Pcd.DefaultValue[0] == 'L']
1171             AutoGenH.Append('extern %s _gPcd_BinaryPatch_%s%s;\n' %(DatumType, TokenCName, Array))
1172         else:
1173             AutoGenH.Append('extern volatile  %s  %s%s;\n' % (DatumType, PcdVariableName, Array))
1174         AutoGenH.Append('#define %s  %s_gPcd_BinaryPatch_%s\n' %(GetModeName, Type, TokenCName))
1175         if Pcd.DatumType == 'VOID*':
1176             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPatchPcdSetPtrAndSize((VOID *)_gPcd_BinaryPatch_%s, &_gPcd_BinaryPatch_Size_%s, (UINTN)_PCD_PATCHABLE_%s_SIZE, (SizeOfBuffer), (Buffer))\n' % (SetModeName, Pcd.TokenCName, Pcd.TokenCName, Pcd.TokenCName))
1177             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPatchPcdSetPtrAndSizeS((VOID *)_gPcd_BinaryPatch_%s, &_gPcd_BinaryPatch_Size_%s, (UINTN)_PCD_PATCHABLE_%s_SIZE, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, Pcd.TokenCName, Pcd.TokenCName, Pcd.TokenCName))
1178         else:
1179             AutoGenH.Append('#define %s(Value)  (%s = (Value))\n' % (SetModeName, PcdVariableName))
1180             AutoGenH.Append('#define %s(Value)  ((%s = (Value)), RETURN_SUCCESS)\n' % (SetModeStatusName, PcdVariableName))
1181
1182         PcdDataSize = GetPcdSize(Pcd)
1183         AutoGenH.Append('#define %s %s\n' % (PatchPcdSizeTokenName, PcdDataSize))
1184         AutoGenH.Append('#define %s %s\n' % (GetModeSizeName,PatchPcdSizeVariableName))
1185         AutoGenH.Append('extern UINTN %s; \n' % PatchPcdSizeVariableName)
1186
1187     if PcdItemType == TAB_PCDS_FIXED_AT_BUILD or PcdItemType == TAB_PCDS_FEATURE_FLAG:
1188         key = ".".join((Pcd.TokenSpaceGuidCName,Pcd.TokenCName))
1189
1190         if DatumType == 'VOID*' and Array == '[]':
1191             DatumType = ['UINT8', 'UINT16'][Pcd.DefaultValue[0] == 'L']
1192         AutoGenH.Append('extern const %s _gPcd_FixedAtBuild_%s%s;\n' %(DatumType, TokenCName, Array))
1193         AutoGenH.Append('#define %s  %s_gPcd_FixedAtBuild_%s\n' %(GetModeName, Type, TokenCName))
1194         AutoGenH.Append('//#define %s  ASSERT(FALSE)  // It is not allowed to set value for a FIXED_AT_BUILD PCD\n' % SetModeName)
1195
1196         if PcdItemType == TAB_PCDS_FIXED_AT_BUILD and key in Info.ConstPcd:
1197             AutoGenH.Append('#define _PCD_VALUE_%s %s\n' %(TokenCName, Pcd.DefaultValue))
1198
1199         if PcdItemType == TAB_PCDS_FIXED_AT_BUILD:
1200             PcdDataSize = GetPcdSize(Pcd)
1201             AutoGenH.Append('#define %s %s\n' % (FixPcdSizeTokenName, PcdDataSize))
1202             AutoGenH.Append('#define %s %s\n' % (GetModeSizeName,FixPcdSizeTokenName))
1203
1204 ## Create code for library constructor
1205 #
1206 #   @param      Info        The ModuleAutoGen object
1207 #   @param      AutoGenC    The TemplateString object for C code
1208 #   @param      AutoGenH    The TemplateString object for header file
1209 #
1210 def CreateLibraryConstructorCode(Info, AutoGenC, AutoGenH):
1211     #
1212     # Library Constructors
1213     #
1214     ConstructorPrototypeString = TemplateString()
1215     ConstructorCallingString = TemplateString()
1216     if Info.IsLibrary:
1217         DependentLibraryList = [Info.Module]
1218     else:
1219         DependentLibraryList = Info.DependentLibraryList
1220     for Lib in DependentLibraryList:
1221         if len(Lib.ConstructorList) <= 0:
1222             continue
1223         Dict = {'Function':Lib.ConstructorList}
1224         if Lib.ModuleType in ['BASE', 'SEC']:
1225             ConstructorPrototypeString.Append(gLibraryStructorPrototype['BASE'].Replace(Dict))
1226             ConstructorCallingString.Append(gLibraryStructorCall['BASE'].Replace(Dict))
1227         elif Lib.ModuleType in ['PEI_CORE','PEIM']:
1228             ConstructorPrototypeString.Append(gLibraryStructorPrototype['PEI'].Replace(Dict))
1229             ConstructorCallingString.Append(gLibraryStructorCall['PEI'].Replace(Dict))
1230         elif Lib.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER',
1231                                 'DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION','SMM_CORE']:
1232             ConstructorPrototypeString.Append(gLibraryStructorPrototype['DXE'].Replace(Dict))
1233             ConstructorCallingString.Append(gLibraryStructorCall['DXE'].Replace(Dict))
1234
1235     if str(ConstructorPrototypeString) == '':
1236         ConstructorPrototypeList = []
1237     else:
1238         ConstructorPrototypeList = [str(ConstructorPrototypeString)]
1239     if str(ConstructorCallingString) == '':
1240         ConstructorCallingList = []
1241     else:
1242         ConstructorCallingList = [str(ConstructorCallingString)]
1243
1244     Dict = {
1245         'Type'              :   'Constructor',
1246         'FunctionPrototype' :   ConstructorPrototypeList,
1247         'FunctionCall'      :   ConstructorCallingList
1248     }
1249     if Info.IsLibrary:
1250         AutoGenH.Append("${BEGIN}${FunctionPrototype}${END}", Dict)
1251     else:
1252         if Info.ModuleType in ['BASE', 'SEC']:
1253             AutoGenC.Append(gLibraryString['BASE'].Replace(Dict))
1254         elif Info.ModuleType in ['PEI_CORE','PEIM']:
1255             AutoGenC.Append(gLibraryString['PEI'].Replace(Dict))
1256         elif Info.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER',
1257                                  'DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION','SMM_CORE']:
1258             AutoGenC.Append(gLibraryString['DXE'].Replace(Dict))
1259
1260 ## Create code for library destructor
1261 #
1262 #   @param      Info        The ModuleAutoGen object
1263 #   @param      AutoGenC    The TemplateString object for C code
1264 #   @param      AutoGenH    The TemplateString object for header file
1265 #
1266 def CreateLibraryDestructorCode(Info, AutoGenC, AutoGenH):
1267     #
1268     # Library Destructors
1269     #
1270     DestructorPrototypeString = TemplateString()
1271     DestructorCallingString = TemplateString()
1272     if Info.IsLibrary:
1273         DependentLibraryList = [Info.Module]
1274     else:
1275         DependentLibraryList = Info.DependentLibraryList
1276     for Index in range(len(DependentLibraryList)-1, -1, -1):
1277         Lib = DependentLibraryList[Index]
1278         if len(Lib.DestructorList) <= 0:
1279             continue
1280         Dict = {'Function':Lib.DestructorList}
1281         if Lib.ModuleType in ['BASE', 'SEC']:
1282             DestructorPrototypeString.Append(gLibraryStructorPrototype['BASE'].Replace(Dict))
1283             DestructorCallingString.Append(gLibraryStructorCall['BASE'].Replace(Dict))
1284         elif Lib.ModuleType in ['PEI_CORE','PEIM']:
1285             DestructorPrototypeString.Append(gLibraryStructorPrototype['PEI'].Replace(Dict))
1286             DestructorCallingString.Append(gLibraryStructorCall['PEI'].Replace(Dict))
1287         elif Lib.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER',
1288                                 'DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION', 'SMM_CORE']:
1289             DestructorPrototypeString.Append(gLibraryStructorPrototype['DXE'].Replace(Dict))
1290             DestructorCallingString.Append(gLibraryStructorCall['DXE'].Replace(Dict))
1291
1292     if str(DestructorPrototypeString) == '':
1293         DestructorPrototypeList = []
1294     else:
1295         DestructorPrototypeList = [str(DestructorPrototypeString)]
1296     if str(DestructorCallingString) == '':
1297         DestructorCallingList = []
1298     else:
1299         DestructorCallingList = [str(DestructorCallingString)]
1300
1301     Dict = {
1302         'Type'              :   'Destructor',
1303         'FunctionPrototype' :   DestructorPrototypeList,
1304         'FunctionCall'      :   DestructorCallingList
1305     }
1306     if Info.IsLibrary:
1307         AutoGenH.Append("${BEGIN}${FunctionPrototype}${END}", Dict)
1308     else:
1309         if Info.ModuleType in ['BASE', 'SEC']:
1310             AutoGenC.Append(gLibraryString['BASE'].Replace(Dict))
1311         elif Info.ModuleType in ['PEI_CORE','PEIM']:
1312             AutoGenC.Append(gLibraryString['PEI'].Replace(Dict))
1313         elif Info.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER',
1314                                  'DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION','SMM_CORE']:
1315             AutoGenC.Append(gLibraryString['DXE'].Replace(Dict))
1316
1317
1318 ## Create code for ModuleEntryPoint
1319 #
1320 #   @param      Info        The ModuleAutoGen object
1321 #   @param      AutoGenC    The TemplateString object for C code
1322 #   @param      AutoGenH    The TemplateString object for header file
1323 #
1324 def CreateModuleEntryPointCode(Info, AutoGenC, AutoGenH):
1325     if Info.IsLibrary or Info.ModuleType in ['USER_DEFINED', 'SEC']:
1326         return
1327     #
1328     # Module Entry Points
1329     #
1330     NumEntryPoints = len(Info.Module.ModuleEntryPointList)
1331     if 'PI_SPECIFICATION_VERSION' in Info.Module.Specification:
1332         PiSpecVersion = Info.Module.Specification['PI_SPECIFICATION_VERSION']
1333     else:
1334         PiSpecVersion = '0x00000000'
1335     if 'UEFI_SPECIFICATION_VERSION' in Info.Module.Specification:
1336         UefiSpecVersion = Info.Module.Specification['UEFI_SPECIFICATION_VERSION']
1337     else:
1338         UefiSpecVersion = '0x00000000'
1339     Dict = {
1340         'Function'       :   Info.Module.ModuleEntryPointList,
1341         'PiSpecVersion'  :   PiSpecVersion + 'U',
1342         'UefiSpecVersion':   UefiSpecVersion + 'U'
1343     }
1344
1345     if Info.ModuleType in ['PEI_CORE', 'DXE_CORE', 'SMM_CORE']:
1346         if Info.SourceFileList <> None and Info.SourceFileList <> []:
1347           if NumEntryPoints != 1:
1348               EdkLogger.error(
1349                   "build",
1350                   AUTOGEN_ERROR,
1351                   '%s must have exactly one entry point' % Info.ModuleType,
1352                   File=str(Info),
1353                   ExtraData= ", ".join(Info.Module.ModuleEntryPointList)
1354                   )
1355     if Info.ModuleType == 'PEI_CORE':
1356         AutoGenC.Append(gPeiCoreEntryPointString.Replace(Dict))
1357         AutoGenH.Append(gPeiCoreEntryPointPrototype.Replace(Dict))
1358     elif Info.ModuleType == 'DXE_CORE':
1359         AutoGenC.Append(gDxeCoreEntryPointString.Replace(Dict))
1360         AutoGenH.Append(gDxeCoreEntryPointPrototype.Replace(Dict))
1361     elif Info.ModuleType == 'SMM_CORE':
1362         AutoGenC.Append(gSmmCoreEntryPointString.Replace(Dict))
1363         AutoGenH.Append(gSmmCoreEntryPointPrototype.Replace(Dict))
1364     elif Info.ModuleType == 'PEIM':
1365         if NumEntryPoints < 2:
1366             AutoGenC.Append(gPeimEntryPointString[NumEntryPoints].Replace(Dict))
1367         else:
1368             AutoGenC.Append(gPeimEntryPointString[2].Replace(Dict))
1369         AutoGenH.Append(gPeimEntryPointPrototype.Replace(Dict))
1370     elif Info.ModuleType in ['DXE_RUNTIME_DRIVER','DXE_DRIVER','DXE_SAL_DRIVER','UEFI_DRIVER']:
1371         if NumEntryPoints < 2:
1372             AutoGenC.Append(gUefiDriverEntryPointString[NumEntryPoints].Replace(Dict))
1373         else:
1374             AutoGenC.Append(gUefiDriverEntryPointString[2].Replace(Dict))
1375         AutoGenH.Append(gUefiDriverEntryPointPrototype.Replace(Dict))
1376     elif Info.ModuleType == 'DXE_SMM_DRIVER':
1377         if NumEntryPoints == 0:
1378             AutoGenC.Append(gDxeSmmEntryPointString[0].Replace(Dict))
1379         else:
1380             AutoGenC.Append(gDxeSmmEntryPointString[1].Replace(Dict))
1381         AutoGenH.Append(gDxeSmmEntryPointPrototype.Replace(Dict))
1382     elif Info.ModuleType == 'UEFI_APPLICATION':
1383         if NumEntryPoints < 2:
1384             AutoGenC.Append(gUefiApplicationEntryPointString[NumEntryPoints].Replace(Dict))
1385         else:
1386             AutoGenC.Append(gUefiApplicationEntryPointString[2].Replace(Dict))
1387         AutoGenH.Append(gUefiApplicationEntryPointPrototype.Replace(Dict))
1388
1389 ## Create code for ModuleUnloadImage
1390 #
1391 #   @param      Info        The ModuleAutoGen object
1392 #   @param      AutoGenC    The TemplateString object for C code
1393 #   @param      AutoGenH    The TemplateString object for header file
1394 #
1395 def CreateModuleUnloadImageCode(Info, AutoGenC, AutoGenH):
1396     if Info.IsLibrary or Info.ModuleType in ['USER_DEFINED', 'SEC']:
1397         return
1398     #
1399     # Unload Image Handlers
1400     #
1401     NumUnloadImage = len(Info.Module.ModuleUnloadImageList)
1402     Dict = {'Count':str(NumUnloadImage) + 'U', 'Function':Info.Module.ModuleUnloadImageList}
1403     if NumUnloadImage < 2:
1404         AutoGenC.Append(gUefiUnloadImageString[NumUnloadImage].Replace(Dict))
1405     else:
1406         AutoGenC.Append(gUefiUnloadImageString[2].Replace(Dict))
1407     AutoGenH.Append(gUefiUnloadImagePrototype.Replace(Dict))
1408
1409 ## Create code for GUID
1410 #
1411 #   @param      Info        The ModuleAutoGen object
1412 #   @param      AutoGenC    The TemplateString object for C code
1413 #   @param      AutoGenH    The TemplateString object for header file
1414 #
1415 def CreateGuidDefinitionCode(Info, AutoGenC, AutoGenH):
1416     if Info.ModuleType in ["USER_DEFINED", "BASE"]:
1417         GuidType = "GUID"
1418     else:
1419         GuidType = "EFI_GUID"
1420
1421     if Info.GuidList:
1422         if not Info.IsLibrary:
1423             AutoGenC.Append("\n// Guids\n")
1424         AutoGenH.Append("\n// Guids\n")
1425     #
1426     # GUIDs
1427     #
1428     for Key in Info.GuidList:
1429         if not Info.IsLibrary:
1430             AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.GuidList[Key]))
1431         AutoGenH.Append('extern %s %s;\n' % (GuidType, Key))
1432
1433 ## Create code for protocol
1434 #
1435 #   @param      Info        The ModuleAutoGen object
1436 #   @param      AutoGenC    The TemplateString object for C code
1437 #   @param      AutoGenH    The TemplateString object for header file
1438 #
1439 def CreateProtocolDefinitionCode(Info, AutoGenC, AutoGenH):
1440     if Info.ModuleType in ["USER_DEFINED", "BASE"]:
1441         GuidType = "GUID"
1442     else:
1443         GuidType = "EFI_GUID"
1444
1445     if Info.ProtocolList:
1446         if not Info.IsLibrary:
1447             AutoGenC.Append("\n// Protocols\n")
1448         AutoGenH.Append("\n// Protocols\n")
1449     #
1450     # Protocol GUIDs
1451     #
1452     for Key in Info.ProtocolList:
1453         if not Info.IsLibrary:
1454             AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.ProtocolList[Key]))
1455         AutoGenH.Append('extern %s %s;\n' % (GuidType, Key))
1456
1457 ## Create code for PPI
1458 #
1459 #   @param      Info        The ModuleAutoGen object
1460 #   @param      AutoGenC    The TemplateString object for C code
1461 #   @param      AutoGenH    The TemplateString object for header file
1462 #
1463 def CreatePpiDefinitionCode(Info, AutoGenC, AutoGenH):
1464     if Info.ModuleType in ["USER_DEFINED", "BASE"]:
1465         GuidType = "GUID"
1466     else:
1467         GuidType = "EFI_GUID"
1468
1469     if Info.PpiList:
1470         if not Info.IsLibrary:
1471             AutoGenC.Append("\n// PPIs\n")
1472         AutoGenH.Append("\n// PPIs\n")
1473     #
1474     # PPI GUIDs
1475     #
1476     for Key in Info.PpiList:
1477         if not Info.IsLibrary:
1478             AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.PpiList[Key]))
1479         AutoGenH.Append('extern %s %s;\n' % (GuidType, Key))
1480
1481 ## Create code for PCD
1482 #
1483 #   @param      Info        The ModuleAutoGen object
1484 #   @param      AutoGenC    The TemplateString object for C code
1485 #   @param      AutoGenH    The TemplateString object for header file
1486 #
1487 def CreatePcdCode(Info, AutoGenC, AutoGenH):
1488
1489     # Collect Token Space GUIDs used by DynamicEc PCDs
1490     TokenSpaceList = []
1491     for Pcd in Info.ModulePcdList:
1492         if Pcd.Type in gDynamicExPcd and Pcd.TokenSpaceGuidCName not in TokenSpaceList:
1493             TokenSpaceList += [Pcd.TokenSpaceGuidCName]
1494
1495     # Add extern declarations to AutoGen.h if one or more Token Space GUIDs were found
1496     if TokenSpaceList <> []:
1497         AutoGenH.Append("\n// Definition of PCD Token Space GUIDs used in this module\n\n")
1498         if Info.ModuleType in ["USER_DEFINED", "BASE"]:
1499             GuidType = "GUID"
1500         else:
1501             GuidType = "EFI_GUID"
1502         for Item in TokenSpaceList:
1503             AutoGenH.Append('extern %s %s;\n' % (GuidType, Item))
1504
1505     if Info.IsLibrary:
1506         if Info.ModulePcdList:
1507             AutoGenH.Append("\n// PCD definitions\n")
1508         for Pcd in Info.ModulePcdList:
1509             CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd)
1510         DynExPcdTokenNumberMapping (Info, AutoGenH)
1511     else:
1512         if Info.ModulePcdList:
1513             AutoGenH.Append("\n// Definition of PCDs used in this module\n")
1514             AutoGenC.Append("\n// Definition of PCDs used in this module\n")
1515         for Pcd in Info.ModulePcdList:
1516             CreateModulePcdCode(Info, AutoGenC, AutoGenH, Pcd)
1517         DynExPcdTokenNumberMapping (Info, AutoGenH)
1518         if Info.LibraryPcdList:
1519             AutoGenH.Append("\n// Definition of PCDs used in libraries is in AutoGen.c\n")
1520             AutoGenC.Append("\n// Definition of PCDs used in libraries\n")
1521         for Pcd in Info.LibraryPcdList:
1522             CreateModulePcdCode(Info, AutoGenC, AutoGenC, Pcd)
1523     CreatePcdDatabaseCode(Info, AutoGenC, AutoGenH)
1524
1525 ## Create code for unicode string definition
1526 #
1527 #   @param      Info        The ModuleAutoGen object
1528 #   @param      AutoGenC    The TemplateString object for C code
1529 #   @param      AutoGenH    The TemplateString object for header file
1530 #   @param      UniGenCFlag     UniString is generated into AutoGen C file when it is set to True
1531 #   @param      UniGenBinBuffer Buffer to store uni string package data
1532 #
1533 def CreateUnicodeStringCode(Info, AutoGenC, AutoGenH, UniGenCFlag, UniGenBinBuffer):
1534     WorkingDir = os.getcwd()
1535     os.chdir(Info.WorkspaceDir)
1536
1537     IncList = [Info.MetaFile.Dir]
1538     # Get all files under [Sources] section in inf file for EDK-II module
1539     EDK2Module = True
1540     SrcList = [F for F in Info.SourceFileList]
1541     if Info.AutoGenVersion < 0x00010005:
1542         EDK2Module = False
1543         # Get all files under the module directory for EDK-I module
1544         Cwd = os.getcwd()
1545         os.chdir(Info.MetaFile.Dir)
1546         for Root, Dirs, Files in os.walk("."):
1547             if 'CVS' in Dirs:
1548                 Dirs.remove('CVS')
1549             if '.svn' in Dirs:
1550                 Dirs.remove('.svn')
1551             for File in Files:
1552                 File = PathClass(os.path.join(Root, File), Info.MetaFile.Dir)
1553                 if File in SrcList:
1554                     continue
1555                 SrcList.append(File)
1556         os.chdir(Cwd)
1557
1558     if 'BUILD' in Info.BuildOption and Info.BuildOption['BUILD']['FLAGS'].find('-c') > -1:
1559         CompatibleMode = True
1560     else:
1561         CompatibleMode = False
1562
1563     #
1564     # -s is a temporary option dedicated for building .UNI files with ISO 639-2 language codes of EDK Shell in EDK2
1565     #
1566     if 'BUILD' in Info.BuildOption and Info.BuildOption['BUILD']['FLAGS'].find('-s') > -1:
1567         if CompatibleMode:
1568             EdkLogger.error("build", AUTOGEN_ERROR,
1569                             "-c and -s build options should be used exclusively",
1570                             ExtraData="[%s]" % str(Info))
1571         ShellMode = True
1572     else:
1573         ShellMode = False
1574
1575     #RFC4646 is only for EDKII modules and ISO639-2 for EDK modules
1576     if EDK2Module:
1577         FilterInfo = [EDK2Module] + [Info.PlatformInfo.Platform.RFCLanguages]
1578     else:
1579         FilterInfo = [EDK2Module] + [Info.PlatformInfo.Platform.ISOLanguages]
1580     Header, Code = GetStringFiles(Info.UnicodeFileList, SrcList, IncList, Info.IncludePathList, ['.uni', '.inf'], Info.Name, CompatibleMode, ShellMode, UniGenCFlag, UniGenBinBuffer, FilterInfo)
1581     if CompatibleMode or UniGenCFlag:
1582         AutoGenC.Append("\n//\n//Unicode String Pack Definition\n//\n")
1583         AutoGenC.Append(Code)
1584         AutoGenC.Append("\n")
1585     AutoGenH.Append("\n//\n//Unicode String ID\n//\n")
1586     AutoGenH.Append(Header)
1587     if CompatibleMode or UniGenCFlag:
1588         AutoGenH.Append("\n#define STRING_ARRAY_NAME %sStrings\n" % Info.Name)
1589     os.chdir(WorkingDir)
1590
1591 ## Create common code
1592 #
1593 #   @param      Info        The ModuleAutoGen object
1594 #   @param      AutoGenC    The TemplateString object for C code
1595 #   @param      AutoGenH    The TemplateString object for header file
1596 #
1597 def CreateHeaderCode(Info, AutoGenC, AutoGenH):
1598     # file header
1599     AutoGenH.Append(gAutoGenHeaderString.Replace({'FileName':'AutoGen.h'}))
1600     # header file Prologue
1601     AutoGenH.Append(gAutoGenHPrologueString.Replace({'File':'AUTOGENH','Guid':Info.Guid.replace('-','_')}))
1602     AutoGenH.Append(gAutoGenHCppPrologueString)
1603     if Info.AutoGenVersion >= 0x00010005:
1604         # header files includes
1605         AutoGenH.Append("#include <%s>\n" % gBasicHeaderFile)
1606         if Info.ModuleType in gModuleTypeHeaderFile \
1607            and gModuleTypeHeaderFile[Info.ModuleType][0] != gBasicHeaderFile:
1608             AutoGenH.Append("#include <%s>\n" % gModuleTypeHeaderFile[Info.ModuleType][0])
1609         #
1610         # if either PcdLib in [LibraryClasses] sections or there exist Pcd section, add PcdLib.h
1611         # As if modules only uses FixedPcd, then PcdLib is not needed in [LibraryClasses] section.
1612         #
1613         if 'PcdLib' in Info.Module.LibraryClasses or Info.Module.Pcds:
1614             AutoGenH.Append("#include <Library/PcdLib.h>\n")
1615
1616         AutoGenH.Append('\nextern GUID  gEfiCallerIdGuid;')
1617         AutoGenH.Append('\nextern CHAR8 *gEfiCallerBaseName;\n\n')
1618
1619         if Info.IsLibrary:
1620             return
1621
1622         AutoGenH.Append("#define EFI_CALLER_ID_GUID \\\n  %s\n" % GuidStringToGuidStructureString(Info.Guid))
1623
1624     if Info.IsLibrary:
1625         return
1626     # C file header
1627     AutoGenC.Append(gAutoGenHeaderString.Replace({'FileName':'AutoGen.c'}))
1628     if Info.AutoGenVersion >= 0x00010005:
1629         # C file header files includes
1630         if Info.ModuleType in gModuleTypeHeaderFile:
1631             for Inc in gModuleTypeHeaderFile[Info.ModuleType]:
1632                 AutoGenC.Append("#include <%s>\n" % Inc)
1633         else:
1634             AutoGenC.Append("#include <%s>\n" % gBasicHeaderFile)
1635
1636         #
1637         # Publish the CallerId Guid
1638         #
1639         AutoGenC.Append('\nGLOBAL_REMOVE_IF_UNREFERENCED GUID gEfiCallerIdGuid = %s;\n' % GuidStringToGuidStructureString(Info.Guid))
1640         AutoGenC.Append('\nGLOBAL_REMOVE_IF_UNREFERENCED CHAR8 *gEfiCallerBaseName = "%s";\n' % Info.Name)
1641
1642 ## Create common code for header file
1643 #
1644 #   @param      Info        The ModuleAutoGen object
1645 #   @param      AutoGenC    The TemplateString object for C code
1646 #   @param      AutoGenH    The TemplateString object for header file
1647 #
1648 def CreateFooterCode(Info, AutoGenC, AutoGenH):
1649     AutoGenH.Append(gAutoGenHEpilogueString)
1650
1651 ## Create code for a module
1652 #
1653 #   @param      Info        The ModuleAutoGen object
1654 #   @param      AutoGenC    The TemplateString object for C code
1655 #   @param      AutoGenH    The TemplateString object for header file
1656 #   @param      UniGenCFlag     UniString is generated into AutoGen C file when it is set to True
1657 #   @param      UniGenBinBuffer Buffer to store uni string package data
1658 #
1659 def CreateCode(Info, AutoGenC, AutoGenH, StringH, UniGenCFlag, UniGenBinBuffer):
1660     CreateHeaderCode(Info, AutoGenC, AutoGenH)
1661
1662     if Info.AutoGenVersion >= 0x00010005:
1663         CreateGuidDefinitionCode(Info, AutoGenC, AutoGenH)
1664         CreateProtocolDefinitionCode(Info, AutoGenC, AutoGenH)
1665         CreatePpiDefinitionCode(Info, AutoGenC, AutoGenH)
1666         CreatePcdCode(Info, AutoGenC, AutoGenH)
1667         CreateLibraryConstructorCode(Info, AutoGenC, AutoGenH)
1668         CreateLibraryDestructorCode(Info, AutoGenC, AutoGenH)
1669         CreateModuleEntryPointCode(Info, AutoGenC, AutoGenH)
1670         CreateModuleUnloadImageCode(Info, AutoGenC, AutoGenH)
1671
1672     if Info.UnicodeFileList:
1673         FileName = "%sStrDefs.h" % Info.Name
1674         StringH.Append(gAutoGenHeaderString.Replace({'FileName':FileName}))
1675         StringH.Append(gAutoGenHPrologueString.Replace({'File':'STRDEFS', 'Guid':Info.Guid.replace('-','_')}))
1676         CreateUnicodeStringCode(Info, AutoGenC, StringH, UniGenCFlag, UniGenBinBuffer)
1677
1678         GuidMacros = []
1679         for Guid in Info.Module.Guids:
1680             if Guid in Info.Module.GetGuidsUsedByPcd():
1681                 continue
1682             GuidMacros.append('#define %s %s' % (Guid, Info.Module.Guids[Guid]))
1683         for Guid, Value in Info.Module.Protocols.items() + Info.Module.Ppis.items():
1684             GuidMacros.append('#define %s %s' % (Guid, Value))
1685         if GuidMacros:
1686             StringH.Append('\n#ifdef VFRCOMPILE\n%s\n#endif\n' % '\n'.join(GuidMacros))
1687
1688         StringH.Append("\n#endif\n")
1689         AutoGenH.Append('#include "%s"\n' % FileName)
1690
1691     CreateFooterCode(Info, AutoGenC, AutoGenH)
1692
1693     # no generation of AutoGen.c for Edk modules without unicode file
1694     if Info.AutoGenVersion < 0x00010005 and len(Info.UnicodeFileList) == 0:
1695         AutoGenC.String = ''
1696
1697 ## Create the code file
1698 #
1699 #   @param      FilePath     The path of code file
1700 #   @param      Content      The content of code file
1701 #   @param      IsBinaryFile The flag indicating if the file is binary file or not
1702 #
1703 #   @retval     True        If file content is changed or file doesn't exist
1704 #   @retval     False       If the file exists and the content is not changed
1705 #
1706 def Generate(FilePath, Content, IsBinaryFile):
1707     return SaveFileOnChange(FilePath, Content, IsBinaryFile)
1708