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