]> git.proxmox.com Git - mirror_edk2.git/blob - BaseTools/Source/Python/AutoGen/GenC.py
projects / mirror_edk2.git / blob
? search:


0f1b3bb9a3e9633d8e824e851e76ed1b13b1d2aa
[mirror_edk2.git] / BaseTools / Source / Python / AutoGen / GenC.py
1 ## @file
2 # Routines for generating AutoGen.h and AutoGen.c
3 #
4 # Copyright (c) 2007 - 2018, 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 from __future__ import absolute_import
17 import string
18 import collections
19 import struct
20 from Common import EdkLogger
21 from Common import GlobalData
22 from Common.BuildToolError import *
23 from Common.DataType import *
24 from Common.Misc import *
25 from Common.StringUtils import StringToArray
26 from .StrGather import *
27 from .GenPcdDb import CreatePcdDatabaseCode
28 from .IdfClassObject import *
29
30 ## PCD type string
31 gItemTypeStringDatabase = {
32 TAB_PCDS_FEATURE_FLAG : TAB_PCDS_FIXED_AT_BUILD,
33 TAB_PCDS_FIXED_AT_BUILD : TAB_PCDS_FIXED_AT_BUILD,
34 TAB_PCDS_PATCHABLE_IN_MODULE: 'BinaryPatch',
35 TAB_PCDS_DYNAMIC : '',
36 TAB_PCDS_DYNAMIC_DEFAULT : '',
37 TAB_PCDS_DYNAMIC_VPD : '',
38 TAB_PCDS_DYNAMIC_HII : '',
39 TAB_PCDS_DYNAMIC_EX : '',
40 TAB_PCDS_DYNAMIC_EX_DEFAULT : '',
41 TAB_PCDS_DYNAMIC_EX_VPD : '',
42 TAB_PCDS_DYNAMIC_EX_HII : '',
43 }
44
45
46 ## Datum size
47 gDatumSizeStringDatabase = {TAB_UINT8:'8',TAB_UINT16:'16',TAB_UINT32:'32',TAB_UINT64:'64','BOOLEAN':'BOOLEAN',TAB_VOID:'8'}
48 gDatumSizeStringDatabaseH = {TAB_UINT8:'8',TAB_UINT16:'16',TAB_UINT32:'32',TAB_UINT64:'64','BOOLEAN':'BOOL',TAB_VOID:'PTR'}
49 gDatumSizeStringDatabaseLib = {TAB_UINT8:'8',TAB_UINT16:'16',TAB_UINT32:'32',TAB_UINT64:'64','BOOLEAN':'Bool',TAB_VOID:'Ptr'}
50
51 ## AutoGen File Header Templates
52 gAutoGenHeaderString = TemplateString("""\
53 /**
54 DO NOT EDIT
55 FILE auto-generated
56 Module name:
57 ${FileName}
58 Abstract: Auto-generated ${FileName} for building module or library.
59 **/
60 """)
61
62 gAutoGenHPrologueString = TemplateString("""
63 #ifndef _${File}_${Guid}
64 #define _${File}_${Guid}
65
66 """)
67
68 gAutoGenHCppPrologueString = """\
69 #ifdef __cplusplus
70 extern "C" {
71 #endif
72
73 """
74
75 gAutoGenHEpilogueString = """
76
77 #ifdef __cplusplus
78 }
79 #endif
80
81 #endif
82 """
83
84 ## PEI Core Entry Point Templates
85 gPeiCoreEntryPointPrototype = TemplateString("""
86 ${BEGIN}
87 VOID
88 EFIAPI
89 ${Function} (
90 IN CONST EFI_SEC_PEI_HAND_OFF *SecCoreData,
91 IN CONST EFI_PEI_PPI_DESCRIPTOR *PpiList,
92 IN VOID *Context
93 );
94 ${END}
95 """)
96
97 gPeiCoreEntryPointString = TemplateString("""
98 ${BEGIN}
99 VOID
100 EFIAPI
101 ProcessModuleEntryPointList (
102 IN CONST EFI_SEC_PEI_HAND_OFF *SecCoreData,
103 IN CONST EFI_PEI_PPI_DESCRIPTOR *PpiList,
104 IN VOID *Context
105 )
106
107 {
108 ${Function} (SecCoreData, PpiList, Context);
109 }
110 ${END}
111 """)
112
113
114 ## DXE Core Entry Point Templates
115 gDxeCoreEntryPointPrototype = TemplateString("""
116 ${BEGIN}
117 VOID
118 EFIAPI
119 ${Function} (
120 IN VOID *HobStart
121 );
122 ${END}
123 """)
124
125 gDxeCoreEntryPointString = TemplateString("""
126 ${BEGIN}
127 VOID
128 EFIAPI
129 ProcessModuleEntryPointList (
130 IN VOID *HobStart
131 )
132
133 {
134 ${Function} (HobStart);
135 }
136 ${END}
137 """)
138
139 ## PEIM Entry Point Templates
140 gPeimEntryPointPrototype = TemplateString("""
141 ${BEGIN}
142 EFI_STATUS
143 EFIAPI
144 ${Function} (
145 IN EFI_PEI_FILE_HANDLE FileHandle,
146 IN CONST EFI_PEI_SERVICES **PeiServices
147 );
148 ${END}
149 """)
150
151 gPeimEntryPointString = [
152 TemplateString("""
153 GLOBAL_REMOVE_IF_UNREFERENCED const UINT32 _gPeimRevision = ${PiSpecVersion};
154
155 EFI_STATUS
156 EFIAPI
157 ProcessModuleEntryPointList (
158 IN EFI_PEI_FILE_HANDLE FileHandle,
159 IN CONST EFI_PEI_SERVICES **PeiServices
160 )
161
162 {
163 return EFI_SUCCESS;
164 }
165 """),
166 TemplateString("""
167 GLOBAL_REMOVE_IF_UNREFERENCED const UINT32 _gPeimRevision = ${PiSpecVersion};
168 ${BEGIN}
169 EFI_STATUS
170 EFIAPI
171 ProcessModuleEntryPointList (
172 IN EFI_PEI_FILE_HANDLE FileHandle,
173 IN CONST EFI_PEI_SERVICES **PeiServices
174 )
175
176 {
177 return ${Function} (FileHandle, PeiServices);
178 }
179 ${END}
180 """),
181 TemplateString("""
182 GLOBAL_REMOVE_IF_UNREFERENCED const UINT32 _gPeimRevision = ${PiSpecVersion};
183
184 EFI_STATUS
185 EFIAPI
186 ProcessModuleEntryPointList (
187 IN EFI_PEI_FILE_HANDLE FileHandle,
188 IN CONST EFI_PEI_SERVICES **PeiServices
189 )
190
191 {
192 EFI_STATUS Status;
193 EFI_STATUS CombinedStatus;
194
195 CombinedStatus = EFI_LOAD_ERROR;
196 ${BEGIN}
197 Status = ${Function} (FileHandle, PeiServices);
198 if (!EFI_ERROR (Status) || EFI_ERROR (CombinedStatus)) {
199 CombinedStatus = Status;
200 }
201 ${END}
202 return CombinedStatus;
203 }
204 """)
205 ]
206
207 ## SMM_CORE Entry Point Templates
208 gSmmCoreEntryPointPrototype = TemplateString("""
209 ${BEGIN}
210 EFI_STATUS
211 EFIAPI
212 ${Function} (
213 IN EFI_HANDLE ImageHandle,
214 IN EFI_SYSTEM_TABLE *SystemTable
215 );
216 ${END}
217 """)
218
219 gSmmCoreEntryPointString = TemplateString("""
220 ${BEGIN}
221 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
222 const UINT32 _gDxeRevision = ${PiSpecVersion};
223
224 EFI_STATUS
225 EFIAPI
226 ProcessModuleEntryPointList (
227 IN EFI_HANDLE ImageHandle,
228 IN EFI_SYSTEM_TABLE *SystemTable
229 )
230 {
231 return ${Function} (ImageHandle, SystemTable);
232 }
233 ${END}
234 """)
235
236 ## MM_CORE_STANDALONE Entry Point Templates
237 gMmCoreStandaloneEntryPointPrototype = TemplateString("""
238 ${BEGIN}
239 EFI_STATUS
240 EFIAPI
241 ${Function} (
242 IN VOID *HobStart
243 );
244 ${END}
245 """)
246
247 gMmCoreStandaloneEntryPointString = TemplateString("""
248 ${BEGIN}
249 const UINT32 _gMmRevision = ${PiSpecVersion};
250
251 VOID
252 EFIAPI
253 ProcessModuleEntryPointList (
254 IN VOID *HobStart
255 )
256 {
257 ${Function} (HobStart);
258 }
259 ${END}
260 """)
261
262 ## MM_STANDALONE Entry Point Templates
263 gMmStandaloneEntryPointPrototype = TemplateString("""
264 ${BEGIN}
265 EFI_STATUS
266 EFIAPI
267 ${Function} (
268 IN EFI_HANDLE ImageHandle,
269 IN EFI_MM_SYSTEM_TABLE *MmSystemTable
270 );
271 ${END}
272 """)
273
274 gMmStandaloneEntryPointString = [
275 TemplateString("""
276 GLOBAL_REMOVE_IF_UNREFERENCED const UINT32 _gMmRevision = ${PiSpecVersion};
277
278 EFI_STATUS
279 EFIAPI
280 ProcessModuleEntryPointList (
281 IN EFI_HANDLE ImageHandle,
282 IN EFI_MM_SYSTEM_TABLE *MmSystemTable
283 )
284
285 {
286 return EFI_SUCCESS;
287 }
288 """),
289 TemplateString("""
290 GLOBAL_REMOVE_IF_UNREFERENCED const UINT32 _gMmRevision = ${PiSpecVersion};
291 ${BEGIN}
292 EFI_STATUS
293 EFIAPI
294 ProcessModuleEntryPointList (
295 IN EFI_HANDLE ImageHandle,
296 IN EFI_MM_SYSTEM_TABLE *MmSystemTable
297 )
298
299 {
300 return ${Function} (ImageHandle, MmSystemTable);
301 }
302 ${END}
303 """),
304 TemplateString("""
305 GLOBAL_REMOVE_IF_UNREFERENCED const UINT32 _gMmRevision = ${PiSpecVersion};
306
307 EFI_STATUS
308 EFIAPI
309 ProcessModuleEntryPointList (
310 IN EFI_HANDLE ImageHandle,
311 IN EFI_MM_SYSTEM_TABLE *MmSystemTable
312 )
313
314 {
315 EFI_STATUS Status;
316 EFI_STATUS CombinedStatus;
317
318 CombinedStatus = EFI_LOAD_ERROR;
319 ${BEGIN}
320 Status = ${Function} (ImageHandle, MmSystemTable);
321 if (!EFI_ERROR (Status) || EFI_ERROR (CombinedStatus)) {
322 CombinedStatus = Status;
323 }
324 ${END}
325 return CombinedStatus;
326 }
327 """)
328 ]
329
330 ## DXE SMM Entry Point Templates
331 gDxeSmmEntryPointPrototype = TemplateString("""
332 ${BEGIN}
333 EFI_STATUS
334 EFIAPI
335 ${Function} (
336 IN EFI_HANDLE ImageHandle,
337 IN EFI_SYSTEM_TABLE *SystemTable
338 );
339 ${END}
340 """)
341
342 gDxeSmmEntryPointString = [
343 TemplateString("""
344 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
345 const UINT32 _gDxeRevision = ${PiSpecVersion};
346
347 EFI_STATUS
348 EFIAPI
349 ProcessModuleEntryPointList (
350 IN EFI_HANDLE ImageHandle,
351 IN EFI_SYSTEM_TABLE *SystemTable
352 )
353
354 {
355 return EFI_SUCCESS;
356 }
357 """),
358 TemplateString("""
359 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
360 const UINT32 _gDxeRevision = ${PiSpecVersion};
361
362 static BASE_LIBRARY_JUMP_BUFFER mJumpContext;
363 static EFI_STATUS mDriverEntryPointStatus;
364
365 VOID
366 EFIAPI
367 ExitDriver (
368 IN EFI_STATUS Status
369 )
370 {
371 if (!EFI_ERROR (Status) || EFI_ERROR (mDriverEntryPointStatus)) {
372 mDriverEntryPointStatus = Status;
373 }
374 LongJump (&mJumpContext, (UINTN)-1);
375 ASSERT (FALSE);
376 }
377
378 EFI_STATUS
379 EFIAPI
380 ProcessModuleEntryPointList (
381 IN EFI_HANDLE ImageHandle,
382 IN EFI_SYSTEM_TABLE *SystemTable
383 )
384 {
385 mDriverEntryPointStatus = EFI_LOAD_ERROR;
386
387 ${BEGIN}
388 if (SetJump (&mJumpContext) == 0) {
389 ExitDriver (${Function} (ImageHandle, SystemTable));
390 ASSERT (FALSE);
391 }
392 ${END}
393
394 return mDriverEntryPointStatus;
395 }
396 """)
397 ]
398
399 ## UEFI Driver Entry Point Templates
400 gUefiDriverEntryPointPrototype = TemplateString("""
401 ${BEGIN}
402 EFI_STATUS
403 EFIAPI
404 ${Function} (
405 IN EFI_HANDLE ImageHandle,
406 IN EFI_SYSTEM_TABLE *SystemTable
407 );
408 ${END}
409 """)
410
411 gUefiDriverEntryPointString = [
412 TemplateString("""
413 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
414 const UINT32 _gDxeRevision = ${PiSpecVersion};
415
416 EFI_STATUS
417 EFIAPI
418 ProcessModuleEntryPointList (
419 IN EFI_HANDLE ImageHandle,
420 IN EFI_SYSTEM_TABLE *SystemTable
421 )
422 {
423 return EFI_SUCCESS;
424 }
425 """),
426 TemplateString("""
427 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
428 const UINT32 _gDxeRevision = ${PiSpecVersion};
429
430 ${BEGIN}
431 EFI_STATUS
432 EFIAPI
433 ProcessModuleEntryPointList (
434 IN EFI_HANDLE ImageHandle,
435 IN EFI_SYSTEM_TABLE *SystemTable
436 )
437
438 {
439 return ${Function} (ImageHandle, SystemTable);
440 }
441 ${END}
442 VOID
443 EFIAPI
444 ExitDriver (
445 IN EFI_STATUS Status
446 )
447 {
448 if (EFI_ERROR (Status)) {
449 ProcessLibraryDestructorList (gImageHandle, gST);
450 }
451 gBS->Exit (gImageHandle, Status, 0, NULL);
452 }
453 """),
454 TemplateString("""
455 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
456 const UINT32 _gDxeRevision = ${PiSpecVersion};
457
458 static BASE_LIBRARY_JUMP_BUFFER mJumpContext;
459 static EFI_STATUS mDriverEntryPointStatus;
460
461 EFI_STATUS
462 EFIAPI
463 ProcessModuleEntryPointList (
464 IN EFI_HANDLE ImageHandle,
465 IN EFI_SYSTEM_TABLE *SystemTable
466 )
467 {
468 mDriverEntryPointStatus = EFI_LOAD_ERROR;
469 ${BEGIN}
470 if (SetJump (&mJumpContext) == 0) {
471 ExitDriver (${Function} (ImageHandle, SystemTable));
472 ASSERT (FALSE);
473 }
474 ${END}
475 return mDriverEntryPointStatus;
476 }
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
494 ## UEFI Application Entry Point Templates
495 gUefiApplicationEntryPointPrototype = TemplateString("""
496 ${BEGIN}
497 EFI_STATUS
498 EFIAPI
499 ${Function} (
500 IN EFI_HANDLE ImageHandle,
501 IN EFI_SYSTEM_TABLE *SystemTable
502 );
503 ${END}
504 """)
505
506 gUefiApplicationEntryPointString = [
507 TemplateString("""
508 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
509
510 EFI_STATUS
511 EFIAPI
512 ProcessModuleEntryPointList (
513 IN EFI_HANDLE ImageHandle,
514 IN EFI_SYSTEM_TABLE *SystemTable
515 )
516 {
517 return EFI_SUCCESS;
518 }
519 """),
520 TemplateString("""
521 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
522
523 ${BEGIN}
524 EFI_STATUS
525 EFIAPI
526 ProcessModuleEntryPointList (
527 IN EFI_HANDLE ImageHandle,
528 IN EFI_SYSTEM_TABLE *SystemTable
529 )
530
531 {
532 return ${Function} (ImageHandle, SystemTable);
533 }
534 ${END}
535 VOID
536 EFIAPI
537 ExitDriver (
538 IN EFI_STATUS Status
539 )
540 {
541 if (EFI_ERROR (Status)) {
542 ProcessLibraryDestructorList (gImageHandle, gST);
543 }
544 gBS->Exit (gImageHandle, Status, 0, NULL);
545 }
546 """),
547 TemplateString("""
548 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
549
550 EFI_STATUS
551 EFIAPI
552 ProcessModuleEntryPointList (
553 IN EFI_HANDLE ImageHandle,
554 IN EFI_SYSTEM_TABLE *SystemTable
555 )
556
557 {
558 ${BEGIN}
559 if (SetJump (&mJumpContext) == 0) {
560 ExitDriver (${Function} (ImageHandle, SystemTable));
561 ASSERT (FALSE);
562 }
563 ${END}
564 return mDriverEntryPointStatus;
565 }
566
567 static BASE_LIBRARY_JUMP_BUFFER mJumpContext;
568 static EFI_STATUS mDriverEntryPointStatus = EFI_LOAD_ERROR;
569
570 VOID
571 EFIAPI
572 ExitDriver (
573 IN EFI_STATUS Status
574 )
575 {
576 if (!EFI_ERROR (Status) || EFI_ERROR (mDriverEntryPointStatus)) {
577 mDriverEntryPointStatus = Status;
578 }
579 LongJump (&mJumpContext, (UINTN)-1);
580 ASSERT (FALSE);
581 }
582 """)
583 ]
584
585 ## UEFI Unload Image Templates
586 gUefiUnloadImagePrototype = TemplateString("""
587 ${BEGIN}
588 EFI_STATUS
589 EFIAPI
590 ${Function} (
591 IN EFI_HANDLE ImageHandle
592 );
593 ${END}
594 """)
595
596 gUefiUnloadImageString = [
597 TemplateString("""
598 GLOBAL_REMOVE_IF_UNREFERENCED const UINT8 _gDriverUnloadImageCount = ${Count};
599
600 EFI_STATUS
601 EFIAPI
602 ProcessModuleUnloadList (
603 IN EFI_HANDLE ImageHandle
604 )
605 {
606 return EFI_SUCCESS;
607 }
608 """),
609 TemplateString("""
610 GLOBAL_REMOVE_IF_UNREFERENCED const UINT8 _gDriverUnloadImageCount = ${Count};
611
612 ${BEGIN}
613 EFI_STATUS
614 EFIAPI
615 ProcessModuleUnloadList (
616 IN EFI_HANDLE ImageHandle
617 )
618 {
619 return ${Function} (ImageHandle);
620 }
621 ${END}
622 """),
623 TemplateString("""
624 GLOBAL_REMOVE_IF_UNREFERENCED const UINT8 _gDriverUnloadImageCount = ${Count};
625
626 EFI_STATUS
627 EFIAPI
628 ProcessModuleUnloadList (
629 IN EFI_HANDLE ImageHandle
630 )
631 {
632 EFI_STATUS Status;
633
634 Status = EFI_SUCCESS;
635 ${BEGIN}
636 if (EFI_ERROR (Status)) {
637 ${Function} (ImageHandle);
638 } else {
639 Status = ${Function} (ImageHandle);
640 }
641 ${END}
642 return Status;
643 }
644 """)
645 ]
646
647 gLibraryStructorPrototype = {
648 SUP_MODULE_BASE : TemplateString("""${BEGIN}
649 RETURN_STATUS
650 EFIAPI
651 ${Function} (
652 VOID
653 );${END}
654 """),
655
656 'PEI' : TemplateString("""${BEGIN}
657 EFI_STATUS
658 EFIAPI
659 ${Function} (
660 IN EFI_PEI_FILE_HANDLE FileHandle,
661 IN CONST EFI_PEI_SERVICES **PeiServices
662 );${END}
663 """),
664
665 'DXE' : TemplateString("""${BEGIN}
666 EFI_STATUS
667 EFIAPI
668 ${Function} (
669 IN EFI_HANDLE ImageHandle,
670 IN EFI_SYSTEM_TABLE *SystemTable
671 );${END}
672 """),
673
674 'MM' : TemplateString("""${BEGIN}
675 EFI_STATUS
676 EFIAPI
677 ${Function} (
678 IN EFI_HANDLE ImageHandle,
679 IN EFI_MM_SYSTEM_TABLE *MmSystemTable
680 );${END}
681 """),
682 }
683
684 gLibraryStructorCall = {
685 SUP_MODULE_BASE : TemplateString("""${BEGIN}
686 Status = ${Function} ();
687 ASSERT_RETURN_ERROR (Status);${END}
688 """),
689
690 'PEI' : TemplateString("""${BEGIN}
691 Status = ${Function} (FileHandle, PeiServices);
692 ASSERT_EFI_ERROR (Status);${END}
693 """),
694
695 'DXE' : TemplateString("""${BEGIN}
696 Status = ${Function} (ImageHandle, SystemTable);
697 ASSERT_EFI_ERROR (Status);${END}
698 """),
699
700 'MM' : TemplateString("""${BEGIN}
701 Status = ${Function} (ImageHandle, MmSystemTable);
702 ASSERT_EFI_ERROR (Status);${END}
703 """),
704 }
705
706 ## Library Constructor and Destructor Templates
707 gLibraryString = {
708 SUP_MODULE_BASE : TemplateString("""
709 ${BEGIN}${FunctionPrototype}${END}
710
711 VOID
712 EFIAPI
713 ProcessLibrary${Type}List (
714 VOID
715 )
716 {
717 ${BEGIN} RETURN_STATUS Status;
718 ${FunctionCall}${END}
719 }
720 """),
721
722 'PEI' : TemplateString("""
723 ${BEGIN}${FunctionPrototype}${END}
724
725 VOID
726 EFIAPI
727 ProcessLibrary${Type}List (
728 IN EFI_PEI_FILE_HANDLE FileHandle,
729 IN CONST EFI_PEI_SERVICES **PeiServices
730 )
731 {
732 ${BEGIN} EFI_STATUS Status;
733 ${FunctionCall}${END}
734 }
735 """),
736
737 'DXE' : TemplateString("""
738 ${BEGIN}${FunctionPrototype}${END}
739
740 VOID
741 EFIAPI
742 ProcessLibrary${Type}List (
743 IN EFI_HANDLE ImageHandle,
744 IN EFI_SYSTEM_TABLE *SystemTable
745 )
746 {
747 ${BEGIN} EFI_STATUS Status;
748 ${FunctionCall}${END}
749 }
750 """),
751
752 'MM' : TemplateString("""
753 ${BEGIN}${FunctionPrototype}${END}
754
755 VOID
756 EFIAPI
757 ProcessLibrary${Type}List (
758 IN EFI_HANDLE ImageHandle,
759 IN EFI_MM_SYSTEM_TABLE *MmSystemTable
760 )
761 {
762 ${BEGIN} EFI_STATUS Status;
763 ${FunctionCall}${END}
764 }
765 """),
766 }
767
768 gBasicHeaderFile = "Base.h"
769
770 gModuleTypeHeaderFile = {
771 SUP_MODULE_BASE : [gBasicHeaderFile, "Library/DebugLib.h"],
772 SUP_MODULE_SEC : ["PiPei.h", "Library/DebugLib.h"],
773 SUP_MODULE_PEI_CORE : ["PiPei.h", "Library/DebugLib.h", "Library/PeiCoreEntryPoint.h"],
774 SUP_MODULE_PEIM : ["PiPei.h", "Library/DebugLib.h", "Library/PeimEntryPoint.h"],
775 SUP_MODULE_DXE_CORE : ["PiDxe.h", "Library/DebugLib.h", "Library/DxeCoreEntryPoint.h"],
776 SUP_MODULE_DXE_DRIVER : ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h", "Library/UefiDriverEntryPoint.h"],
777 SUP_MODULE_DXE_SMM_DRIVER : ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h", "Library/UefiDriverEntryPoint.h"],
778 SUP_MODULE_DXE_RUNTIME_DRIVER: ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h", "Library/UefiDriverEntryPoint.h"],
779 SUP_MODULE_DXE_SAL_DRIVER : ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h", "Library/UefiDriverEntryPoint.h"],
780 SUP_MODULE_UEFI_DRIVER : ["Uefi.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h", "Library/UefiDriverEntryPoint.h"],
781 SUP_MODULE_UEFI_APPLICATION : ["Uefi.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h", "Library/UefiApplicationEntryPoint.h"],
782 SUP_MODULE_SMM_CORE : ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiDriverEntryPoint.h"],
783 SUP_MODULE_MM_STANDALONE : ["PiMm.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/StandaloneMmDriverEntryPoint.h"],
784 SUP_MODULE_MM_CORE_STANDALONE : ["PiMm.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/StandaloneMmCoreEntryPoint.h"],
785 SUP_MODULE_USER_DEFINED : [gBasicHeaderFile, "Library/DebugLib.h"]
786 }
787
788 ## Autogen internal worker macro to define DynamicEx PCD name includes both the TokenSpaceGuidName
789 # the TokenName and Guid comparison to avoid define name collisions.
790 #
791 # @param Info The ModuleAutoGen object
792 # @param AutoGenH The TemplateString object for header file
793 #
794 #
795 def DynExPcdTokenNumberMapping(Info, AutoGenH):
796 ExTokenCNameList = []
797 PcdExList = []
798 # Even it is the Library, the PCD is saved in the ModulePcdList
799 PcdList = Info.ModulePcdList
800 for Pcd in PcdList:
801 if Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:
802 ExTokenCNameList.append(Pcd.TokenCName)
803 PcdExList.append(Pcd)
804 if len(ExTokenCNameList) == 0:
805 return
806 AutoGenH.Append('\n#define COMPAREGUID(Guid1, Guid2) (BOOLEAN)(*(CONST UINT64*)Guid1 == *(CONST UINT64*)Guid2 && *((CONST UINT64*)Guid1 + 1) == *((CONST UINT64*)Guid2 + 1))\n')
807 # AutoGen for each PCD listed in a [PcdEx] section of a Module/Lib INF file.
808 # Auto generate a macro for each TokenName that takes a Guid pointer as a parameter.
809 # Use the Guid pointer to see if it matches any of the token space GUIDs.
810 TokenCNameList = set()
811 for TokenCName in ExTokenCNameList:
812 if TokenCName in TokenCNameList:
813 continue
814 Index = 0
815 Count = ExTokenCNameList.count(TokenCName)
816 for Pcd in PcdExList:
817 RealTokenCName = Pcd.TokenCName
818 for PcdItem in GlobalData.MixedPcd:
819 if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:
820 RealTokenCName = PcdItem[0]
821 break
822 if Pcd.TokenCName == TokenCName:
823 Index = Index + 1
824 if Index == 1:
825 AutoGenH.Append('\n#define __PCD_%s_ADDR_CMP(GuidPtr) (' % (RealTokenCName))
826 AutoGenH.Append('\\\n (GuidPtr == &%s) ? _PCD_TOKEN_%s_%s:'
827 % (Pcd.TokenSpaceGuidCName, Pcd.TokenSpaceGuidCName, RealTokenCName))
828 else:
829 AutoGenH.Append('\\\n (GuidPtr == &%s) ? _PCD_TOKEN_%s_%s:'
830 % (Pcd.TokenSpaceGuidCName, Pcd.TokenSpaceGuidCName, RealTokenCName))
831 if Index == Count:
832 AutoGenH.Append('0 \\\n )\n')
833 TokenCNameList.add(TokenCName)
834
835 TokenCNameList = set()
836 for TokenCName in ExTokenCNameList:
837 if TokenCName in TokenCNameList:
838 continue
839 Index = 0
840 Count = ExTokenCNameList.count(TokenCName)
841 for Pcd in PcdExList:
842 RealTokenCName = Pcd.TokenCName
843 for PcdItem in GlobalData.MixedPcd:
844 if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:
845 RealTokenCName = PcdItem[0]
846 break
847 if Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET and Pcd.TokenCName == TokenCName:
848 Index = Index + 1
849 if Index == 1:
850 AutoGenH.Append('\n#define __PCD_%s_VAL_CMP(GuidPtr) (' % (RealTokenCName))
851 AutoGenH.Append('\\\n (GuidPtr == NULL) ? 0:')
852 AutoGenH.Append('\\\n COMPAREGUID (GuidPtr, &%s) ? _PCD_TOKEN_%s_%s:'
853 % (Pcd.TokenSpaceGuidCName, Pcd.TokenSpaceGuidCName, RealTokenCName))
854 else:
855 AutoGenH.Append('\\\n COMPAREGUID (GuidPtr, &%s) ? _PCD_TOKEN_%s_%s:'
856 % (Pcd.TokenSpaceGuidCName, Pcd.TokenSpaceGuidCName, RealTokenCName))
857 if Index == Count:
858 AutoGenH.Append('0 \\\n )\n')
859 # Autogen internal worker macro to compare GUIDs. Guid1 is a pointer to a GUID.
860 # Guid2 is a C name for a GUID. Compare pointers first because optimizing compiler
861 # can do this at build time on CONST GUID pointers and optimize away call to COMPAREGUID().
862 # COMPAREGUID() will only be used if the Guid passed in is local to the module.
863 AutoGenH.Append('#define _PCD_TOKEN_EX_%s(GuidPtr) __PCD_%s_ADDR_CMP(GuidPtr) ? __PCD_%s_ADDR_CMP(GuidPtr) : __PCD_%s_VAL_CMP(GuidPtr) \n'
864 % (RealTokenCName, RealTokenCName, RealTokenCName, RealTokenCName))
865 TokenCNameList.add(TokenCName)
866
867 ## Create code for module PCDs
868 #
869 # @param Info The ModuleAutoGen object
870 # @param AutoGenC The TemplateString object for C code
871 # @param AutoGenH The TemplateString object for header file
872 # @param Pcd The PCD object
873 #
874 def CreateModulePcdCode(Info, AutoGenC, AutoGenH, Pcd):
875 TokenSpaceGuidValue = Pcd.TokenSpaceGuidValue #Info.GuidList[Pcd.TokenSpaceGuidCName]
876 PcdTokenNumber = Info.PlatformInfo.PcdTokenNumber
877 #
878 # Write PCDs
879 #
880 TokenCName = Pcd.TokenCName
881 for PcdItem in GlobalData.MixedPcd:
882 if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:
883 TokenCName = PcdItem[0]
884 break
885 PcdTokenName = '_PCD_TOKEN_' + TokenCName
886 PatchPcdSizeTokenName = '_PCD_PATCHABLE_' + TokenCName +'_SIZE'
887 PatchPcdSizeVariableName = '_gPcd_BinaryPatch_Size_' + TokenCName
888 PatchPcdMaxSizeVariable = '_gPcd_BinaryPatch_MaxSize_' + TokenCName
889 FixPcdSizeTokenName = '_PCD_SIZE_' + TokenCName
890 FixedPcdSizeVariableName = '_gPcd_FixedAtBuild_Size_' + TokenCName
891
892 if Pcd.PcdValueFromComm:
893 Pcd.DefaultValue = Pcd.PcdValueFromComm
894 elif Pcd.PcdValueFromFdf:
895 Pcd.DefaultValue = Pcd.PcdValueFromFdf
896
897 if Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:
898 TokenNumber = int(Pcd.TokenValue, 0)
899 # Add TokenSpaceGuidValue value to PcdTokenName to discriminate the DynamicEx PCDs with
900 # different Guids but same TokenCName
901 PcdExTokenName = '_PCD_TOKEN_' + Pcd.TokenSpaceGuidCName + '_' + TokenCName
902 AutoGenH.Append('\n#define %s %dU\n' % (PcdExTokenName, TokenNumber))
903 else:
904 if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in PcdTokenNumber:
905 # If one of the Source built modules listed in the DSC is not listed in FDF modules,
906 # and the INF lists a PCD can only use the PcdsDynamic access method (it is only
907 # listed in the DEC file that declares the PCD as PcdsDynamic), then build tool will
908 # report warning message notify the PI that they are attempting to build a module
909 # that must be included in a flash image in order to be functional. These Dynamic PCD
910 # will not be added into the Database unless it is used by other modules that are
911 # included in the FDF file.
912 # In this case, just assign an invalid token number to make it pass build.
913 if Pcd.Type in PCD_DYNAMIC_TYPE_SET:
914 TokenNumber = 0
915 else:
916 EdkLogger.error("build", AUTOGEN_ERROR,
917 "No generated token number for %s.%s\n" % (Pcd.TokenSpaceGuidCName, TokenCName),
918 ExtraData="[%s]" % str(Info))
919 else:
920 TokenNumber = PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName]
921 AutoGenH.Append('\n#define %s %dU\n' % (PcdTokenName, TokenNumber))
922
923 EdkLogger.debug(EdkLogger.DEBUG_3, "Creating code for " + TokenCName + "." + Pcd.TokenSpaceGuidCName)
924 if Pcd.Type not in gItemTypeStringDatabase:
925 EdkLogger.error("build", AUTOGEN_ERROR,
926 "Unknown PCD type [%s] of PCD %s.%s" % (Pcd.Type, Pcd.TokenSpaceGuidCName, TokenCName),
927 ExtraData="[%s]" % str(Info))
928
929 DatumSize = gDatumSizeStringDatabase[Pcd.DatumType] if Pcd.DatumType in gDatumSizeStringDatabase else gDatumSizeStringDatabase[TAB_VOID]
930 DatumSizeLib = gDatumSizeStringDatabaseLib[Pcd.DatumType] if Pcd.DatumType in gDatumSizeStringDatabaseLib else gDatumSizeStringDatabaseLib[TAB_VOID]
931 GetModeName = '_PCD_GET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + TokenCName if Pcd.DatumType in gDatumSizeStringDatabaseH else '_PCD_GET_MODE_' + gDatumSizeStringDatabaseH[TAB_VOID] + '_' + TokenCName
932 SetModeName = '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + TokenCName if Pcd.DatumType in gDatumSizeStringDatabaseH else '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH[TAB_VOID] + '_' + TokenCName
933 SetModeStatusName = '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_S_' + TokenCName if Pcd.DatumType in gDatumSizeStringDatabaseH else '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH[TAB_VOID] + '_S_' + TokenCName
934 GetModeSizeName = '_PCD_GET_MODE_SIZE' + '_' + TokenCName
935
936 if Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:
937 if Info.IsLibrary:
938 PcdList = Info.LibraryPcdList
939 else:
940 PcdList = Info.ModulePcdList + Info.LibraryPcdList
941 PcdExCNameTest = 0
942 for PcdModule in PcdList:
943 if PcdModule.Type in PCD_DYNAMIC_EX_TYPE_SET and Pcd.TokenCName == PcdModule.TokenCName:
944 PcdExCNameTest += 1
945 # get out early once we found > 1...
946 if PcdExCNameTest > 1:
947 break
948 # Be compatible with the current code which using PcdToken and PcdGet/Set for DynamicEx Pcd.
949 # If only PcdToken and PcdGet/Set used in all Pcds with different CName, it should succeed to build.
950 # If PcdToken and PcdGet/Set used in the Pcds with different Guids but same CName, it should failed to build.
951 if PcdExCNameTest > 1:
952 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')
953 AutoGenH.Append('// #define %s %s\n' % (PcdTokenName, PcdExTokenName))
954 AutoGenH.Append('// #define %s LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
955 AutoGenH.Append('// #define %s LibPcdGetExSize(&%s, %s)\n' % (GetModeSizeName, Pcd.TokenSpaceGuidCName, PcdTokenName))
956 if Pcd.DatumType not in TAB_PCD_NUMERIC_TYPES:
957 AutoGenH.Append('// #define %s(SizeOfBuffer, Buffer) LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
958 AutoGenH.Append('// #define %s(SizeOfBuffer, Buffer) LibPcdSetEx%sS(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
959 else:
960 AutoGenH.Append('// #define %s(Value) LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
961 AutoGenH.Append('// #define %s(Value) LibPcdSetEx%sS(&%s, %s, (Value))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
962 else:
963 AutoGenH.Append('#define %s %s\n' % (PcdTokenName, PcdExTokenName))
964 AutoGenH.Append('#define %s LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
965 AutoGenH.Append('#define %s LibPcdGetExSize(&%s, %s)\n' % (GetModeSizeName, Pcd.TokenSpaceGuidCName, PcdTokenName))
966 if Pcd.DatumType not in TAB_PCD_NUMERIC_TYPES:
967 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer) LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
968 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer) LibPcdSetEx%sS(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
969 else:
970 AutoGenH.Append('#define %s(Value) LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
971 AutoGenH.Append('#define %s(Value) LibPcdSetEx%sS(&%s, %s, (Value))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
972 elif Pcd.Type in PCD_DYNAMIC_TYPE_SET:
973 PcdCNameTest = 0
974 for PcdModule in Info.LibraryPcdList + Info.ModulePcdList:
975 if PcdModule.Type in PCD_DYNAMIC_TYPE_SET and Pcd.TokenCName == PcdModule.TokenCName:
976 PcdCNameTest += 1
977 # get out early once we found > 1...
978 if PcdCNameTest > 1:
979 break
980 if PcdCNameTest > 1:
981 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" % (TokenCName), ExtraData="[%s]" % str(Info.MetaFile.Path))
982 else:
983 AutoGenH.Append('#define %s LibPcdGet%s(%s)\n' % (GetModeName, DatumSizeLib, PcdTokenName))
984 AutoGenH.Append('#define %s LibPcdGetSize(%s)\n' % (GetModeSizeName, PcdTokenName))
985 if Pcd.DatumType not in TAB_PCD_NUMERIC_TYPES:
986 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer) LibPcdSet%s(%s, (SizeOfBuffer), (Buffer))\n' %(SetModeName, DatumSizeLib, PcdTokenName))
987 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer) LibPcdSet%sS(%s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, DatumSizeLib, PcdTokenName))
988 else:
989 AutoGenH.Append('#define %s(Value) LibPcdSet%s(%s, (Value))\n' % (SetModeName, DatumSizeLib, PcdTokenName))
990 AutoGenH.Append('#define %s(Value) LibPcdSet%sS(%s, (Value))\n' % (SetModeStatusName, DatumSizeLib, PcdTokenName))
991 else:
992 PcdVariableName = '_gPcd_' + gItemTypeStringDatabase[Pcd.Type] + '_' + TokenCName
993 Const = 'const'
994 if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
995 Const = ''
996 Type = ''
997 Array = ''
998 Value = Pcd.DefaultValue
999 Unicode = False
1000 ValueNumber = 0
1001
1002 if Pcd.DatumType == 'BOOLEAN':
1003 BoolValue = Value.upper()
1004 if BoolValue == 'TRUE' or BoolValue == '1':
1005 Value = '1U'
1006 elif BoolValue == 'FALSE' or BoolValue == '0':
1007 Value = '0U'
1008
1009 if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:
1010 try:
1011 if Value.upper().endswith('L'):
1012 Value = Value[:-1]
1013 if Value.startswith('0') and not Value.lower().startswith('0x') and len(Value) > 1 and Value.lstrip('0'):
1014 Value = Value.lstrip('0')
1015 ValueNumber = int (Value, 0)
1016 except:
1017 EdkLogger.error("build", AUTOGEN_ERROR,
1018 "PCD value is not valid dec or hex number for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, TokenCName),
1019 ExtraData="[%s]" % str(Info))
1020 if ValueNumber < 0:
1021 EdkLogger.error("build", AUTOGEN_ERROR,
1022 "PCD can't be set to negative value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, TokenCName),
1023 ExtraData="[%s]" % str(Info))
1024 elif ValueNumber > MAX_VAL_TYPE[Pcd.DatumType]:
1025 EdkLogger.error("build", AUTOGEN_ERROR,
1026 "Too large PCD value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, TokenCName),
1027 ExtraData="[%s]" % str(Info))
1028 if Pcd.DatumType == TAB_UINT64 and not Value.endswith('ULL'):
1029 Value += 'ULL'
1030 elif Pcd.DatumType != TAB_UINT64 and not Value.endswith('U'):
1031 Value += 'U'
1032
1033 if Pcd.DatumType not in TAB_PCD_NUMERIC_TYPES:
1034 if not Pcd.MaxDatumSize:
1035 EdkLogger.error("build", AUTOGEN_ERROR,
1036 "Unknown [MaxDatumSize] of PCD [%s.%s]" % (Pcd.TokenSpaceGuidCName, TokenCName),
1037 ExtraData="[%s]" % str(Info))
1038
1039 ArraySize = int(Pcd.MaxDatumSize, 0)
1040 if Value[0] == '{':
1041 Type = '(VOID *)'
1042 ValueSize = len(Value.split(','))
1043 else:
1044 if Value[0] == 'L':
1045 Unicode = True
1046 Value = Value.lstrip('L') #.strip('"')
1047 Value = eval(Value) # translate escape character
1048 ValueSize = len(Value) + 1
1049 NewValue = '{'
1050 for Index in range(0, len(Value)):
1051 if Unicode:
1052 NewValue = NewValue + str(ord(Value[Index]) % 0x10000) + ', '
1053 else:
1054 NewValue = NewValue + str(ord(Value[Index]) % 0x100) + ', '
1055 if Unicode:
1056 ArraySize = ArraySize // 2
1057 Value = NewValue + '0 }'
1058 if ArraySize < ValueSize:
1059 if Pcd.MaxSizeUserSet:
1060 EdkLogger.error("build", AUTOGEN_ERROR,
1061 "The maximum size of VOID* type PCD '%s.%s' is less than its actual size occupied." % (Pcd.TokenSpaceGuidCName, TokenCName),
1062 ExtraData="[%s]" % str(Info))
1063 else:
1064 ArraySize = Pcd.GetPcdSize()
1065 if Unicode:
1066 ArraySize = ArraySize // 2
1067 Array = '[%d]' % ArraySize
1068 #
1069 # skip casting for fixed at build since it breaks ARM assembly.
1070 # Long term we need PCD macros that work in assembly
1071 #
1072 elif Pcd.Type != TAB_PCDS_FIXED_AT_BUILD and Pcd.DatumType in TAB_PCD_NUMERIC_TYPES_VOID:
1073 Value = "((%s)%s)" % (Pcd.DatumType, Value)
1074
1075 if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
1076 PcdValueName = '_PCD_PATCHABLE_VALUE_' + TokenCName
1077 else:
1078 PcdValueName = '_PCD_VALUE_' + TokenCName
1079
1080 if Pcd.DatumType not in TAB_PCD_NUMERIC_TYPES:
1081 #
1082 # For unicode, UINT16 array will be generated, so the alignment of unicode is guaranteed.
1083 #
1084 AutoGenH.Append('#define %s %s%s\n' %(PcdValueName, Type, PcdVariableName))
1085 if Unicode:
1086 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s UINT16 %s%s = %s;\n' % (Const, PcdVariableName, Array, Value))
1087 AutoGenH.Append('extern %s UINT16 %s%s;\n' %(Const, PcdVariableName, Array))
1088 else:
1089 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s UINT8 %s%s = %s;\n' % (Const, PcdVariableName, Array, Value))
1090 AutoGenH.Append('extern %s UINT8 %s%s;\n' %(Const, PcdVariableName, Array))
1091 AutoGenH.Append('#define %s %s%s\n' %(GetModeName, Type, PcdVariableName))
1092
1093 PcdDataSize = Pcd.GetPcdSize()
1094 if Pcd.Type == TAB_PCDS_FIXED_AT_BUILD:
1095 AutoGenH.Append('#define %s %s\n' % (FixPcdSizeTokenName, PcdDataSize))
1096 AutoGenH.Append('#define %s %s \n' % (GetModeSizeName, FixPcdSizeTokenName))
1097 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED const UINTN %s = %s;\n' % (FixedPcdSizeVariableName, PcdDataSize))
1098 if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
1099 AutoGenH.Append('#define %s %s\n' % (PatchPcdSizeTokenName, Pcd.MaxDatumSize))
1100 AutoGenH.Append('#define %s %s \n' % (GetModeSizeName, PatchPcdSizeVariableName))
1101 AutoGenH.Append('extern UINTN %s; \n' % PatchPcdSizeVariableName)
1102 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED UINTN %s = %s;\n' % (PatchPcdSizeVariableName, PcdDataSize))
1103 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED const UINTN %s = %s;\n' % (PatchPcdMaxSizeVariable, Pcd.MaxDatumSize))
1104 elif Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
1105 AutoGenH.Append('#define %s %s\n' %(PcdValueName, Value))
1106 AutoGenC.Append('volatile %s %s %s = %s;\n' %(Const, Pcd.DatumType, PcdVariableName, PcdValueName))
1107 AutoGenH.Append('extern volatile %s %s %s%s;\n' % (Const, Pcd.DatumType, PcdVariableName, Array))
1108 AutoGenH.Append('#define %s %s%s\n' % (GetModeName, Type, PcdVariableName))
1109
1110 PcdDataSize = Pcd.GetPcdSize()
1111 AutoGenH.Append('#define %s %s\n' % (PatchPcdSizeTokenName, PcdDataSize))
1112
1113 AutoGenH.Append('#define %s %s \n' % (GetModeSizeName, PatchPcdSizeVariableName))
1114 AutoGenH.Append('extern UINTN %s; \n' % PatchPcdSizeVariableName)
1115 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED UINTN %s = %s;\n' % (PatchPcdSizeVariableName, PcdDataSize))
1116 else:
1117 PcdDataSize = Pcd.GetPcdSize()
1118 AutoGenH.Append('#define %s %s\n' % (FixPcdSizeTokenName, PcdDataSize))
1119 AutoGenH.Append('#define %s %s \n' % (GetModeSizeName, FixPcdSizeTokenName))
1120
1121 AutoGenH.Append('#define %s %s\n' %(PcdValueName, Value))
1122 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s %s = %s;\n' %(Const, Pcd.DatumType, PcdVariableName, PcdValueName))
1123 AutoGenH.Append('extern %s %s %s%s;\n' % (Const, Pcd.DatumType, PcdVariableName, Array))
1124 AutoGenH.Append('#define %s %s%s\n' % (GetModeName, Type, PcdVariableName))
1125
1126 if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
1127 if Pcd.DatumType not in TAB_PCD_NUMERIC_TYPES:
1128 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))
1129 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))
1130 else:
1131 AutoGenH.Append('#define %s(Value) (%s = (Value))\n' % (SetModeName, PcdVariableName))
1132 AutoGenH.Append('#define %s(Value) ((%s = (Value)), RETURN_SUCCESS) \n' % (SetModeStatusName, PcdVariableName))
1133 else:
1134 AutoGenH.Append('//#define %s ASSERT(FALSE) // It is not allowed to set value for a FIXED_AT_BUILD PCD\n' % SetModeName)
1135
1136 ## Create code for library module PCDs
1137 #
1138 # @param Info The ModuleAutoGen object
1139 # @param AutoGenC The TemplateString object for C code
1140 # @param AutoGenH The TemplateString object for header file
1141 # @param Pcd The PCD object
1142 #
1143 def CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd):
1144 PcdTokenNumber = Info.PlatformInfo.PcdTokenNumber
1145 TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName
1146 TokenCName = Pcd.TokenCName
1147 for PcdItem in GlobalData.MixedPcd:
1148 if (TokenCName, TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:
1149 TokenCName = PcdItem[0]
1150 break
1151 PcdTokenName = '_PCD_TOKEN_' + TokenCName
1152 FixPcdSizeTokenName = '_PCD_SIZE_' + TokenCName
1153 PatchPcdSizeTokenName = '_PCD_PATCHABLE_' + TokenCName +'_SIZE'
1154 PatchPcdSizeVariableName = '_gPcd_BinaryPatch_Size_' + TokenCName
1155 PatchPcdMaxSizeVariable = '_gPcd_BinaryPatch_MaxSize_' + TokenCName
1156 FixedPcdSizeVariableName = '_gPcd_FixedAtBuild_Size_' + TokenCName
1157
1158 if Pcd.PcdValueFromComm:
1159 Pcd.DefaultValue = Pcd.PcdValueFromComm
1160 elif Pcd.PcdValueFromFdf:
1161 Pcd.DefaultValue = Pcd.PcdValueFromFdf
1162 #
1163 # Write PCDs
1164 #
1165 if Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:
1166 TokenNumber = int(Pcd.TokenValue, 0)
1167 else:
1168 if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in PcdTokenNumber:
1169 # If one of the Source built modules listed in the DSC is not listed in FDF modules,
1170 # and the INF lists a PCD can only use the PcdsDynamic access method (it is only
1171 # listed in the DEC file that declares the PCD as PcdsDynamic), then build tool will
1172 # report warning message notify the PI that they are attempting to build a module
1173 # that must be included in a flash image in order to be functional. These Dynamic PCD
1174 # will not be added into the Database unless it is used by other modules that are
1175 # included in the FDF file.
1176 # In this case, just assign an invalid token number to make it pass build.
1177 if Pcd.Type in PCD_DYNAMIC_TYPE_SET:
1178 TokenNumber = 0
1179 else:
1180 EdkLogger.error("build", AUTOGEN_ERROR,
1181 "No generated token number for %s.%s\n" % (Pcd.TokenSpaceGuidCName, TokenCName),
1182 ExtraData="[%s]" % str(Info))
1183 else:
1184 TokenNumber = PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName]
1185
1186 if Pcd.Type not in gItemTypeStringDatabase:
1187 EdkLogger.error("build", AUTOGEN_ERROR,
1188 "Unknown PCD type [%s] of PCD %s.%s" % (Pcd.Type, Pcd.TokenSpaceGuidCName, TokenCName),
1189 ExtraData="[%s]" % str(Info))
1190
1191 DatumType = Pcd.DatumType
1192 DatumSize = gDatumSizeStringDatabase[Pcd.DatumType] if Pcd.DatumType in gDatumSizeStringDatabase else gDatumSizeStringDatabase[TAB_VOID]
1193 DatumSizeLib = gDatumSizeStringDatabaseLib[Pcd.DatumType] if Pcd.DatumType in gDatumSizeStringDatabaseLib else gDatumSizeStringDatabaseLib[TAB_VOID]
1194 GetModeName = '_PCD_GET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + TokenCName if Pcd.DatumType in gDatumSizeStringDatabaseH else '_PCD_GET_MODE_' + gDatumSizeStringDatabaseH[TAB_VOID] + '_' + TokenCName
1195 SetModeName = '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + TokenCName if Pcd.DatumType in gDatumSizeStringDatabaseH else '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH[TAB_VOID] + '_' + TokenCName
1196 SetModeStatusName = '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_S_' + TokenCName if Pcd.DatumType in gDatumSizeStringDatabaseH else '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH[TAB_VOID] + '_S_' + TokenCName
1197 GetModeSizeName = '_PCD_GET_MODE_SIZE' + '_' + TokenCName
1198
1199 Type = ''
1200 Array = ''
1201 if Pcd.DatumType not in TAB_PCD_NUMERIC_TYPES:
1202 if Pcd.DefaultValue[0]== '{':
1203 Type = '(VOID *)'
1204 Array = '[]'
1205 PcdItemType = Pcd.Type
1206 if PcdItemType in PCD_DYNAMIC_EX_TYPE_SET:
1207 PcdExTokenName = '_PCD_TOKEN_' + TokenSpaceGuidCName + '_' + TokenCName
1208 AutoGenH.Append('\n#define %s %dU\n' % (PcdExTokenName, TokenNumber))
1209
1210 if Info.IsLibrary:
1211 PcdList = Info.LibraryPcdList
1212 else:
1213 PcdList = Info.ModulePcdList
1214 PcdExCNameTest = 0
1215 for PcdModule in PcdList:
1216 if PcdModule.Type in PCD_DYNAMIC_EX_TYPE_SET and Pcd.TokenCName == PcdModule.TokenCName:
1217 PcdExCNameTest += 1
1218 # get out early once we found > 1...
1219 if PcdExCNameTest > 1:
1220 break
1221 # Be compatible with the current code which using PcdGet/Set for DynamicEx Pcd.
1222 # If only PcdGet/Set used in all Pcds with different CName, it should succeed to build.
1223 # If PcdGet/Set used in the Pcds with different Guids but same CName, it should failed to build.
1224 if PcdExCNameTest > 1:
1225 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')
1226 AutoGenH.Append('// #define %s %s\n' % (PcdTokenName, PcdExTokenName))
1227 AutoGenH.Append('// #define %s LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1228 AutoGenH.Append('// #define %s LibPcdGetExSize(&%s, %s)\n' % (GetModeSizeName, Pcd.TokenSpaceGuidCName, PcdTokenName))
1229 if Pcd.DatumType not in TAB_PCD_NUMERIC_TYPES:
1230 AutoGenH.Append('// #define %s(SizeOfBuffer, Buffer) LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1231 AutoGenH.Append('// #define %s(SizeOfBuffer, Buffer) LibPcdSetEx%sS(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1232 else:
1233 AutoGenH.Append('// #define %s(Value) LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1234 AutoGenH.Append('// #define %s(Value) LibPcdSetEx%sS(&%s, %s, (Value))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1235 else:
1236 AutoGenH.Append('#define %s %s\n' % (PcdTokenName, PcdExTokenName))
1237 AutoGenH.Append('#define %s LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1238 AutoGenH.Append('#define %s LibPcdGetExSize(&%s, %s)\n' % (GetModeSizeName, Pcd.TokenSpaceGuidCName, PcdTokenName))
1239 if Pcd.DatumType not in TAB_PCD_NUMERIC_TYPES:
1240 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer) LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1241 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer) LibPcdSetEx%sS(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1242 else:
1243 AutoGenH.Append('#define %s(Value) LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1244 AutoGenH.Append('#define %s(Value) LibPcdSetEx%sS(&%s, %s, (Value))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1245 else:
1246 AutoGenH.Append('#define _PCD_TOKEN_%s %dU\n' % (TokenCName, TokenNumber))
1247 if PcdItemType in PCD_DYNAMIC_TYPE_SET:
1248 PcdList = []
1249 PcdCNameList = []
1250 PcdList.extend(Info.LibraryPcdList)
1251 PcdList.extend(Info.ModulePcdList)
1252 for PcdModule in PcdList:
1253 if PcdModule.Type in PCD_DYNAMIC_TYPE_SET:
1254 PcdCNameList.append(PcdModule.TokenCName)
1255 if PcdCNameList.count(Pcd.TokenCName) > 1:
1256 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" % (TokenCName), ExtraData="[%s]" % str(Info.MetaFile.Path))
1257 else:
1258 AutoGenH.Append('#define %s LibPcdGet%s(%s)\n' % (GetModeName, DatumSizeLib, PcdTokenName))
1259 AutoGenH.Append('#define %s LibPcdGetSize(%s)\n' % (GetModeSizeName, PcdTokenName))
1260 if DatumType not in TAB_PCD_NUMERIC_TYPES:
1261 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer) LibPcdSet%s(%s, (SizeOfBuffer), (Buffer))\n' %(SetModeName, DatumSizeLib, PcdTokenName))
1262 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer) LibPcdSet%sS(%s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, DatumSizeLib, PcdTokenName))
1263 else:
1264 AutoGenH.Append('#define %s(Value) LibPcdSet%s(%s, (Value))\n' % (SetModeName, DatumSizeLib, PcdTokenName))
1265 AutoGenH.Append('#define %s(Value) LibPcdSet%sS(%s, (Value))\n' % (SetModeStatusName, DatumSizeLib, PcdTokenName))
1266 if PcdItemType == TAB_PCDS_PATCHABLE_IN_MODULE:
1267 PcdVariableName = '_gPcd_' + gItemTypeStringDatabase[TAB_PCDS_PATCHABLE_IN_MODULE] + '_' + TokenCName
1268 if DatumType not in TAB_PCD_NUMERIC_TYPES:
1269 if DatumType == TAB_VOID and Array == '[]':
1270 DatumType = [TAB_UINT8, TAB_UINT16][Pcd.DefaultValue[0] == 'L']
1271 else:
1272 DatumType = TAB_UINT8
1273 AutoGenH.Append('extern %s _gPcd_BinaryPatch_%s%s;\n' %(DatumType, TokenCName, Array))
1274 else:
1275 AutoGenH.Append('extern volatile %s %s%s;\n' % (DatumType, PcdVariableName, Array))
1276 AutoGenH.Append('#define %s %s_gPcd_BinaryPatch_%s\n' %(GetModeName, Type, TokenCName))
1277 PcdDataSize = Pcd.GetPcdSize()
1278 if Pcd.DatumType not in TAB_PCD_NUMERIC_TYPES:
1279 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer) LibPatchPcdSetPtrAndSize((VOID *)_gPcd_BinaryPatch_%s, &%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, TokenCName, PatchPcdSizeVariableName, PatchPcdMaxSizeVariable))
1280 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer) LibPatchPcdSetPtrAndSizeS((VOID *)_gPcd_BinaryPatch_%s, &%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, TokenCName, PatchPcdSizeVariableName, PatchPcdMaxSizeVariable))
1281 AutoGenH.Append('#define %s %s\n' % (PatchPcdSizeTokenName, PatchPcdMaxSizeVariable))
1282 AutoGenH.Append('extern const UINTN %s; \n' % PatchPcdMaxSizeVariable)
1283 else:
1284 AutoGenH.Append('#define %s(Value) (%s = (Value))\n' % (SetModeName, PcdVariableName))
1285 AutoGenH.Append('#define %s(Value) ((%s = (Value)), RETURN_SUCCESS)\n' % (SetModeStatusName, PcdVariableName))
1286 AutoGenH.Append('#define %s %s\n' % (PatchPcdSizeTokenName, PcdDataSize))
1287
1288 AutoGenH.Append('#define %s %s\n' % (GetModeSizeName, PatchPcdSizeVariableName))
1289 AutoGenH.Append('extern UINTN %s; \n' % PatchPcdSizeVariableName)
1290
1291 if PcdItemType == TAB_PCDS_FIXED_AT_BUILD or PcdItemType == TAB_PCDS_FEATURE_FLAG:
1292 key = ".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
1293 PcdVariableName = '_gPcd_' + gItemTypeStringDatabase[Pcd.Type] + '_' + TokenCName
1294 if DatumType == TAB_VOID and Array == '[]':
1295 DatumType = [TAB_UINT8, TAB_UINT16][Pcd.DefaultValue[0] == 'L']
1296 if DatumType not in TAB_PCD_NUMERIC_TYPES_VOID:
1297 DatumType = TAB_UINT8
1298 AutoGenH.Append('extern const %s _gPcd_FixedAtBuild_%s%s;\n' %(DatumType, TokenCName, Array))
1299 AutoGenH.Append('#define %s %s_gPcd_FixedAtBuild_%s\n' %(GetModeName, Type, TokenCName))
1300 AutoGenH.Append('//#define %s ASSERT(FALSE) // It is not allowed to set value for a FIXED_AT_BUILD PCD\n' % SetModeName)
1301
1302 ConstFixedPcd = False
1303 if PcdItemType == TAB_PCDS_FIXED_AT_BUILD and (key in Info.ConstPcd or (Info.IsLibrary and not Info.ReferenceModules)):
1304 ConstFixedPcd = True
1305 if key in Info.ConstPcd:
1306 Pcd.DefaultValue = Info.ConstPcd[key]
1307 if Pcd.DatumType not in TAB_PCD_NUMERIC_TYPES:
1308 AutoGenH.Append('#define _PCD_VALUE_%s %s%s\n' %(TokenCName, Type, PcdVariableName))
1309 else:
1310 AutoGenH.Append('#define _PCD_VALUE_%s %s\n' %(TokenCName, Pcd.DefaultValue))
1311 PcdDataSize = Pcd.GetPcdSize()
1312 if PcdItemType == TAB_PCDS_FIXED_AT_BUILD:
1313 if Pcd.DatumType not in TAB_PCD_NUMERIC_TYPES:
1314 if ConstFixedPcd:
1315 AutoGenH.Append('#define %s %s\n' % (FixPcdSizeTokenName, PcdDataSize))
1316 AutoGenH.Append('#define %s %s\n' % (GetModeSizeName, FixPcdSizeTokenName))
1317 else:
1318 AutoGenH.Append('#define %s %s\n' % (GetModeSizeName, FixedPcdSizeVariableName))
1319 AutoGenH.Append('#define %s %s\n' % (FixPcdSizeTokenName, FixedPcdSizeVariableName))
1320 AutoGenH.Append('extern const UINTN %s; \n' % FixedPcdSizeVariableName)
1321 else:
1322 AutoGenH.Append('#define %s %s\n' % (FixPcdSizeTokenName, PcdDataSize))
1323 AutoGenH.Append('#define %s %s\n' % (GetModeSizeName, FixPcdSizeTokenName))
1324
1325 ## Create code for library constructor
1326 #
1327 # @param Info The ModuleAutoGen object
1328 # @param AutoGenC The TemplateString object for C code
1329 # @param AutoGenH The TemplateString object for header file
1330 #
1331 def CreateLibraryConstructorCode(Info, AutoGenC, AutoGenH):
1332 #
1333 # Library Constructors
1334 #
1335 ConstructorPrototypeString = TemplateString()
1336 ConstructorCallingString = TemplateString()
1337 if Info.IsLibrary:
1338 DependentLibraryList = [Info.Module]
1339 else:
1340 DependentLibraryList = Info.DependentLibraryList
1341 for Lib in DependentLibraryList:
1342 if len(Lib.ConstructorList) <= 0:
1343 continue
1344 Dict = {'Function':Lib.ConstructorList}
1345 if Lib.ModuleType in [SUP_MODULE_BASE, SUP_MODULE_SEC]:
1346 ConstructorPrototypeString.Append(gLibraryStructorPrototype[SUP_MODULE_BASE].Replace(Dict))
1347 ConstructorCallingString.Append(gLibraryStructorCall[SUP_MODULE_BASE].Replace(Dict))
1348 if Info.ModuleType not in [SUP_MODULE_BASE, SUP_MODULE_USER_DEFINED]:
1349 if Lib.ModuleType in SUP_MODULE_SET_PEI:
1350 ConstructorPrototypeString.Append(gLibraryStructorPrototype['PEI'].Replace(Dict))
1351 ConstructorCallingString.Append(gLibraryStructorCall['PEI'].Replace(Dict))
1352 elif Lib.ModuleType in [SUP_MODULE_DXE_CORE, SUP_MODULE_DXE_DRIVER, SUP_MODULE_DXE_SMM_DRIVER, SUP_MODULE_DXE_RUNTIME_DRIVER,
1353 SUP_MODULE_DXE_SAL_DRIVER, SUP_MODULE_UEFI_DRIVER, SUP_MODULE_UEFI_APPLICATION, SUP_MODULE_SMM_CORE]:
1354 ConstructorPrototypeString.Append(gLibraryStructorPrototype['DXE'].Replace(Dict))
1355 ConstructorCallingString.Append(gLibraryStructorCall['DXE'].Replace(Dict))
1356 elif Lib.ModuleType in [SUP_MODULE_MM_STANDALONE, SUP_MODULE_MM_CORE_STANDALONE]:
1357 ConstructorPrototypeString.Append(gLibraryStructorPrototype['MM'].Replace(Dict))
1358 ConstructorCallingString.Append(gLibraryStructorCall['MM'].Replace(Dict))
1359
1360 if str(ConstructorPrototypeString) == '':
1361 ConstructorPrototypeList = []
1362 else:
1363 ConstructorPrototypeList = [str(ConstructorPrototypeString)]
1364 if str(ConstructorCallingString) == '':
1365 ConstructorCallingList = []
1366 else:
1367 ConstructorCallingList = [str(ConstructorCallingString)]
1368
1369 Dict = {
1370 'Type' : 'Constructor',
1371 'FunctionPrototype' : ConstructorPrototypeList,
1372 'FunctionCall' : ConstructorCallingList
1373 }
1374 if Info.IsLibrary:
1375 AutoGenH.Append("${BEGIN}${FunctionPrototype}${END}", Dict)
1376 else:
1377 if Info.ModuleType in [SUP_MODULE_BASE, SUP_MODULE_SEC, SUP_MODULE_USER_DEFINED]:
1378 AutoGenC.Append(gLibraryString[SUP_MODULE_BASE].Replace(Dict))
1379 elif Info.ModuleType in SUP_MODULE_SET_PEI:
1380 AutoGenC.Append(gLibraryString['PEI'].Replace(Dict))
1381 elif Info.ModuleType in [SUP_MODULE_DXE_CORE, SUP_MODULE_DXE_DRIVER, SUP_MODULE_DXE_SMM_DRIVER, SUP_MODULE_DXE_RUNTIME_DRIVER,
1382 SUP_MODULE_DXE_SAL_DRIVER, SUP_MODULE_UEFI_DRIVER, SUP_MODULE_UEFI_APPLICATION, SUP_MODULE_SMM_CORE]:
1383 AutoGenC.Append(gLibraryString['DXE'].Replace(Dict))
1384 elif Info.ModuleType in [SUP_MODULE_MM_STANDALONE, SUP_MODULE_MM_CORE_STANDALONE]:
1385 AutoGenC.Append(gLibraryString['MM'].Replace(Dict))
1386
1387 ## Create code for library destructor
1388 #
1389 # @param Info The ModuleAutoGen object
1390 # @param AutoGenC The TemplateString object for C code
1391 # @param AutoGenH The TemplateString object for header file
1392 #
1393 def CreateLibraryDestructorCode(Info, AutoGenC, AutoGenH):
1394 #
1395 # Library Destructors
1396 #
1397 DestructorPrototypeString = TemplateString()
1398 DestructorCallingString = TemplateString()
1399 if Info.IsLibrary:
1400 DependentLibraryList = [Info.Module]
1401 else:
1402 DependentLibraryList = Info.DependentLibraryList
1403 for Index in range(len(DependentLibraryList)-1, -1, -1):
1404 Lib = DependentLibraryList[Index]
1405 if len(Lib.DestructorList) <= 0:
1406 continue
1407 Dict = {'Function':Lib.DestructorList}
1408 if Lib.ModuleType in [SUP_MODULE_BASE, SUP_MODULE_SEC]:
1409 DestructorPrototypeString.Append(gLibraryStructorPrototype[SUP_MODULE_BASE].Replace(Dict))
1410 DestructorCallingString.Append(gLibraryStructorCall[SUP_MODULE_BASE].Replace(Dict))
1411 if Info.ModuleType not in [SUP_MODULE_BASE, SUP_MODULE_USER_DEFINED]:
1412 if Lib.ModuleType in SUP_MODULE_SET_PEI:
1413 DestructorPrototypeString.Append(gLibraryStructorPrototype['PEI'].Replace(Dict))
1414 DestructorCallingString.Append(gLibraryStructorCall['PEI'].Replace(Dict))
1415 elif Lib.ModuleType in [SUP_MODULE_DXE_CORE, SUP_MODULE_DXE_DRIVER, SUP_MODULE_DXE_SMM_DRIVER, SUP_MODULE_DXE_RUNTIME_DRIVER,
1416 SUP_MODULE_DXE_SAL_DRIVER, SUP_MODULE_UEFI_DRIVER, SUP_MODULE_UEFI_APPLICATION, SUP_MODULE_SMM_CORE]:
1417 DestructorPrototypeString.Append(gLibraryStructorPrototype['DXE'].Replace(Dict))
1418 DestructorCallingString.Append(gLibraryStructorCall['DXE'].Replace(Dict))
1419 elif Lib.ModuleType in [SUP_MODULE_MM_STANDALONE, SUP_MODULE_MM_CORE_STANDALONE]:
1420 DestructorPrototypeString.Append(gLibraryStructorPrototype['MM'].Replace(Dict))
1421 DestructorCallingString.Append(gLibraryStructorCall['MM'].Replace(Dict))
1422
1423 if str(DestructorPrototypeString) == '':
1424 DestructorPrototypeList = []
1425 else:
1426 DestructorPrototypeList = [str(DestructorPrototypeString)]
1427 if str(DestructorCallingString) == '':
1428 DestructorCallingList = []
1429 else:
1430 DestructorCallingList = [str(DestructorCallingString)]
1431
1432 Dict = {
1433 'Type' : 'Destructor',
1434 'FunctionPrototype' : DestructorPrototypeList,
1435 'FunctionCall' : DestructorCallingList
1436 }
1437 if Info.IsLibrary:
1438 AutoGenH.Append("${BEGIN}${FunctionPrototype}${END}", Dict)
1439 else:
1440 if Info.ModuleType in [SUP_MODULE_BASE, SUP_MODULE_SEC, SUP_MODULE_USER_DEFINED]:
1441 AutoGenC.Append(gLibraryString[SUP_MODULE_BASE].Replace(Dict))
1442 elif Info.ModuleType in SUP_MODULE_SET_PEI:
1443 AutoGenC.Append(gLibraryString['PEI'].Replace(Dict))
1444 elif Info.ModuleType in [SUP_MODULE_DXE_CORE, SUP_MODULE_DXE_DRIVER, SUP_MODULE_DXE_SMM_DRIVER, SUP_MODULE_DXE_RUNTIME_DRIVER,
1445 SUP_MODULE_DXE_SAL_DRIVER, SUP_MODULE_UEFI_DRIVER, SUP_MODULE_UEFI_APPLICATION, SUP_MODULE_SMM_CORE]:
1446 AutoGenC.Append(gLibraryString['DXE'].Replace(Dict))
1447 elif Info.ModuleType in [SUP_MODULE_MM_STANDALONE, SUP_MODULE_MM_CORE_STANDALONE]:
1448 AutoGenC.Append(gLibraryString['MM'].Replace(Dict))
1449
1450
1451 ## Create code for ModuleEntryPoint
1452 #
1453 # @param Info The ModuleAutoGen object
1454 # @param AutoGenC The TemplateString object for C code
1455 # @param AutoGenH The TemplateString object for header file
1456 #
1457 def CreateModuleEntryPointCode(Info, AutoGenC, AutoGenH):
1458 if Info.IsLibrary or Info.ModuleType in [SUP_MODULE_USER_DEFINED, SUP_MODULE_SEC]:
1459 return
1460 ModuleEntryPointList = []
1461 for Lib in Info.DependentLibraryList:
1462 if len(Lib.ModuleEntryPointList) > 0:
1463 if Lib.ModuleType == Info.ModuleType:
1464 ModuleEntryPointList = ModuleEntryPointList + Lib.ModuleEntryPointList
1465 else:
1466 EdkLogger.error(
1467 "build",
1468 PREBUILD_ERROR,
1469 "Driver's ModuleType must be consistent [%s]"%(str(Lib)),
1470 File=str(Info.PlatformInfo),
1471 ExtraData="consumed by [%s]" % str(Info.MetaFile)
1472 )
1473 ModuleEntryPointList = ModuleEntryPointList + Info.Module.ModuleEntryPointList
1474
1475 #
1476 # Module Entry Points
1477 #
1478 NumEntryPoints = len(ModuleEntryPointList)
1479 if 'PI_SPECIFICATION_VERSION' in Info.Module.Specification:
1480 PiSpecVersion = Info.Module.Specification['PI_SPECIFICATION_VERSION']
1481 else:
1482 PiSpecVersion = '0x00000000'
1483 if 'UEFI_SPECIFICATION_VERSION' in Info.Module.Specification:
1484 UefiSpecVersion = Info.Module.Specification['UEFI_SPECIFICATION_VERSION']
1485 else:
1486 UefiSpecVersion = '0x00000000'
1487 Dict = {
1488 'Function' : ModuleEntryPointList,
1489 'PiSpecVersion' : PiSpecVersion + 'U',
1490 'UefiSpecVersion': UefiSpecVersion + 'U'
1491 }
1492
1493 if Info.ModuleType in [SUP_MODULE_PEI_CORE, SUP_MODULE_DXE_CORE, SUP_MODULE_SMM_CORE, SUP_MODULE_MM_CORE_STANDALONE]:
1494 if Info.SourceFileList:
1495 if NumEntryPoints != 1:
1496 EdkLogger.error(
1497 "build",
1498 AUTOGEN_ERROR,
1499 '%s must have exactly one entry point' % Info.ModuleType,
1500 File=str(Info),
1501 ExtraData= ", ".join(ModuleEntryPointList)
1502 )
1503 if Info.ModuleType == SUP_MODULE_PEI_CORE:
1504 AutoGenC.Append(gPeiCoreEntryPointString.Replace(Dict))
1505 AutoGenH.Append(gPeiCoreEntryPointPrototype.Replace(Dict))
1506 elif Info.ModuleType == SUP_MODULE_DXE_CORE:
1507 AutoGenC.Append(gDxeCoreEntryPointString.Replace(Dict))
1508 AutoGenH.Append(gDxeCoreEntryPointPrototype.Replace(Dict))
1509 elif Info.ModuleType == SUP_MODULE_SMM_CORE:
1510 AutoGenC.Append(gSmmCoreEntryPointString.Replace(Dict))
1511 AutoGenH.Append(gSmmCoreEntryPointPrototype.Replace(Dict))
1512 elif Info.ModuleType == SUP_MODULE_MM_CORE_STANDALONE:
1513 AutoGenC.Append(gMmCoreStandaloneEntryPointString.Replace(Dict))
1514 AutoGenH.Append(gMmCoreStandaloneEntryPointPrototype.Replace(Dict))
1515 elif Info.ModuleType == SUP_MODULE_PEIM:
1516 if NumEntryPoints < 2:
1517 AutoGenC.Append(gPeimEntryPointString[NumEntryPoints].Replace(Dict))
1518 else:
1519 AutoGenC.Append(gPeimEntryPointString[2].Replace(Dict))
1520 AutoGenH.Append(gPeimEntryPointPrototype.Replace(Dict))
1521 elif Info.ModuleType in [SUP_MODULE_DXE_RUNTIME_DRIVER, SUP_MODULE_DXE_DRIVER, SUP_MODULE_DXE_SAL_DRIVER, SUP_MODULE_UEFI_DRIVER]:
1522 if NumEntryPoints < 2:
1523 AutoGenC.Append(gUefiDriverEntryPointString[NumEntryPoints].Replace(Dict))
1524 else:
1525 AutoGenC.Append(gUefiDriverEntryPointString[2].Replace(Dict))
1526 AutoGenH.Append(gUefiDriverEntryPointPrototype.Replace(Dict))
1527 elif Info.ModuleType == SUP_MODULE_DXE_SMM_DRIVER:
1528 if NumEntryPoints == 0:
1529 AutoGenC.Append(gDxeSmmEntryPointString[0].Replace(Dict))
1530 else:
1531 AutoGenC.Append(gDxeSmmEntryPointString[1].Replace(Dict))
1532 AutoGenH.Append(gDxeSmmEntryPointPrototype.Replace(Dict))
1533 elif Info.ModuleType == SUP_MODULE_MM_STANDALONE:
1534 if NumEntryPoints < 2:
1535 AutoGenC.Append(gMmStandaloneEntryPointString[NumEntryPoints].Replace(Dict))
1536 else:
1537 AutoGenC.Append(gMmStandaloneEntryPointString[2].Replace(Dict))
1538 AutoGenH.Append(gMmStandaloneEntryPointPrototype.Replace(Dict))
1539 elif Info.ModuleType == SUP_MODULE_UEFI_APPLICATION:
1540 if NumEntryPoints < 2:
1541 AutoGenC.Append(gUefiApplicationEntryPointString[NumEntryPoints].Replace(Dict))
1542 else:
1543 AutoGenC.Append(gUefiApplicationEntryPointString[2].Replace(Dict))
1544 AutoGenH.Append(gUefiApplicationEntryPointPrototype.Replace(Dict))
1545
1546 ## Create code for ModuleUnloadImage
1547 #
1548 # @param Info The ModuleAutoGen object
1549 # @param AutoGenC The TemplateString object for C code
1550 # @param AutoGenH The TemplateString object for header file
1551 #
1552 def CreateModuleUnloadImageCode(Info, AutoGenC, AutoGenH):
1553 if Info.IsLibrary or Info.ModuleType in [SUP_MODULE_USER_DEFINED, SUP_MODULE_BASE, SUP_MODULE_SEC]:
1554 return
1555
1556 ModuleUnloadImageList = []
1557 for Lib in Info.DependentLibraryList:
1558 if len(Lib.ModuleUnloadImageList) > 0:
1559 ModuleUnloadImageList = ModuleUnloadImageList + Lib.ModuleUnloadImageList
1560 ModuleUnloadImageList = ModuleUnloadImageList + Info.Module.ModuleUnloadImageList
1561
1562 #
1563 # Unload Image Handlers
1564 #
1565 NumUnloadImage = len(ModuleUnloadImageList)
1566 Dict = {'Count':str(NumUnloadImage) + 'U', 'Function':ModuleUnloadImageList}
1567 if NumUnloadImage < 2:
1568 AutoGenC.Append(gUefiUnloadImageString[NumUnloadImage].Replace(Dict))
1569 else:
1570 AutoGenC.Append(gUefiUnloadImageString[2].Replace(Dict))
1571 AutoGenH.Append(gUefiUnloadImagePrototype.Replace(Dict))
1572
1573 ## Create code for GUID
1574 #
1575 # @param Info The ModuleAutoGen object
1576 # @param AutoGenC The TemplateString object for C code
1577 # @param AutoGenH The TemplateString object for header file
1578 #
1579 def CreateGuidDefinitionCode(Info, AutoGenC, AutoGenH):
1580 if Info.ModuleType in [SUP_MODULE_USER_DEFINED, SUP_MODULE_BASE]:
1581 GuidType = TAB_GUID
1582 else:
1583 GuidType = "EFI_GUID"
1584
1585 if Info.GuidList:
1586 if not Info.IsLibrary:
1587 AutoGenC.Append("\n// Guids\n")
1588 AutoGenH.Append("\n// Guids\n")
1589 #
1590 # GUIDs
1591 #
1592 for Key in Info.GuidList:
1593 if not Info.IsLibrary:
1594 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.GuidList[Key]))
1595 AutoGenH.Append('extern %s %s;\n' % (GuidType, Key))
1596
1597 ## Create code for protocol
1598 #
1599 # @param Info The ModuleAutoGen object
1600 # @param AutoGenC The TemplateString object for C code
1601 # @param AutoGenH The TemplateString object for header file
1602 #
1603 def CreateProtocolDefinitionCode(Info, AutoGenC, AutoGenH):
1604 if Info.ModuleType in [SUP_MODULE_USER_DEFINED, SUP_MODULE_BASE]:
1605 GuidType = TAB_GUID
1606 else:
1607 GuidType = "EFI_GUID"
1608
1609 if Info.ProtocolList:
1610 if not Info.IsLibrary:
1611 AutoGenC.Append("\n// Protocols\n")
1612 AutoGenH.Append("\n// Protocols\n")
1613 #
1614 # Protocol GUIDs
1615 #
1616 for Key in Info.ProtocolList:
1617 if not Info.IsLibrary:
1618 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.ProtocolList[Key]))
1619 AutoGenH.Append('extern %s %s;\n' % (GuidType, Key))
1620
1621 ## Create code for PPI
1622 #
1623 # @param Info The ModuleAutoGen object
1624 # @param AutoGenC The TemplateString object for C code
1625 # @param AutoGenH The TemplateString object for header file
1626 #
1627 def CreatePpiDefinitionCode(Info, AutoGenC, AutoGenH):
1628 if Info.ModuleType in [SUP_MODULE_USER_DEFINED, SUP_MODULE_BASE]:
1629 GuidType = TAB_GUID
1630 else:
1631 GuidType = "EFI_GUID"
1632
1633 if Info.PpiList:
1634 if not Info.IsLibrary:
1635 AutoGenC.Append("\n// PPIs\n")
1636 AutoGenH.Append("\n// PPIs\n")
1637 #
1638 # PPI GUIDs
1639 #
1640 for Key in Info.PpiList:
1641 if not Info.IsLibrary:
1642 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.PpiList[Key]))
1643 AutoGenH.Append('extern %s %s;\n' % (GuidType, Key))
1644
1645 ## Create code for PCD
1646 #
1647 # @param Info The ModuleAutoGen object
1648 # @param AutoGenC The TemplateString object for C code
1649 # @param AutoGenH The TemplateString object for header file
1650 #
1651 def CreatePcdCode(Info, AutoGenC, AutoGenH):
1652
1653 # Collect Token Space GUIDs used by DynamicEc PCDs
1654 TokenSpaceList = []
1655 for Pcd in Info.ModulePcdList:
1656 if Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET and Pcd.TokenSpaceGuidCName not in TokenSpaceList:
1657 TokenSpaceList.append(Pcd.TokenSpaceGuidCName)
1658
1659 SkuMgr = Info.Workspace.Platform.SkuIdMgr
1660 AutoGenH.Append("\n// Definition of SkuId Array\n")
1661 AutoGenH.Append("extern UINT64 _gPcd_SkuId_Array[];\n")
1662 # Add extern declarations to AutoGen.h if one or more Token Space GUIDs were found
1663 if TokenSpaceList:
1664 AutoGenH.Append("\n// Definition of PCD Token Space GUIDs used in this module\n\n")
1665 if Info.ModuleType in [SUP_MODULE_USER_DEFINED, SUP_MODULE_BASE]:
1666 GuidType = TAB_GUID
1667 else:
1668 GuidType = "EFI_GUID"
1669 for Item in TokenSpaceList:
1670 AutoGenH.Append('extern %s %s;\n' % (GuidType, Item))
1671
1672 if Info.IsLibrary:
1673 if Info.ModulePcdList:
1674 AutoGenH.Append("\n// PCD definitions\n")
1675 for Pcd in Info.ModulePcdList:
1676 CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd)
1677 DynExPcdTokenNumberMapping (Info, AutoGenH)
1678 else:
1679 AutoGenC.Append("\n// Definition of SkuId Array\n")
1680 AutoGenC.Append("GLOBAL_REMOVE_IF_UNREFERENCED UINT64 _gPcd_SkuId_Array[] = %s;\n" % SkuMgr.DumpSkuIdArrary())
1681 if Info.ModulePcdList:
1682 AutoGenH.Append("\n// Definition of PCDs used in this module\n")
1683 AutoGenC.Append("\n// Definition of PCDs used in this module\n")
1684 for Pcd in Info.ModulePcdList:
1685 CreateModulePcdCode(Info, AutoGenC, AutoGenH, Pcd)
1686 DynExPcdTokenNumberMapping (Info, AutoGenH)
1687 if Info.LibraryPcdList:
1688 AutoGenH.Append("\n// Definition of PCDs used in libraries is in AutoGen.c\n")
1689 AutoGenC.Append("\n// Definition of PCDs used in libraries\n")
1690 for Pcd in Info.LibraryPcdList:
1691 CreateModulePcdCode(Info, AutoGenC, AutoGenC, Pcd)
1692 CreatePcdDatabaseCode(Info, AutoGenC, AutoGenH)
1693
1694 ## Create code for unicode string definition
1695 #
1696 # @param Info The ModuleAutoGen object
1697 # @param AutoGenC The TemplateString object for C code
1698 # @param AutoGenH The TemplateString object for header file
1699 # @param UniGenCFlag UniString is generated into AutoGen C file when it is set to True
1700 # @param UniGenBinBuffer Buffer to store uni string package data
1701 #
1702 def CreateUnicodeStringCode(Info, AutoGenC, AutoGenH, UniGenCFlag, UniGenBinBuffer):
1703 WorkingDir = os.getcwd()
1704 os.chdir(Info.WorkspaceDir)
1705
1706 IncList = [Info.MetaFile.Dir]
1707 # Get all files under [Sources] section in inf file for EDK-II module
1708 EDK2Module = True
1709 SrcList = [F for F in Info.SourceFileList]
1710
1711 if 'BUILD' in Info.BuildOption and Info.BuildOption['BUILD']['FLAGS'].find('-c') > -1:
1712 CompatibleMode = True
1713 else:
1714 CompatibleMode = False
1715
1716 #
1717 # -s is a temporary option dedicated for building .UNI files with ISO 639-2 language codes of EDK Shell in EDK2
1718 #
1719 if 'BUILD' in Info.BuildOption and Info.BuildOption['BUILD']['FLAGS'].find('-s') > -1:
1720 if CompatibleMode:
1721 EdkLogger.error("build", AUTOGEN_ERROR,
1722 "-c and -s build options should be used exclusively",
1723 ExtraData="[%s]" % str(Info))
1724 ShellMode = True
1725 else:
1726 ShellMode = False
1727
1728 #RFC4646 is only for EDKII modules and ISO639-2 for EDK modules
1729 if EDK2Module:
1730 FilterInfo = [EDK2Module] + [Info.PlatformInfo.Platform.RFCLanguages]
1731 else:
1732 FilterInfo = [EDK2Module] + [Info.PlatformInfo.Platform.ISOLanguages]
1733 Header, Code = GetStringFiles(Info.UnicodeFileList, SrcList, IncList, Info.IncludePathList, ['.uni', '.inf'], Info.Name, CompatibleMode, ShellMode, UniGenCFlag, UniGenBinBuffer, FilterInfo)
1734 if CompatibleMode or UniGenCFlag:
1735 AutoGenC.Append("\n//\n//Unicode String Pack Definition\n//\n")
1736 AutoGenC.Append(Code)
1737 AutoGenC.Append("\n")
1738 AutoGenH.Append("\n//\n//Unicode String ID\n//\n")
1739 AutoGenH.Append(Header)
1740 if CompatibleMode or UniGenCFlag:
1741 AutoGenH.Append("\n#define STRING_ARRAY_NAME %sStrings\n" % Info.Name)
1742 os.chdir(WorkingDir)
1743
1744 def CreateIdfFileCode(Info, AutoGenC, StringH, IdfGenCFlag, IdfGenBinBuffer):
1745 if len(Info.IdfFileList) > 0:
1746 ImageFiles = IdfFileClassObject(sorted (Info.IdfFileList))
1747 if ImageFiles.ImageFilesDict:
1748 Index = 1
1749 PaletteIndex = 1
1750 IncList = [Info.MetaFile.Dir]
1751 SrcList = [F for F in Info.SourceFileList]
1752 SkipList = ['.jpg', '.png', '.bmp', '.inf', '.idf']
1753 FileList = GetFileList(SrcList, IncList, SkipList)
1754 ValueStartPtr = 60
1755 StringH.Append("\n//\n//Image ID\n//\n")
1756 ImageInfoOffset = 0
1757 PaletteInfoOffset = 0
1758 ImageBuffer = pack('x')
1759 PaletteBuffer = pack('x')
1760 BufferStr = ''
1761 PaletteStr = ''
1762 FileDict = {}
1763 for Idf in ImageFiles.ImageFilesDict:
1764 if ImageFiles.ImageFilesDict[Idf]:
1765 for FileObj in ImageFiles.ImageFilesDict[Idf]:
1766 for sourcefile in Info.SourceFileList:
1767 if FileObj.FileName == sourcefile.File:
1768 if not sourcefile.Ext.upper() in ['.PNG', '.BMP', '.JPG']:
1769 EdkLogger.error("build", AUTOGEN_ERROR, "The %s's postfix must be one of .bmp, .jpg, .png" % (FileObj.FileName), ExtraData="[%s]" % str(Info))
1770 FileObj.File = sourcefile
1771 break
1772 else:
1773 EdkLogger.error("build", AUTOGEN_ERROR, "The %s in %s is not defined in the driver's [Sources] section" % (FileObj.FileName, Idf), ExtraData="[%s]" % str(Info))
1774
1775 for FileObj in ImageFiles.ImageFilesDict[Idf]:
1776 ID = FileObj.ImageID
1777 File = FileObj.File
1778 if not os.path.exists(File.Path) or not os.path.isfile(File.Path):
1779 EdkLogger.error("build", FILE_NOT_FOUND, ExtraData=File.Path)
1780 SearchImageID (FileObj, FileList)
1781 if FileObj.Referenced:
1782 if (ValueStartPtr - len(DEFINE_STR + ID)) <= 0:
1783 Line = DEFINE_STR + ' ' + ID + ' ' + DecToHexStr(Index, 4) + '\n'
1784 else:
1785 Line = DEFINE_STR + ' ' + ID + ' ' * (ValueStartPtr - len(DEFINE_STR + ID)) + DecToHexStr(Index, 4) + '\n'
1786
1787 if File not in FileDict:
1788 FileDict[File] = Index
1789 else:
1790 DuplicateBlock = pack('B', EFI_HII_IIBT_DUPLICATE)
1791 DuplicateBlock += pack('H', FileDict[File])
1792 ImageBuffer += DuplicateBlock
1793 BufferStr = WriteLine(BufferStr, '// %s: %s: %s' % (DecToHexStr(Index, 4), ID, DecToHexStr(Index, 4)))
1794 TempBufferList = AscToHexList(DuplicateBlock)
1795 BufferStr = WriteLine(BufferStr, CreateArrayItem(TempBufferList, 16) + '\n')
1796 StringH.Append(Line)
1797 Index += 1
1798 continue
1799
1800 TmpFile = open(File.Path, 'rb')
1801 Buffer = TmpFile.read()
1802 TmpFile.close()
1803 if File.Ext.upper() == '.PNG':
1804 TempBuffer = pack('B', EFI_HII_IIBT_IMAGE_PNG)
1805 TempBuffer += pack('I', len(Buffer))
1806 TempBuffer += Buffer
1807 elif File.Ext.upper() == '.JPG':
1808 ImageType, = struct.unpack('4s', Buffer[6:10])
1809 if ImageType != b'JFIF':
1810 EdkLogger.error("build", FILE_TYPE_MISMATCH, "The file %s is not a standard JPG file." % File.Path)
1811 TempBuffer = pack('B', EFI_HII_IIBT_IMAGE_JPEG)
1812 TempBuffer += pack('I', len(Buffer))
1813 TempBuffer += Buffer
1814 elif File.Ext.upper() == '.BMP':
1815 TempBuffer, TempPalette = BmpImageDecoder(File, Buffer, PaletteIndex, FileObj.TransParent)
1816 if len(TempPalette) > 1:
1817 PaletteIndex += 1
1818 NewPalette = pack('H', len(TempPalette))
1819 NewPalette += TempPalette
1820 PaletteBuffer += NewPalette
1821 PaletteStr = WriteLine(PaletteStr, '// %s: %s: %s' % (DecToHexStr(PaletteIndex - 1, 4), ID, DecToHexStr(PaletteIndex - 1, 4)))
1822 TempPaletteList = AscToHexList(NewPalette)
1823 PaletteStr = WriteLine(PaletteStr, CreateArrayItem(TempPaletteList, 16) + '\n')
1824 ImageBuffer += TempBuffer
1825 BufferStr = WriteLine(BufferStr, '// %s: %s: %s' % (DecToHexStr(Index, 4), ID, DecToHexStr(Index, 4)))
1826 TempBufferList = AscToHexList(TempBuffer)
1827 BufferStr = WriteLine(BufferStr, CreateArrayItem(TempBufferList, 16) + '\n')
1828
1829 StringH.Append(Line)
1830 Index += 1
1831
1832 BufferStr = WriteLine(BufferStr, '// End of the Image Info')
1833 BufferStr = WriteLine(BufferStr, CreateArrayItem(DecToHexList(EFI_HII_IIBT_END, 2)) + '\n')
1834 ImageEnd = pack('B', EFI_HII_IIBT_END)
1835 ImageBuffer += ImageEnd
1836
1837 if len(ImageBuffer) > 1:
1838 ImageInfoOffset = 12
1839 if len(PaletteBuffer) > 1:
1840 PaletteInfoOffset = 12 + len(ImageBuffer) - 1 # -1 is for the first empty pad byte of ImageBuffer
1841
1842 IMAGE_PACKAGE_HDR = pack('=II', ImageInfoOffset, PaletteInfoOffset)
1843 # PACKAGE_HEADER_Length = PACKAGE_HEADER + ImageInfoOffset + PaletteInfoOffset + ImageBuffer Length + PaletteCount + PaletteBuffer Length
1844 if len(PaletteBuffer) > 1:
1845 PACKAGE_HEADER_Length = 4 + 4 + 4 + len(ImageBuffer) - 1 + 2 + len(PaletteBuffer) - 1
1846 else:
1847 PACKAGE_HEADER_Length = 4 + 4 + 4 + len(ImageBuffer) - 1
1848 if PaletteIndex > 1:
1849 PALETTE_INFO_HEADER = pack('H', PaletteIndex - 1)
1850 # EFI_HII_PACKAGE_HEADER length max value is 0xFFFFFF
1851 Hex_Length = '%06X' % PACKAGE_HEADER_Length
1852 if PACKAGE_HEADER_Length > 0xFFFFFF:
1853 EdkLogger.error("build", AUTOGEN_ERROR, "The Length of EFI_HII_PACKAGE_HEADER exceed its maximum value", ExtraData="[%s]" % str(Info))
1854 PACKAGE_HEADER = pack('=HBB', int('0x' + Hex_Length[2:], 16), int('0x' + Hex_Length[0:2], 16), EFI_HII_PACKAGE_IMAGES)
1855
1856 IdfGenBinBuffer.write(PACKAGE_HEADER)
1857 IdfGenBinBuffer.write(IMAGE_PACKAGE_HDR)
1858 if len(ImageBuffer) > 1 :
1859 IdfGenBinBuffer.write(ImageBuffer[1:])
1860 if PaletteIndex > 1:
1861 IdfGenBinBuffer.write(PALETTE_INFO_HEADER)
1862 if len(PaletteBuffer) > 1:
1863 IdfGenBinBuffer.write(PaletteBuffer[1:])
1864
1865 if IdfGenCFlag:
1866 TotalLength = EFI_HII_ARRAY_SIZE_LENGTH + PACKAGE_HEADER_Length
1867 AutoGenC.Append("\n//\n//Image Pack Definition\n//\n")
1868 AllStr = WriteLine('', CHAR_ARRAY_DEFIN + ' ' + Info.Module.BaseName + 'Images' + '[] = {\n')
1869 AllStr = WriteLine(AllStr, '// STRGATHER_OUTPUT_HEADER')
1870 AllStr = WriteLine(AllStr, CreateArrayItem(DecToHexList(TotalLength)) + '\n')
1871 AllStr = WriteLine(AllStr, '// Image PACKAGE HEADER\n')
1872 IMAGE_PACKAGE_HDR_List = AscToHexList(PACKAGE_HEADER)
1873 IMAGE_PACKAGE_HDR_List += AscToHexList(IMAGE_PACKAGE_HDR)
1874 AllStr = WriteLine(AllStr, CreateArrayItem(IMAGE_PACKAGE_HDR_List, 16) + '\n')
1875 AllStr = WriteLine(AllStr, '// Image DATA\n')
1876 if BufferStr:
1877 AllStr = WriteLine(AllStr, BufferStr)
1878 if PaletteStr:
1879 AllStr = WriteLine(AllStr, '// Palette Header\n')
1880 PALETTE_INFO_HEADER_List = AscToHexList(PALETTE_INFO_HEADER)
1881 AllStr = WriteLine(AllStr, CreateArrayItem(PALETTE_INFO_HEADER_List, 16) + '\n')
1882 AllStr = WriteLine(AllStr, '// Palette Data\n')
1883 AllStr = WriteLine(AllStr, PaletteStr)
1884 AllStr = WriteLine(AllStr, '};')
1885 AutoGenC.Append(AllStr)
1886 AutoGenC.Append("\n")
1887 StringH.Append('\nextern unsigned char ' + Info.Module.BaseName + 'Images[];\n')
1888 StringH.Append("\n#define IMAGE_ARRAY_NAME %sImages\n" % Info.Module.BaseName)
1889
1890 # typedef struct _EFI_HII_IMAGE_PACKAGE_HDR {
1891 # EFI_HII_PACKAGE_HEADER Header; # Standard package header, where Header.Type = EFI_HII_PACKAGE_IMAGES
1892 # UINT32 ImageInfoOffset;
1893 # UINT32 PaletteInfoOffset;
1894 # } EFI_HII_IMAGE_PACKAGE_HDR;
1895
1896 # typedef struct {
1897 # UINT32 Length:24;
1898 # UINT32 Type:8;
1899 # UINT8 Data[];
1900 # } EFI_HII_PACKAGE_HEADER;
1901
1902 # typedef struct _EFI_HII_IMAGE_BLOCK {
1903 # UINT8 BlockType;
1904 # UINT8 BlockBody[];
1905 # } EFI_HII_IMAGE_BLOCK;
1906
1907 def BmpImageDecoder(File, Buffer, PaletteIndex, TransParent):
1908 ImageType, = struct.unpack('2s', Buffer[0:2])
1909 if ImageType!= b'BM': # BMP file type is 'BM'
1910 EdkLogger.error("build", FILE_TYPE_MISMATCH, "The file %s is not a standard BMP file." % File.Path)
1911 BMP_IMAGE_HEADER = collections.namedtuple('BMP_IMAGE_HEADER', ['bfSize', 'bfReserved1', 'bfReserved2', 'bfOffBits', 'biSize', 'biWidth', 'biHeight', 'biPlanes', 'biBitCount', 'biCompression', 'biSizeImage', 'biXPelsPerMeter', 'biYPelsPerMeter', 'biClrUsed', 'biClrImportant'])
1912 BMP_IMAGE_HEADER_STRUCT = struct.Struct('IHHIIIIHHIIIIII')
1913 BmpHeader = BMP_IMAGE_HEADER._make(BMP_IMAGE_HEADER_STRUCT.unpack_from(Buffer[2:]))
1914 #
1915 # Doesn't support compress.
1916 #
1917 if BmpHeader.biCompression != 0:
1918 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "The compress BMP file %s is not support." % File.Path)
1919
1920 # The Width and Height is UINT16 type in Image Package
1921 if BmpHeader.biWidth > 0xFFFF:
1922 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "The BMP file %s Width is exceed 0xFFFF." % File.Path)
1923 if BmpHeader.biHeight > 0xFFFF:
1924 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "The BMP file %s Height is exceed 0xFFFF." % File.Path)
1925
1926 PaletteBuffer = pack('x')
1927 if BmpHeader.biBitCount == 1:
1928 if TransParent:
1929 ImageBuffer = pack('B', EFI_HII_IIBT_IMAGE_1BIT_TRANS)
1930 else:
1931 ImageBuffer = pack('B', EFI_HII_IIBT_IMAGE_1BIT)
1932 ImageBuffer += pack('B', PaletteIndex)
1933 Width = (BmpHeader.biWidth + 7)//8
1934 if BmpHeader.bfOffBits > BMP_IMAGE_HEADER_STRUCT.size + 2:
1935 PaletteBuffer = Buffer[BMP_IMAGE_HEADER_STRUCT.size + 2 : BmpHeader.bfOffBits]
1936 elif BmpHeader.biBitCount == 4:
1937 if TransParent:
1938 ImageBuffer = pack('B', EFI_HII_IIBT_IMAGE_4BIT_TRANS)
1939 else:
1940 ImageBuffer = pack('B', EFI_HII_IIBT_IMAGE_4BIT)
1941 ImageBuffer += pack('B', PaletteIndex)
1942 Width = (BmpHeader.biWidth + 1)//2
1943 if BmpHeader.bfOffBits > BMP_IMAGE_HEADER_STRUCT.size + 2:
1944 PaletteBuffer = Buffer[BMP_IMAGE_HEADER_STRUCT.size + 2 : BmpHeader.bfOffBits]
1945 elif BmpHeader.biBitCount == 8:
1946 if TransParent:
1947 ImageBuffer = pack('B', EFI_HII_IIBT_IMAGE_8BIT_TRANS)
1948 else:
1949 ImageBuffer = pack('B', EFI_HII_IIBT_IMAGE_8BIT)
1950 ImageBuffer += pack('B', PaletteIndex)
1951 Width = BmpHeader.biWidth
1952 if BmpHeader.bfOffBits > BMP_IMAGE_HEADER_STRUCT.size + 2:
1953 PaletteBuffer = Buffer[BMP_IMAGE_HEADER_STRUCT.size + 2 : BmpHeader.bfOffBits]
1954 elif BmpHeader.biBitCount == 24:
1955 if TransParent:
1956 ImageBuffer = pack('B', EFI_HII_IIBT_IMAGE_24BIT_TRANS)
1957 else:
1958 ImageBuffer = pack('B', EFI_HII_IIBT_IMAGE_24BIT)
1959 Width = BmpHeader.biWidth * 3
1960 else:
1961 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "Only support the 1 bit, 4 bit, 8bit, 24 bit BMP files.", ExtraData="[%s]" % str(File.Path))
1962
1963 ImageBuffer += pack('H', BmpHeader.biWidth)
1964 ImageBuffer += pack('H', BmpHeader.biHeight)
1965 Start = BmpHeader.bfOffBits
1966 End = BmpHeader.bfSize - 1
1967 for Height in range(0, BmpHeader.biHeight):
1968 if Width % 4 != 0:
1969 Start = End + (Width % 4) - 4 - Width
1970 else:
1971 Start = End - Width
1972 ImageBuffer += Buffer[Start + 1 : Start + Width + 1]
1973 End = Start
1974
1975 # handle the Palette info, BMP use 4 bytes for R, G, B and Reserved info while EFI_HII_RGB_PIXEL only have the R, G, B info
1976 if PaletteBuffer and len(PaletteBuffer) > 1:
1977 PaletteTemp = pack('x')
1978 for Index in range(0, len(PaletteBuffer)):
1979 if Index % 4 == 3:
1980 continue
1981 PaletteTemp += PaletteBuffer[Index:Index+1]
1982 PaletteBuffer = PaletteTemp[1:]
1983 return ImageBuffer, PaletteBuffer
1984
1985 ## Create common code
1986 #
1987 # @param Info The ModuleAutoGen object
1988 # @param AutoGenC The TemplateString object for C code
1989 # @param AutoGenH The TemplateString object for header file
1990 #
1991 def CreateHeaderCode(Info, AutoGenC, AutoGenH):
1992 # file header
1993 AutoGenH.Append(gAutoGenHeaderString.Replace({'FileName':'AutoGen.h'}))
1994 # header file Prologue
1995 AutoGenH.Append(gAutoGenHPrologueString.Replace({'File':'AUTOGENH','Guid':Info.Guid.replace('-', '_')}))
1996 AutoGenH.Append(gAutoGenHCppPrologueString)
1997
1998 # header files includes
1999 if Info.ModuleType in gModuleTypeHeaderFile:
2000 AutoGenH.Append("#include <%s>\n" % gModuleTypeHeaderFile[Info.ModuleType][0])
2001 #
2002 # if either PcdLib in [LibraryClasses] sections or there exist Pcd section, add PcdLib.h
2003 # As if modules only uses FixedPcd, then PcdLib is not needed in [LibraryClasses] section.
2004 #
2005 if 'PcdLib' in Info.Module.LibraryClasses or Info.Module.Pcds:
2006 AutoGenH.Append("#include <Library/PcdLib.h>\n")
2007
2008 AutoGenH.Append('\nextern GUID gEfiCallerIdGuid;')
2009 AutoGenH.Append('\nextern CHAR8 *gEfiCallerBaseName;\n\n')
2010
2011 if Info.IsLibrary:
2012 return
2013
2014 AutoGenH.Append("#define EFI_CALLER_ID_GUID \\\n %s\n" % GuidStringToGuidStructureString(Info.Guid))
2015
2016 if Info.IsLibrary:
2017 return
2018 # C file header
2019 AutoGenC.Append(gAutoGenHeaderString.Replace({'FileName':'AutoGen.c'}))
2020 # C file header files includes
2021 if Info.ModuleType in gModuleTypeHeaderFile:
2022 for Inc in gModuleTypeHeaderFile[Info.ModuleType]:
2023 AutoGenC.Append("#include <%s>\n" % Inc)
2024 else:
2025 AutoGenC.Append("#include <%s>\n" % gBasicHeaderFile)
2026
2027 #
2028 # Publish the CallerId Guid
2029 #
2030 AutoGenC.Append('\nGLOBAL_REMOVE_IF_UNREFERENCED GUID gEfiCallerIdGuid = %s;\n' % GuidStringToGuidStructureString(Info.Guid))
2031 AutoGenC.Append('\nGLOBAL_REMOVE_IF_UNREFERENCED CHAR8 *gEfiCallerBaseName = "%s";\n' % Info.Name)
2032
2033 ## Create common code for header file
2034 #
2035 # @param Info The ModuleAutoGen object
2036 # @param AutoGenC The TemplateString object for C code
2037 # @param AutoGenH The TemplateString object for header file
2038 #
2039 def CreateFooterCode(Info, AutoGenC, AutoGenH):
2040 AutoGenH.Append(gAutoGenHEpilogueString)
2041
2042 ## Create code for a module
2043 #
2044 # @param Info The ModuleAutoGen object
2045 # @param AutoGenC The TemplateString object for C code
2046 # @param AutoGenH The TemplateString object for header file
2047 # @param StringH The TemplateString object for header file
2048 # @param UniGenCFlag UniString is generated into AutoGen C file when it is set to True
2049 # @param UniGenBinBuffer Buffer to store uni string package data
2050 # @param StringIdf The TemplateString object for header file
2051 # @param IdfGenCFlag IdfString is generated into AutoGen C file when it is set to True
2052 # @param IdfGenBinBuffer Buffer to store Idf string package data
2053 #
2054 def CreateCode(Info, AutoGenC, AutoGenH, StringH, UniGenCFlag, UniGenBinBuffer, StringIdf, IdfGenCFlag, IdfGenBinBuffer):
2055 CreateHeaderCode(Info, AutoGenC, AutoGenH)
2056
2057 CreateGuidDefinitionCode(Info, AutoGenC, AutoGenH)
2058 CreateProtocolDefinitionCode(Info, AutoGenC, AutoGenH)
2059 CreatePpiDefinitionCode(Info, AutoGenC, AutoGenH)
2060 CreatePcdCode(Info, AutoGenC, AutoGenH)
2061 CreateLibraryConstructorCode(Info, AutoGenC, AutoGenH)
2062 CreateLibraryDestructorCode(Info, AutoGenC, AutoGenH)
2063 CreateModuleEntryPointCode(Info, AutoGenC, AutoGenH)
2064 CreateModuleUnloadImageCode(Info, AutoGenC, AutoGenH)
2065
2066 if Info.UnicodeFileList:
2067 FileName = "%sStrDefs.h" % Info.Name
2068 StringH.Append(gAutoGenHeaderString.Replace({'FileName':FileName}))
2069 StringH.Append(gAutoGenHPrologueString.Replace({'File':'STRDEFS', 'Guid':Info.Guid.replace('-', '_')}))
2070 CreateUnicodeStringCode(Info, AutoGenC, StringH, UniGenCFlag, UniGenBinBuffer)
2071
2072 GuidMacros = []
2073 for Guid in Info.Module.Guids:
2074 if Guid in Info.Module.GetGuidsUsedByPcd():
2075 continue
2076 GuidMacros.append('#define %s %s' % (Guid, Info.Module.Guids[Guid]))
2077 for Guid, Value in list(Info.Module.Protocols.items()) + list(Info.Module.Ppis.items()):
2078 GuidMacros.append('#define %s %s' % (Guid, Value))
2079 # supports FixedAtBuild and FeaturePcd usage in VFR file
2080 if Info.VfrFileList and Info.ModulePcdList:
2081 GuidMacros.append('#define %s %s' % ('FixedPcdGetBool(TokenName)', '_PCD_VALUE_##TokenName'))
2082 GuidMacros.append('#define %s %s' % ('FixedPcdGet8(TokenName)', '_PCD_VALUE_##TokenName'))
2083 GuidMacros.append('#define %s %s' % ('FixedPcdGet16(TokenName)', '_PCD_VALUE_##TokenName'))
2084 GuidMacros.append('#define %s %s' % ('FixedPcdGet32(TokenName)', '_PCD_VALUE_##TokenName'))
2085 GuidMacros.append('#define %s %s' % ('FixedPcdGet64(TokenName)', '_PCD_VALUE_##TokenName'))
2086 GuidMacros.append('#define %s %s' % ('FeaturePcdGet(TokenName)', '_PCD_VALUE_##TokenName'))
2087 for Pcd in Info.ModulePcdList:
2088 if Pcd.Type in [TAB_PCDS_FIXED_AT_BUILD, TAB_PCDS_FEATURE_FLAG]:
2089 TokenCName = Pcd.TokenCName
2090 Value = Pcd.DefaultValue
2091 if Pcd.DatumType == 'BOOLEAN':
2092 BoolValue = Value.upper()
2093 if BoolValue == 'TRUE':
2094 Value = '1'
2095 elif BoolValue == 'FALSE':
2096 Value = '0'
2097 for PcdItem in GlobalData.MixedPcd:
2098 if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:
2099 TokenCName = PcdItem[0]
2100 break
2101 GuidMacros.append('#define %s %s' % ('_PCD_VALUE_'+TokenCName, Value))
2102
2103 if Info.IdfFileList:
2104 GuidMacros.append('#include "%sImgDefs.h"' % Info.Name)
2105
2106 if GuidMacros:
2107 StringH.Append('\n#ifdef VFRCOMPILE\n%s\n#endif\n' % '\n'.join(GuidMacros))
2108
2109 StringH.Append("\n#endif\n")
2110 AutoGenH.Append('#include "%s"\n' % FileName)
2111
2112 if Info.IdfFileList:
2113 FileName = "%sImgDefs.h" % Info.Name
2114 StringIdf.Append(gAutoGenHeaderString.Replace({'FileName':FileName}))
2115 StringIdf.Append(gAutoGenHPrologueString.Replace({'File':'IMAGEDEFS', 'Guid':Info.Guid.replace('-', '_')}))
2116 CreateIdfFileCode(Info, AutoGenC, StringIdf, IdfGenCFlag, IdfGenBinBuffer)
2117
2118 StringIdf.Append("\n#endif\n")
2119 AutoGenH.Append('#include "%s"\n' % FileName)
2120
2121 CreateFooterCode(Info, AutoGenC, AutoGenH)
2122
2123 ## Create the code file
2124 #
2125 # @param FilePath The path of code file
2126 # @param Content The content of code file
2127 # @param IsBinaryFile The flag indicating if the file is binary file or not
2128 #
2129 # @retval True If file content is changed or file doesn't exist
2130 # @retval False If the file exists and the content is not changed
2131 #
2132 def Generate(FilePath, Content, IsBinaryFile):
2133 return SaveFileOnChange(FilePath, Content, IsBinaryFile)
2134
EFI Development Kit II mirror for PVE