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     if GlobalData.BuildOptionPcd:
 771         for PcdItem in GlobalData.BuildOptionPcd:
 772             if (Pcd.TokenSpaceGuidCName, Pcd.TokenCName) == (PcdItem[0], PcdItem[1]):
 773                 Pcd.DefaultValue = PcdItem[2]
 774                 break
 775
 776     #
 777     # Write PCDs
 778     #
 779     PcdTokenName = '_PCD_TOKEN_' + Pcd.TokenCName
 780     PatchPcdSizeTokenName = '_PCD_PATCHABLE_' + Pcd.TokenCName +'_SIZE'
 781     PatchPcdSizeVariableName = '_gPcd_BinaryPatch_Size_' + Pcd.TokenCName
 782     FixPcdSizeTokenName = '_PCD_SIZE_' + Pcd.TokenCName
 783
 784     if Pcd.Type in gDynamicExPcd:
 785         TokenNumber = int(Pcd.TokenValue, 0)
 786         # Add TokenSpaceGuidValue value to PcdTokenName to discriminate the DynamicEx PCDs with
 787         # different Guids but same TokenCName
 788         PcdExTokenName = '_PCD_TOKEN_' + Pcd.TokenSpaceGuidCName + '_' + Pcd.TokenCName
 789         AutoGenH.Append('\n#define %s  %dU\n' % (PcdExTokenName, TokenNumber))
 790     else:
 791         if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in PcdTokenNumber:
 792             # If one of the Source built modules listed in the DSC is not listed in FDF modules,
 793             # and the INF lists a PCD can only use the PcdsDynamic access method (it is only
 794             # listed in the DEC file that declares the PCD as PcdsDynamic), then build tool will
 795             # report warning message notify the PI that they are attempting to build a module
 796             # that must be included in a flash image in order to be functional. These Dynamic PCD
 797             # will not be added into the Database unless it is used by other modules that are
 798             # included in the FDF file.
 799             # In this case, just assign an invalid token number to make it pass build.
 800             if Pcd.Type in PCD_DYNAMIC_TYPE_LIST:
 801                 TokenNumber = 0
 802             else:
 803                 EdkLogger.error("build", AUTOGEN_ERROR,
 804                                 "No generated token number for %s.%s\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 805                                 ExtraData="[%s]" % str(Info))
 806         else:
 807             TokenNumber = PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName]
 808         AutoGenH.Append('\n#define %s  %dU\n' % (PcdTokenName, TokenNumber))
 809
 810     EdkLogger.debug(EdkLogger.DEBUG_3, "Creating code for " + Pcd.TokenCName + "." + Pcd.TokenSpaceGuidCName)
 811     if Pcd.Type not in gItemTypeStringDatabase:
 812         EdkLogger.error("build", AUTOGEN_ERROR,
 813                         "Unknown PCD type [%s] of PCD %s.%s" % (Pcd.Type, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 814                         ExtraData="[%s]" % str(Info))
 815     if Pcd.DatumType not in gDatumSizeStringDatabase:
 816         EdkLogger.error("build", AUTOGEN_ERROR,
 817                         "Unknown datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 818                         ExtraData="[%s]" % str(Info))
 819
 820     DatumSize = gDatumSizeStringDatabase[Pcd.DatumType]
 821     DatumSizeLib = gDatumSizeStringDatabaseLib[Pcd.DatumType]
 822     GetModeName = '_PCD_GET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + Pcd.TokenCName
 823     SetModeName = '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + Pcd.TokenCName
 824     SetModeStatusName = '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_S_' + Pcd.TokenCName
 825     GetModeSizeName = '_PCD_GET_MODE_SIZE' + '_' + Pcd.TokenCName
 826
 827     PcdExCNameList  = []
 828     if Pcd.Type in gDynamicExPcd:
 829         if Info.IsLibrary:
 830             PcdList = Info.LibraryPcdList
 831         else:
 832             PcdList = Info.ModulePcdList
 833         for PcdModule in PcdList:
 834             if PcdModule.Type in gDynamicExPcd:
 835                 PcdExCNameList.append(PcdModule.TokenCName)
 836         # Be compatible with the current code which using PcdToken and PcdGet/Set for DynamicEx Pcd.
 837         # If only PcdToken and PcdGet/Set used in all Pcds with different CName, it should succeed to build.
 838         # If PcdToken and PcdGet/Set used in the Pcds with different Guids but same CName, it should failed to build.
 839         if PcdExCNameList.count(Pcd.TokenCName) > 1:
 840             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')
 841             AutoGenH.Append('// #define %s  %s\n' % (PcdTokenName, PcdExTokenName))
 842             AutoGenH.Append('// #define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 843             AutoGenH.Append('// #define %s  LibPcdGetExSize(&%s, %s)\n' % (GetModeSizeName,Pcd.TokenSpaceGuidCName, PcdTokenName))
 844             if Pcd.DatumType == 'VOID*':
 845                 AutoGenH.Append('// #define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 846                 AutoGenH.Append('// #define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%sS(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 847             else:
 848                 AutoGenH.Append('// #define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 849                 AutoGenH.Append('// #define %s(Value)  LibPcdSetEx%sS(&%s, %s, (Value))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 850         else:
 851             AutoGenH.Append('#define %s  %s\n' % (PcdTokenName, PcdExTokenName))
 852             AutoGenH.Append('#define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 853             AutoGenH.Append('#define %s LibPcdGetExSize(&%s, %s)\n' % (GetModeSizeName,Pcd.TokenSpaceGuidCName, PcdTokenName))
 854             if Pcd.DatumType == 'VOID*':
 855                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 856                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%sS(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 857             else:
 858                 AutoGenH.Append('#define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 859                 AutoGenH.Append('#define %s(Value)  LibPcdSetEx%sS(&%s, %s, (Value))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 860     elif Pcd.Type in gDynamicPcd:
 861         PcdList = []
 862         PcdCNameList = []
 863         PcdList.extend(Info.LibraryPcdList)
 864         PcdList.extend(Info.ModulePcdList)
 865         for PcdModule in PcdList:
 866             if PcdModule.Type in gDynamicPcd:
 867                 PcdCNameList.append(PcdModule.TokenCName)
 868         if PcdCNameList.count(Pcd.TokenCName) > 1:
 869             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))
 870         else:
 871             AutoGenH.Append('#define %s  LibPcdGet%s(%s)\n' % (GetModeName, DatumSizeLib, PcdTokenName))
 872             AutoGenH.Append('#define %s  LibPcdGetSize(%s)\n' % (GetModeSizeName, PcdTokenName))
 873             if Pcd.DatumType == 'VOID*':
 874                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSet%s(%s, (SizeOfBuffer), (Buffer))\n' %(SetModeName, DatumSizeLib, PcdTokenName))
 875                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSet%sS(%s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, DatumSizeLib, PcdTokenName))
 876             else:
 877                 AutoGenH.Append('#define %s(Value)  LibPcdSet%s(%s, (Value))\n' % (SetModeName, DatumSizeLib, PcdTokenName))
 878                 AutoGenH.Append('#define %s(Value)  LibPcdSet%sS(%s, (Value))\n' % (SetModeStatusName, DatumSizeLib, PcdTokenName))
 879     else:
 880         PcdVariableName = '_gPcd_' + gItemTypeStringDatabase[Pcd.Type] + '_' + Pcd.TokenCName
 881         Const = 'const'
 882         if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
 883             Const = ''
 884         Type = ''
 885         Array = ''
 886         Value = Pcd.DefaultValue
 887         Unicode = False
 888         ValueNumber = 0
 889
 890         if Pcd.DatumType == 'BOOLEAN':
 891             BoolValue = Value.upper()
 892             if BoolValue == 'TRUE' or BoolValue == '1':
 893                 Value = '1U'
 894             elif BoolValue == 'FALSE' or BoolValue == '0':
 895                 Value = '0U'
 896
 897         if Pcd.DatumType in ['UINT64', 'UINT32', 'UINT16', 'UINT8']:
 898             try:
 899                 if Value.upper().startswith('0X'):
 900                     ValueNumber = int (Value, 16)
 901                 else:
 902                     ValueNumber = int (Value)
 903             except:
 904                 EdkLogger.error("build", AUTOGEN_ERROR,
 905                                 "PCD value is not valid dec or hex number for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 906                                 ExtraData="[%s]" % str(Info))
 907             if Pcd.DatumType == 'UINT64':
 908                 if ValueNumber < 0:
 909                     EdkLogger.error("build", AUTOGEN_ERROR,
 910                                     "PCD can't be set to negative value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 911                                     ExtraData="[%s]" % str(Info))
 912                 elif ValueNumber >= 0x10000000000000000:
 913                     EdkLogger.error("build", AUTOGEN_ERROR,
 914                                     "Too large PCD value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 915                                     ExtraData="[%s]" % str(Info))
 916                 if not Value.endswith('ULL'):
 917                     Value += 'ULL'
 918             elif Pcd.DatumType == 'UINT32':
 919                 if ValueNumber < 0:
 920                     EdkLogger.error("build", AUTOGEN_ERROR,
 921                                     "PCD can't be set to negative value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 922                                     ExtraData="[%s]" % str(Info))
 923                 elif ValueNumber >= 0x100000000:
 924                     EdkLogger.error("build", AUTOGEN_ERROR,
 925                                     "Too large PCD value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 926                                     ExtraData="[%s]" % str(Info))
 927                 if not Value.endswith('U'):
 928                     Value += 'U'
 929             elif Pcd.DatumType == 'UINT16':
 930                 if ValueNumber < 0:
 931                     EdkLogger.error("build", AUTOGEN_ERROR,
 932                                     "PCD can't be set to negative value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 933                                     ExtraData="[%s]" % str(Info))
 934                 elif ValueNumber >= 0x10000:
 935                     EdkLogger.error("build", AUTOGEN_ERROR,
 936                                     "Too large PCD value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 937                                     ExtraData="[%s]" % str(Info))
 938                 if not Value.endswith('U'):
 939                     Value += 'U'
 940             elif Pcd.DatumType == 'UINT8':
 941                 if ValueNumber < 0:
 942                     EdkLogger.error("build", AUTOGEN_ERROR,
 943                                     "PCD can't be set to negative value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 944                                     ExtraData="[%s]" % str(Info))
 945                 elif ValueNumber >= 0x100:
 946                     EdkLogger.error("build", AUTOGEN_ERROR,
 947                                     "Too large PCD value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 948                                     ExtraData="[%s]" % str(Info))
 949                 if not Value.endswith('U'):
 950                     Value += 'U'
 951         if Pcd.DatumType == 'VOID*':
 952             if Pcd.MaxDatumSize == None or Pcd.MaxDatumSize == '':
 953                 EdkLogger.error("build", AUTOGEN_ERROR,
 954                                 "Unknown [MaxDatumSize] of PCD [%s.%s]" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 955                                 ExtraData="[%s]" % str(Info))
 956
 957             ArraySize = int(Pcd.MaxDatumSize, 0)
 958             if Value[0] == '{':
 959                 Type = '(VOID *)'
 960             else:
 961                 if Value[0] == 'L':
 962                     Unicode = True
 963                 Value = Value.lstrip('L')   #.strip('"')
 964                 Value = eval(Value)         # translate escape character
 965                 NewValue = '{'
 966                 for Index in range(0,len(Value)):
 967                     if Unicode:
 968                         NewValue = NewValue + str(ord(Value[Index]) % 0x10000) + ', '
 969                     else:
 970                         NewValue = NewValue + str(ord(Value[Index]) % 0x100) + ', '
 971                 if Unicode:
 972                     ArraySize = ArraySize / 2;
 973
 974                 if ArraySize < (len(Value) + 1):
 975                     EdkLogger.error("build", AUTOGEN_ERROR,
 976                                     "The maximum size of VOID* type PCD '%s.%s' is less than its actual size occupied." % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 977                                     ExtraData="[%s]" % str(Info))
 978                 Value = NewValue + '0 }'
 979             Array = '[%d]' % ArraySize
 980         #
 981         # skip casting for fixed at build since it breaks ARM assembly.
 982         # Long term we need PCD macros that work in assembly
 983         #
 984         elif Pcd.Type != TAB_PCDS_FIXED_AT_BUILD:
 985             Value = "((%s)%s)" % (Pcd.DatumType, Value)
 986
 987         if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
 988             PcdValueName = '_PCD_PATCHABLE_VALUE_' + Pcd.TokenCName
 989         else:
 990             PcdValueName = '_PCD_VALUE_' + Pcd.TokenCName
 991
 992         if Pcd.DatumType == 'VOID*':
 993             #
 994             # For unicode, UINT16 array will be generated, so the alignment of unicode is guaranteed.
 995             #
 996             if Unicode:
 997                 AutoGenH.Append('#define %s  %s%s\n' %(PcdValueName, Type, PcdVariableName))
 998                 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s UINT16 %s%s = %s;\n' % (Const, PcdVariableName, Array, Value))
 999                 AutoGenH.Append('extern %s UINT16 %s%s;\n' %(Const, PcdVariableName, Array))
1000                 AutoGenH.Append('#define %s  %s%s\n' %(GetModeName, Type, PcdVariableName))
1001             else:
1002                 AutoGenH.Append('#define %s  %s%s\n' %(PcdValueName, Type, PcdVariableName))
1003                 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s UINT8 %s%s = %s;\n' % (Const, PcdVariableName, Array, Value))
1004                 AutoGenH.Append('extern %s UINT8 %s%s;\n' %(Const, PcdVariableName, Array))
1005                 AutoGenH.Append('#define %s  %s%s\n' %(GetModeName, Type, PcdVariableName))
1006
1007             PcdDataSize = GetPcdSize(Pcd)
1008             if Pcd.Type == TAB_PCDS_FIXED_AT_BUILD:
1009                 AutoGenH.Append('#define %s %s\n' % (FixPcdSizeTokenName, PcdDataSize))
1010                 AutoGenH.Append('#define %s  %s \n' % (GetModeSizeName,FixPcdSizeTokenName))
1011
1012             if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
1013                 AutoGenH.Append('#define %s %s\n' % (PatchPcdSizeTokenName, Pcd.MaxDatumSize))
1014                 AutoGenH.Append('#define %s  %s \n' % (GetModeSizeName,PatchPcdSizeVariableName))
1015                 AutoGenH.Append('extern UINTN %s; \n' % PatchPcdSizeVariableName)
1016                 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED UINTN %s = %s;\n' % (PatchPcdSizeVariableName,PcdDataSize))
1017         elif Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
1018             AutoGenH.Append('#define %s  %s\n' %(PcdValueName, Value))
1019             AutoGenC.Append('volatile %s %s %s = %s;\n' %(Const, Pcd.DatumType, PcdVariableName, PcdValueName))
1020             AutoGenH.Append('extern volatile %s  %s  %s%s;\n' % (Const, Pcd.DatumType, PcdVariableName, Array))
1021             AutoGenH.Append('#define %s  %s%s\n' % (GetModeName, Type, PcdVariableName))
1022
1023             PcdDataSize = GetPcdSize(Pcd)
1024             AutoGenH.Append('#define %s %s\n' % (PatchPcdSizeTokenName, PcdDataSize))
1025
1026             AutoGenH.Append('#define %s  %s \n' % (GetModeSizeName,PatchPcdSizeVariableName))
1027             AutoGenH.Append('extern UINTN %s; \n' % PatchPcdSizeVariableName)
1028             AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED UINTN %s = %s;\n' % (PatchPcdSizeVariableName,PcdDataSize))
1029         else:
1030             PcdDataSize = GetPcdSize(Pcd)
1031             AutoGenH.Append('#define %s %s\n' % (FixPcdSizeTokenName, PcdDataSize))
1032             AutoGenH.Append('#define %s  %s \n' % (GetModeSizeName,FixPcdSizeTokenName))
1033
1034             AutoGenH.Append('#define %s  %s\n' %(PcdValueName, Value))
1035             AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s %s = %s;\n' %(Const, Pcd.DatumType, PcdVariableName, PcdValueName))
1036             AutoGenH.Append('extern %s  %s  %s%s;\n' % (Const, Pcd.DatumType, PcdVariableName, Array))
1037             AutoGenH.Append('#define %s  %s%s\n' % (GetModeName, Type, PcdVariableName))
1038
1039         if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
1040             if Pcd.DatumType == 'VOID*':
1041                 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))
1042                 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))
1043             else:
1044                 AutoGenH.Append('#define %s(Value)  (%s = (Value))\n' % (SetModeName, PcdVariableName))
1045                 AutoGenH.Append('#define %s(Value)  ((%s = (Value)), RETURN_SUCCESS) \n' % (SetModeStatusName, PcdVariableName))
1046         else:
1047             AutoGenH.Append('//#define %s  ASSERT(FALSE)  // It is not allowed to set value for a FIXED_AT_BUILD PCD\n' % SetModeName)
1048
1049 ## Create code for library module PCDs
1050 #
1051 #   @param      Info        The ModuleAutoGen object
1052 #   @param      AutoGenC    The TemplateString object for C code
1053 #   @param      AutoGenH    The TemplateString object for header file
1054 #   @param      Pcd         The PCD object
1055 #
1056 def CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd):
1057     PcdTokenNumber = Info.PlatformInfo.PcdTokenNumber
1058     TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName
1059     TokenCName  = Pcd.TokenCName
1060     PcdTokenName = '_PCD_TOKEN_' + TokenCName
1061     FixPcdSizeTokenName = '_PCD_SIZE_' + Pcd.TokenCName
1062     PatchPcdSizeTokenName = '_PCD_PATCHABLE_' + Pcd.TokenCName +'_SIZE'
1063     PatchPcdSizeVariableName = '_gPcd_BinaryPatch_Size_' + Pcd.TokenCName
1064
1065     if GlobalData.BuildOptionPcd:
1066         for PcdItem in GlobalData.BuildOptionPcd:
1067             if (Pcd.TokenSpaceGuidCName, Pcd.TokenCName) == (PcdItem[0], PcdItem[1]):
1068                 Pcd.DefaultValue = PcdItem[2]
1069                 break
1070
1071     #
1072     # Write PCDs
1073     #
1074     if Pcd.Type in gDynamicExPcd:
1075         TokenNumber = int(Pcd.TokenValue, 0)
1076     else:
1077         if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in PcdTokenNumber:
1078             # If one of the Source built modules listed in the DSC is not listed in FDF modules,
1079             # and the INF lists a PCD can only use the PcdsDynamic access method (it is only
1080             # listed in the DEC file that declares the PCD as PcdsDynamic), then build tool will
1081             # report warning message notify the PI that they are attempting to build a module
1082             # that must be included in a flash image in order to be functional. These Dynamic PCD
1083             # will not be added into the Database unless it is used by other modules that are
1084             # included in the FDF file.
1085             # In this case, just assign an invalid token number to make it pass build.
1086             if Pcd.Type in PCD_DYNAMIC_TYPE_LIST:
1087                 TokenNumber = 0
1088             else:
1089                 EdkLogger.error("build", AUTOGEN_ERROR,
1090                                 "No generated token number for %s.%s\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
1091                                 ExtraData="[%s]" % str(Info))
1092         else:
1093             TokenNumber = PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName]
1094
1095     if Pcd.Type not in gItemTypeStringDatabase:
1096         EdkLogger.error("build", AUTOGEN_ERROR,
1097                         "Unknown PCD type [%s] of PCD %s.%s" % (Pcd.Type, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
1098                         ExtraData="[%s]" % str(Info))
1099     if Pcd.DatumType not in gDatumSizeStringDatabase:
1100         EdkLogger.error("build", AUTOGEN_ERROR,
1101                         "Unknown datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
1102                         ExtraData="[%s]" % str(Info))
1103
1104     DatumType   = Pcd.DatumType
1105     DatumSize   = gDatumSizeStringDatabaseH[DatumType]
1106     DatumSizeLib= gDatumSizeStringDatabaseLib[DatumType]
1107     GetModeName = '_PCD_GET_MODE_' + DatumSize + '_' + TokenCName
1108     SetModeName = '_PCD_SET_MODE_' + DatumSize + '_' + TokenCName
1109     SetModeStatusName = '_PCD_SET_MODE_' + DatumSize + '_S_' + TokenCName
1110     GetModeSizeName = '_PCD_GET_MODE_SIZE' + '_' + Pcd.TokenCName
1111
1112     Type = ''
1113     Array = ''
1114     if Pcd.DatumType == 'VOID*':
1115         if Pcd.DefaultValue[0]== '{':
1116             Type = '(VOID *)'
1117         Array = '[]'
1118     PcdItemType = Pcd.Type
1119     PcdExCNameList  = []
1120     if PcdItemType in gDynamicExPcd:
1121         PcdExTokenName = '_PCD_TOKEN_' + TokenSpaceGuidCName + '_' + Pcd.TokenCName
1122         AutoGenH.Append('\n#define %s  %dU\n' % (PcdExTokenName, TokenNumber))
1123
1124         if Info.IsLibrary:
1125             PcdList = Info.LibraryPcdList
1126         else:
1127             PcdList = Info.ModulePcdList
1128         for PcdModule in PcdList:
1129             if PcdModule.Type in gDynamicExPcd:
1130                 PcdExCNameList.append(PcdModule.TokenCName)
1131         # Be compatible with the current code which using PcdGet/Set for DynamicEx Pcd.
1132         # If only PcdGet/Set used in all Pcds with different CName, it should succeed to build.
1133         # If PcdGet/Set used in the Pcds with different Guids but same CName, it should failed to build.
1134         if PcdExCNameList.count(Pcd.TokenCName) > 1:
1135             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')
1136             AutoGenH.Append('// #define %s  %s\n' % (PcdTokenName, PcdExTokenName))
1137             AutoGenH.Append('// #define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1138             AutoGenH.Append('// #define %s  LibPcdGetExSize(&%s, %s \n' % (GetModeSizeName,Pcd.TokenSpaceGuidCName, PcdTokenName))
1139             if Pcd.DatumType == 'VOID*':
1140                 AutoGenH.Append('// #define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1141                 AutoGenH.Append('// #define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%sS(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1142             else:
1143                 AutoGenH.Append('// #define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1144                 AutoGenH.Append('// #define %s(Value)  LibPcdSetEx%sS(&%s, %s, (Value))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1145         else:
1146             AutoGenH.Append('#define %s  %s\n' % (PcdTokenName, PcdExTokenName))
1147             AutoGenH.Append('#define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1148             AutoGenH.Append('#define %s LibPcdGetExSize(&%s, %s)\n' % (GetModeSizeName,Pcd.TokenSpaceGuidCName, PcdTokenName))
1149             if Pcd.DatumType == 'VOID*':
1150                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1151                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%sS(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1152             else:
1153                 AutoGenH.Append('#define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1154                 AutoGenH.Append('#define %s(Value)  LibPcdSetEx%sS(&%s, %s, (Value))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1155     else:
1156         AutoGenH.Append('#define _PCD_TOKEN_%s  %dU\n' % (TokenCName, TokenNumber))
1157     if PcdItemType in gDynamicPcd:
1158         PcdList = []
1159         PcdCNameList = []
1160         PcdList.extend(Info.LibraryPcdList)
1161         PcdList.extend(Info.ModulePcdList)
1162         for PcdModule in PcdList:
1163             if PcdModule.Type in gDynamicPcd:
1164                 PcdCNameList.append(PcdModule.TokenCName)
1165         if PcdCNameList.count(Pcd.TokenCName) > 1:
1166             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))
1167         else:
1168             AutoGenH.Append('#define %s  LibPcdGet%s(%s)\n' % (GetModeName, DatumSizeLib, PcdTokenName))
1169             AutoGenH.Append('#define %s  LibPcdGetSize(%s)\n' % (GetModeSizeName, PcdTokenName))
1170             if DatumType == 'VOID*':
1171                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSet%s(%s, (SizeOfBuffer), (Buffer))\n' %(SetModeName, DatumSizeLib, PcdTokenName))
1172                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSet%sS(%s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, DatumSizeLib, PcdTokenName))
1173             else:
1174                 AutoGenH.Append('#define %s(Value)  LibPcdSet%s(%s, (Value))\n' % (SetModeName, DatumSizeLib, PcdTokenName))
1175                 AutoGenH.Append('#define %s(Value)  LibPcdSet%sS(%s, (Value))\n' % (SetModeStatusName, DatumSizeLib, PcdTokenName))
1176     if PcdItemType == TAB_PCDS_PATCHABLE_IN_MODULE:
1177         PcdVariableName = '_gPcd_' + gItemTypeStringDatabase[TAB_PCDS_PATCHABLE_IN_MODULE] + '_' + TokenCName
1178         if DatumType == 'VOID*':
1179             ArraySize = int(Pcd.MaxDatumSize, 0)
1180             if Pcd.DefaultValue[0] == 'L':
1181                 ArraySize = ArraySize / 2
1182             Array = '[%d]' % ArraySize
1183             DatumType = ['UINT8', 'UINT16'][Pcd.DefaultValue[0] == 'L']
1184             AutoGenH.Append('extern %s _gPcd_BinaryPatch_%s%s;\n' %(DatumType, TokenCName, Array))
1185         else:
1186             AutoGenH.Append('extern volatile  %s  %s%s;\n' % (DatumType, PcdVariableName, Array))
1187         AutoGenH.Append('#define %s  %s_gPcd_BinaryPatch_%s\n' %(GetModeName, Type, TokenCName))
1188         if Pcd.DatumType == 'VOID*':
1189             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))
1190             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))
1191         else:
1192             AutoGenH.Append('#define %s(Value)  (%s = (Value))\n' % (SetModeName, PcdVariableName))
1193             AutoGenH.Append('#define %s(Value)  ((%s = (Value)), RETURN_SUCCESS)\n' % (SetModeStatusName, PcdVariableName))
1194
1195         PcdDataSize = GetPcdSize(Pcd)
1196         AutoGenH.Append('#define %s %s\n' % (PatchPcdSizeTokenName, PcdDataSize))
1197         AutoGenH.Append('#define %s %s\n' % (GetModeSizeName,PatchPcdSizeVariableName))
1198         AutoGenH.Append('extern UINTN %s; \n' % PatchPcdSizeVariableName)
1199
1200     if PcdItemType == TAB_PCDS_FIXED_AT_BUILD or PcdItemType == TAB_PCDS_FEATURE_FLAG:
1201         key = ".".join((Pcd.TokenSpaceGuidCName,Pcd.TokenCName))
1202
1203         if DatumType == 'VOID*' and Array == '[]':
1204             DatumType = ['UINT8', 'UINT16'][Pcd.DefaultValue[0] == 'L']
1205         AutoGenH.Append('extern const %s _gPcd_FixedAtBuild_%s%s;\n' %(DatumType, TokenCName, Array))
1206         AutoGenH.Append('#define %s  %s_gPcd_FixedAtBuild_%s\n' %(GetModeName, Type, TokenCName))
1207         AutoGenH.Append('//#define %s  ASSERT(FALSE)  // It is not allowed to set value for a FIXED_AT_BUILD PCD\n' % SetModeName)
1208
1209         if PcdItemType == TAB_PCDS_FIXED_AT_BUILD and key in Info.ConstPcd:
1210             AutoGenH.Append('#define _PCD_VALUE_%s %s\n' %(TokenCName, Pcd.DefaultValue))
1211
1212         if PcdItemType == TAB_PCDS_FIXED_AT_BUILD:
1213             PcdDataSize = GetPcdSize(Pcd)
1214             AutoGenH.Append('#define %s %s\n' % (FixPcdSizeTokenName, PcdDataSize))
1215             AutoGenH.Append('#define %s %s\n' % (GetModeSizeName,FixPcdSizeTokenName))
1216
1217 ## Create code for library constructor
1218 #
1219 #   @param      Info        The ModuleAutoGen object
1220 #   @param      AutoGenC    The TemplateString object for C code
1221 #   @param      AutoGenH    The TemplateString object for header file
1222 #
1223 def CreateLibraryConstructorCode(Info, AutoGenC, AutoGenH):
1224     #
1225     # Library Constructors
1226     #
1227     ConstructorPrototypeString = TemplateString()
1228     ConstructorCallingString = TemplateString()
1229     if Info.IsLibrary:
1230         DependentLibraryList = [Info.Module]
1231     else:
1232         DependentLibraryList = Info.DependentLibraryList
1233     for Lib in DependentLibraryList:
1234         if len(Lib.ConstructorList) <= 0:
1235             continue
1236         Dict = {'Function':Lib.ConstructorList}
1237         if Lib.ModuleType in ['BASE', 'SEC']:
1238             ConstructorPrototypeString.Append(gLibraryStructorPrototype['BASE'].Replace(Dict))
1239             ConstructorCallingString.Append(gLibraryStructorCall['BASE'].Replace(Dict))
1240         elif Lib.ModuleType in ['PEI_CORE','PEIM']:
1241             ConstructorPrototypeString.Append(gLibraryStructorPrototype['PEI'].Replace(Dict))
1242             ConstructorCallingString.Append(gLibraryStructorCall['PEI'].Replace(Dict))
1243         elif Lib.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER',
1244                                 'DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION','SMM_CORE']:
1245             ConstructorPrototypeString.Append(gLibraryStructorPrototype['DXE'].Replace(Dict))
1246             ConstructorCallingString.Append(gLibraryStructorCall['DXE'].Replace(Dict))
1247
1248     if str(ConstructorPrototypeString) == '':
1249         ConstructorPrototypeList = []
1250     else:
1251         ConstructorPrototypeList = [str(ConstructorPrototypeString)]
1252     if str(ConstructorCallingString) == '':
1253         ConstructorCallingList = []
1254     else:
1255         ConstructorCallingList = [str(ConstructorCallingString)]
1256
1257     Dict = {
1258         'Type'              :   'Constructor',
1259         'FunctionPrototype' :   ConstructorPrototypeList,
1260         'FunctionCall'      :   ConstructorCallingList
1261     }
1262     if Info.IsLibrary:
1263         AutoGenH.Append("${BEGIN}${FunctionPrototype}${END}", Dict)
1264     else:
1265         if Info.ModuleType in ['BASE', 'SEC']:
1266             AutoGenC.Append(gLibraryString['BASE'].Replace(Dict))
1267         elif Info.ModuleType in ['PEI_CORE','PEIM']:
1268             AutoGenC.Append(gLibraryString['PEI'].Replace(Dict))
1269         elif Info.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER',
1270                                  'DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION','SMM_CORE']:
1271             AutoGenC.Append(gLibraryString['DXE'].Replace(Dict))
1272
1273 ## Create code for library destructor
1274 #
1275 #   @param      Info        The ModuleAutoGen object
1276 #   @param      AutoGenC    The TemplateString object for C code
1277 #   @param      AutoGenH    The TemplateString object for header file
1278 #
1279 def CreateLibraryDestructorCode(Info, AutoGenC, AutoGenH):
1280     #
1281     # Library Destructors
1282     #
1283     DestructorPrototypeString = TemplateString()
1284     DestructorCallingString = TemplateString()
1285     if Info.IsLibrary:
1286         DependentLibraryList = [Info.Module]
1287     else:
1288         DependentLibraryList = Info.DependentLibraryList
1289     for Index in range(len(DependentLibraryList)-1, -1, -1):
1290         Lib = DependentLibraryList[Index]
1291         if len(Lib.DestructorList) <= 0:
1292             continue
1293         Dict = {'Function':Lib.DestructorList}
1294         if Lib.ModuleType in ['BASE', 'SEC']:
1295             DestructorPrototypeString.Append(gLibraryStructorPrototype['BASE'].Replace(Dict))
1296             DestructorCallingString.Append(gLibraryStructorCall['BASE'].Replace(Dict))
1297         elif Lib.ModuleType in ['PEI_CORE','PEIM']:
1298             DestructorPrototypeString.Append(gLibraryStructorPrototype['PEI'].Replace(Dict))
1299             DestructorCallingString.Append(gLibraryStructorCall['PEI'].Replace(Dict))
1300         elif Lib.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER',
1301                                 'DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION', 'SMM_CORE']:
1302             DestructorPrototypeString.Append(gLibraryStructorPrototype['DXE'].Replace(Dict))
1303             DestructorCallingString.Append(gLibraryStructorCall['DXE'].Replace(Dict))
1304
1305     if str(DestructorPrototypeString) == '':
1306         DestructorPrototypeList = []
1307     else:
1308         DestructorPrototypeList = [str(DestructorPrototypeString)]
1309     if str(DestructorCallingString) == '':
1310         DestructorCallingList = []
1311     else:
1312         DestructorCallingList = [str(DestructorCallingString)]
1313
1314     Dict = {
1315         'Type'              :   'Destructor',
1316         'FunctionPrototype' :   DestructorPrototypeList,
1317         'FunctionCall'      :   DestructorCallingList
1318     }
1319     if Info.IsLibrary:
1320         AutoGenH.Append("${BEGIN}${FunctionPrototype}${END}", Dict)
1321     else:
1322         if Info.ModuleType in ['BASE', 'SEC']:
1323             AutoGenC.Append(gLibraryString['BASE'].Replace(Dict))
1324         elif Info.ModuleType in ['PEI_CORE','PEIM']:
1325             AutoGenC.Append(gLibraryString['PEI'].Replace(Dict))
1326         elif Info.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER',
1327                                  'DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION','SMM_CORE']:
1328             AutoGenC.Append(gLibraryString['DXE'].Replace(Dict))
1329
1330
1331 ## Create code for ModuleEntryPoint
1332 #
1333 #   @param      Info        The ModuleAutoGen object
1334 #   @param      AutoGenC    The TemplateString object for C code
1335 #   @param      AutoGenH    The TemplateString object for header file
1336 #
1337 def CreateModuleEntryPointCode(Info, AutoGenC, AutoGenH):
1338     if Info.IsLibrary or Info.ModuleType in ['USER_DEFINED', 'SEC']:
1339         return
1340     #
1341     # Module Entry Points
1342     #
1343     NumEntryPoints = len(Info.Module.ModuleEntryPointList)
1344     if 'PI_SPECIFICATION_VERSION' in Info.Module.Specification:
1345         PiSpecVersion = Info.Module.Specification['PI_SPECIFICATION_VERSION']
1346     else:
1347         PiSpecVersion = '0x00000000'
1348     if 'UEFI_SPECIFICATION_VERSION' in Info.Module.Specification:
1349         UefiSpecVersion = Info.Module.Specification['UEFI_SPECIFICATION_VERSION']
1350     else:
1351         UefiSpecVersion = '0x00000000'
1352     Dict = {
1353         'Function'       :   Info.Module.ModuleEntryPointList,
1354         'PiSpecVersion'  :   PiSpecVersion + 'U',
1355         'UefiSpecVersion':   UefiSpecVersion + 'U'
1356     }
1357
1358     if Info.ModuleType in ['PEI_CORE', 'DXE_CORE', 'SMM_CORE']:
1359         if Info.SourceFileList <> None and Info.SourceFileList <> []:
1360           if NumEntryPoints != 1:
1361               EdkLogger.error(
1362                   "build",
1363                   AUTOGEN_ERROR,
1364                   '%s must have exactly one entry point' % Info.ModuleType,
1365                   File=str(Info),
1366                   ExtraData= ", ".join(Info.Module.ModuleEntryPointList)
1367                   )
1368     if Info.ModuleType == 'PEI_CORE':
1369         AutoGenC.Append(gPeiCoreEntryPointString.Replace(Dict))
1370         AutoGenH.Append(gPeiCoreEntryPointPrototype.Replace(Dict))
1371     elif Info.ModuleType == 'DXE_CORE':
1372         AutoGenC.Append(gDxeCoreEntryPointString.Replace(Dict))
1373         AutoGenH.Append(gDxeCoreEntryPointPrototype.Replace(Dict))
1374     elif Info.ModuleType == 'SMM_CORE':
1375         AutoGenC.Append(gSmmCoreEntryPointString.Replace(Dict))
1376         AutoGenH.Append(gSmmCoreEntryPointPrototype.Replace(Dict))
1377     elif Info.ModuleType == 'PEIM':
1378         if NumEntryPoints < 2:
1379             AutoGenC.Append(gPeimEntryPointString[NumEntryPoints].Replace(Dict))
1380         else:
1381             AutoGenC.Append(gPeimEntryPointString[2].Replace(Dict))
1382         AutoGenH.Append(gPeimEntryPointPrototype.Replace(Dict))
1383     elif Info.ModuleType in ['DXE_RUNTIME_DRIVER','DXE_DRIVER','DXE_SAL_DRIVER','UEFI_DRIVER']:
1384         if NumEntryPoints < 2:
1385             AutoGenC.Append(gUefiDriverEntryPointString[NumEntryPoints].Replace(Dict))
1386         else:
1387             AutoGenC.Append(gUefiDriverEntryPointString[2].Replace(Dict))
1388         AutoGenH.Append(gUefiDriverEntryPointPrototype.Replace(Dict))
1389     elif Info.ModuleType == 'DXE_SMM_DRIVER':
1390         if NumEntryPoints == 0:
1391             AutoGenC.Append(gDxeSmmEntryPointString[0].Replace(Dict))
1392         else:
1393             AutoGenC.Append(gDxeSmmEntryPointString[1].Replace(Dict))
1394         AutoGenH.Append(gDxeSmmEntryPointPrototype.Replace(Dict))
1395     elif Info.ModuleType == 'UEFI_APPLICATION':
1396         if NumEntryPoints < 2:
1397             AutoGenC.Append(gUefiApplicationEntryPointString[NumEntryPoints].Replace(Dict))
1398         else:
1399             AutoGenC.Append(gUefiApplicationEntryPointString[2].Replace(Dict))
1400         AutoGenH.Append(gUefiApplicationEntryPointPrototype.Replace(Dict))
1401
1402 ## Create code for ModuleUnloadImage
1403 #
1404 #   @param      Info        The ModuleAutoGen object
1405 #   @param      AutoGenC    The TemplateString object for C code
1406 #   @param      AutoGenH    The TemplateString object for header file
1407 #
1408 def CreateModuleUnloadImageCode(Info, AutoGenC, AutoGenH):
1409     if Info.IsLibrary or Info.ModuleType in ['USER_DEFINED', 'SEC']:
1410         return
1411     #
1412     # Unload Image Handlers
1413     #
1414     NumUnloadImage = len(Info.Module.ModuleUnloadImageList)
1415     Dict = {'Count':str(NumUnloadImage) + 'U', 'Function':Info.Module.ModuleUnloadImageList}
1416     if NumUnloadImage < 2:
1417         AutoGenC.Append(gUefiUnloadImageString[NumUnloadImage].Replace(Dict))
1418     else:
1419         AutoGenC.Append(gUefiUnloadImageString[2].Replace(Dict))
1420     AutoGenH.Append(gUefiUnloadImagePrototype.Replace(Dict))
1421
1422 ## Create code for GUID
1423 #
1424 #   @param      Info        The ModuleAutoGen object
1425 #   @param      AutoGenC    The TemplateString object for C code
1426 #   @param      AutoGenH    The TemplateString object for header file
1427 #
1428 def CreateGuidDefinitionCode(Info, AutoGenC, AutoGenH):
1429     if Info.ModuleType in ["USER_DEFINED", "BASE"]:
1430         GuidType = "GUID"
1431     else:
1432         GuidType = "EFI_GUID"
1433
1434     if Info.GuidList:
1435         if not Info.IsLibrary:
1436             AutoGenC.Append("\n// Guids\n")
1437         AutoGenH.Append("\n// Guids\n")
1438     #
1439     # GUIDs
1440     #
1441     for Key in Info.GuidList:
1442         if not Info.IsLibrary:
1443             AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.GuidList[Key]))
1444         AutoGenH.Append('extern %s %s;\n' % (GuidType, Key))
1445
1446 ## Create code for protocol
1447 #
1448 #   @param      Info        The ModuleAutoGen object
1449 #   @param      AutoGenC    The TemplateString object for C code
1450 #   @param      AutoGenH    The TemplateString object for header file
1451 #
1452 def CreateProtocolDefinitionCode(Info, AutoGenC, AutoGenH):
1453     if Info.ModuleType in ["USER_DEFINED", "BASE"]:
1454         GuidType = "GUID"
1455     else:
1456         GuidType = "EFI_GUID"
1457
1458     if Info.ProtocolList:
1459         if not Info.IsLibrary:
1460             AutoGenC.Append("\n// Protocols\n")
1461         AutoGenH.Append("\n// Protocols\n")
1462     #
1463     # Protocol GUIDs
1464     #
1465     for Key in Info.ProtocolList:
1466         if not Info.IsLibrary:
1467             AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.ProtocolList[Key]))
1468         AutoGenH.Append('extern %s %s;\n' % (GuidType, Key))
1469
1470 ## Create code for PPI
1471 #
1472 #   @param      Info        The ModuleAutoGen object
1473 #   @param      AutoGenC    The TemplateString object for C code
1474 #   @param      AutoGenH    The TemplateString object for header file
1475 #
1476 def CreatePpiDefinitionCode(Info, AutoGenC, AutoGenH):
1477     if Info.ModuleType in ["USER_DEFINED", "BASE"]:
1478         GuidType = "GUID"
1479     else:
1480         GuidType = "EFI_GUID"
1481
1482     if Info.PpiList:
1483         if not Info.IsLibrary:
1484             AutoGenC.Append("\n// PPIs\n")
1485         AutoGenH.Append("\n// PPIs\n")
1486     #
1487     # PPI GUIDs
1488     #
1489     for Key in Info.PpiList:
1490         if not Info.IsLibrary:
1491             AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.PpiList[Key]))
1492         AutoGenH.Append('extern %s %s;\n' % (GuidType, Key))
1493
1494 ## Create code for PCD
1495 #
1496 #   @param      Info        The ModuleAutoGen object
1497 #   @param      AutoGenC    The TemplateString object for C code
1498 #   @param      AutoGenH    The TemplateString object for header file
1499 #
1500 def CreatePcdCode(Info, AutoGenC, AutoGenH):
1501
1502     # Collect Token Space GUIDs used by DynamicEc PCDs
1503     TokenSpaceList = []
1504     for Pcd in Info.ModulePcdList:
1505         if Pcd.Type in gDynamicExPcd and Pcd.TokenSpaceGuidCName not in TokenSpaceList:
1506             TokenSpaceList += [Pcd.TokenSpaceGuidCName]
1507
1508     # Add extern declarations to AutoGen.h if one or more Token Space GUIDs were found
1509     if TokenSpaceList <> []:
1510         AutoGenH.Append("\n// Definition of PCD Token Space GUIDs used in this module\n\n")
1511         if Info.ModuleType in ["USER_DEFINED", "BASE"]:
1512             GuidType = "GUID"
1513         else:
1514             GuidType = "EFI_GUID"
1515         for Item in TokenSpaceList:
1516             AutoGenH.Append('extern %s %s;\n' % (GuidType, Item))
1517
1518     if Info.IsLibrary:
1519         if Info.ModulePcdList:
1520             AutoGenH.Append("\n// PCD definitions\n")
1521         for Pcd in Info.ModulePcdList:
1522             CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd)
1523         DynExPcdTokenNumberMapping (Info, AutoGenH)
1524     else:
1525         if Info.ModulePcdList:
1526             AutoGenH.Append("\n// Definition of PCDs used in this module\n")
1527             AutoGenC.Append("\n// Definition of PCDs used in this module\n")
1528         for Pcd in Info.ModulePcdList:
1529             CreateModulePcdCode(Info, AutoGenC, AutoGenH, Pcd)
1530         DynExPcdTokenNumberMapping (Info, AutoGenH)
1531         if Info.LibraryPcdList:
1532             AutoGenH.Append("\n// Definition of PCDs used in libraries is in AutoGen.c\n")
1533             AutoGenC.Append("\n// Definition of PCDs used in libraries\n")
1534         for Pcd in Info.LibraryPcdList:
1535             CreateModulePcdCode(Info, AutoGenC, AutoGenC, Pcd)
1536     CreatePcdDatabaseCode(Info, AutoGenC, AutoGenH)
1537
1538 ## Create code for unicode string definition
1539 #
1540 #   @param      Info        The ModuleAutoGen object
1541 #   @param      AutoGenC    The TemplateString object for C code
1542 #   @param      AutoGenH    The TemplateString object for header file
1543 #   @param      UniGenCFlag     UniString is generated into AutoGen C file when it is set to True
1544 #   @param      UniGenBinBuffer Buffer to store uni string package data
1545 #
1546 def CreateUnicodeStringCode(Info, AutoGenC, AutoGenH, UniGenCFlag, UniGenBinBuffer):
1547     WorkingDir = os.getcwd()
1548     os.chdir(Info.WorkspaceDir)
1549
1550     IncList = [Info.MetaFile.Dir]
1551     # Get all files under [Sources] section in inf file for EDK-II module
1552     EDK2Module = True
1553     SrcList = [F for F in Info.SourceFileList]
1554     if Info.AutoGenVersion < 0x00010005:
1555         EDK2Module = False
1556         # Get all files under the module directory for EDK-I module
1557         Cwd = os.getcwd()
1558         os.chdir(Info.MetaFile.Dir)
1559         for Root, Dirs, Files in os.walk("."):
1560             if 'CVS' in Dirs:
1561                 Dirs.remove('CVS')
1562             if '.svn' in Dirs:
1563                 Dirs.remove('.svn')
1564             for File in Files:
1565                 File = PathClass(os.path.join(Root, File), Info.MetaFile.Dir)
1566                 if File in SrcList:
1567                     continue
1568                 SrcList.append(File)
1569         os.chdir(Cwd)
1570
1571     if 'BUILD' in Info.BuildOption and Info.BuildOption['BUILD']['FLAGS'].find('-c') > -1:
1572         CompatibleMode = True
1573     else:
1574         CompatibleMode = False
1575
1576     #
1577     # -s is a temporary option dedicated for building .UNI files with ISO 639-2 language codes of EDK Shell in EDK2
1578     #
1579     if 'BUILD' in Info.BuildOption and Info.BuildOption['BUILD']['FLAGS'].find('-s') > -1:
1580         if CompatibleMode:
1581             EdkLogger.error("build", AUTOGEN_ERROR,
1582                             "-c and -s build options should be used exclusively",
1583                             ExtraData="[%s]" % str(Info))
1584         ShellMode = True
1585     else:
1586         ShellMode = False
1587
1588     #RFC4646 is only for EDKII modules and ISO639-2 for EDK modules
1589     if EDK2Module:
1590         FilterInfo = [EDK2Module] + [Info.PlatformInfo.Platform.RFCLanguages]
1591     else:
1592         FilterInfo = [EDK2Module] + [Info.PlatformInfo.Platform.ISOLanguages]
1593     Header, Code = GetStringFiles(Info.UnicodeFileList, SrcList, IncList, Info.IncludePathList, ['.uni', '.inf'], Info.Name, CompatibleMode, ShellMode, UniGenCFlag, UniGenBinBuffer, FilterInfo)
1594     if CompatibleMode or UniGenCFlag:
1595         AutoGenC.Append("\n//\n//Unicode String Pack Definition\n//\n")
1596         AutoGenC.Append(Code)
1597         AutoGenC.Append("\n")
1598     AutoGenH.Append("\n//\n//Unicode String ID\n//\n")
1599     AutoGenH.Append(Header)
1600     if CompatibleMode or UniGenCFlag:
1601         AutoGenH.Append("\n#define STRING_ARRAY_NAME %sStrings\n" % Info.Name)
1602     os.chdir(WorkingDir)
1603
1604 ## Create common code
1605 #
1606 #   @param      Info        The ModuleAutoGen object
1607 #   @param      AutoGenC    The TemplateString object for C code
1608 #   @param      AutoGenH    The TemplateString object for header file
1609 #
1610 def CreateHeaderCode(Info, AutoGenC, AutoGenH):
1611     # file header
1612     AutoGenH.Append(gAutoGenHeaderString.Replace({'FileName':'AutoGen.h'}))
1613     # header file Prologue
1614     AutoGenH.Append(gAutoGenHPrologueString.Replace({'File':'AUTOGENH','Guid':Info.Guid.replace('-','_')}))
1615     AutoGenH.Append(gAutoGenHCppPrologueString)
1616     if Info.AutoGenVersion >= 0x00010005:
1617         # header files includes
1618         AutoGenH.Append("#include <%s>\n" % gBasicHeaderFile)
1619         if Info.ModuleType in gModuleTypeHeaderFile \
1620            and gModuleTypeHeaderFile[Info.ModuleType][0] != gBasicHeaderFile:
1621             AutoGenH.Append("#include <%s>\n" % gModuleTypeHeaderFile[Info.ModuleType][0])
1622         #
1623         # if either PcdLib in [LibraryClasses] sections or there exist Pcd section, add PcdLib.h
1624         # As if modules only uses FixedPcd, then PcdLib is not needed in [LibraryClasses] section.
1625         #
1626         if 'PcdLib' in Info.Module.LibraryClasses or Info.Module.Pcds:
1627             AutoGenH.Append("#include <Library/PcdLib.h>\n")
1628
1629         AutoGenH.Append('\nextern GUID  gEfiCallerIdGuid;')
1630         AutoGenH.Append('\nextern CHAR8 *gEfiCallerBaseName;\n\n')
1631
1632         if Info.IsLibrary:
1633             return
1634
1635         AutoGenH.Append("#define EFI_CALLER_ID_GUID \\\n  %s\n" % GuidStringToGuidStructureString(Info.Guid))
1636
1637     if Info.IsLibrary:
1638         return
1639     # C file header
1640     AutoGenC.Append(gAutoGenHeaderString.Replace({'FileName':'AutoGen.c'}))
1641     if Info.AutoGenVersion >= 0x00010005:
1642         # C file header files includes
1643         if Info.ModuleType in gModuleTypeHeaderFile:
1644             for Inc in gModuleTypeHeaderFile[Info.ModuleType]:
1645                 AutoGenC.Append("#include <%s>\n" % Inc)
1646         else:
1647             AutoGenC.Append("#include <%s>\n" % gBasicHeaderFile)
1648
1649         #
1650         # Publish the CallerId Guid
1651         #
1652         AutoGenC.Append('\nGLOBAL_REMOVE_IF_UNREFERENCED GUID gEfiCallerIdGuid = %s;\n' % GuidStringToGuidStructureString(Info.Guid))
1653         AutoGenC.Append('\nGLOBAL_REMOVE_IF_UNREFERENCED CHAR8 *gEfiCallerBaseName = "%s";\n' % Info.Name)
1654
1655 ## Create common code for header file
1656 #
1657 #   @param      Info        The ModuleAutoGen object
1658 #   @param      AutoGenC    The TemplateString object for C code
1659 #   @param      AutoGenH    The TemplateString object for header file
1660 #
1661 def CreateFooterCode(Info, AutoGenC, AutoGenH):
1662     AutoGenH.Append(gAutoGenHEpilogueString)
1663
1664 ## Create code for a module
1665 #
1666 #   @param      Info        The ModuleAutoGen object
1667 #   @param      AutoGenC    The TemplateString object for C code
1668 #   @param      AutoGenH    The TemplateString object for header file
1669 #   @param      UniGenCFlag     UniString is generated into AutoGen C file when it is set to True
1670 #   @param      UniGenBinBuffer Buffer to store uni string package data
1671 #
1672 def CreateCode(Info, AutoGenC, AutoGenH, StringH, UniGenCFlag, UniGenBinBuffer):
1673     CreateHeaderCode(Info, AutoGenC, AutoGenH)
1674
1675     if Info.AutoGenVersion >= 0x00010005:
1676         CreateGuidDefinitionCode(Info, AutoGenC, AutoGenH)
1677         CreateProtocolDefinitionCode(Info, AutoGenC, AutoGenH)
1678         CreatePpiDefinitionCode(Info, AutoGenC, AutoGenH)
1679         CreatePcdCode(Info, AutoGenC, AutoGenH)
1680         CreateLibraryConstructorCode(Info, AutoGenC, AutoGenH)
1681         CreateLibraryDestructorCode(Info, AutoGenC, AutoGenH)
1682         CreateModuleEntryPointCode(Info, AutoGenC, AutoGenH)
1683         CreateModuleUnloadImageCode(Info, AutoGenC, AutoGenH)
1684
1685     if Info.UnicodeFileList:
1686         FileName = "%sStrDefs.h" % Info.Name
1687         StringH.Append(gAutoGenHeaderString.Replace({'FileName':FileName}))
1688         StringH.Append(gAutoGenHPrologueString.Replace({'File':'STRDEFS', 'Guid':Info.Guid.replace('-','_')}))
1689         CreateUnicodeStringCode(Info, AutoGenC, StringH, UniGenCFlag, UniGenBinBuffer)
1690
1691         GuidMacros = []
1692         for Guid in Info.Module.Guids:
1693             if Guid in Info.Module.GetGuidsUsedByPcd():
1694                 continue
1695             GuidMacros.append('#define %s %s' % (Guid, Info.Module.Guids[Guid]))
1696         for Guid, Value in Info.Module.Protocols.items() + Info.Module.Ppis.items():
1697             GuidMacros.append('#define %s %s' % (Guid, Value))
1698         if GuidMacros:
1699             StringH.Append('\n#ifdef VFRCOMPILE\n%s\n#endif\n' % '\n'.join(GuidMacros))
1700
1701         StringH.Append("\n#endif\n")
1702         AutoGenH.Append('#include "%s"\n' % FileName)
1703
1704     CreateFooterCode(Info, AutoGenC, AutoGenH)
1705
1706     # no generation of AutoGen.c for Edk modules without unicode file
1707     if Info.AutoGenVersion < 0x00010005 and len(Info.UnicodeFileList) == 0:
1708         AutoGenC.String = ''
1709
1710 ## Create the code file
1711 #
1712 #   @param      FilePath     The path of code file
1713 #   @param      Content      The content of code file
1714 #   @param      IsBinaryFile The flag indicating if the file is binary file or not
1715 #
1716 #   @retval     True        If file content is changed or file doesn't exist
1717 #   @retval     False       If the file exists and the content is not changed
1718 #
1719 def Generate(FilePath, Content, IsBinaryFile):
1720     return SaveFileOnChange(FilePath, Content, IsBinaryFile)
1721