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