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