]> 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: Support Structure PCD value inherit between the different SKUs
[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 not in ['UINT8', 'UINT16', 'UINT32', 'UINT64', 'BOOLEAN']:
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 else:
893 return Pcd.MaxDatumSize
894
895
896 ## Create code for module PCDs
897 #
898 # @param Info The ModuleAutoGen object
899 # @param AutoGenC The TemplateString object for C code
900 # @param AutoGenH The TemplateString object for header file
901 # @param Pcd The PCD object
902 #
903 def CreateModulePcdCode(Info, AutoGenC, AutoGenH, Pcd):
904 TokenSpaceGuidValue = Pcd.TokenSpaceGuidValue #Info.GuidList[Pcd.TokenSpaceGuidCName]
905 PcdTokenNumber = Info.PlatformInfo.PcdTokenNumber
906 #
907 # Write PCDs
908 #
909 TokenCName = Pcd.TokenCName
910 for PcdItem in GlobalData.MixedPcd:
911 if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:
912 TokenCName = PcdItem[0]
913 break
914 PcdTokenName = '_PCD_TOKEN_' + TokenCName
915 PatchPcdSizeTokenName = '_PCD_PATCHABLE_' + TokenCName +'_SIZE'
916 PatchPcdSizeVariableName = '_gPcd_BinaryPatch_Size_' + TokenCName
917 FixPcdSizeTokenName = '_PCD_SIZE_' + TokenCName
918
919 if GlobalData.BuildOptionPcd:
920 for PcdItem in GlobalData.BuildOptionPcd:
921 if (Pcd.TokenSpaceGuidCName, TokenCName) == (PcdItem[0], PcdItem[1]):
922 Pcd.DefaultValue = PcdItem[2]
923 break
924
925 if Pcd.Type in gDynamicExPcd:
926 TokenNumber = int(Pcd.TokenValue, 0)
927 # Add TokenSpaceGuidValue value to PcdTokenName to discriminate the DynamicEx PCDs with
928 # different Guids but same TokenCName
929 PcdExTokenName = '_PCD_TOKEN_' + Pcd.TokenSpaceGuidCName + '_' + TokenCName
930 AutoGenH.Append('\n#define %s %dU\n' % (PcdExTokenName, TokenNumber))
931 else:
932 if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in PcdTokenNumber:
933 # If one of the Source built modules listed in the DSC is not listed in FDF modules,
934 # and the INF lists a PCD can only use the PcdsDynamic access method (it is only
935 # listed in the DEC file that declares the PCD as PcdsDynamic), then build tool will
936 # report warning message notify the PI that they are attempting to build a module
937 # that must be included in a flash image in order to be functional. These Dynamic PCD
938 # will not be added into the Database unless it is used by other modules that are
939 # included in the FDF file.
940 # In this case, just assign an invalid token number to make it pass build.
941 if Pcd.Type in PCD_DYNAMIC_TYPE_LIST:
942 TokenNumber = 0
943 else:
944 EdkLogger.error("build", AUTOGEN_ERROR,
945 "No generated token number for %s.%s\n" % (Pcd.TokenSpaceGuidCName, TokenCName),
946 ExtraData="[%s]" % str(Info))
947 else:
948 TokenNumber = PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName]
949 AutoGenH.Append('\n#define %s %dU\n' % (PcdTokenName, TokenNumber))
950
951 EdkLogger.debug(EdkLogger.DEBUG_3, "Creating code for " + TokenCName + "." + Pcd.TokenSpaceGuidCName)
952 if Pcd.Type not in gItemTypeStringDatabase:
953 EdkLogger.error("build", AUTOGEN_ERROR,
954 "Unknown PCD type [%s] of PCD %s.%s" % (Pcd.Type, Pcd.TokenSpaceGuidCName, TokenCName),
955 ExtraData="[%s]" % str(Info))
956
957 DatumSize = gDatumSizeStringDatabase[Pcd.DatumType] if Pcd.DatumType in gDatumSizeStringDatabase else gDatumSizeStringDatabase['VOID*']
958 DatumSizeLib = gDatumSizeStringDatabaseLib[Pcd.DatumType] if Pcd.DatumType in gDatumSizeStringDatabaseLib else gDatumSizeStringDatabaseLib['VOID*']
959 GetModeName = '_PCD_GET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + TokenCName if Pcd.DatumType in gDatumSizeStringDatabaseH else '_PCD_GET_MODE_' + gDatumSizeStringDatabaseH['VOID*'] + '_' + TokenCName
960 SetModeName = '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + TokenCName if Pcd.DatumType in gDatumSizeStringDatabaseH else '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH['VOID*'] + '_' + TokenCName
961 SetModeStatusName = '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_S_' + TokenCName if Pcd.DatumType in gDatumSizeStringDatabaseH else '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH['VOID*'] + '_S_' + TokenCName
962 GetModeSizeName = '_PCD_GET_MODE_SIZE' + '_' + TokenCName
963
964 PcdExCNameList = []
965 if Pcd.Type in gDynamicExPcd:
966 if Info.IsLibrary:
967 PcdList = Info.LibraryPcdList
968 else:
969 PcdList = Info.ModulePcdList
970 for PcdModule in PcdList:
971 if PcdModule.Type in gDynamicExPcd:
972 PcdExCNameList.append(PcdModule.TokenCName)
973 # Be compatible with the current code which using PcdToken and PcdGet/Set for DynamicEx Pcd.
974 # If only PcdToken and PcdGet/Set used in all Pcds with different CName, it should succeed to build.
975 # If PcdToken and PcdGet/Set used in the Pcds with different Guids but same CName, it should failed to build.
976 if PcdExCNameList.count(Pcd.TokenCName) > 1:
977 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')
978 AutoGenH.Append('// #define %s %s\n' % (PcdTokenName, PcdExTokenName))
979 AutoGenH.Append('// #define %s LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
980 AutoGenH.Append('// #define %s LibPcdGetExSize(&%s, %s)\n' % (GetModeSizeName,Pcd.TokenSpaceGuidCName, PcdTokenName))
981 if Pcd.DatumType not in ['UINT8', 'UINT16', 'UINT32', 'UINT64', 'BOOLEAN']:
982 AutoGenH.Append('// #define %s(SizeOfBuffer, Buffer) LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
983 AutoGenH.Append('// #define %s(SizeOfBuffer, Buffer) LibPcdSetEx%sS(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
984 else:
985 AutoGenH.Append('// #define %s(Value) LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
986 AutoGenH.Append('// #define %s(Value) LibPcdSetEx%sS(&%s, %s, (Value))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
987 else:
988 AutoGenH.Append('#define %s %s\n' % (PcdTokenName, PcdExTokenName))
989 AutoGenH.Append('#define %s LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
990 AutoGenH.Append('#define %s LibPcdGetExSize(&%s, %s)\n' % (GetModeSizeName,Pcd.TokenSpaceGuidCName, PcdTokenName))
991 if Pcd.DatumType not in ['UINT8', 'UINT16', 'UINT32', 'UINT64', 'BOOLEAN']:
992 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer) LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
993 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer) LibPcdSetEx%sS(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
994 else:
995 AutoGenH.Append('#define %s(Value) LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
996 AutoGenH.Append('#define %s(Value) LibPcdSetEx%sS(&%s, %s, (Value))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
997 elif Pcd.Type in gDynamicPcd:
998 PcdList = []
999 PcdCNameList = []
1000 PcdList.extend(Info.LibraryPcdList)
1001 PcdList.extend(Info.ModulePcdList)
1002 for PcdModule in PcdList:
1003 if PcdModule.Type in gDynamicPcd:
1004 PcdCNameList.append(PcdModule.TokenCName)
1005 if PcdCNameList.count(Pcd.TokenCName) > 1:
1006 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))
1007 else:
1008 AutoGenH.Append('#define %s LibPcdGet%s(%s)\n' % (GetModeName, DatumSizeLib, PcdTokenName))
1009 AutoGenH.Append('#define %s LibPcdGetSize(%s)\n' % (GetModeSizeName, PcdTokenName))
1010 if Pcd.DatumType not in ['UINT8', 'UINT16', 'UINT32', 'UINT64', 'BOOLEAN']:
1011 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer) LibPcdSet%s(%s, (SizeOfBuffer), (Buffer))\n' %(SetModeName, DatumSizeLib, PcdTokenName))
1012 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer) LibPcdSet%sS(%s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, DatumSizeLib, PcdTokenName))
1013 else:
1014 AutoGenH.Append('#define %s(Value) LibPcdSet%s(%s, (Value))\n' % (SetModeName, DatumSizeLib, PcdTokenName))
1015 AutoGenH.Append('#define %s(Value) LibPcdSet%sS(%s, (Value))\n' % (SetModeStatusName, DatumSizeLib, PcdTokenName))
1016 else:
1017 PcdVariableName = '_gPcd_' + gItemTypeStringDatabase[Pcd.Type] + '_' + TokenCName
1018 Const = 'const'
1019 if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
1020 Const = ''
1021 Type = ''
1022 Array = ''
1023 Value = Pcd.DefaultValue
1024 Unicode = False
1025 ValueNumber = 0
1026
1027 if Pcd.DatumType == 'BOOLEAN':
1028 BoolValue = Value.upper()
1029 if BoolValue == 'TRUE' or BoolValue == '1':
1030 Value = '1U'
1031 elif BoolValue == 'FALSE' or BoolValue == '0':
1032 Value = '0U'
1033
1034 if Pcd.DatumType in ['UINT64', 'UINT32', 'UINT16', 'UINT8']:
1035 try:
1036 if Value.upper().startswith('0X'):
1037 ValueNumber = int (Value, 16)
1038 else:
1039 ValueNumber = int (Value)
1040 except:
1041 EdkLogger.error("build", AUTOGEN_ERROR,
1042 "PCD value is not valid dec or hex number for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, TokenCName),
1043 ExtraData="[%s]" % str(Info))
1044 if Pcd.DatumType == 'UINT64':
1045 if ValueNumber < 0:
1046 EdkLogger.error("build", AUTOGEN_ERROR,
1047 "PCD can't be set to negative value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, TokenCName),
1048 ExtraData="[%s]" % str(Info))
1049 elif ValueNumber >= 0x10000000000000000:
1050 EdkLogger.error("build", AUTOGEN_ERROR,
1051 "Too large PCD value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, TokenCName),
1052 ExtraData="[%s]" % str(Info))
1053 if not Value.endswith('ULL'):
1054 Value += 'ULL'
1055 elif Pcd.DatumType == 'UINT32':
1056 if ValueNumber < 0:
1057 EdkLogger.error("build", AUTOGEN_ERROR,
1058 "PCD can't be set to negative value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, TokenCName),
1059 ExtraData="[%s]" % str(Info))
1060 elif ValueNumber >= 0x100000000:
1061 EdkLogger.error("build", AUTOGEN_ERROR,
1062 "Too large PCD value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, TokenCName),
1063 ExtraData="[%s]" % str(Info))
1064 if not Value.endswith('U'):
1065 Value += 'U'
1066 elif Pcd.DatumType == 'UINT16':
1067 if ValueNumber < 0:
1068 EdkLogger.error("build", AUTOGEN_ERROR,
1069 "PCD can't be set to negative value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, TokenCName),
1070 ExtraData="[%s]" % str(Info))
1071 elif ValueNumber >= 0x10000:
1072 EdkLogger.error("build", AUTOGEN_ERROR,
1073 "Too large PCD value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, TokenCName),
1074 ExtraData="[%s]" % str(Info))
1075 if not Value.endswith('U'):
1076 Value += 'U'
1077 elif Pcd.DatumType == 'UINT8':
1078 if ValueNumber < 0:
1079 EdkLogger.error("build", AUTOGEN_ERROR,
1080 "PCD can't be set to negative value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, TokenCName),
1081 ExtraData="[%s]" % str(Info))
1082 elif ValueNumber >= 0x100:
1083 EdkLogger.error("build", AUTOGEN_ERROR,
1084 "Too large PCD value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, TokenCName),
1085 ExtraData="[%s]" % str(Info))
1086 if not Value.endswith('U'):
1087 Value += 'U'
1088 if Pcd.DatumType not in ['UINT8', 'UINT16', 'UINT32', 'UINT64', 'BOOLEAN']:
1089 if Pcd.MaxDatumSize == None or Pcd.MaxDatumSize == '':
1090 EdkLogger.error("build", AUTOGEN_ERROR,
1091 "Unknown [MaxDatumSize] of PCD [%s.%s]" % (Pcd.TokenSpaceGuidCName, TokenCName),
1092 ExtraData="[%s]" % str(Info))
1093
1094 ArraySize = int(Pcd.MaxDatumSize, 0)
1095 if Value[0] == '{':
1096 Type = '(VOID *)'
1097 else:
1098 if Value[0] == 'L':
1099 Unicode = True
1100 Value = Value.lstrip('L') #.strip('"')
1101 Value = eval(Value) # translate escape character
1102 NewValue = '{'
1103 for Index in range(0,len(Value)):
1104 if Unicode:
1105 NewValue = NewValue + str(ord(Value[Index]) % 0x10000) + ', '
1106 else:
1107 NewValue = NewValue + str(ord(Value[Index]) % 0x100) + ', '
1108 if Unicode:
1109 ArraySize = ArraySize / 2;
1110
1111 if ArraySize < (len(Value) + 1):
1112 EdkLogger.error("build", AUTOGEN_ERROR,
1113 "The maximum size of VOID* type PCD '%s.%s' is less than its actual size occupied." % (Pcd.TokenSpaceGuidCName, TokenCName),
1114 ExtraData="[%s]" % str(Info))
1115 Value = NewValue + '0 }'
1116 Array = '[%d]' % ArraySize
1117 #
1118 # skip casting for fixed at build since it breaks ARM assembly.
1119 # Long term we need PCD macros that work in assembly
1120 #
1121 elif Pcd.Type != TAB_PCDS_FIXED_AT_BUILD and Pcd.DatumType in ['UINT8', 'UINT16', 'UINT32', 'UINT64', 'BOOLEAN', 'VOID*']:
1122 Value = "((%s)%s)" % (Pcd.DatumType, Value)
1123
1124 if Pcd.DatumType not in ['UINT8', 'UINT16', 'UINT32', 'UINT64', 'BOOLEAN', 'VOID*']:
1125 # handle structure PCD
1126 if Pcd.MaxDatumSize == None or Pcd.MaxDatumSize == '':
1127 EdkLogger.error("build", AUTOGEN_ERROR,
1128 "Unknown [MaxDatumSize] of PCD [%s.%s]" % (Pcd.TokenSpaceGuidCName, TokenCName),
1129 ExtraData="[%s]" % str(Info))
1130
1131 ArraySize = int(Pcd.MaxDatumSize, 0)
1132 Array = '[%d]' % ArraySize
1133
1134 if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
1135 PcdValueName = '_PCD_PATCHABLE_VALUE_' + TokenCName
1136 else:
1137 PcdValueName = '_PCD_VALUE_' + TokenCName
1138
1139 if Pcd.DatumType not in ['UINT8', 'UINT16', 'UINT32', 'UINT64', 'BOOLEAN']:
1140 #
1141 # For unicode, UINT16 array will be generated, so the alignment of unicode is guaranteed.
1142 #
1143 if Unicode:
1144 AutoGenH.Append('#define %s %s%s\n' %(PcdValueName, Type, PcdVariableName))
1145 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s UINT16 %s%s = %s;\n' % (Const, PcdVariableName, Array, Value))
1146 AutoGenH.Append('extern %s UINT16 %s%s;\n' %(Const, PcdVariableName, Array))
1147 AutoGenH.Append('#define %s %s%s\n' %(GetModeName, Type, PcdVariableName))
1148 else:
1149 AutoGenH.Append('#define %s %s%s\n' %(PcdValueName, Type, PcdVariableName))
1150 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s UINT8 %s%s = %s;\n' % (Const, PcdVariableName, Array, Value))
1151 AutoGenH.Append('extern %s UINT8 %s%s;\n' %(Const, PcdVariableName, Array))
1152 AutoGenH.Append('#define %s %s%s\n' %(GetModeName, Type, PcdVariableName))
1153
1154 PcdDataSize = GetPcdSize(Pcd)
1155 if Pcd.Type == TAB_PCDS_FIXED_AT_BUILD:
1156 AutoGenH.Append('#define %s %s\n' % (FixPcdSizeTokenName, PcdDataSize))
1157 AutoGenH.Append('#define %s %s \n' % (GetModeSizeName,FixPcdSizeTokenName))
1158
1159 if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
1160 AutoGenH.Append('#define %s %s\n' % (PatchPcdSizeTokenName, Pcd.MaxDatumSize))
1161 AutoGenH.Append('#define %s %s \n' % (GetModeSizeName,PatchPcdSizeVariableName))
1162 AutoGenH.Append('extern UINTN %s; \n' % PatchPcdSizeVariableName)
1163 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED UINTN %s = %s;\n' % (PatchPcdSizeVariableName,PcdDataSize))
1164 elif Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
1165 AutoGenH.Append('#define %s %s\n' %(PcdValueName, Value))
1166 AutoGenC.Append('volatile %s %s %s = %s;\n' %(Const, Pcd.DatumType, PcdVariableName, PcdValueName))
1167 AutoGenH.Append('extern volatile %s %s %s%s;\n' % (Const, Pcd.DatumType, PcdVariableName, Array))
1168 AutoGenH.Append('#define %s %s%s\n' % (GetModeName, Type, PcdVariableName))
1169
1170 PcdDataSize = GetPcdSize(Pcd)
1171 AutoGenH.Append('#define %s %s\n' % (PatchPcdSizeTokenName, PcdDataSize))
1172
1173 AutoGenH.Append('#define %s %s \n' % (GetModeSizeName,PatchPcdSizeVariableName))
1174 AutoGenH.Append('extern UINTN %s; \n' % PatchPcdSizeVariableName)
1175 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED UINTN %s = %s;\n' % (PatchPcdSizeVariableName,PcdDataSize))
1176 else:
1177 PcdDataSize = GetPcdSize(Pcd)
1178 AutoGenH.Append('#define %s %s\n' % (FixPcdSizeTokenName, PcdDataSize))
1179 AutoGenH.Append('#define %s %s \n' % (GetModeSizeName,FixPcdSizeTokenName))
1180
1181 AutoGenH.Append('#define %s %s\n' %(PcdValueName, Value))
1182 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s %s = %s;\n' %(Const, Pcd.DatumType, PcdVariableName, PcdValueName))
1183 AutoGenH.Append('extern %s %s %s%s;\n' % (Const, Pcd.DatumType, PcdVariableName, Array))
1184 AutoGenH.Append('#define %s %s%s\n' % (GetModeName, Type, PcdVariableName))
1185
1186 if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
1187 if Pcd.DatumType not in ['UINT8', 'UINT16', 'UINT32', 'UINT64', 'BOOLEAN']:
1188 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))
1189 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))
1190 else:
1191 AutoGenH.Append('#define %s(Value) (%s = (Value))\n' % (SetModeName, PcdVariableName))
1192 AutoGenH.Append('#define %s(Value) ((%s = (Value)), RETURN_SUCCESS) \n' % (SetModeStatusName, PcdVariableName))
1193 else:
1194 AutoGenH.Append('//#define %s ASSERT(FALSE) // It is not allowed to set value for a FIXED_AT_BUILD PCD\n' % SetModeName)
1195
1196 ## Create code for library module PCDs
1197 #
1198 # @param Info The ModuleAutoGen object
1199 # @param AutoGenC The TemplateString object for C code
1200 # @param AutoGenH The TemplateString object for header file
1201 # @param Pcd The PCD object
1202 #
1203 def CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd):
1204 PcdTokenNumber = Info.PlatformInfo.PcdTokenNumber
1205 TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName
1206 TokenCName = Pcd.TokenCName
1207 for PcdItem in GlobalData.MixedPcd:
1208 if (TokenCName, TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:
1209 TokenCName = PcdItem[0]
1210 break
1211 PcdTokenName = '_PCD_TOKEN_' + TokenCName
1212 FixPcdSizeTokenName = '_PCD_SIZE_' + TokenCName
1213 PatchPcdSizeTokenName = '_PCD_PATCHABLE_' + TokenCName +'_SIZE'
1214 PatchPcdSizeVariableName = '_gPcd_BinaryPatch_Size_' + TokenCName
1215
1216 if GlobalData.BuildOptionPcd:
1217 for PcdItem in GlobalData.BuildOptionPcd:
1218 if (Pcd.TokenSpaceGuidCName, TokenCName) == (PcdItem[0], PcdItem[1]):
1219 Pcd.DefaultValue = PcdItem[2]
1220 break
1221
1222 #
1223 # Write PCDs
1224 #
1225 if Pcd.Type in gDynamicExPcd:
1226 TokenNumber = int(Pcd.TokenValue, 0)
1227 else:
1228 if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in PcdTokenNumber:
1229 # If one of the Source built modules listed in the DSC is not listed in FDF modules,
1230 # and the INF lists a PCD can only use the PcdsDynamic access method (it is only
1231 # listed in the DEC file that declares the PCD as PcdsDynamic), then build tool will
1232 # report warning message notify the PI that they are attempting to build a module
1233 # that must be included in a flash image in order to be functional. These Dynamic PCD
1234 # will not be added into the Database unless it is used by other modules that are
1235 # included in the FDF file.
1236 # In this case, just assign an invalid token number to make it pass build.
1237 if Pcd.Type in PCD_DYNAMIC_TYPE_LIST:
1238 TokenNumber = 0
1239 else:
1240 EdkLogger.error("build", AUTOGEN_ERROR,
1241 "No generated token number for %s.%s\n" % (Pcd.TokenSpaceGuidCName, TokenCName),
1242 ExtraData="[%s]" % str(Info))
1243 else:
1244 TokenNumber = PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName]
1245
1246 if Pcd.Type not in gItemTypeStringDatabase:
1247 EdkLogger.error("build", AUTOGEN_ERROR,
1248 "Unknown PCD type [%s] of PCD %s.%s" % (Pcd.Type, Pcd.TokenSpaceGuidCName, TokenCName),
1249 ExtraData="[%s]" % str(Info))
1250
1251 DatumType = Pcd.DatumType
1252 DatumSize = gDatumSizeStringDatabase[Pcd.DatumType] if Pcd.DatumType in gDatumSizeStringDatabase else gDatumSizeStringDatabase['VOID*']
1253 DatumSizeLib = gDatumSizeStringDatabaseLib[Pcd.DatumType] if Pcd.DatumType in gDatumSizeStringDatabaseLib else gDatumSizeStringDatabaseLib['VOID*']
1254 GetModeName = '_PCD_GET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + TokenCName if Pcd.DatumType in gDatumSizeStringDatabaseH else '_PCD_GET_MODE_' + gDatumSizeStringDatabaseH['VOID*'] + '_' + TokenCName
1255 SetModeName = '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + TokenCName if Pcd.DatumType in gDatumSizeStringDatabaseH else '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH['VOID*'] + '_' + TokenCName
1256 SetModeStatusName = '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_S_' + TokenCName if Pcd.DatumType in gDatumSizeStringDatabaseH else '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH['VOID*'] + '_S_' + TokenCName
1257 GetModeSizeName = '_PCD_GET_MODE_SIZE' + '_' + TokenCName
1258
1259 Type = ''
1260 Array = ''
1261 if Pcd.DatumType not in ['UINT8', 'UINT16', 'UINT32', 'UINT64', 'BOOLEAN']:
1262 if Pcd.DefaultValue[0]== '{':
1263 Type = '(VOID *)'
1264 Array = '[]'
1265 PcdItemType = Pcd.Type
1266 PcdExCNameList = []
1267 if PcdItemType in gDynamicExPcd:
1268 PcdExTokenName = '_PCD_TOKEN_' + TokenSpaceGuidCName + '_' + TokenCName
1269 AutoGenH.Append('\n#define %s %dU\n' % (PcdExTokenName, TokenNumber))
1270
1271 if Info.IsLibrary:
1272 PcdList = Info.LibraryPcdList
1273 else:
1274 PcdList = Info.ModulePcdList
1275 for PcdModule in PcdList:
1276 if PcdModule.Type in gDynamicExPcd:
1277 PcdExCNameList.append(PcdModule.TokenCName)
1278 # Be compatible with the current code which using PcdGet/Set for DynamicEx Pcd.
1279 # If only PcdGet/Set used in all Pcds with different CName, it should succeed to build.
1280 # If PcdGet/Set used in the Pcds with different Guids but same CName, it should failed to build.
1281 if PcdExCNameList.count(Pcd.TokenCName) > 1:
1282 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')
1283 AutoGenH.Append('// #define %s %s\n' % (PcdTokenName, PcdExTokenName))
1284 AutoGenH.Append('// #define %s LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1285 AutoGenH.Append('// #define %s LibPcdGetExSize(&%s, %s)\n' % (GetModeSizeName,Pcd.TokenSpaceGuidCName, PcdTokenName))
1286 if Pcd.DatumType not in ['UINT8', 'UINT16', 'UINT32', 'UINT64', 'BOOLEAN']:
1287 AutoGenH.Append('// #define %s(SizeOfBuffer, Buffer) LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1288 AutoGenH.Append('// #define %s(SizeOfBuffer, Buffer) LibPcdSetEx%sS(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1289 else:
1290 AutoGenH.Append('// #define %s(Value) LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1291 AutoGenH.Append('// #define %s(Value) LibPcdSetEx%sS(&%s, %s, (Value))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1292 else:
1293 AutoGenH.Append('#define %s %s\n' % (PcdTokenName, PcdExTokenName))
1294 AutoGenH.Append('#define %s LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1295 AutoGenH.Append('#define %s LibPcdGetExSize(&%s, %s)\n' % (GetModeSizeName,Pcd.TokenSpaceGuidCName, PcdTokenName))
1296 if Pcd.DatumType not in ['UINT8', 'UINT16', 'UINT32', 'UINT64', 'BOOLEAN']:
1297 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer) LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1298 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer) LibPcdSetEx%sS(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1299 else:
1300 AutoGenH.Append('#define %s(Value) LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1301 AutoGenH.Append('#define %s(Value) LibPcdSetEx%sS(&%s, %s, (Value))\n' % (SetModeStatusName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1302 else:
1303 AutoGenH.Append('#define _PCD_TOKEN_%s %dU\n' % (TokenCName, TokenNumber))
1304 if PcdItemType in gDynamicPcd:
1305 PcdList = []
1306 PcdCNameList = []
1307 PcdList.extend(Info.LibraryPcdList)
1308 PcdList.extend(Info.ModulePcdList)
1309 for PcdModule in PcdList:
1310 if PcdModule.Type in gDynamicPcd:
1311 PcdCNameList.append(PcdModule.TokenCName)
1312 if PcdCNameList.count(Pcd.TokenCName) > 1:
1313 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))
1314 else:
1315 AutoGenH.Append('#define %s LibPcdGet%s(%s)\n' % (GetModeName, DatumSizeLib, PcdTokenName))
1316 AutoGenH.Append('#define %s LibPcdGetSize(%s)\n' % (GetModeSizeName, PcdTokenName))
1317 if DatumType not in ['UINT8', 'UINT16', 'UINT32', 'UINT64', 'BOOLEAN']:
1318 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer) LibPcdSet%s(%s, (SizeOfBuffer), (Buffer))\n' %(SetModeName, DatumSizeLib, PcdTokenName))
1319 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer) LibPcdSet%sS(%s, (SizeOfBuffer), (Buffer))\n' % (SetModeStatusName, DatumSizeLib, PcdTokenName))
1320 else:
1321 AutoGenH.Append('#define %s(Value) LibPcdSet%s(%s, (Value))\n' % (SetModeName, DatumSizeLib, PcdTokenName))
1322 AutoGenH.Append('#define %s(Value) LibPcdSet%sS(%s, (Value))\n' % (SetModeStatusName, DatumSizeLib, PcdTokenName))
1323 if PcdItemType == TAB_PCDS_PATCHABLE_IN_MODULE:
1324 PcdVariableName = '_gPcd_' + gItemTypeStringDatabase[TAB_PCDS_PATCHABLE_IN_MODULE] + '_' + TokenCName
1325 if DatumType not in ['UINT8', 'UINT16', 'UINT32', 'UINT64', 'BOOLEAN']:
1326 ArraySize = int(Pcd.MaxDatumSize, 0)
1327 if Pcd.DefaultValue[0] == 'L':
1328 ArraySize = ArraySize / 2
1329 Array = '[%d]' % ArraySize
1330 DatumType = ['UINT8', 'UINT16'][Pcd.DefaultValue[0] == 'L']
1331 AutoGenH.Append('extern %s _gPcd_BinaryPatch_%s%s;\n' %(DatumType, TokenCName, Array))
1332 else:
1333 AutoGenH.Append('extern volatile %s %s%s;\n' % (DatumType, PcdVariableName, Array))
1334 AutoGenH.Append('#define %s %s_gPcd_BinaryPatch_%s\n' %(GetModeName, Type, TokenCName))
1335 PcdDataSize = GetPcdSize(Pcd)
1336 if Pcd.DatumType not in ['UINT8', 'UINT16', 'UINT32', 'UINT64', 'BOOLEAN']:
1337 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))
1338 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))
1339 AutoGenH.Append('#define %s %s\n' % (PatchPcdSizeTokenName, Pcd.MaxDatumSize))
1340 else:
1341 AutoGenH.Append('#define %s(Value) (%s = (Value))\n' % (SetModeName, PcdVariableName))
1342 AutoGenH.Append('#define %s(Value) ((%s = (Value)), RETURN_SUCCESS)\n' % (SetModeStatusName, PcdVariableName))
1343 AutoGenH.Append('#define %s %s\n' % (PatchPcdSizeTokenName, PcdDataSize))
1344
1345 AutoGenH.Append('#define %s %s\n' % (GetModeSizeName,PatchPcdSizeVariableName))
1346 AutoGenH.Append('extern UINTN %s; \n' % PatchPcdSizeVariableName)
1347
1348 if PcdItemType == TAB_PCDS_FIXED_AT_BUILD or PcdItemType == TAB_PCDS_FEATURE_FLAG:
1349 key = ".".join((Pcd.TokenSpaceGuidCName,Pcd.TokenCName))
1350 PcdVariableName = '_gPcd_' + gItemTypeStringDatabase[Pcd.Type] + '_' + TokenCName
1351 if DatumType == 'VOID*' and Array == '[]':
1352 DatumType = ['UINT8', 'UINT16'][Pcd.DefaultValue[0] == 'L']
1353 if DatumType not in ['UINT8', 'UINT16', 'UINT32', 'UINT64', 'BOOLEAN', 'VOID*']:
1354 DatumType = 'UINT8'
1355 AutoGenH.Append('extern const %s _gPcd_FixedAtBuild_%s%s;\n' %(DatumType, TokenCName, Array))
1356 AutoGenH.Append('#define %s %s_gPcd_FixedAtBuild_%s\n' %(GetModeName, Type, TokenCName))
1357 AutoGenH.Append('//#define %s ASSERT(FALSE) // It is not allowed to set value for a FIXED_AT_BUILD PCD\n' % SetModeName)
1358
1359 if PcdItemType == TAB_PCDS_FIXED_AT_BUILD and (key in Info.ConstPcd or (Info.IsLibrary and not Info._ReferenceModules)):
1360 if Pcd.DatumType not in ['UINT8', 'UINT16', 'UINT32', 'UINT64', 'BOOLEAN']:
1361 AutoGenH.Append('#define _PCD_VALUE_%s %s%s\n' %(TokenCName, Type, PcdVariableName))
1362 else:
1363 AutoGenH.Append('#define _PCD_VALUE_%s %s\n' %(TokenCName, Pcd.DefaultValue))
1364
1365 if PcdItemType == TAB_PCDS_FIXED_AT_BUILD:
1366 PcdDataSize = GetPcdSize(Pcd)
1367 AutoGenH.Append('#define %s %s\n' % (FixPcdSizeTokenName, PcdDataSize))
1368 AutoGenH.Append('#define %s %s\n' % (GetModeSizeName,FixPcdSizeTokenName))
1369
1370 ## Create code for library constructor
1371 #
1372 # @param Info The ModuleAutoGen object
1373 # @param AutoGenC The TemplateString object for C code
1374 # @param AutoGenH The TemplateString object for header file
1375 #
1376 def CreateLibraryConstructorCode(Info, AutoGenC, AutoGenH):
1377 #
1378 # Library Constructors
1379 #
1380 ConstructorPrototypeString = TemplateString()
1381 ConstructorCallingString = TemplateString()
1382 if Info.IsLibrary:
1383 DependentLibraryList = [Info.Module]
1384 else:
1385 DependentLibraryList = Info.DependentLibraryList
1386 for Lib in DependentLibraryList:
1387 if len(Lib.ConstructorList) <= 0:
1388 continue
1389 Dict = {'Function':Lib.ConstructorList}
1390 if Lib.ModuleType in ['BASE', 'SEC']:
1391 ConstructorPrototypeString.Append(gLibraryStructorPrototype['BASE'].Replace(Dict))
1392 ConstructorCallingString.Append(gLibraryStructorCall['BASE'].Replace(Dict))
1393 elif Lib.ModuleType in ['PEI_CORE','PEIM']:
1394 ConstructorPrototypeString.Append(gLibraryStructorPrototype['PEI'].Replace(Dict))
1395 ConstructorCallingString.Append(gLibraryStructorCall['PEI'].Replace(Dict))
1396 elif Lib.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER',
1397 'DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION','SMM_CORE']:
1398 ConstructorPrototypeString.Append(gLibraryStructorPrototype['DXE'].Replace(Dict))
1399 ConstructorCallingString.Append(gLibraryStructorCall['DXE'].Replace(Dict))
1400 elif Lib.ModuleType in ['MM_STANDALONE','MM_CORE_STANDALONE']:
1401 ConstructorPrototypeString.Append(gLibraryStructorPrototype['MM'].Replace(Dict))
1402 ConstructorCallingString.Append(gLibraryStructorCall['MM'].Replace(Dict))
1403
1404 if str(ConstructorPrototypeString) == '':
1405 ConstructorPrototypeList = []
1406 else:
1407 ConstructorPrototypeList = [str(ConstructorPrototypeString)]
1408 if str(ConstructorCallingString) == '':
1409 ConstructorCallingList = []
1410 else:
1411 ConstructorCallingList = [str(ConstructorCallingString)]
1412
1413 Dict = {
1414 'Type' : 'Constructor',
1415 'FunctionPrototype' : ConstructorPrototypeList,
1416 'FunctionCall' : ConstructorCallingList
1417 }
1418 if Info.IsLibrary:
1419 AutoGenH.Append("${BEGIN}${FunctionPrototype}${END}", Dict)
1420 else:
1421 if Info.ModuleType in ['BASE', 'SEC']:
1422 AutoGenC.Append(gLibraryString['BASE'].Replace(Dict))
1423 elif Info.ModuleType in ['PEI_CORE','PEIM']:
1424 AutoGenC.Append(gLibraryString['PEI'].Replace(Dict))
1425 elif Info.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER',
1426 'DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION','SMM_CORE']:
1427 AutoGenC.Append(gLibraryString['DXE'].Replace(Dict))
1428 elif Info.ModuleType in ['MM_STANDALONE','MM_CORE_STANDALONE']:
1429 AutoGenC.Append(gLibraryString['MM'].Replace(Dict))
1430
1431 ## Create code for library destructor
1432 #
1433 # @param Info The ModuleAutoGen object
1434 # @param AutoGenC The TemplateString object for C code
1435 # @param AutoGenH The TemplateString object for header file
1436 #
1437 def CreateLibraryDestructorCode(Info, AutoGenC, AutoGenH):
1438 #
1439 # Library Destructors
1440 #
1441 DestructorPrototypeString = TemplateString()
1442 DestructorCallingString = TemplateString()
1443 if Info.IsLibrary:
1444 DependentLibraryList = [Info.Module]
1445 else:
1446 DependentLibraryList = Info.DependentLibraryList
1447 for Index in range(len(DependentLibraryList)-1, -1, -1):
1448 Lib = DependentLibraryList[Index]
1449 if len(Lib.DestructorList) <= 0:
1450 continue
1451 Dict = {'Function':Lib.DestructorList}
1452 if Lib.ModuleType in ['BASE', 'SEC']:
1453 DestructorPrototypeString.Append(gLibraryStructorPrototype['BASE'].Replace(Dict))
1454 DestructorCallingString.Append(gLibraryStructorCall['BASE'].Replace(Dict))
1455 elif Lib.ModuleType in ['PEI_CORE','PEIM']:
1456 DestructorPrototypeString.Append(gLibraryStructorPrototype['PEI'].Replace(Dict))
1457 DestructorCallingString.Append(gLibraryStructorCall['PEI'].Replace(Dict))
1458 elif Lib.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER',
1459 'DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION', 'SMM_CORE']:
1460 DestructorPrototypeString.Append(gLibraryStructorPrototype['DXE'].Replace(Dict))
1461 DestructorCallingString.Append(gLibraryStructorCall['DXE'].Replace(Dict))
1462 elif Lib.ModuleType in ['MM_STANDALONE','MM_CORE_STANDALONE']:
1463 DestructorPrototypeString.Append(gLibraryStructorPrototype['MM'].Replace(Dict))
1464 DestructorCallingString.Append(gLibraryStructorCall['MM'].Replace(Dict))
1465
1466 if str(DestructorPrototypeString) == '':
1467 DestructorPrototypeList = []
1468 else:
1469 DestructorPrototypeList = [str(DestructorPrototypeString)]
1470 if str(DestructorCallingString) == '':
1471 DestructorCallingList = []
1472 else:
1473 DestructorCallingList = [str(DestructorCallingString)]
1474
1475 Dict = {
1476 'Type' : 'Destructor',
1477 'FunctionPrototype' : DestructorPrototypeList,
1478 'FunctionCall' : DestructorCallingList
1479 }
1480 if Info.IsLibrary:
1481 AutoGenH.Append("${BEGIN}${FunctionPrototype}${END}", Dict)
1482 else:
1483 if Info.ModuleType in ['BASE', 'SEC']:
1484 AutoGenC.Append(gLibraryString['BASE'].Replace(Dict))
1485 elif Info.ModuleType in ['PEI_CORE','PEIM']:
1486 AutoGenC.Append(gLibraryString['PEI'].Replace(Dict))
1487 elif Info.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER',
1488 'DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION','SMM_CORE']:
1489 AutoGenC.Append(gLibraryString['DXE'].Replace(Dict))
1490 elif Info.ModuleType in ['MM_STANDALONE','MM_CORE_STANDALONE']:
1491 AutoGenC.Append(gLibraryString['MM'].Replace(Dict))
1492
1493
1494 ## Create code for ModuleEntryPoint
1495 #
1496 # @param Info The ModuleAutoGen object
1497 # @param AutoGenC The TemplateString object for C code
1498 # @param AutoGenH The TemplateString object for header file
1499 #
1500 def CreateModuleEntryPointCode(Info, AutoGenC, AutoGenH):
1501 if Info.IsLibrary or Info.ModuleType in ['USER_DEFINED', 'SEC']:
1502 return
1503 #
1504 # Module Entry Points
1505 #
1506 NumEntryPoints = len(Info.Module.ModuleEntryPointList)
1507 if 'PI_SPECIFICATION_VERSION' in Info.Module.Specification:
1508 PiSpecVersion = Info.Module.Specification['PI_SPECIFICATION_VERSION']
1509 else:
1510 PiSpecVersion = '0x00000000'
1511 if 'UEFI_SPECIFICATION_VERSION' in Info.Module.Specification:
1512 UefiSpecVersion = Info.Module.Specification['UEFI_SPECIFICATION_VERSION']
1513 else:
1514 UefiSpecVersion = '0x00000000'
1515 Dict = {
1516 'Function' : Info.Module.ModuleEntryPointList,
1517 'PiSpecVersion' : PiSpecVersion + 'U',
1518 'UefiSpecVersion': UefiSpecVersion + 'U'
1519 }
1520
1521 if Info.ModuleType in ['PEI_CORE', 'DXE_CORE', 'SMM_CORE', 'MM_CORE_STANDALONE']:
1522 if Info.SourceFileList <> None and Info.SourceFileList <> []:
1523 if NumEntryPoints != 1:
1524 EdkLogger.error(
1525 "build",
1526 AUTOGEN_ERROR,
1527 '%s must have exactly one entry point' % Info.ModuleType,
1528 File=str(Info),
1529 ExtraData= ", ".join(Info.Module.ModuleEntryPointList)
1530 )
1531 if Info.ModuleType == 'PEI_CORE':
1532 AutoGenC.Append(gPeiCoreEntryPointString.Replace(Dict))
1533 AutoGenH.Append(gPeiCoreEntryPointPrototype.Replace(Dict))
1534 elif Info.ModuleType == 'DXE_CORE':
1535 AutoGenC.Append(gDxeCoreEntryPointString.Replace(Dict))
1536 AutoGenH.Append(gDxeCoreEntryPointPrototype.Replace(Dict))
1537 elif Info.ModuleType == 'SMM_CORE':
1538 AutoGenC.Append(gSmmCoreEntryPointString.Replace(Dict))
1539 AutoGenH.Append(gSmmCoreEntryPointPrototype.Replace(Dict))
1540 elif Info.ModuleType == 'MM_CORE_STANDALONE':
1541 AutoGenC.Append(gMmCoreStandaloneEntryPointString.Replace(Dict))
1542 AutoGenH.Append(gMmCoreStandaloneEntryPointPrototype.Replace(Dict))
1543 elif Info.ModuleType == 'PEIM':
1544 if NumEntryPoints < 2:
1545 AutoGenC.Append(gPeimEntryPointString[NumEntryPoints].Replace(Dict))
1546 else:
1547 AutoGenC.Append(gPeimEntryPointString[2].Replace(Dict))
1548 AutoGenH.Append(gPeimEntryPointPrototype.Replace(Dict))
1549 elif Info.ModuleType in ['DXE_RUNTIME_DRIVER','DXE_DRIVER','DXE_SAL_DRIVER','UEFI_DRIVER']:
1550 if NumEntryPoints < 2:
1551 AutoGenC.Append(gUefiDriverEntryPointString[NumEntryPoints].Replace(Dict))
1552 else:
1553 AutoGenC.Append(gUefiDriverEntryPointString[2].Replace(Dict))
1554 AutoGenH.Append(gUefiDriverEntryPointPrototype.Replace(Dict))
1555 elif Info.ModuleType == 'DXE_SMM_DRIVER':
1556 if NumEntryPoints == 0:
1557 AutoGenC.Append(gDxeSmmEntryPointString[0].Replace(Dict))
1558 else:
1559 AutoGenC.Append(gDxeSmmEntryPointString[1].Replace(Dict))
1560 AutoGenH.Append(gDxeSmmEntryPointPrototype.Replace(Dict))
1561 elif Info.ModuleType == 'MM_STANDALONE':
1562 if NumEntryPoints < 2:
1563 AutoGenC.Append(gMmStandaloneEntryPointString[NumEntryPoints].Replace(Dict))
1564 else:
1565 AutoGenC.Append(gMmStandaloneEntryPointString[2].Replace(Dict))
1566 AutoGenH.Append(gMmStandaloneEntryPointPrototype.Replace(Dict))
1567 elif Info.ModuleType == 'UEFI_APPLICATION':
1568 if NumEntryPoints < 2:
1569 AutoGenC.Append(gUefiApplicationEntryPointString[NumEntryPoints].Replace(Dict))
1570 else:
1571 AutoGenC.Append(gUefiApplicationEntryPointString[2].Replace(Dict))
1572 AutoGenH.Append(gUefiApplicationEntryPointPrototype.Replace(Dict))
1573
1574 ## Create code for ModuleUnloadImage
1575 #
1576 # @param Info The ModuleAutoGen object
1577 # @param AutoGenC The TemplateString object for C code
1578 # @param AutoGenH The TemplateString object for header file
1579 #
1580 def CreateModuleUnloadImageCode(Info, AutoGenC, AutoGenH):
1581 if Info.IsLibrary or Info.ModuleType in ['USER_DEFINED', 'SEC']:
1582 return
1583 #
1584 # Unload Image Handlers
1585 #
1586 NumUnloadImage = len(Info.Module.ModuleUnloadImageList)
1587 Dict = {'Count':str(NumUnloadImage) + 'U', 'Function':Info.Module.ModuleUnloadImageList}
1588 if NumUnloadImage < 2:
1589 AutoGenC.Append(gUefiUnloadImageString[NumUnloadImage].Replace(Dict))
1590 else:
1591 AutoGenC.Append(gUefiUnloadImageString[2].Replace(Dict))
1592 AutoGenH.Append(gUefiUnloadImagePrototype.Replace(Dict))
1593
1594 ## Create code for GUID
1595 #
1596 # @param Info The ModuleAutoGen object
1597 # @param AutoGenC The TemplateString object for C code
1598 # @param AutoGenH The TemplateString object for header file
1599 #
1600 def CreateGuidDefinitionCode(Info, AutoGenC, AutoGenH):
1601 if Info.ModuleType in ["USER_DEFINED", "BASE"]:
1602 GuidType = "GUID"
1603 else:
1604 GuidType = "EFI_GUID"
1605
1606 if Info.GuidList:
1607 if not Info.IsLibrary:
1608 AutoGenC.Append("\n// Guids\n")
1609 AutoGenH.Append("\n// Guids\n")
1610 #
1611 # GUIDs
1612 #
1613 for Key in Info.GuidList:
1614 if not Info.IsLibrary:
1615 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.GuidList[Key]))
1616 AutoGenH.Append('extern %s %s;\n' % (GuidType, Key))
1617
1618 ## Create code for protocol
1619 #
1620 # @param Info The ModuleAutoGen object
1621 # @param AutoGenC The TemplateString object for C code
1622 # @param AutoGenH The TemplateString object for header file
1623 #
1624 def CreateProtocolDefinitionCode(Info, AutoGenC, AutoGenH):
1625 if Info.ModuleType in ["USER_DEFINED", "BASE"]:
1626 GuidType = "GUID"
1627 else:
1628 GuidType = "EFI_GUID"
1629
1630 if Info.ProtocolList:
1631 if not Info.IsLibrary:
1632 AutoGenC.Append("\n// Protocols\n")
1633 AutoGenH.Append("\n// Protocols\n")
1634 #
1635 # Protocol GUIDs
1636 #
1637 for Key in Info.ProtocolList:
1638 if not Info.IsLibrary:
1639 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.ProtocolList[Key]))
1640 AutoGenH.Append('extern %s %s;\n' % (GuidType, Key))
1641
1642 ## Create code for PPI
1643 #
1644 # @param Info The ModuleAutoGen object
1645 # @param AutoGenC The TemplateString object for C code
1646 # @param AutoGenH The TemplateString object for header file
1647 #
1648 def CreatePpiDefinitionCode(Info, AutoGenC, AutoGenH):
1649 if Info.ModuleType in ["USER_DEFINED", "BASE"]:
1650 GuidType = "GUID"
1651 else:
1652 GuidType = "EFI_GUID"
1653
1654 if Info.PpiList:
1655 if not Info.IsLibrary:
1656 AutoGenC.Append("\n// PPIs\n")
1657 AutoGenH.Append("\n// PPIs\n")
1658 #
1659 # PPI GUIDs
1660 #
1661 for Key in Info.PpiList:
1662 if not Info.IsLibrary:
1663 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.PpiList[Key]))
1664 AutoGenH.Append('extern %s %s;\n' % (GuidType, Key))
1665
1666 ## Create code for PCD
1667 #
1668 # @param Info The ModuleAutoGen object
1669 # @param AutoGenC The TemplateString object for C code
1670 # @param AutoGenH The TemplateString object for header file
1671 #
1672 def CreatePcdCode(Info, AutoGenC, AutoGenH):
1673
1674 # Collect Token Space GUIDs used by DynamicEc PCDs
1675 TokenSpaceList = []
1676 for Pcd in Info.ModulePcdList:
1677 if Pcd.Type in gDynamicExPcd and Pcd.TokenSpaceGuidCName not in TokenSpaceList:
1678 TokenSpaceList += [Pcd.TokenSpaceGuidCName]
1679
1680 SkuMgr = Info.Workspace.Platform.SkuIdMgr
1681 AutoGenH.Append("\n// Definition of SkuId Array\n")
1682 AutoGenH.Append("extern UINT64 _gPcd_SkuId_Array[];\n")
1683 # Add extern declarations to AutoGen.h if one or more Token Space GUIDs were found
1684 if TokenSpaceList <> []:
1685 AutoGenH.Append("\n// Definition of PCD Token Space GUIDs used in this module\n\n")
1686 if Info.ModuleType in ["USER_DEFINED", "BASE"]:
1687 GuidType = "GUID"
1688 else:
1689 GuidType = "EFI_GUID"
1690 for Item in TokenSpaceList:
1691 AutoGenH.Append('extern %s %s;\n' % (GuidType, Item))
1692
1693 if Info.IsLibrary:
1694 if Info.ModulePcdList:
1695 AutoGenH.Append("\n// PCD definitions\n")
1696 for Pcd in Info.ModulePcdList:
1697 CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd)
1698 DynExPcdTokenNumberMapping (Info, AutoGenH)
1699 else:
1700 AutoGenC.Append("\n// Definition of SkuId Array\n")
1701 AutoGenC.Append("GLOBAL_REMOVE_IF_UNREFERENCED UINT64 _gPcd_SkuId_Array[] = %s;\n" % SkuMgr.DumpSkuIdArrary())
1702 if Info.ModulePcdList:
1703 AutoGenH.Append("\n// Definition of PCDs used in this module\n")
1704 AutoGenC.Append("\n// Definition of PCDs used in this module\n")
1705 for Pcd in Info.ModulePcdList:
1706 CreateModulePcdCode(Info, AutoGenC, AutoGenH, Pcd)
1707 DynExPcdTokenNumberMapping (Info, AutoGenH)
1708 if Info.LibraryPcdList:
1709 AutoGenH.Append("\n// Definition of PCDs used in libraries is in AutoGen.c\n")
1710 AutoGenC.Append("\n// Definition of PCDs used in libraries\n")
1711 for Pcd in Info.LibraryPcdList:
1712 CreateModulePcdCode(Info, AutoGenC, AutoGenC, Pcd)
1713 CreatePcdDatabaseCode(Info, AutoGenC, AutoGenH)
1714
1715 ## Create code for unicode string definition
1716 #
1717 # @param Info The ModuleAutoGen object
1718 # @param AutoGenC The TemplateString object for C code
1719 # @param AutoGenH The TemplateString object for header file
1720 # @param UniGenCFlag UniString is generated into AutoGen C file when it is set to True
1721 # @param UniGenBinBuffer Buffer to store uni string package data
1722 #
1723 def CreateUnicodeStringCode(Info, AutoGenC, AutoGenH, UniGenCFlag, UniGenBinBuffer):
1724 WorkingDir = os.getcwd()
1725 os.chdir(Info.WorkspaceDir)
1726
1727 IncList = [Info.MetaFile.Dir]
1728 # Get all files under [Sources] section in inf file for EDK-II module
1729 EDK2Module = True
1730 SrcList = [F for F in Info.SourceFileList]
1731 if Info.AutoGenVersion < 0x00010005:
1732 EDK2Module = False
1733 # Get all files under the module directory for EDK-I module
1734 Cwd = os.getcwd()
1735 os.chdir(Info.MetaFile.Dir)
1736 for Root, Dirs, Files in os.walk("."):
1737 if 'CVS' in Dirs:
1738 Dirs.remove('CVS')
1739 if '.svn' in Dirs:
1740 Dirs.remove('.svn')
1741 for File in Files:
1742 File = PathClass(os.path.join(Root, File), Info.MetaFile.Dir)
1743 if File in SrcList:
1744 continue
1745 SrcList.append(File)
1746 os.chdir(Cwd)
1747
1748 if 'BUILD' in Info.BuildOption and Info.BuildOption['BUILD']['FLAGS'].find('-c') > -1:
1749 CompatibleMode = True
1750 else:
1751 CompatibleMode = False
1752
1753 #
1754 # -s is a temporary option dedicated for building .UNI files with ISO 639-2 language codes of EDK Shell in EDK2
1755 #
1756 if 'BUILD' in Info.BuildOption and Info.BuildOption['BUILD']['FLAGS'].find('-s') > -1:
1757 if CompatibleMode:
1758 EdkLogger.error("build", AUTOGEN_ERROR,
1759 "-c and -s build options should be used exclusively",
1760 ExtraData="[%s]" % str(Info))
1761 ShellMode = True
1762 else:
1763 ShellMode = False
1764
1765 #RFC4646 is only for EDKII modules and ISO639-2 for EDK modules
1766 if EDK2Module:
1767 FilterInfo = [EDK2Module] + [Info.PlatformInfo.Platform.RFCLanguages]
1768 else:
1769 FilterInfo = [EDK2Module] + [Info.PlatformInfo.Platform.ISOLanguages]
1770 Header, Code = GetStringFiles(Info.UnicodeFileList, SrcList, IncList, Info.IncludePathList, ['.uni', '.inf'], Info.Name, CompatibleMode, ShellMode, UniGenCFlag, UniGenBinBuffer, FilterInfo)
1771 if CompatibleMode or UniGenCFlag:
1772 AutoGenC.Append("\n//\n//Unicode String Pack Definition\n//\n")
1773 AutoGenC.Append(Code)
1774 AutoGenC.Append("\n")
1775 AutoGenH.Append("\n//\n//Unicode String ID\n//\n")
1776 AutoGenH.Append(Header)
1777 if CompatibleMode or UniGenCFlag:
1778 AutoGenH.Append("\n#define STRING_ARRAY_NAME %sStrings\n" % Info.Name)
1779 os.chdir(WorkingDir)
1780
1781 def CreateIdfFileCode(Info, AutoGenC, StringH, IdfGenCFlag, IdfGenBinBuffer):
1782 if len(Info.IdfFileList) > 0:
1783 ImageFiles = IdfFileClassObject(sorted (Info.IdfFileList))
1784 if ImageFiles.ImageFilesDict:
1785 Index = 1
1786 PaletteIndex = 1
1787 IncList = [Info.MetaFile.Dir]
1788 SrcList = [F for F in Info.SourceFileList]
1789 SkipList = ['.jpg', '.png', '.bmp', '.inf', '.idf']
1790 FileList = GetFileList(SrcList, IncList, SkipList)
1791 ValueStartPtr = 60
1792 StringH.Append("\n//\n//Image ID\n//\n")
1793 ImageInfoOffset = 0
1794 PaletteInfoOffset = 0
1795 ImageBuffer = pack('x')
1796 PaletteBuffer = pack('x')
1797 BufferStr = ''
1798 PaletteStr = ''
1799 FileDict = {}
1800 for Idf in ImageFiles.ImageFilesDict:
1801 if ImageFiles.ImageFilesDict[Idf]:
1802 for FileObj in ImageFiles.ImageFilesDict[Idf]:
1803 for sourcefile in Info.SourceFileList:
1804 if FileObj.FileName == sourcefile.File:
1805 if not sourcefile.Ext.upper() in ['.PNG', '.BMP', '.JPG']:
1806 EdkLogger.error("build", AUTOGEN_ERROR, "The %s's postfix must be one of .bmp, .jpg, .png" % (FileObj.FileName), ExtraData="[%s]" % str(Info))
1807 FileObj.File = sourcefile
1808 break
1809 else:
1810 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))
1811
1812 for FileObj in ImageFiles.ImageFilesDict[Idf]:
1813 ID = FileObj.ImageID
1814 File = FileObj.File
1815 if not os.path.exists(File.Path) or not os.path.isfile(File.Path):
1816 EdkLogger.error("build", FILE_NOT_FOUND, ExtraData=File.Path)
1817 SearchImageID (FileObj, FileList)
1818 if FileObj.Referenced:
1819 if (ValueStartPtr - len(DEFINE_STR + ID)) <= 0:
1820 Line = DEFINE_STR + ' ' + ID + ' ' + DecToHexStr(Index, 4) + '\n'
1821 else:
1822 Line = DEFINE_STR + ' ' + ID + ' ' * (ValueStartPtr - len(DEFINE_STR + ID)) + DecToHexStr(Index, 4) + '\n'
1823
1824 if File not in FileDict:
1825 FileDict[File] = Index
1826 else:
1827 DuplicateBlock = pack('B', EFI_HII_IIBT_DUPLICATE)
1828 DuplicateBlock += pack('H', FileDict[File])
1829 ImageBuffer += DuplicateBlock
1830 BufferStr = WriteLine(BufferStr, '// %s: %s: %s' % (DecToHexStr(Index, 4), ID, DecToHexStr(Index, 4)))
1831 TempBufferList = AscToHexList(DuplicateBlock)
1832 BufferStr = WriteLine(BufferStr, CreateArrayItem(TempBufferList, 16) + '\n')
1833 StringH.Append(Line)
1834 Index += 1
1835 continue
1836
1837 TmpFile = open(File.Path, 'rb')
1838 Buffer = TmpFile.read()
1839 TmpFile.close()
1840 if File.Ext.upper() == '.PNG':
1841 TempBuffer = pack('B', EFI_HII_IIBT_IMAGE_PNG)
1842 TempBuffer += pack('I', len(Buffer))
1843 TempBuffer += Buffer
1844 elif File.Ext.upper() == '.JPG':
1845 ImageType, = struct.unpack('4s', Buffer[6:10])
1846 if ImageType != 'JFIF':
1847 EdkLogger.error("build", FILE_TYPE_MISMATCH, "The file %s is not a standard JPG file." % File.Path)
1848 TempBuffer = pack('B', EFI_HII_IIBT_IMAGE_JPEG)
1849 TempBuffer += pack('I', len(Buffer))
1850 TempBuffer += Buffer
1851 elif File.Ext.upper() == '.BMP':
1852 TempBuffer, TempPalette = BmpImageDecoder(File, Buffer, PaletteIndex, FileObj.TransParent)
1853 if len(TempPalette) > 1:
1854 PaletteIndex += 1
1855 NewPalette = pack('H', len(TempPalette))
1856 NewPalette += TempPalette
1857 PaletteBuffer += NewPalette
1858 PaletteStr = WriteLine(PaletteStr, '// %s: %s: %s' % (DecToHexStr(PaletteIndex - 1, 4), ID, DecToHexStr(PaletteIndex - 1, 4)))
1859 TempPaletteList = AscToHexList(NewPalette)
1860 PaletteStr = WriteLine(PaletteStr, CreateArrayItem(TempPaletteList, 16) + '\n')
1861 ImageBuffer += TempBuffer
1862 BufferStr = WriteLine(BufferStr, '// %s: %s: %s' % (DecToHexStr(Index, 4), ID, DecToHexStr(Index, 4)))
1863 TempBufferList = AscToHexList(TempBuffer)
1864 BufferStr = WriteLine(BufferStr, CreateArrayItem(TempBufferList, 16) + '\n')
1865
1866 StringH.Append(Line)
1867 Index += 1
1868
1869 BufferStr = WriteLine(BufferStr, '// End of the Image Info')
1870 BufferStr = WriteLine(BufferStr, CreateArrayItem(DecToHexList(EFI_HII_IIBT_END, 2)) + '\n')
1871 ImageEnd = pack('B', EFI_HII_IIBT_END)
1872 ImageBuffer += ImageEnd
1873
1874 if len(ImageBuffer) > 1:
1875 ImageInfoOffset = 12
1876 if len(PaletteBuffer) > 1:
1877 PaletteInfoOffset = 12 + len(ImageBuffer) - 1 # -1 is for the first empty pad byte of ImageBuffer
1878
1879 IMAGE_PACKAGE_HDR = pack('=II', ImageInfoOffset, PaletteInfoOffset)
1880 # PACKAGE_HEADER_Length = PACKAGE_HEADER + ImageInfoOffset + PaletteInfoOffset + ImageBuffer Length + PaletteCount + PaletteBuffer Length
1881 if len(PaletteBuffer) > 1:
1882 PACKAGE_HEADER_Length = 4 + 4 + 4 + len(ImageBuffer) - 1 + 2 + len(PaletteBuffer) - 1
1883 else:
1884 PACKAGE_HEADER_Length = 4 + 4 + 4 + len(ImageBuffer) - 1
1885 if PaletteIndex > 1:
1886 PALETTE_INFO_HEADER = pack('H', PaletteIndex - 1)
1887 # EFI_HII_PACKAGE_HEADER length max value is 0xFFFFFF
1888 Hex_Length = '%06X' % PACKAGE_HEADER_Length
1889 if PACKAGE_HEADER_Length > 0xFFFFFF:
1890 EdkLogger.error("build", AUTOGEN_ERROR, "The Length of EFI_HII_PACKAGE_HEADER exceed its maximum value", ExtraData="[%s]" % str(Info))
1891 PACKAGE_HEADER = pack('=HBB', int('0x' + Hex_Length[2:], 16), int('0x' + Hex_Length[0:2], 16), EFI_HII_PACKAGE_IMAGES)
1892
1893 IdfGenBinBuffer.write(PACKAGE_HEADER)
1894 IdfGenBinBuffer.write(IMAGE_PACKAGE_HDR)
1895 if len(ImageBuffer) > 1 :
1896 IdfGenBinBuffer.write(ImageBuffer[1:])
1897 if PaletteIndex > 1:
1898 IdfGenBinBuffer.write(PALETTE_INFO_HEADER)
1899 if len(PaletteBuffer) > 1:
1900 IdfGenBinBuffer.write(PaletteBuffer[1:])
1901
1902 if IdfGenCFlag:
1903 TotalLength = EFI_HII_ARRAY_SIZE_LENGTH + PACKAGE_HEADER_Length
1904 AutoGenC.Append("\n//\n//Image Pack Definition\n//\n")
1905 AllStr = WriteLine('', CHAR_ARRAY_DEFIN + ' ' + Info.Module.BaseName + 'Images' + '[] = {\n')
1906 AllStr = WriteLine(AllStr, '// STRGATHER_OUTPUT_HEADER')
1907 AllStr = WriteLine(AllStr, CreateArrayItem(DecToHexList(TotalLength)) + '\n')
1908 AllStr = WriteLine(AllStr, '// Image PACKAGE HEADER\n')
1909 IMAGE_PACKAGE_HDR_List = AscToHexList(PACKAGE_HEADER)
1910 IMAGE_PACKAGE_HDR_List += AscToHexList(IMAGE_PACKAGE_HDR)
1911 AllStr = WriteLine(AllStr, CreateArrayItem(IMAGE_PACKAGE_HDR_List, 16) + '\n')
1912 AllStr = WriteLine(AllStr, '// Image DATA\n')
1913 if BufferStr:
1914 AllStr = WriteLine(AllStr, BufferStr)
1915 if PaletteStr:
1916 AllStr = WriteLine(AllStr, '// Palette Header\n')
1917 PALETTE_INFO_HEADER_List = AscToHexList(PALETTE_INFO_HEADER)
1918 AllStr = WriteLine(AllStr, CreateArrayItem(PALETTE_INFO_HEADER_List, 16) + '\n')
1919 AllStr = WriteLine(AllStr, '// Palette Data\n')
1920 AllStr = WriteLine(AllStr, PaletteStr)
1921 AllStr = WriteLine(AllStr, '};')
1922 AutoGenC.Append(AllStr)
1923 AutoGenC.Append("\n")
1924 StringH.Append('\nextern unsigned char ' + Info.Module.BaseName + 'Images[];\n')
1925 StringH.Append("\n#define IMAGE_ARRAY_NAME %sImages\n" % Info.Module.BaseName)
1926
1927 # typedef struct _EFI_HII_IMAGE_PACKAGE_HDR {
1928 # EFI_HII_PACKAGE_HEADER Header; # Standard package header, where Header.Type = EFI_HII_PACKAGE_IMAGES
1929 # UINT32 ImageInfoOffset;
1930 # UINT32 PaletteInfoOffset;
1931 # } EFI_HII_IMAGE_PACKAGE_HDR;
1932
1933 # typedef struct {
1934 # UINT32 Length:24;
1935 # UINT32 Type:8;
1936 # UINT8 Data[];
1937 # } EFI_HII_PACKAGE_HEADER;
1938
1939 # typedef struct _EFI_HII_IMAGE_BLOCK {
1940 # UINT8 BlockType;
1941 # UINT8 BlockBody[];
1942 # } EFI_HII_IMAGE_BLOCK;
1943
1944 def BmpImageDecoder(File, Buffer, PaletteIndex, TransParent):
1945 ImageType, = struct.unpack('2s', Buffer[0:2])
1946 if ImageType!= 'BM': # BMP file type is 'BM'
1947 EdkLogger.error("build", FILE_TYPE_MISMATCH, "The file %s is not a standard BMP file." % File.Path)
1948 BMP_IMAGE_HEADER = collections.namedtuple('BMP_IMAGE_HEADER', ['bfSize','bfReserved1','bfReserved2','bfOffBits','biSize','biWidth','biHeight','biPlanes','biBitCount', 'biCompression', 'biSizeImage','biXPelsPerMeter','biYPelsPerMeter','biClrUsed','biClrImportant'])
1949 BMP_IMAGE_HEADER_STRUCT = struct.Struct('IHHIIIIHHIIIIII')
1950 BmpHeader = BMP_IMAGE_HEADER._make(BMP_IMAGE_HEADER_STRUCT.unpack_from(Buffer[2:]))
1951 #
1952 # Doesn't support compress.
1953 #
1954 if BmpHeader.biCompression != 0:
1955 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "The compress BMP file %s is not support." % File.Path)
1956
1957 # The Width and Height is UINT16 type in Image Package
1958 if BmpHeader.biWidth > 0xFFFF:
1959 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "The BMP file %s Width is exceed 0xFFFF." % File.Path)
1960 if BmpHeader.biHeight > 0xFFFF:
1961 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "The BMP file %s Height is exceed 0xFFFF." % File.Path)
1962
1963 PaletteBuffer = pack('x')
1964 if BmpHeader.biBitCount == 1:
1965 if TransParent:
1966 ImageBuffer = pack('B', EFI_HII_IIBT_IMAGE_1BIT_TRANS)
1967 else:
1968 ImageBuffer = pack('B', EFI_HII_IIBT_IMAGE_1BIT)
1969 ImageBuffer += pack('B', PaletteIndex)
1970 Width = (BmpHeader.biWidth + 7)/8
1971 if BmpHeader.bfOffBits > BMP_IMAGE_HEADER_STRUCT.size + 2:
1972 PaletteBuffer = Buffer[BMP_IMAGE_HEADER_STRUCT.size + 2 : BmpHeader.bfOffBits]
1973 elif BmpHeader.biBitCount == 4:
1974 if TransParent:
1975 ImageBuffer = pack('B', EFI_HII_IIBT_IMAGE_4BIT_TRANS)
1976 else:
1977 ImageBuffer = pack('B', EFI_HII_IIBT_IMAGE_4BIT)
1978 ImageBuffer += pack('B', PaletteIndex)
1979 Width = (BmpHeader.biWidth + 1)/2
1980 if BmpHeader.bfOffBits > BMP_IMAGE_HEADER_STRUCT.size + 2:
1981 PaletteBuffer = Buffer[BMP_IMAGE_HEADER_STRUCT.size + 2 : BmpHeader.bfOffBits]
1982 elif BmpHeader.biBitCount == 8:
1983 if TransParent:
1984 ImageBuffer = pack('B', EFI_HII_IIBT_IMAGE_8BIT_TRANS)
1985 else:
1986 ImageBuffer = pack('B', EFI_HII_IIBT_IMAGE_8BIT)
1987 ImageBuffer += pack('B', PaletteIndex)
1988 Width = BmpHeader.biWidth
1989 if BmpHeader.bfOffBits > BMP_IMAGE_HEADER_STRUCT.size + 2:
1990 PaletteBuffer = Buffer[BMP_IMAGE_HEADER_STRUCT.size + 2 : BmpHeader.bfOffBits]
1991 elif BmpHeader.biBitCount == 24:
1992 if TransParent:
1993 ImageBuffer = pack('B', EFI_HII_IIBT_IMAGE_24BIT_TRANS)
1994 else:
1995 ImageBuffer = pack('B', EFI_HII_IIBT_IMAGE_24BIT)
1996 Width = BmpHeader.biWidth * 3
1997 else:
1998 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "Only support the 1 bit, 4 bit, 8bit, 24 bit BMP files.", ExtraData="[%s]" % str(File.Path))
1999
2000 ImageBuffer += pack('H', BmpHeader.biWidth)
2001 ImageBuffer += pack('H', BmpHeader.biHeight)
2002 Start = BmpHeader.bfOffBits
2003 End = BmpHeader.bfSize - 1
2004 for Height in range(0, BmpHeader.biHeight):
2005 if Width % 4 != 0:
2006 Start = End + (Width % 4) - 4 - Width
2007 else:
2008 Start = End - Width
2009 ImageBuffer += Buffer[Start + 1 : Start + Width + 1]
2010 End = Start
2011
2012 # 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
2013 if PaletteBuffer and len(PaletteBuffer) > 1:
2014 PaletteTemp = pack('x')
2015 for Index in range(0, len(PaletteBuffer)):
2016 if Index % 4 == 3:
2017 continue
2018 PaletteTemp += PaletteBuffer[Index]
2019 PaletteBuffer = PaletteTemp[1:]
2020 return ImageBuffer, PaletteBuffer
2021
2022 ## Create common code
2023 #
2024 # @param Info The ModuleAutoGen object
2025 # @param AutoGenC The TemplateString object for C code
2026 # @param AutoGenH The TemplateString object for header file
2027 #
2028 def CreateHeaderCode(Info, AutoGenC, AutoGenH):
2029 # file header
2030 AutoGenH.Append(gAutoGenHeaderString.Replace({'FileName':'AutoGen.h'}))
2031 # header file Prologue
2032 AutoGenH.Append(gAutoGenHPrologueString.Replace({'File':'AUTOGENH','Guid':Info.Guid.replace('-','_')}))
2033 AutoGenH.Append(gAutoGenHCppPrologueString)
2034 if Info.AutoGenVersion >= 0x00010005:
2035 # header files includes
2036 AutoGenH.Append("#include <%s>\n" % gBasicHeaderFile)
2037 if Info.ModuleType in gModuleTypeHeaderFile \
2038 and gModuleTypeHeaderFile[Info.ModuleType][0] != gBasicHeaderFile:
2039 AutoGenH.Append("#include <%s>\n" % gModuleTypeHeaderFile[Info.ModuleType][0])
2040 #
2041 # if either PcdLib in [LibraryClasses] sections or there exist Pcd section, add PcdLib.h
2042 # As if modules only uses FixedPcd, then PcdLib is not needed in [LibraryClasses] section.
2043 #
2044 if 'PcdLib' in Info.Module.LibraryClasses or Info.Module.Pcds:
2045 AutoGenH.Append("#include <Library/PcdLib.h>\n")
2046
2047 AutoGenH.Append('\nextern GUID gEfiCallerIdGuid;')
2048 AutoGenH.Append('\nextern CHAR8 *gEfiCallerBaseName;\n\n')
2049
2050 if Info.IsLibrary:
2051 return
2052
2053 AutoGenH.Append("#define EFI_CALLER_ID_GUID \\\n %s\n" % GuidStringToGuidStructureString(Info.Guid))
2054
2055 if Info.IsLibrary:
2056 return
2057 # C file header
2058 AutoGenC.Append(gAutoGenHeaderString.Replace({'FileName':'AutoGen.c'}))
2059 if Info.AutoGenVersion >= 0x00010005:
2060 # C file header files includes
2061 if Info.ModuleType in gModuleTypeHeaderFile:
2062 for Inc in gModuleTypeHeaderFile[Info.ModuleType]:
2063 AutoGenC.Append("#include <%s>\n" % Inc)
2064 else:
2065 AutoGenC.Append("#include <%s>\n" % gBasicHeaderFile)
2066
2067 #
2068 # Publish the CallerId Guid
2069 #
2070 AutoGenC.Append('\nGLOBAL_REMOVE_IF_UNREFERENCED GUID gEfiCallerIdGuid = %s;\n' % GuidStringToGuidStructureString(Info.Guid))
2071 AutoGenC.Append('\nGLOBAL_REMOVE_IF_UNREFERENCED CHAR8 *gEfiCallerBaseName = "%s";\n' % Info.Name)
2072
2073 ## Create common code for header file
2074 #
2075 # @param Info The ModuleAutoGen object
2076 # @param AutoGenC The TemplateString object for C code
2077 # @param AutoGenH The TemplateString object for header file
2078 #
2079 def CreateFooterCode(Info, AutoGenC, AutoGenH):
2080 AutoGenH.Append(gAutoGenHEpilogueString)
2081
2082 ## Create code for a module
2083 #
2084 # @param Info The ModuleAutoGen object
2085 # @param AutoGenC The TemplateString object for C code
2086 # @param AutoGenH The TemplateString object for header file
2087 # @param StringH The TemplateString object for header file
2088 # @param UniGenCFlag UniString is generated into AutoGen C file when it is set to True
2089 # @param UniGenBinBuffer Buffer to store uni string package data
2090 # @param StringIdf The TemplateString object for header file
2091 # @param IdfGenCFlag IdfString is generated into AutoGen C file when it is set to True
2092 # @param IdfGenBinBuffer Buffer to store Idf string package data
2093 #
2094 def CreateCode(Info, AutoGenC, AutoGenH, StringH, UniGenCFlag, UniGenBinBuffer, StringIdf, IdfGenCFlag, IdfGenBinBuffer):
2095 CreateHeaderCode(Info, AutoGenC, AutoGenH)
2096
2097 if Info.AutoGenVersion >= 0x00010005:
2098 CreateGuidDefinitionCode(Info, AutoGenC, AutoGenH)
2099 CreateProtocolDefinitionCode(Info, AutoGenC, AutoGenH)
2100 CreatePpiDefinitionCode(Info, AutoGenC, AutoGenH)
2101 CreatePcdCode(Info, AutoGenC, AutoGenH)
2102 CreateLibraryConstructorCode(Info, AutoGenC, AutoGenH)
2103 CreateLibraryDestructorCode(Info, AutoGenC, AutoGenH)
2104 CreateModuleEntryPointCode(Info, AutoGenC, AutoGenH)
2105 CreateModuleUnloadImageCode(Info, AutoGenC, AutoGenH)
2106
2107 if Info.UnicodeFileList:
2108 FileName = "%sStrDefs.h" % Info.Name
2109 StringH.Append(gAutoGenHeaderString.Replace({'FileName':FileName}))
2110 StringH.Append(gAutoGenHPrologueString.Replace({'File':'STRDEFS', 'Guid':Info.Guid.replace('-','_')}))
2111 CreateUnicodeStringCode(Info, AutoGenC, StringH, UniGenCFlag, UniGenBinBuffer)
2112
2113 GuidMacros = []
2114 for Guid in Info.Module.Guids:
2115 if Guid in Info.Module.GetGuidsUsedByPcd():
2116 continue
2117 GuidMacros.append('#define %s %s' % (Guid, Info.Module.Guids[Guid]))
2118 for Guid, Value in Info.Module.Protocols.items() + Info.Module.Ppis.items():
2119 GuidMacros.append('#define %s %s' % (Guid, Value))
2120 # supports FixedAtBuild usage in VFR file
2121 if Info.VfrFileList and Info.ModulePcdList:
2122 GuidMacros.append('#define %s %s' % ('FixedPcdGetBool(TokenName)', '_PCD_VALUE_##TokenName'))
2123 GuidMacros.append('#define %s %s' % ('FixedPcdGet8(TokenName)', '_PCD_VALUE_##TokenName'))
2124 GuidMacros.append('#define %s %s' % ('FixedPcdGet16(TokenName)', '_PCD_VALUE_##TokenName'))
2125 GuidMacros.append('#define %s %s' % ('FixedPcdGet32(TokenName)', '_PCD_VALUE_##TokenName'))
2126 GuidMacros.append('#define %s %s' % ('FixedPcdGet64(TokenName)', '_PCD_VALUE_##TokenName'))
2127 for Pcd in Info.ModulePcdList:
2128 if Pcd.Type == TAB_PCDS_FIXED_AT_BUILD:
2129 TokenCName = Pcd.TokenCName
2130 Value = Pcd.DefaultValue
2131 if Pcd.DatumType == 'BOOLEAN':
2132 BoolValue = Value.upper()
2133 if BoolValue == 'TRUE':
2134 Value = '1'
2135 elif BoolValue == 'FALSE':
2136 Value = '0'
2137 for PcdItem in GlobalData.MixedPcd:
2138 if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:
2139 TokenCName = PcdItem[0]
2140 break
2141 GuidMacros.append('#define %s %s' % ('_PCD_VALUE_'+TokenCName, Value))
2142
2143 if Info.IdfFileList:
2144 GuidMacros.append('#include "%sImgDefs.h"' % Info.Name)
2145
2146 if GuidMacros:
2147 StringH.Append('\n#ifdef VFRCOMPILE\n%s\n#endif\n' % '\n'.join(GuidMacros))
2148
2149 StringH.Append("\n#endif\n")
2150 AutoGenH.Append('#include "%s"\n' % FileName)
2151
2152 if Info.IdfFileList:
2153 FileName = "%sImgDefs.h" % Info.Name
2154 StringIdf.Append(gAutoGenHeaderString.Replace({'FileName':FileName}))
2155 StringIdf.Append(gAutoGenHPrologueString.Replace({'File':'IMAGEDEFS', 'Guid':Info.Guid.replace('-','_')}))
2156 CreateIdfFileCode(Info, AutoGenC, StringIdf, IdfGenCFlag, IdfGenBinBuffer)
2157
2158 StringIdf.Append("\n#endif\n")
2159 AutoGenH.Append('#include "%s"\n' % FileName)
2160
2161 CreateFooterCode(Info, AutoGenC, AutoGenH)
2162
2163 # no generation of AutoGen.c for Edk modules without unicode file
2164 if Info.AutoGenVersion < 0x00010005 and len(Info.UnicodeFileList) == 0:
2165 AutoGenC.String = ''
2166
2167 ## Create the code file
2168 #
2169 # @param FilePath The path of code file
2170 # @param Content The content of code file
2171 # @param IsBinaryFile The flag indicating if the file is binary file or not
2172 #
2173 # @retval True If file content is changed or file doesn't exist
2174 # @retval False If the file exists and the content is not changed
2175 #
2176 def Generate(FilePath, Content, IsBinaryFile):
2177 return SaveFileOnChange(FilePath, Content, IsBinaryFile)
2178
EFI Development Kit II mirror for PVE