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


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