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