00f66eb26f92f08f2bf57f24fbdeafcf7033c46b
[people/mcb30/basetools.git] / Source / Python / AutoGen / GenC.py
1 ## @file\r
2 # Routines for generating AutoGen.h and AutoGen.c\r
3 #\r
4 # Copyright (c) 2007, Intel Corporation\r
5 # All rights reserved. This program and the accompanying materials\r
6 # are licensed and made available under the terms and conditions of the BSD License\r
7 # which accompanies this distribution.  The full text of the license may be found at\r
8 # http://opensource.org/licenses/bsd-license.php\r
9 #\r
10 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
11 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
12 #\r
13 \r
14 ## Import Modules\r
15 #\r
16 import string\r
17 \r
18 from Common import EdkLogger\r
19 \r
20 from Common.BuildToolError import *\r
21 from Common.DataType import *\r
22 from Common.EdkIIWorkspace import *\r
23 from Common.Misc import *\r
24 from BuildInfo import *\r
25 from StrGather import *\r
26 \r
27 ## PCD type string\r
28 gItemTypeStringDatabase  = {\r
29     TAB_PCDS_FEATURE_FLAG       :   'FixedAtBuild',\r
30     TAB_PCDS_FIXED_AT_BUILD     :   'FixedAtBuild',\r
31     TAB_PCDS_PATCHABLE_IN_MODULE:   'BinaryPatch',\r
32     TAB_PCDS_DYNAMIC            :   '',\r
33     TAB_PCDS_DYNAMIC_DEFAULT    :   '',\r
34     TAB_PCDS_DYNAMIC_VPD        :   '',\r
35     TAB_PCDS_DYNAMIC_HII        :   '',\r
36     TAB_PCDS_DYNAMIC_EX         :   '',\r
37     TAB_PCDS_DYNAMIC_EX_DEFAULT :   '',\r
38     TAB_PCDS_DYNAMIC_EX_VPD     :   '',\r
39     TAB_PCDS_DYNAMIC_EX_HII     :   '',\r
40 }\r
41 \r
42 ## Dynamic PCD types\r
43 gDynamicPcd = [TAB_PCDS_DYNAMIC, TAB_PCDS_DYNAMIC_DEFAULT, TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_HII]\r
44 \r
45 ## Dynamic-ex PCD types\r
46 gDynamicExPcd = [TAB_PCDS_DYNAMIC_EX, TAB_PCDS_DYNAMIC_EX_DEFAULT, TAB_PCDS_DYNAMIC_EX_VPD, TAB_PCDS_DYNAMIC_EX_HII]\r
47 \r
48 ## Datum size\r
49 gDatumSizeStringDatabase = {'UINT8':'8','UINT16':'16','UINT32':'32','UINT64':'64','BOOLEAN':'BOOLEAN','VOID*':'8'}\r
50 gDatumSizeStringDatabaseH = {'UINT8':'8','UINT16':'16','UINT32':'32','UINT64':'64','BOOLEAN':'BOOL','VOID*':'PTR'}\r
51 gDatumSizeStringDatabaseLib = {'UINT8':'8','UINT16':'16','UINT32':'32','UINT64':'64','BOOLEAN':'Bool','VOID*':'Ptr'}\r
52 \r
53 ## Mapping between PCD driver type and EFI phase\r
54 gPcdPhaseMap = {\r
55     "PEI_PCD_DRIVER"    :   "PEI",\r
56     "DXE_PCD_DRIVER"    :   "DXE"\r
57 }\r
58 \r
59 gPcdDatabaseCommonAutoGenH = """\r
60 //\r
61 // The following definition will be generated by build tool\r
62 //\r
63 \r
64 //\r
65 // Common definitions\r
66 //\r
67 typedef UINT8 SKU_ID;\r
68 \r
69 #define PCD_TYPE_SHIFT        28\r
70 \r
71 #define PCD_TYPE_DATA         (0x0 << PCD_TYPE_SHIFT)\r
72 #define PCD_TYPE_HII          (0x8 << PCD_TYPE_SHIFT)\r
73 #define PCD_TYPE_VPD          (0x4 << PCD_TYPE_SHIFT)\r
74 #define PCD_TYPE_SKU_ENABLED  (0x2 << PCD_TYPE_SHIFT)\r
75 #define PCD_TYPE_STRING       (0x1 << PCD_TYPE_SHIFT)\r
76 \r
77 #define PCD_TYPE_ALL_SET      (PCD_TYPE_DATA | PCD_TYPE_HII | PCD_TYPE_VPD | PCD_TYPE_SKU_ENABLED | PCD_TYPE_STRING)\r
78 \r
79 #define PCD_DATUM_TYPE_SHIFT  24\r
80 \r
81 #define PCD_DATUM_TYPE_POINTER  (0x0 << PCD_DATUM_TYPE_SHIFT)\r
82 #define PCD_DATUM_TYPE_UINT8    (0x1 << PCD_DATUM_TYPE_SHIFT)\r
83 #define PCD_DATUM_TYPE_UINT16   (0x2 << PCD_DATUM_TYPE_SHIFT)\r
84 #define PCD_DATUM_TYPE_UINT32   (0x4 << PCD_DATUM_TYPE_SHIFT)\r
85 #define PCD_DATUM_TYPE_UINT64   (0x8 << PCD_DATUM_TYPE_SHIFT)\r
86 \r
87 #define PCD_DATUM_TYPE_ALL_SET  (PCD_DATUM_TYPE_POINTER | \\\r
88                                  PCD_DATUM_TYPE_UINT8   | \\\r
89                                  PCD_DATUM_TYPE_UINT16  | \\\r
90                                  PCD_DATUM_TYPE_UINT32  | \\\r
91                                  PCD_DATUM_TYPE_UINT64)\r
92 \r
93 #define PCD_DATABASE_OFFSET_MASK (~(PCD_TYPE_ALL_SET | PCD_DATUM_TYPE_ALL_SET))\r
94 \r
95 typedef struct  {\r
96   UINT32  ExTokenNumber;\r
97   UINT16  LocalTokenNumber;   // PCD Number of this particular platform build\r
98   UINT16  ExGuidIndex;        // Index of GuidTable\r
99 } DYNAMICEX_MAPPING;\r
100 \r
101 typedef struct {\r
102   UINT32  SkuDataStartOffset; //We have to use offsetof MACRO as we don't know padding done by compiler\r
103   UINT32  SkuIdTableOffset;   //Offset from the PCD_DB\r
104 } SKU_HEAD;\r
105 \r
106 typedef struct {\r
107   UINT16  GuidTableIndex;     // Offset in Guid Table in units of GUID.\r
108   UINT16  StringIndex;        // Offset in String Table in units of UINT16.\r
109   UINT16  Offset;             // Offset in Variable\r
110   UINT16  DefaultValueOffset; // Offset of the Default Value\r
111 } VARIABLE_HEAD;\r
112 \r
113 typedef  struct {\r
114   UINT32  Offset;\r
115 } VPD_HEAD;\r
116 \r
117 typedef UINT16 STRING_HEAD;\r
118 \r
119 typedef UINT16 SIZE_INFO;\r
120 \r
121 #define offsetof(s,m)  (UINT32) (UINTN) &(((s *)0)->m)\r
122 \r
123 """\r
124 \r
125 gPcdDatabaseEpilogueAutoGenH = """\r
126 typedef struct {\r
127   PEI_PCD_DATABASE PeiDb;\r
128   DXE_PCD_DATABASE DxeDb;\r
129 } PCD_DATABASE;\r
130 \r
131 #define PCD_TOTAL_TOKEN_NUMBER (PEI_LOCAL_TOKEN_NUMBER + DXE_LOCAL_TOKEN_NUMBER)\r
132 \r
133 """\r
134 \r
135 gPcdDatabaseAutoGenH = """\r
136 #define ${PHASE}_GUID_TABLE_SIZE                ${GUID_TABLE_SIZE}\r
137 #define ${PHASE}_STRING_TABLE_SIZE              ${STRING_TABLE_SIZE}\r
138 #define ${PHASE}_SKUID_TABLE_SIZE               ${SKUID_TABLE_SIZE}\r
139 #define ${PHASE}_LOCAL_TOKEN_NUMBER_TABLE_SIZE  ${LOCAL_TOKEN_NUMBER_TABLE_SIZE}\r
140 #define ${PHASE}_LOCAL_TOKEN_NUMBER             ${LOCAL_TOKEN_NUMBER}\r
141 #define ${PHASE}_EXMAPPING_TABLE_SIZE           ${EXMAPPING_TABLE_SIZE}\r
142 #define ${PHASE}_EX_TOKEN_NUMBER                ${EX_TOKEN_NUMBER}\r
143 #define ${PHASE}_SIZE_TABLE_SIZE                ${SIZE_TABLE_SIZE}\r
144 #define ${PHASE}_GUID_TABLE_EMPTY               ${GUID_TABLE_EMPTY}\r
145 #define ${PHASE}_STRING_TABLE_EMPTY             ${STRING_TABLE_EMPTY}\r
146 #define ${PHASE}_SKUID_TABLE_EMPTY              ${SKUID_TABLE_EMPTY}\r
147 #define ${PHASE}_DATABASE_EMPTY                 ${DATABASE_EMPTY}\r
148 #define ${PHASE}_EXMAP_TABLE_EMPTY              ${EXMAP_TABLE_EMPTY}\r
149 \r
150 typedef struct {\r
151 ${BEGIN}  UINT64             ${INIT_CNAME_DECL_UINT64}_${INIT_GUID_DECL_UINT64}[${INIT_NUMSKUS_DECL_UINT64}];\r
152 ${END}\r
153 ${BEGIN}  UINT64             ${VARDEF_CNAME_UINT64}_${VARDEF_GUID_UINT64}_VariableDefault_${VARDEF_SKUID_UINT64};\r
154 ${END}\r
155 ${BEGIN}  UINT32             ${INIT_CNAME_DECL_UINT32}_${INIT_GUID_DECL_UINT32}[${INIT_NUMSKUS_DECL_UINT32}];\r
156 ${END}\r
157 ${BEGIN}  UINT32             ${VARDEF_CNAME_UINT32}_${VARDEF_GUID_UINT32}_VariableDefault_${VARDEF_SKUID_UINT32};\r
158 ${END}\r
159 ${BEGIN}  VPD_HEAD           ${VPD_HEAD_CNAME_DECL}_${VPD_HEAD_GUID_DECL}[${VPD_HEAD_NUMSKUS_DECL}];\r
160 ${END}\r
161   DYNAMICEX_MAPPING  ExMapTable[${PHASE}_EXMAPPING_TABLE_SIZE];\r
162   UINT32             LocalTokenNumberTable[${PHASE}_LOCAL_TOKEN_NUMBER_TABLE_SIZE];\r
163   GUID               GuidTable[${PHASE}_GUID_TABLE_SIZE];\r
164 ${BEGIN}  STRING_HEAD        ${STRING_HEAD_CNAME_DECL}_${STRING_HEAD_GUID_DECL}[${STRING_HEAD_NUMSKUS_DECL}];\r
165 ${END}\r
166 ${BEGIN}  VARIABLE_HEAD      ${VARIABLE_HEAD_CNAME_DECL}_${VARIABLE_HEAD_GUID_DECL}[${VARIABLE_HEAD_NUMSKUS_DECL}];\r
167 ${END}\r
168 ${BEGIN}  UINT16             StringTable${STRING_TABLE_INDEX}[${STRING_TABLE_LENGTH}]; /* ${STRING_TABLE_CNAME}_${STRING_TABLE_GUID} */\r
169 ${END}\r
170   SIZE_INFO          SizeTable[${PHASE}_SIZE_TABLE_SIZE];\r
171 ${BEGIN}  UINT16             ${INIT_CNAME_DECL_UINT16}_${INIT_GUID_DECL_UINT16}[${INIT_NUMSKUS_DECL_UINT16}];\r
172 ${END}\r
173 ${BEGIN}  UINT16             ${VARDEF_CNAME_UINT16}_${VARDEF_GUID_UINT16}_VariableDefault_${VARDEF_SKUID_UINT16};\r
174 ${END}\r
175 ${BEGIN}  UINT8              ${INIT_CNAME_DECL_UINT8}_${INIT_GUID_DECL_UINT8}[${INIT_NUMSKUS_DECL_UINT8}];\r
176 ${END}\r
177 ${BEGIN}  UINT8              ${VARDEF_CNAME_UINT8}_${VARDEF_GUID_UINT8}_VariableDefault_${VARDEF_SKUID_UINT8};\r
178 ${END}\r
179 ${BEGIN}  BOOLEAN            ${INIT_CNAME_DECL_BOOLEAN}_${INIT_GUID_DECL_BOOLEAN}[${INIT_NUMSKUS_DECL_BOOLEAN}];\r
180 ${END}\r
181 ${BEGIN}  BOOLEAN            ${VARDEF_CNAME_BOOLEAN}_${VARDEF_GUID_BOOLEAN}_VariableDefault_${VARDEF_SKUID_BOOLEAN};\r
182 ${END}\r
183   UINT8              SkuIdTable[${PHASE}_SKUID_TABLE_SIZE];\r
184 ${SYSTEM_SKU_ID}\r
185 } ${PHASE}_PCD_DATABASE_INIT;\r
186 \r
187 typedef struct {\r
188 ${PCD_DATABASE_UNINIT_EMPTY}\r
189 ${BEGIN}  UINT64   ${UNINIT_CNAME_DECL_UINT64}_${UNINIT_GUID_DECL_UINT64}[${UNINIT_NUMSKUS_DECL_UINT64}];\r
190 ${END}\r
191 ${BEGIN}  UINT32   ${UNINIT_CNAME_DECL_UINT32}_${UNINIT_GUID_DECL_UINT32}[${UNINIT_NUMSKUS_DECL_UINT32}];\r
192 ${END}\r
193 ${BEGIN}  UINT16   ${UNINIT_CNAME_DECL_UINT16}_${UNINIT_GUID_DECL_UINT16}[${UNINIT_NUMSKUS_DECL_UINT16}];\r
194 ${END}\r
195 ${BEGIN}  UINT8    ${UNINIT_CNAME_DECL_UINT8}_${UNINIT_GUID_DECL_UINT8}[${UNINIT_NUMSKUS_DECL_UINT8}];\r
196 ${END}\r
197 ${BEGIN}  BOOLEAN  ${UNINIT_CNAME_DECL_BOOLEAN}_${UNINIT_GUID_DECL_BOOLEAN}[${UNINIT_NUMSKUS_DECL_BOOLEAN}];\r
198 ${END}\r
199 } ${PHASE}_PCD_DATABASE_UNINIT;\r
200 \r
201 #define PCD_${PHASE}_SERVICE_DRIVER_VERSION         2\r
202 \r
203 typedef struct {\r
204   ${PHASE}_PCD_DATABASE_INIT    Init;\r
205   ${PHASE}_PCD_DATABASE_UNINIT  Uninit;\r
206 } ${PHASE}_PCD_DATABASE;\r
207 \r
208 #define ${PHASE}_NEX_TOKEN_NUMBER (${PHASE}_LOCAL_TOKEN_NUMBER - ${PHASE}_EX_TOKEN_NUMBER)\r
209 """\r
210 \r
211 gEmptyPcdDatabaseAutoGenC = """\r
212 ${PHASE}_PCD_DATABASE_INIT g${PHASE}PcdDbInit = {\r
213   /* ExMapTable */\r
214   {\r
215     {0, 0, 0}\r
216   },\r
217   /* LocalTokenNumberTable */\r
218   {\r
219     0\r
220   },\r
221   /* GuidTable */\r
222   {\r
223     {0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}\r
224   },\r
225   /* StringTable */\r
226   { 0 },\r
227   /* SizeTable */\r
228   {\r
229     0, 0\r
230   },\r
231   /* SkuIdTable */\r
232   { 0 },\r
233   ${SYSTEM_SKU_ID_VALUE}\r
234 };\r
235 """\r
236 \r
237 gPcdDatabaseAutoGenC = """\r
238 ${PHASE}_PCD_DATABASE_INIT g${PHASE}PcdDbInit = {\r
239 ${BEGIN}  { ${INIT_VALUE_UINT64} }, /*  ${INIT_CNAME_DECL_UINT64}_${INIT_GUID_DECL_UINT64}[${INIT_NUMSKUS_DECL_UINT64}] */\r
240 ${END}\r
241 ${BEGIN}  ${VARDEF_VALUE_UINT64}, /* ${VARDEF_CNAME_UINT64}_${VARDEF_GUID_UINT64}_VariableDefault_${VARDEF_SKUID_UINT64} */\r
242 ${END}\r
243 ${BEGIN}  { ${INIT_VALUE_UINT32} }, /*  ${INIT_CNAME_DECL_UINT32}_${INIT_GUID_DECL_UINT32}[${INIT_NUMSKUS_DECL_UINT32}] */\r
244 ${END}\r
245 ${BEGIN}  ${VARDEF_VALUE_UINT32}, /* ${VARDEF_CNAME_UINT32}_${VARDEF_GUID_UINT32}_VariableDefault_${VARDEF_SKUID_UINT32} */\r
246 ${END}\r
247   /* VPD */\r
248 ${BEGIN}  { ${VPD_HEAD_VALUE} }, /* ${VPD_HEAD_CNAME_DECL}_${VPD_HEAD_GUID_DECL}[${VPD_HEAD_NUMSKUS_DECL}] */\r
249 ${END}\r
250   /* ExMapTable */\r
251   {\r
252 ${BEGIN}    { ${EXMAPPING_TABLE_EXTOKEN}, ${EXMAPPING_TABLE_LOCAL_TOKEN}, ${EXMAPPING_TABLE_GUID_INDEX} },\r
253 ${END}\r
254   },\r
255   /* LocalTokenNumberTable */\r
256   {\r
257 ${BEGIN}    offsetof(${PHASE}_PCD_DATABASE, ${TOKEN_INIT}.${TOKEN_CNAME}_${TOKEN_GUID}) | ${TOKEN_TYPE},\r
258 ${END}\r
259   },\r
260   /* GuidTable */\r
261   {\r
262 ${BEGIN}    ${GUID_STRUCTURE},\r
263 ${END}\r
264   },\r
265 ${BEGIN}  { ${STRING_HEAD_VALUE} }, /* ${STRING_HEAD_CNAME_DECL}_${STRING_HEAD_GUID_DECL}[${STRING_HEAD_NUMSKUS_DECL}] */\r
266 ${END}\r
267 ${BEGIN}  /* ${VARIABLE_HEAD_CNAME_DECL}_${VARIABLE_HEAD_GUID_DECL}[${VARIABLE_HEAD_NUMSKUS_DECL}] */\r
268   {\r
269     ${VARIABLE_HEAD_VALUE}\r
270   },\r
271 ${END}\r
272  /* StringTable */\r
273 ${BEGIN}  ${STRING_TABLE_VALUE}, /* ${STRING_TABLE_CNAME}_${STRING_TABLE_GUID} */\r
274 ${END}\r
275   /* SizeTable */\r
276   {\r
277 ${BEGIN}    ${SIZE_TABLE_MAXIMUM_LENGTH}, ${SIZE_TABLE_CURRENT_LENGTH}, /* ${SIZE_TABLE_CNAME}_${SIZE_TABLE_GUID} */\r
278 ${END}\r
279   },\r
280 ${BEGIN}  { ${INIT_VALUE_UINT16} }, /*  ${INIT_CNAME_DECL_UINT16}_${INIT_GUID_DECL_UINT16}[${INIT_NUMSKUS_DECL_UINT16}] */\r
281 ${END}\r
282 ${BEGIN}  ${VARDEF_VALUE_UINT16}, /* ${VARDEF_CNAME_UINT16}_${VARDEF_GUID_UINT16}_VariableDefault_${VARDEF_SKUID_UINT16} */\r
283 ${END}\r
284 ${BEGIN}  { ${INIT_VALUE_UINT8} }, /*  ${INIT_CNAME_DECL_UINT8}_${INIT_GUID_DECL_UINT8}[${INIT_NUMSKUS_DECL_UINT8}] */\r
285 ${END}\r
286 ${BEGIN}  ${VARDEF_VALUE_UINT8}, /* ${VARDEF_CNAME_UINT8}_${VARDEF_GUID_UINT8}_VariableDefault_${VARDEF_SKUID_UINT8} */\r
287 ${END}\r
288 ${BEGIN}  { ${INIT_VALUE_BOOLEAN} }, /*  ${INIT_CNAME_DECL_BOOLEAN}_${INIT_GUID_DECL_BOOLEAN}[${INIT_NUMSKUS_DECL_BOOLEAN}] */\r
289 ${END}\r
290 ${BEGIN}  ${VARDEF_VALUE_BOOLEAN}, /* ${VARDEF_CNAME_BOOLEAN}_${VARDEF_GUID_BOOLEAN}_VariableDefault_${VARDEF_SKUID_BOOLEAN} */\r
291 ${END}\r
292   /* SkuIdTable */\r
293   { ${BEGIN}${SKUID_VALUE}, ${END} },\r
294   ${SYSTEM_SKU_ID_VALUE}\r
295 };\r
296 """\r
297 \r
298 \r
299 ## AutoGen File Header Templates\r
300 gAutoGenHeaderString = """\\r
301 /**\r
302   DO NOT EDIT\r
303   FILE auto-generated\r
304   Module name:\r
305     $FileName\r
306   Abstract:       Auto-generated $FileName for building module or library.\r
307 **/\r
308 """\r
309 \r
310 gAutoGenHPrologueString = """\r
311 #ifndef _AUTOGENH_${Guid}\r
312 #define _AUTOGENH_${Guid}\r
313 \r
314 extern int __make_me_compile_correctly;\r
315 """\r
316 \r
317 gAutoGenHEpilogueString = """\r
318 #endif\r
319 """\r
320 \r
321 ## PEI Core Entry Point Templates\r
322 gPeiCoreEntryPointString = """\r
323 ${BEGIN}\r
324 EFI_STATUS\r
325 ${Function} (\r
326   IN CONST  EFI_SEC_PEI_HAND_OFF    *SecCoreData,\r
327   IN CONST  EFI_PEI_PPI_DESCRIPTOR  *PpiList,\r
328   IN VOID                           *OldCoreData\r
329   );\r
330 \r
331 EFI_STATUS\r
332 EFIAPI\r
333 ProcessModuleEntryPointList (\r
334   IN CONST  EFI_SEC_PEI_HAND_OFF    *SecCoreData,\r
335   IN CONST  EFI_PEI_PPI_DESCRIPTOR  *PpiList,\r
336   IN VOID                           *OldCoreData\r
337   )\r
338 \r
339 {\r
340   return ${Function} (SecCoreData, PpiList, OldCoreData);\r
341 }\r
342 ${END}\r
343 """\r
344 \r
345 \r
346 ## DXE Core Entry Point Templates\r
347 gDxeCoreEntryPointString = """\r
348 const UINT32 _gUefiDriverRevision = 0;\r
349 ${BEGIN}\r
350 VOID\r
351 ${Function} (\r
352   IN VOID  *HobStart\r
353   );\r
354 \r
355 VOID\r
356 EFIAPI\r
357 ProcessModuleEntryPointList (\r
358   IN VOID  *HobStart\r
359   )\r
360 \r
361 {\r
362   ${Function} (HobStart);\r
363 }\r
364 ${END}\r
365 """\r
366 \r
367 ## PEIM Entry Point Templates\r
368 gPeimEntryPointString = [\r
369 """\r
370 GLOBAL_REMOVE_IF_UNREFERENCED const UINT32 _gPeimRevision = 0;\r
371 \r
372 EFI_STATUS\r
373 EFIAPI\r
374 ProcessModuleEntryPointList (\r
375   IN EFI_PEI_FILE_HANDLE  FileHandle,\r
376   IN EFI_PEI_SERVICES     **PeiServices\r
377   )\r
378 \r
379 {\r
380   return EFI_SUCCESS;\r
381 }\r
382 """,\r
383 """\r
384 GLOBAL_REMOVE_IF_UNREFERENCED const UINT32 _gPeimRevision = 0;\r
385 ${BEGIN}\r
386 EFI_STATUS\r
387 ${Function} (\r
388   IN EFI_PEI_FILE_HANDLE  FileHandle,\r
389   IN EFI_PEI_SERVICES     **PeiServices\r
390   );\r
391 \r
392 EFI_STATUS\r
393 EFIAPI\r
394 ProcessModuleEntryPointList (\r
395   IN EFI_PEI_FILE_HANDLE  FileHandle,\r
396   IN EFI_PEI_SERVICES     **PeiServices\r
397   )\r
398 \r
399 {\r
400   return ${Function} (FileHandle, PeiServices);\r
401 }\r
402 ${END}\r
403 """,\r
404 """\r
405 GLOBAL_REMOVE_IF_UNREFERENCED const UINT32 _gPeimRevision = 0;\r
406 \r
407 ${BEGIN}\r
408 EFI_STATUS\r
409 ${Function} (\r
410   IN EFI_PEI_FILE_HANDLE  FileHandle,\r
411   IN EFI_PEI_SERVICES     **PeiServices\r
412   );\r
413 ${END}\r
414 \r
415 EFI_STATUS\r
416 EFIAPI\r
417 ProcessModuleEntryPointList (\r
418   IN EFI_PEI_FILE_HANDLE  FileHandle,\r
419   IN EFI_PEI_SERVICES     **PeiServices\r
420   )\r
421 \r
422 {\r
423   EFI_STATUS  Status;\r
424   EFI_STATUS  CombinedStatus;\r
425 \r
426   CombinedStatus = EFI_LOAD_ERROR;\r
427 ${BEGIN}\r
428   Status = ${Function} (FileHandle, PeiServices);\r
429   if (!EFI_ERROR (Status) || EFI_ERROR (CombinedStatus)) {\r
430     CombinedStatus = Status;\r
431   }\r
432 ${END}\r
433   return CombinedStatus;\r
434 }\r
435 """\r
436 ]\r
437 \r
438 ## DXE SMM Entry Point Templates\r
439 gDxeSmmEntryPointString = [\r
440 """\r
441 EFI_STATUS\r
442 EFIAPI\r
443 ProcessModuleEntryPointList (\r
444   IN EFI_HANDLE        ImageHandle,\r
445   IN EFI_SYSTEM_TABLE  *SystemTable\r
446   )\r
447 \r
448 {\r
449   return EFI_SUCCESS;\r
450 }\r
451 """,\r
452 """\r
453 ${BEGIN}\r
454 EFI_STATUS\r
455 ${Function} (\r
456   IN EFI_HANDLE        ImageHandle,\r
457   IN EFI_SYSTEM_TABLE  *SystemTable\r
458   );\r
459 ${END}\r
460 \r
461 static BASE_LIBRARY_JUMP_BUFFER  mJumpContext;\r
462 static EFI_STATUS  mDriverEntryPointStatus = EFI_LOAD_ERROR;\r
463 \r
464 VOID\r
465 EFIAPI\r
466 ExitDriver (\r
467   IN EFI_STATUS  Status\r
468   )\r
469 {\r
470   if (!EFI_ERROR (Status) || EFI_ERROR (mDriverEntryPointStatus)) {\r
471     mDriverEntryPointStatus = Status;\r
472   }\r
473   LongJump (&mJumpContext, (UINTN)-1);\r
474   ASSERT (FALSE);\r
475 }\r
476 \r
477 EFI_STATUS\r
478 EFIAPI\r
479 ProcessModuleEntryPointList (\r
480   IN EFI_HANDLE        ImageHandle,\r
481   IN EFI_SYSTEM_TABLE  *SystemTable\r
482   )\r
483 \r
484 {\r
485 ${BEGIN}\r
486   if (SetJump (&mJumpContext) == 0) {\r
487     ExitDriver (${Function} (ImageHandle, SystemTable));\r
488     ASSERT (FALSE);\r
489   }\r
490 ${END}\r
491 \r
492   return mDriverEntryPointStatus;\r
493 }\r
494 """\r
495 ]\r
496 \r
497 ## UEFI Entry Point Templates\r
498 gUefiEntryPointString = [\r
499 """\r
500 const UINT32 _gUefiDriverRevision = 0;\r
501 \r
502 EFI_STATUS\r
503 EFIAPI\r
504 ProcessModuleEntryPointList (\r
505   IN EFI_HANDLE        ImageHandle,\r
506   IN EFI_SYSTEM_TABLE  *SystemTable\r
507   )\r
508 {\r
509   return EFI_SUCCESS;\r
510 }\r
511 """,\r
512 """\r
513 const UINT32 _gUefiDriverRevision = 0;\r
514 ${BEGIN}\r
515 EFI_STATUS\r
516 ${Function} (\r
517   IN EFI_HANDLE        ImageHandle,\r
518   IN EFI_SYSTEM_TABLE  *SystemTable\r
519   );\r
520 \r
521 EFI_STATUS\r
522 EFIAPI\r
523 ProcessModuleEntryPointList (\r
524   IN EFI_HANDLE        ImageHandle,\r
525   IN EFI_SYSTEM_TABLE  *SystemTable\r
526   )\r
527 \r
528 {\r
529   return ${Function} (ImageHandle, SystemTable);\r
530 }\r
531 ${END}\r
532 VOID\r
533 EFIAPI\r
534 ExitDriver (\r
535   IN EFI_STATUS  Status\r
536   )\r
537 {\r
538   if (EFI_ERROR (Status)) {\r
539     ProcessLibraryDestructorList (gImageHandle, gST);\r
540   }\r
541   gBS->Exit (gImageHandle, Status, 0, NULL);\r
542 }\r
543 """,\r
544 """\r
545 const UINT32 _gUefiDriverRevision = 0;\r
546 \r
547 ${BEGIN}\r
548 EFI_STATUS\r
549 ${Function} (\r
550   IN EFI_HANDLE        ImageHandle,\r
551   IN EFI_SYSTEM_TABLE  *SystemTable\r
552   );\r
553 ${END}\r
554 \r
555 EFI_STATUS\r
556 EFIAPI\r
557 ProcessModuleEntryPointList (\r
558   IN EFI_HANDLE        ImageHandle,\r
559   IN EFI_SYSTEM_TABLE  *SystemTable\r
560   )\r
561 \r
562 {\r
563   ${BEGIN}\r
564   if (SetJump (&mJumpContext) == 0) {\r
565     ExitDriver (${Function} (ImageHandle, SystemTable));\r
566     ASSERT (FALSE);\r
567   }\r
568   ${END}\r
569   return mDriverEntryPointStatus;\r
570 }\r
571 \r
572 static BASE_LIBRARY_JUMP_BUFFER  mJumpContext;\r
573 static EFI_STATUS  mDriverEntryPointStatus = EFI_LOAD_ERROR;\r
574 \r
575 VOID\r
576 EFIAPI\r
577 ExitDriver (\r
578   IN EFI_STATUS  Status\r
579   )\r
580 {\r
581   if (!EFI_ERROR (Status) || EFI_ERROR (mDriverEntryPointStatus)) {\r
582     mDriverEntryPointStatus = Status;\r
583   }\r
584   LongJump (&mJumpContext, (UINTN)-1);\r
585   ASSERT (FALSE);\r
586 }\r
587 """\r
588 ]\r
589 \r
590 ## UEFI Unload Image Templates\r
591 gUefiUnloadImageString = [\r
592 """\r
593 GLOBAL_REMOVE_IF_UNREFERENCED const UINT8 _gDriverUnloadImageCount = ${Count};\r
594 \r
595 EFI_STATUS\r
596 EFIAPI\r
597 ProcessModuleUnloadList (\r
598   IN EFI_HANDLE        ImageHandle\r
599   )\r
600 {\r
601   return EFI_SUCCESS;\r
602 }\r
603 """,\r
604 """\r
605 GLOBAL_REMOVE_IF_UNREFERENCED const UINT8 _gDriverUnloadImageCount = ${Count};\r
606 \r
607 ${BEGIN}\r
608 EFI_STATUS\r
609 ${Function} (\r
610   IN EFI_HANDLE        ImageHandle\r
611   );\r
612 \r
613 EFI_STATUS\r
614 EFIAPI\r
615 ProcessModuleUnloadList (\r
616   IN EFI_HANDLE        ImageHandle\r
617   )\r
618 {\r
619   return ${Function} (ImageHandle);\r
620 }\r
621 ${END}\r
622 """,\r
623 """\r
624 GLOBAL_REMOVE_IF_UNREFERENCED const UINT8 _gDriverUnloadImageCount = ${Count};\r
625 \r
626 ${BEGIN}\r
627 EFI_STATUS\r
628 ${Function} (\r
629   IN EFI_HANDLE        ImageHandle\r
630   );\r
631 ${END}\r
632 \r
633 EFI_STATUS\r
634 EFIAPI\r
635 ProcessModuleUnloadList (\r
636   IN EFI_HANDLE        ImageHandle\r
637   )\r
638 {\r
639   EFI_STATUS  Status;\r
640 \r
641   Status = EFI_SUCCESS;\r
642 ${BEGIN}\r
643   if (EFI_ERROR (Status)) {\r
644     ${Function} (ImageHandle);\r
645   } else {\r
646     Status = ${Function} (ImageHandle);\r
647   }\r
648 ${END}\r
649   return Status;\r
650 }\r
651 """\r
652 ]\r
653 \r
654 gLibraryStructorPrototype = {\r
655 'BASE'  : """${BEGIN}\r
656 EFI_STATUS\r
657 EFIAPI\r
658 ${Function} (\r
659   VOID\r
660   );${END}\r
661 """,\r
662 \r
663 'PEI'   : """${BEGIN}\r
664 EFI_STATUS\r
665 EFIAPI\r
666 ${Function} (\r
667   IN EFI_PEI_FILE_HANDLE       FileHandle,\r
668   IN EFI_PEI_SERVICES          **PeiServices\r
669   );${END}\r
670 """,\r
671 \r
672 'DXE'   : """${BEGIN}\r
673 EFI_STATUS\r
674 EFIAPI\r
675 ${Function} (\r
676   IN EFI_HANDLE        ImageHandle,\r
677   IN EFI_SYSTEM_TABLE  *SystemTable\r
678   );${END}\r
679 """,\r
680 }\r
681 \r
682 gLibraryStructorCall = {\r
683 'BASE'  : """${BEGIN}\r
684   Status = ${Function} ();\r
685   ASSERT_EFI_ERROR (Status);${END}\r
686 """,\r
687 \r
688 'PEI'   : """${BEGIN}\r
689   Status = ${Function} (FileHandle, PeiServices);\r
690   ASSERT_EFI_ERROR (Status);${END}\r
691 """,\r
692 \r
693 'DXE'   : """${BEGIN}\r
694   Status = ${Function} (ImageHandle, SystemTable);\r
695   ASSERT_EFI_ERROR (Status);${END}\r
696 """,\r
697 }\r
698 \r
699 ## Library Constructor and Destructor Templates\r
700 gLibraryString = {\r
701 'BASE'  :   """\r
702 ${BEGIN}${FunctionPrototype}${END}\r
703 \r
704 VOID\r
705 EFIAPI\r
706 ProcessLibrary${Type}List (\r
707   VOID\r
708   )\r
709 {\r
710 ${BEGIN}  EFI_STATUS  Status;\r
711 ${FunctionCall}${END}\r
712 }\r
713 """,\r
714 \r
715 'PEI'   :   """\r
716 ${BEGIN}${FunctionPrototype}${END}\r
717 \r
718 VOID\r
719 EFIAPI\r
720 ProcessLibrary${Type}List (\r
721   IN EFI_PEI_FILE_HANDLE       FileHandle,\r
722   IN EFI_PEI_SERVICES          **PeiServices\r
723   )\r
724 {\r
725 ${BEGIN}  EFI_STATUS  Status;\r
726 ${FunctionCall}${END}\r
727 }\r
728 """,\r
729 \r
730 'DXE'   :   """\r
731 ${BEGIN}${FunctionPrototype}${END}\r
732 \r
733 VOID\r
734 EFIAPI\r
735 ProcessLibrary${Type}List (\r
736   IN EFI_HANDLE        ImageHandle,\r
737   IN EFI_SYSTEM_TABLE  *SystemTable\r
738   )\r
739 {\r
740 ${BEGIN}  EFI_STATUS  Status;\r
741 ${FunctionCall}${END}\r
742 }\r
743 """,\r
744 }\r
745 \r
746 gSpecificationString = """\r
747 ${BEGIN}\r
748 #undef ${SpecificationName}\r
749 #define ${SpecificationName} ${SpecificationValue}\r
750 ${END}\r
751 """\r
752 \r
753 gBasicHeaderFile = "Base.h"\r
754 \r
755 gModuleTypeHeaderFile = {\r
756     "BASE"              :   [gBasicHeaderFile],\r
757     "SEC"               :   ["PiPei.h", "Library/DebugLib.h"],\r
758     "PEI_CORE"          :   ["PiPei.h", "Library/DebugLib.h"],\r
759     "PEIM"              :   ["PiPei.h", "Library/DebugLib.h"],\r
760     "DXE_CORE"          :   ["PiDxe.h", "Library/DebugLib.h"],\r
761     "DXE_DRIVER"        :   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h"],\r
762     "DXE_SMM_DRIVER"    :   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h"],\r
763     "DXE_RUNTIME_DRIVER":   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h"],\r
764     "DXE_SAL_DRIVER"    :   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h"],\r
765     "UEFI_DRIVER"       :   ["Uefi.h",  "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h"],\r
766     "UEFI_APPLICATION"  :   ["Uefi.h",  "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h"],\r
767     "USER_DEFINED"      :   [gBasicHeaderFile]\r
768 }\r
769 \r
770 ## Find value for the given GUID C name\r
771 #\r
772 #   @param      Packages    The list of package object\r
773 #   @param      CName       The C name of the GUID\r
774 #   @retval     string      The value string of given GUID\r
775 #\r
776 def GetGuidValue(Packages, CName):\r
777     for P in Packages:\r
778         if CName in P.Guids:\r
779             return P.Guids[CName]\r
780         if CName in P.Protocols:\r
781             return P.Protocols[CName]\r
782         if CName in P.Ppis:\r
783             return P.Ppis[CName]\r
784     else:\r
785         PackageListString = "\t" + "\n\t".join([str(P) for P in Packages])\r
786         EdkLogger.error("AutoGen", AUTOGEN_ERROR,\r
787                         "Cannot find GUID value for %s in all given packages" % CName,\r
788                         ExtraData=PackageListString)\r
789 \r
790 ## Create code for module PCDs\r
791 #\r
792 #   @param      Info        The ModuleBuildInfo object\r
793 #   @param      AutoGenC    The TemplateString object for C code\r
794 #   @param      AutoGenH    The TemplateString object for header file\r
795 #   @param      Pcd         The PCD object\r
796 #\r
797 def CreateModulePcdCode(Info, AutoGenC, AutoGenH, Pcd):\r
798     TokenSpaceGuidValue = GetGuidValue(Info.PlatformInfo.PackageList, Pcd.TokenSpaceGuidCName)\r
799     PcdTokenNumber = Info.PlatformInfo.PcdTokenNumber\r
800     #\r
801     # Write PCDs\r
802     #\r
803     PcdTokenName = '_PCD_TOKEN_' + Pcd.TokenCName\r
804     if Pcd.Type in gDynamicExPcd:\r
805         TokenNumber = int(Pcd.TokenValue, 0)\r
806     else:\r
807         if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in PcdTokenNumber:\r
808             EdkLogger.error("AutoGen", AUTOGEN_ERROR, "No generated token number for %s|%s\n" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
809         TokenNumber = PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName]\r
810     AutoGenH.Append('#define %s  %d\n' % (PcdTokenName, TokenNumber))\r
811 \r
812     EdkLogger.debug(EdkLogger.DEBUG_3, "Creating code for " + Pcd.TokenCName + "|" + Pcd.TokenSpaceGuidCName)\r
813     if Pcd.Type not in gItemTypeStringDatabase:\r
814         EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Unknown PCD type [%s] of PCD %s|%s" % (Pcd.Type, Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
815     if Pcd.DatumType not in gDatumSizeStringDatabase:\r
816         EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Unknown datum type [%s] of PCD %s|%s" % (Pcd.DatumType, Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
817 \r
818     DatumSize = gDatumSizeStringDatabase[Pcd.DatumType]\r
819     DatumSizeLib = gDatumSizeStringDatabaseLib[Pcd.DatumType]\r
820     GetModeName = '_PCD_GET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + Pcd.TokenCName\r
821     SetModeName = '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + Pcd.TokenCName\r
822 \r
823     if Pcd.Type in gDynamicExPcd:\r
824         AutoGenH.Append('#define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))\r
825         if Pcd.DatumType == 'VOID*':\r
826             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))\r
827         else:\r
828             AutoGenH.Append('#define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))\r
829     elif Pcd.Type in gDynamicPcd:\r
830         AutoGenH.Append('#define %s  LibPcdGet%s(%s)\n' % (GetModeName, DatumSizeLib, PcdTokenName))\r
831         if Pcd.DatumType == 'VOID*':\r
832             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSet%s(%s, (SizeOfBuffer), (Buffer))\n' %(SetModeName, DatumSizeLib, PcdTokenName))\r
833         else:\r
834             AutoGenH.Append('#define %s(Value)  LibPcdSet%s(%s, (Value))\n' % (SetModeName, DatumSizeLib, PcdTokenName))\r
835     else:\r
836         PcdVariableName = '_gPcd_' + gItemTypeStringDatabase[Pcd.Type] + '_' + Pcd.TokenCName\r
837         Const = 'const'\r
838         if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:\r
839             Const = ''\r
840         Type = ''\r
841         Array = ''\r
842         Value = Pcd.DefaultValue\r
843         if Pcd.DatumType == 'UINT64':\r
844             if not Value.endswith('ULL'):\r
845                 Value += 'ULL'\r
846         if Pcd.DatumType == 'VOID*':\r
847             if Pcd.MaxDatumSize == None or Pcd.MaxDatumSize == '':\r
848                 EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Unknown [MaxDatumSize] of PCD [%s.%s]" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName))\r
849 \r
850             ArraySize = int(Pcd.MaxDatumSize, 0)\r
851             if Value[0] == '{':\r
852                 Type = '(VOID *)'\r
853             else:\r
854                 Unicode = False\r
855                 if Value[0] == 'L':\r
856                     Unicode = True\r
857                 Value = Value.lstrip('L').strip('"')\r
858                 NewValue = '{'\r
859                 for Index in range(0,len(Value)):\r
860                     NewValue = NewValue + str(ord(Value[Index]) % 0x100) + ', '\r
861                     if Unicode:\r
862                         NewValue = NewValue + str(ord(Value[Index]) / 0x100) + ', '\r
863                 if Unicode:\r
864                     if ArraySize < (len(Value)*2 + 2):\r
865                         ArraySize = len(Value)*2 + 2\r
866                     NewValue = NewValue + '0, '\r
867                 else:\r
868                     if ArraySize < (len(Value) + 1):\r
869                         ArraySize = len(Value) + 1\r
870                 Value = NewValue + '0 }'\r
871             Array = '[%d]' % ArraySize\r
872 \r
873         PcdValueName = '_PCD_VALUE_' + Pcd.TokenCName\r
874         if Pcd.DatumType == 'VOID*' and Value[0] == '{':\r
875             AutoGenH.Append('#define _PCD_PATCHABLE_%s_SIZE %s\n' % (Pcd.TokenCName, Pcd.MaxDatumSize))\r
876             AutoGenH.Append('#define %s  %s%s\n' %(PcdValueName, Type, PcdVariableName))\r
877             AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s UINT8 %s%s = %s;\n' % (Const, PcdVariableName, Array, Value))\r
878             AutoGenH.Append('extern %s UINT8 %s%s;\n' %(Const, PcdVariableName, Array))\r
879             AutoGenH.Append('#define %s  %s%s\n' %(GetModeName, Type, PcdVariableName))\r
880         else:\r
881             AutoGenH.Append('#define %s  %s\n' %(PcdValueName, Value))\r
882             AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s %s = %s;\n' %(Const, Pcd.DatumType, PcdVariableName, PcdValueName))\r
883             AutoGenH.Append('extern %s  %s  %s%s;\n' % (Const, Pcd.DatumType, PcdVariableName, Array))\r
884             AutoGenH.Append('#define %s  %s%s\n' % (GetModeName, Type, PcdVariableName))\r
885 \r
886         if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:\r
887             if Pcd.DatumType == 'VOID*':\r
888                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPatchPcdSetPtr(_gPcd_BinaryPatch_%s, (UINTN)_PCD_PATCHABLE_%s_SIZE, (SizeOfBuffer), (Buffer))\n' % (SetModeName, Pcd.TokenCName, Pcd.TokenCName))\r
889             else:\r
890                 AutoGenH.Append('#define %s(Value)  (%s = (Value))\n' % (SetModeName, PcdVariableName))\r
891         else:\r
892             AutoGenH.Append('//#define %s  ASSERT(FALSE)  // It is not allowed to set value for a FIXED_AT_BUILD PCD\n' % SetModeName)\r
893 \r
894 ## Create code for library module PCDs\r
895 #\r
896 #   @param      Info        The ModuleBuildInfo object\r
897 #   @param      AutoGenC    The TemplateString object for C code\r
898 #   @param      AutoGenH    The TemplateString object for header file\r
899 #   @param      Pcd         The PCD object\r
900 #\r
901 def CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd):\r
902     PcdTokenNumber = Info.PlatformInfo.PcdTokenNumber\r
903     TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName\r
904     TokenCName  = Pcd.TokenCName\r
905     TokenSpaceGuidValue = GetGuidValue(Info.PlatformInfo.PackageList, TokenSpaceGuidCName)\r
906     if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in PcdTokenNumber:\r
907         EdkLogger.error("AutoGen", AUTOGEN_ERROR, "No generated token number for %s|%s\n" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
908     TokenNumber = PcdTokenNumber[TokenCName, TokenSpaceGuidCName]\r
909 \r
910     if Pcd.Type not in gItemTypeStringDatabase:\r
911         EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Unknown PCD type [%s] of PCD %s|%s" % (Pcd.Type, Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
912     if Pcd.DatumType not in gDatumSizeStringDatabase:\r
913         EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Unknown datum type [%s] of PCD %s|%s" % (Pcd.DatumType, Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
914 \r
915     DatumType   = Pcd.DatumType\r
916     DatumSize   = gDatumSizeStringDatabaseH[DatumType]\r
917     DatumSizeLib= gDatumSizeStringDatabaseLib[DatumType]\r
918     GetModeName = '_PCD_GET_MODE_' + DatumSize + '_' + TokenCName\r
919     SetModeName = '_PCD_SET_MODE_' + DatumSize + '_' + TokenCName\r
920 \r
921     Type = ''\r
922     Array = ''\r
923     if Pcd.DatumType == 'VOID*':\r
924         Type = '(VOID *)'\r
925         Array = '[]'\r
926 \r
927     AutoGenH.Append('#define _PCD_TOKEN_%s  %d\n' % (TokenCName, TokenNumber))\r
928 \r
929     PcdItemType = Pcd.Type\r
930     #if PcdItemType in gDynamicPcd:\r
931     #    PcdItemType = TAB_PCDS_FIXED_AT_BUILD\r
932     #    if (TokenCName, TokenSpaceGuidCName) in Info.PlatformInfo.Platform.Pcds:\r
933     #        PcdItemType  = Info.PlatformInfo.Platform.Pcds[TokenCName, TokenSpaceGuidCName].Type\r
934     if PcdItemType in gDynamicExPcd:\r
935         PcdTokenName = '_PCD_TOKEN_' + TokenCName\r
936         AutoGenH.Append('#define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, TokenSpaceGuidCName, PcdTokenName))\r
937         if DatumType == 'VOID*':\r
938             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName,DatumSizeLib, TokenSpaceGuidCName, PcdTokenName))\r
939         else:\r
940             AutoGenH.Append('#define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, TokenSpaceGuidCName, PcdTokenName))\r
941     if PcdItemType in gDynamicPcd:\r
942         PcdTokenName = '_PCD_TOKEN_' + TokenCName\r
943         AutoGenH.Append('#define %s  LibPcdGet%s(%s)\n' % (GetModeName, DatumSizeLib, PcdTokenName))\r
944         if DatumType == 'VOID*':\r
945             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSet%s(%s, (SizeOfBuffer), (Buffer))\n' %(SetModeName, DatumSizeLib, PcdTokenName))\r
946         else:\r
947             AutoGenH.Append('#define %s(Value)  LibPcdSet%s(%s, (Value))\n' % (SetModeName, DatumSizeLib, PcdTokenName))\r
948     if PcdItemType == TAB_PCDS_PATCHABLE_IN_MODULE:\r
949         PcdVariableName = '_gPcd_' + gItemTypeStringDatabase[TAB_PCDS_PATCHABLE_IN_MODULE] + '_' + TokenCName\r
950         AutoGenH.Append('extern %s _gPcd_BinaryPatch_%s%s;\n' %(DatumType, TokenCName, Array) )\r
951         AutoGenH.Append('#define %s  %s_gPcd_BinaryPatch_%s\n' %(GetModeName, Type, TokenCName))\r
952         AutoGenH.Append('#define %s(Value)  (%s = (Value))\n' % (SetModeName, PcdVariableName))\r
953     if PcdItemType == TAB_PCDS_FIXED_AT_BUILD or PcdItemType == TAB_PCDS_FEATURE_FLAG:\r
954         AutoGenH.Append('extern const %s _gPcd_FixedAtBuild_%s%s;\n' %(DatumType, TokenCName, Array))\r
955         AutoGenH.Append('#define %s  %s_gPcd_FixedAtBuild_%s\n' %(GetModeName, Type, TokenCName))\r
956         AutoGenH.Append('//#define %s  ASSERT(FALSE)  // It is not allowed to set value for a FIXED_AT_BUILD PCD\n' % SetModeName)\r
957 \r
958 ## Create code for PCD database in DXE or PEI phase\r
959 #\r
960 #   @param      Platform    The platform object\r
961 #   @retval     tuple       Two TemplateString objects for C code and header file,\r
962 #                           respectively\r
963 #\r
964 def CreatePcdDatabasePhaseSpecificAutoGen (Platform, Phase):\r
965     AutoGenC = TemplateString()\r
966     AutoGenH = TemplateString()\r
967 \r
968     Dict = {\r
969         'PHASE'                         : Phase,\r
970         'GUID_TABLE_SIZE'               : '1',\r
971         'STRING_TABLE_SIZE'             : '1',\r
972         'SKUID_TABLE_SIZE'              : '1',\r
973         'LOCAL_TOKEN_NUMBER_TABLE_SIZE' : '1',\r
974         'LOCAL_TOKEN_NUMBER'            : '0',\r
975         'EXMAPPING_TABLE_SIZE'          : '1',\r
976         'EX_TOKEN_NUMBER'               : '0',\r
977         'SIZE_TABLE_SIZE'               : '2',\r
978         'GUID_TABLE_EMPTY'              : 'TRUE',\r
979         'STRING_TABLE_EMPTY'            : 'TRUE',\r
980         'SKUID_TABLE_EMPTY'             : 'TRUE',\r
981         'DATABASE_EMPTY'                : 'TRUE',\r
982         'EXMAP_TABLE_EMPTY'             : 'TRUE',\r
983         'PCD_DATABASE_UNINIT_EMPTY'     : '  UINT8  dummy; /* PCD_DATABASE_UNINIT is emptry */',\r
984         'SYSTEM_SKU_ID'                 : '  SKU_ID             SystemSkuId;',\r
985         'SYSTEM_SKU_ID_VALUE'           : '0'\r
986     }\r
987 \r
988     for DatumType in ['UINT64','UINT32','UINT16','UINT8','BOOLEAN']:\r
989         Dict['VARDEF_CNAME_' + DatumType] = []\r
990         Dict['VARDEF_GUID_' + DatumType]  = []\r
991         Dict['VARDEF_SKUID_' + DatumType] = []\r
992         Dict['VARDEF_VALUE_' + DatumType] = []\r
993         for Init in ['INIT','UNINIT']:\r
994             Dict[Init+'_CNAME_DECL_' + DatumType]   = []\r
995             Dict[Init+'_GUID_DECL_' + DatumType]    = []\r
996             Dict[Init+'_NUMSKUS_DECL_' + DatumType] = []\r
997             Dict[Init+'_VALUE_' + DatumType]        = []\r
998 \r
999     for Type in ['STRING_HEAD','VPD_HEAD','VARIABLE_HEAD']:\r
1000         Dict[Type + '_CNAME_DECL']   = []\r
1001         Dict[Type + '_GUID_DECL']    = []\r
1002         Dict[Type + '_NUMSKUS_DECL'] = []\r
1003         Dict[Type + '_VALUE'] = []\r
1004 \r
1005     Dict['STRING_TABLE_INDEX'] = []\r
1006     Dict['STRING_TABLE_LENGTH']  = []\r
1007     Dict['STRING_TABLE_CNAME'] = []\r
1008     Dict['STRING_TABLE_GUID']  = []\r
1009     Dict['STRING_TABLE_VALUE'] = []\r
1010 \r
1011     Dict['SIZE_TABLE_CNAME'] = []\r
1012     Dict['SIZE_TABLE_GUID']  = []\r
1013     Dict['SIZE_TABLE_CURRENT_LENGTH']  = []\r
1014     Dict['SIZE_TABLE_MAXIMUM_LENGTH']  = []\r
1015 \r
1016     Dict['EXMAPPING_TABLE_EXTOKEN'] = []\r
1017     Dict['EXMAPPING_TABLE_LOCAL_TOKEN'] = []\r
1018     Dict['EXMAPPING_TABLE_GUID_INDEX'] = []\r
1019 \r
1020     Dict['GUID_STRUCTURE'] = []\r
1021 \r
1022     Dict['SKUID_VALUE'] = []\r
1023 \r
1024     if Phase == 'DXE':\r
1025         Dict['SYSTEM_SKU_ID'] = ''\r
1026         Dict['SYSTEM_SKU_ID_VALUE'] = ''\r
1027 \r
1028     StringTableIndex = 0\r
1029     StringTableSize = 0\r
1030     NumberOfLocalTokens = 0\r
1031     NumberOfPeiLocalTokens = 0\r
1032     NumberOfDxeLocalTokens = 0\r
1033     NumberOfExTokens = 0\r
1034     NumberOfSizeItems = 0\r
1035     GuidList = []\r
1036 \r
1037     for Pcd in Platform.DynamicPcdList:\r
1038         CName = Pcd.TokenCName\r
1039         TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName\r
1040 \r
1041         EdkLogger.debug(EdkLogger.DEBUG_3, "PCD: %s %s (%s : %s)" % (CName, TokenSpaceGuidCName, Pcd.Phase, Phase))\r
1042         if Pcd.DatumType not in gDatumSizeStringDatabase:\r
1043             EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Unknown datum type [%s] of PCD %s|%s" % (Pcd.DatumType, Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
1044 \r
1045         if Pcd.Phase == 'PEI':\r
1046             NumberOfPeiLocalTokens += 1\r
1047         if Pcd.Phase == 'DXE':\r
1048             NumberOfDxeLocalTokens += 1\r
1049         if Pcd.Phase != Phase:\r
1050             continue\r
1051 \r
1052         #\r
1053         # TODO: need GetGuidValue() definition\r
1054         #\r
1055         TokenSpaceGuidStructure = GetGuidValue(Platform.PackageList, TokenSpaceGuidCName)\r
1056         TokenSpaceGuid = GuidStructureStringToGuidValueName(TokenSpaceGuidStructure)\r
1057         if Pcd.Type in gDynamicExPcd:\r
1058             if TokenSpaceGuid not in GuidList:\r
1059                 GuidList += [TokenSpaceGuid]\r
1060                 Dict['GUID_STRUCTURE'].append(TokenSpaceGuidStructure)\r
1061             NumberOfExTokens += 1\r
1062 \r
1063         ValueList = []\r
1064         StringHeadOffsetList = []\r
1065         VpdHeadOffsetList = []\r
1066         VariableHeadValueList = []\r
1067         Pcd.InitString = 'UNINIT'\r
1068 \r
1069         if Pcd.DatumType == 'VOID*':\r
1070             Pcd.TokenTypeList = ['PCD_DATUM_TYPE_POINTER']\r
1071         elif Pcd.DatumType == 'BOOLEAN':\r
1072             Pcd.TokenTypeList = ['PCD_DATUM_TYPE_UINT8']\r
1073         else:\r
1074             Pcd.TokenTypeList = ['PCD_DATUM_TYPE_' + Pcd.DatumType]\r
1075 \r
1076         if len(Pcd.SkuInfoList) > 1:\r
1077             Pcd.TokenTypeList += ['PCD_TYPE_SKU_ENABLED']\r
1078 \r
1079         for SkuName in Pcd.SkuInfoList:\r
1080             Sku = Pcd.SkuInfoList[SkuName]\r
1081             SkuId = Sku.SkuId\r
1082             if SkuId == None or SkuId == '':\r
1083                 continue\r
1084 \r
1085             if SkuId not in Dict['SKUID_VALUE']:\r
1086                 Dict['SKUID_VALUE'].append(SkuId)\r
1087 \r
1088             SkuIdIndex =   Dict['SKUID_VALUE'].index(SkuId)\r
1089             if len(Sku.VariableName) > 0:\r
1090                 Pcd.TokenTypeList += ['PCD_TYPE_HII']\r
1091                 Pcd.InitString = 'INIT'\r
1092                 VariableNameStructure = '{' + ', '.join(Sku.VariableName.split(" ")) + ', 0x0000}'\r
1093                 if VariableNameStructure not in Dict['STRING_TABLE_VALUE']:\r
1094                     Dict['STRING_TABLE_CNAME'].append(CName)\r
1095                     Dict['STRING_TABLE_GUID'].append(TokenSpaceGuid)\r
1096                     if StringTableIndex == 0:\r
1097                         Dict['STRING_TABLE_INDEX'].append('')\r
1098                     else:\r
1099                         Dict['STRING_TABLE_INDEX'].append('_%d' % StringTableIndex)\r
1100 \r
1101                     Dict['STRING_TABLE_LENGTH'].append(len(Sku.VariableName) + 1)\r
1102                     Dict['STRING_TABLE_VALUE'].append(VariableNameStructure)\r
1103                     StringTableIndex += 1\r
1104                     StringTableSize += len(Sku.VariableName) + 1\r
1105 \r
1106                 VariableHeadStringIndex = 0\r
1107                 for Index in range(Dict['STRING_TABLE_VALUE'].index(VariableNameStructure)):\r
1108                     VariableHeadStringIndex += Dict['STRING_TABLE_LENGTH'][Index]\r
1109 \r
1110                 VariableGuidStructure = GetGuidValue(Platform.PackageList, Sku.VariableGuid)\r
1111                 VariableGuid = GuidStructureStringToGuidValueName(VariableGuidStructure)\r
1112                 if VariableGuid not in GuidList:\r
1113                     GuidList += [VariableGuid]\r
1114                     Dict['GUID_STRUCTURE'].append(VariableGuidStructure)\r
1115                 VariableHeadGuidIndex = GuidList.index(VariableGuid)\r
1116 \r
1117                 VariableHeadValueList.append('%d, %d, %s, offsetof(${PHASE}_PCD_DATABASE, Init.%s_%s_VariableDefault_%s)' %\r
1118                                              (VariableHeadGuidIndex, VariableHeadStringIndex, Sku.VariableOffset, CName, TokenSpaceGuid, SkuIdIndex))\r
1119                 Dict['VARDEF_CNAME_'+Pcd.DatumType].append(CName)\r
1120                 Dict['VARDEF_GUID_'+Pcd.DatumType].append(TokenSpaceGuid)\r
1121                 Dict['VARDEF_SKUID_'+Pcd.DatumType].append(SkuIdIndex)\r
1122                 Dict['VARDEF_VALUE_'+Pcd.DatumType].append(Sku.HiiDefaultValue)\r
1123             elif Sku.VpdOffset != '':\r
1124                 Pcd.TokenTypeList += ['PCD_TYPE_VPD']\r
1125                 Pcd.InitString = 'INIT'\r
1126                 VpdHeadOffsetList.append(Sku.VpdOffset)\r
1127             else:\r
1128                 if Pcd.DatumType == 'VOID*':\r
1129                     Pcd.TokenTypeList += ['PCD_TYPE_STRING']\r
1130                     Pcd.InitString = 'INIT'\r
1131                     if Sku.DefaultValue != '':\r
1132                         NumberOfSizeItems += 1\r
1133                         Dict['STRING_TABLE_CNAME'].append(CName)\r
1134                         Dict['STRING_TABLE_GUID'].append(TokenSpaceGuid)\r
1135 \r
1136                         if StringTableIndex == 0:\r
1137                             Dict['STRING_TABLE_INDEX'].append('')\r
1138                         else:\r
1139                             Dict['STRING_TABLE_INDEX'].append('_%d' % StringTableIndex)\r
1140                         if Sku.DefaultValue[0] == 'L':\r
1141                             Size = (len(Sku.DefaultValue) - 3) * 2\r
1142                             Dict['STRING_TABLE_VALUE'].append(Sku.DefaultValue)\r
1143                         elif Sku.DefaultValue[0] == '"':\r
1144                             Size = len(Sku.DefaultValue) - 2\r
1145                             Dict['STRING_TABLE_VALUE'].append(Sku.DefaultValue)\r
1146                         elif Sku.DefaultValue[0] == '{':\r
1147                             Size = len(Sku.DefaultValue.replace(',',' ').split())\r
1148                             Dict['STRING_TABLE_VALUE'].append('{' + Sku.DefaultValue + '}')\r
1149 \r
1150                         StringHeadOffsetList.append(str(StringTableSize))\r
1151                         Dict['SIZE_TABLE_CNAME'].append(CName)\r
1152                         Dict['SIZE_TABLE_GUID'].append(TokenSpaceGuid)\r
1153                         Dict['SIZE_TABLE_CURRENT_LENGTH'].append(Size)\r
1154                         Dict['SIZE_TABLE_MAXIMUM_LENGTH'].append(Pcd.MaxDatumSize)\r
1155                         if Pcd.MaxDatumSize != '':\r
1156                             MaxDatumSize = int(Pcd.MaxDatumSize, 0)\r
1157                             if MaxDatumSize > Size:\r
1158                                 Size = MaxDatumSize\r
1159                         Dict['STRING_TABLE_LENGTH'].append(Size / 2 + 1)\r
1160                         StringTableIndex += 1\r
1161                         StringTableSize += (Size / 2 + 1)\r
1162                 else:\r
1163                     Pcd.TokenTypeList += ['PCD_TYPE_DATA']\r
1164                     if Sku.DefaultValue == 'TRUE':\r
1165                         Pcd.InitString = 'INIT'\r
1166                     else:\r
1167                         try:\r
1168                             if int(Sku.DefaultValue, 0) != 0:\r
1169                                 Pcd.InitString = 'INIT'\r
1170                         except:\r
1171                             pass\r
1172                     ValueList.append(Sku.DefaultValue)\r
1173 \r
1174         Pcd.TokenTypeList = list(set(Pcd.TokenTypeList))\r
1175 \r
1176         if 'PCD_TYPE_HII' in Pcd.TokenTypeList:\r
1177             Dict['VARIABLE_HEAD_CNAME_DECL'].append(CName)\r
1178             Dict['VARIABLE_HEAD_GUID_DECL'].append(TokenSpaceGuid)\r
1179             Dict['VARIABLE_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))\r
1180             Dict['VARIABLE_HEAD_VALUE'].append('{ %s }\n' % ' },\n    { '.join(VariableHeadValueList))\r
1181         if 'PCD_TYPE_VPD' in Pcd.TokenTypeList:\r
1182             Dict['VPD_HEAD_CNAME_DECL'].append(CName)\r
1183             Dict['VPD_HEAD_GUID_DECL'].append(TokenSpaceGuid)\r
1184             Dict['VPD_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))\r
1185             Dict['VPD_HEAD_VALUE'].append('{ %s }' % ' }, { '.join(VpdHeadOffsetList))\r
1186         if 'PCD_TYPE_STRING' in Pcd.TokenTypeList:\r
1187             Dict['STRING_HEAD_CNAME_DECL'].append(CName)\r
1188             Dict['STRING_HEAD_GUID_DECL'].append(TokenSpaceGuid)\r
1189             Dict['STRING_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))\r
1190             Dict['STRING_HEAD_VALUE'].append(', '.join(StringHeadOffsetList))\r
1191         if 'PCD_TYPE_DATA' in Pcd.TokenTypeList:\r
1192             Dict[Pcd.InitString+'_CNAME_DECL_'+Pcd.DatumType].append(CName)\r
1193             Dict[Pcd.InitString+'_GUID_DECL_'+Pcd.DatumType].append(TokenSpaceGuid)\r
1194             Dict[Pcd.InitString+'_NUMSKUS_DECL_'+Pcd.DatumType].append(len(Pcd.SkuInfoList))\r
1195             if Pcd.InitString == 'UNINIT':\r
1196                 Dict['PCD_DATABASE_UNINIT_EMPTY'] = ''\r
1197             else:\r
1198                 Dict[Pcd.InitString+'_VALUE_'+Pcd.DatumType].append(', '.join(ValueList))\r
1199 \r
1200     if Phase == 'PEI':\r
1201         NumberOfLocalTokens = NumberOfPeiLocalTokens\r
1202     if Phase == 'DXE':\r
1203         NumberOfLocalTokens = NumberOfDxeLocalTokens\r
1204 \r
1205     Dict['TOKEN_INIT']       = ['' for x in range(NumberOfLocalTokens)]\r
1206     Dict['TOKEN_CNAME']      = ['' for x in range(NumberOfLocalTokens)]\r
1207     Dict['TOKEN_GUID']       = ['' for x in range(NumberOfLocalTokens)]\r
1208     Dict['TOKEN_TYPE']       = ['' for x in range(NumberOfLocalTokens)]\r
1209 \r
1210     for Pcd in Platform.DynamicPcdList:\r
1211         CName = Pcd.TokenCName\r
1212         TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName\r
1213         if Pcd.Phase != Phase:\r
1214             continue\r
1215 \r
1216         TokenSpaceGuid = GuidStructureStringToGuidValueName(GetGuidValue(Platform.PackageList, TokenSpaceGuidCName))\r
1217         GeneratedTokenNumber = Platform.PcdTokenNumber[CName, TokenSpaceGuidCName] - 1\r
1218         if Phase == 'DXE':\r
1219             GeneratedTokenNumber -= NumberOfPeiLocalTokens\r
1220 \r
1221         EdkLogger.debug(EdkLogger.DEBUG_1, "PCD = %s | %s" % (CName, TokenSpaceGuidCName))\r
1222         EdkLogger.debug(EdkLogger.DEBUG_1, "phase = %s" % Phase)\r
1223         EdkLogger.debug(EdkLogger.DEBUG_1, "GeneratedTokenNumber = %s" % str(GeneratedTokenNumber))\r
1224 \r
1225         Dict['TOKEN_INIT'][GeneratedTokenNumber] = 'Init'\r
1226         if Pcd.InitString == 'UNINIT':\r
1227             Dict['TOKEN_INIT'][GeneratedTokenNumber] = 'Uninit'\r
1228         Dict['TOKEN_CNAME'][GeneratedTokenNumber] = CName\r
1229         Dict['TOKEN_GUID'][GeneratedTokenNumber] = TokenSpaceGuid\r
1230         Dict['TOKEN_TYPE'][GeneratedTokenNumber] = ' | '.join(Pcd.TokenTypeList)\r
1231         if Pcd.Type in gDynamicExPcd:\r
1232             Dict['EXMAPPING_TABLE_EXTOKEN'].append(Pcd.TokenValue)\r
1233             if Phase == 'DXE':\r
1234                 GeneratedTokenNumber += NumberOfPeiLocalTokens\r
1235             Dict['EXMAPPING_TABLE_LOCAL_TOKEN'].append(GeneratedTokenNumber)\r
1236             Dict['EXMAPPING_TABLE_GUID_INDEX'].append(GuidList.index(TokenSpaceGuid))\r
1237 \r
1238     if GuidList != []:\r
1239         Dict['GUID_TABLE_EMPTY'] = 'FALSE'\r
1240         Dict['GUID_TABLE_SIZE'] = len(GuidList)\r
1241     else:\r
1242         Dict['GUID_STRUCTURE'] = [GuidStringToGuidStructureString('00000000-0000-0000-0000-000000000000')]\r
1243 \r
1244     if StringTableIndex == 0:\r
1245         Dict['STRING_TABLE_INDEX'].append('')\r
1246         Dict['STRING_TABLE_LENGTH'].append(1)\r
1247         Dict['STRING_TABLE_CNAME'].append('')\r
1248         Dict['STRING_TABLE_GUID'].append('')\r
1249         Dict['STRING_TABLE_VALUE'].append('{ 0 }')\r
1250     else:\r
1251         Dict['STRING_TABLE_EMPTY'] = 'FALSE'\r
1252         Dict['STRING_TABLE_SIZE'] = StringTableSize\r
1253 \r
1254     if Dict['SIZE_TABLE_CNAME'] == []:\r
1255         Dict['SIZE_TABLE_CNAME'].append('')\r
1256         Dict['SIZE_TABLE_GUID'].append('')\r
1257         Dict['SIZE_TABLE_CURRENT_LENGTH'].append(0)\r
1258         Dict['SIZE_TABLE_MAXIMUM_LENGTH'].append(0)\r
1259 \r
1260     if NumberOfLocalTokens != 0:\r
1261         Dict['DATABASE_EMPTY']                = 'FALSE'\r
1262         Dict['LOCAL_TOKEN_NUMBER_TABLE_SIZE'] = NumberOfLocalTokens\r
1263         Dict['LOCAL_TOKEN_NUMBER']            = NumberOfLocalTokens\r
1264 \r
1265     if NumberOfExTokens != 0:\r
1266         Dict['EXMAP_TABLE_EMPTY']    = 'FALSE'\r
1267         Dict['EXMAPPING_TABLE_SIZE'] = NumberOfExTokens\r
1268         Dict['EX_TOKEN_NUMBER']      = NumberOfExTokens\r
1269     else:\r
1270         Dict['EXMAPPING_TABLE_EXTOKEN'].append(0)\r
1271         Dict['EXMAPPING_TABLE_LOCAL_TOKEN'].append(0)\r
1272         Dict['EXMAPPING_TABLE_GUID_INDEX'].append(0)\r
1273 \r
1274     if NumberOfSizeItems != 0:\r
1275         Dict['SIZE_TABLE_SIZE'] = NumberOfSizeItems * 2\r
1276 \r
1277     AutoGenH.Append(gPcdDatabaseAutoGenH, Dict)\r
1278     if NumberOfLocalTokens == 0:\r
1279         AutoGenC.Append(gEmptyPcdDatabaseAutoGenC, Dict)\r
1280     else:\r
1281         AutoGenC.Append(gPcdDatabaseAutoGenC, Dict)\r
1282 \r
1283     return AutoGenH, AutoGenC\r
1284 \r
1285 ## Create code for PCD database\r
1286 #\r
1287 #   @param      Info        The ModuleBuildInfo object\r
1288 #   @param      AutoGenC    The TemplateString object for C code\r
1289 #   @param      AutoGenH    The TemplateString object for header file\r
1290 #\r
1291 def CreatePcdDatabaseCode (Info, AutoGenC, AutoGenH):\r
1292     if Info.PcdIsDriver == "":\r
1293         return\r
1294     if Info.PcdIsDriver not in gPcdPhaseMap:\r
1295         EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Not supported PcdIsDriver type:%s\n" % Info.PcdIsDriver)\r
1296 \r
1297     AutoGenH.Append(gPcdDatabaseCommonAutoGenH)\r
1298     AdditionalAutoGenH, AdditionalAutoGenC = CreatePcdDatabasePhaseSpecificAutoGen (Info.PlatformInfo, 'PEI')\r
1299     AutoGenH.Append(AdditionalAutoGenH.String)\r
1300 \r
1301     Phase = gPcdPhaseMap[Info.PcdIsDriver]\r
1302     if Phase == 'PEI':\r
1303         AutoGenC.Append(AdditionalAutoGenC.String)\r
1304 \r
1305     if Phase == 'DXE':\r
1306         AdditionalAutoGenH, AdditionalAutoGenC = CreatePcdDatabasePhaseSpecificAutoGen (Info.PlatformInfo, Phase)\r
1307         AutoGenH.Append(AdditionalAutoGenH.String)\r
1308         AutoGenC.Append(AdditionalAutoGenC.String)\r
1309         AutoGenH.Append(gPcdDatabaseEpilogueAutoGenH)\r
1310 \r
1311 ## Create code for library constructor\r
1312 #\r
1313 #   @param      Info        The ModuleBuildInfo object\r
1314 #   @param      AutoGenC    The TemplateString object for C code\r
1315 #   @param      AutoGenH    The TemplateString object for header file\r
1316 #\r
1317 def CreateLibraryConstructorCode(Info, AutoGenC, AutoGenH):\r
1318     if Info.IsLibrary:\r
1319         return\r
1320     #\r
1321     # Library Constructors\r
1322     #\r
1323     ConstructorPrototypeString = TemplateString()\r
1324     ConstructorCallingString = TemplateString()\r
1325     for Lib in Info.DependentLibraryList:\r
1326         if len(Lib.ConstructorList) <= 0:\r
1327             continue\r
1328         Dict = {'Function':Lib.ConstructorList}\r
1329         if Lib.ModuleType == 'BASE':\r
1330             ConstructorPrototypeString.Append(gLibraryStructorPrototype['BASE'], Dict)\r
1331             ConstructorCallingString.Append(gLibraryStructorCall['BASE'], Dict)\r
1332         elif Lib.ModuleType in ['PEI_CORE','PEIM']:\r
1333             ConstructorPrototypeString.Append(gLibraryStructorPrototype['PEI'], Dict)\r
1334             ConstructorCallingString.Append(gLibraryStructorCall['PEI'], Dict)\r
1335         elif Lib.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER','DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION']:\r
1336             ConstructorPrototypeString.Append(gLibraryStructorPrototype['DXE'], Dict)\r
1337             ConstructorCallingString.Append(gLibraryStructorCall['DXE'], Dict)\r
1338 \r
1339     if str(ConstructorPrototypeString) == '':\r
1340         ConstructorPrototypeList = []\r
1341     else:\r
1342         ConstructorPrototypeList = [str(ConstructorPrototypeString)]\r
1343     if str(ConstructorCallingString) == '':\r
1344         ConstructorCallingList = []\r
1345     else:\r
1346         ConstructorCallingList = [str(ConstructorCallingString)]\r
1347 \r
1348     Dict = {\r
1349         'Type'              :   'Constructor',\r
1350         'FunctionPrototype' :   ConstructorPrototypeList,\r
1351         'FunctionCall'      :   ConstructorCallingList\r
1352     }\r
1353     if Info.ModuleType == 'BASE':\r
1354         AutoGenC.Append(gLibraryString['BASE'], Dict)\r
1355     elif Info.ModuleType in ['PEI_CORE','PEIM']:\r
1356         AutoGenC.Append(gLibraryString['PEI'], Dict)\r
1357     elif Info.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER','DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION']:\r
1358         AutoGenC.Append(gLibraryString['DXE'], Dict)\r
1359 \r
1360 ## Create code for library destructor\r
1361 #\r
1362 #   @param      Info        The ModuleBuildInfo object\r
1363 #   @param      AutoGenC    The TemplateString object for C code\r
1364 #   @param      AutoGenH    The TemplateString object for header file\r
1365 #\r
1366 def CreateLibraryDestructorCode(Info, AutoGenC, AutoGenH):\r
1367     if Info.IsLibrary:\r
1368         return\r
1369     #\r
1370     # Library Destructors\r
1371     #\r
1372     DestructorPrototypeString = TemplateString()\r
1373     DestructorCallingString = TemplateString()\r
1374     for Index in range(len(Info.DependentLibraryList)-1, -1, -1):\r
1375         Lib = Info.DependentLibraryList[Index]\r
1376         if len(Lib.DestructorList) <= 0:\r
1377             continue\r
1378         Dict = {'Function':Lib.DestructorList}\r
1379         if Lib.ModuleType == 'BASE':\r
1380             DestructorPrototypeString.Append(gLibraryStructorPrototype['BASE'], Dict)\r
1381             DestructorCallingString.Append(gLibraryStructorCall['BASE'], Dict)\r
1382         elif Lib.ModuleType in ['PEI_CORE','PEIM']:\r
1383             DestructorPrototypeString.Append(gLibraryStructorPrototype['PEI'], Dict)\r
1384             DestructorCallingString.Append(gLibraryStructorCall['PEI'], Dict)\r
1385         elif Lib.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER','DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION']:\r
1386             DestructorPrototypeString.Append(gLibraryStructorPrototype['DXE'], Dict)\r
1387             DestructorCallingString.Append(gLibraryStructorCall['DXE'], Dict)\r
1388 \r
1389     if str(DestructorPrototypeString) == '':\r
1390         DestructorPrototypeList = []\r
1391     else:\r
1392         DestructorPrototypeList = [str(DestructorPrototypeString)]\r
1393     if str(DestructorCallingString) == '':\r
1394         DestructorCallingList = []\r
1395     else:\r
1396         DestructorCallingList = [str(DestructorCallingString)]\r
1397 \r
1398     Dict = {\r
1399         'Type'              :   'Destructor',\r
1400         'FunctionPrototype' :   DestructorPrototypeList,\r
1401         'FunctionCall'      :   DestructorCallingList\r
1402     }\r
1403     if Info.ModuleType == 'BASE':\r
1404         AutoGenC.Append(gLibraryString['BASE'], Dict)\r
1405     elif Info.ModuleType in ['PEI_CORE','PEIM']:\r
1406         AutoGenC.Append(gLibraryString['PEI'], Dict)\r
1407     elif Info.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER','DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION']:\r
1408         AutoGenC.Append(gLibraryString['DXE'], Dict)\r
1409 \r
1410 \r
1411 ## Create code for ModuleEntryPoint\r
1412 #\r
1413 #   @param      Info        The ModuleBuildInfo object\r
1414 #   @param      AutoGenC    The TemplateString object for C code\r
1415 #   @param      AutoGenH    The TemplateString object for header file\r
1416 #\r
1417 def CreateModuleEntryPointCode(Info, AutoGenC, AutoGenH):\r
1418     if Info.IsLibrary or Info.ModuleType == "USER_DEFINED":\r
1419         return\r
1420     #\r
1421     # Module Entry Points\r
1422     #\r
1423     NumEntryPoints = len(Info.Module.ModuleEntryPointList)\r
1424     Dict = {'Function':Info.Module.ModuleEntryPointList}\r
1425 \r
1426     if Info.ModuleType in ['PEI_CORE', 'DXE_CORE']:\r
1427         if NumEntryPoints != 1:\r
1428             EdkLogger.error("AutoGen", AUTOGEN_ERROR, '%s must have exactly one entry point' % Info.ModuleType,\r
1429                             ExtraData=", ".join(Info.Module.ModuleEntryPointList))\r
1430     if Info.ModuleType == 'PEI_CORE':\r
1431         AutoGenC.Append(gPeiCoreEntryPointString, Dict)\r
1432     elif Info.ModuleType == 'DXE_CORE':\r
1433         AutoGenC.Append(gDxeCoreEntryPointString, Dict)\r
1434     elif Info.ModuleType == 'PEIM':\r
1435         if NumEntryPoints < 2:\r
1436             AutoGenC.Append(gPeimEntryPointString[NumEntryPoints], Dict)\r
1437         else:\r
1438             AutoGenC.Append(gPeimEntryPointString[2], Dict)\r
1439     elif Info.ModuleType in ['DXE_RUNTIME_DRIVER','DXE_DRIVER','DXE_SMM_DRIVER', 'DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION']:\r
1440         if Info.ModuleType == 'DXE_SMM_DRIVER':\r
1441             if NumEntryPoints == 0:\r
1442                 AutoGenC.Append(gDxeSmmEntryPointString[0], Dict)\r
1443             else:\r
1444                 AutoGenC.Append(gDxeSmmEntryPointString[1], Dict)\r
1445         else:\r
1446             if NumEntryPoints < 2:\r
1447                 AutoGenC.Append(gUefiEntryPointString[NumEntryPoints], Dict)\r
1448             else:\r
1449                 AutoGenC.Append(gUefiEntryPointString[2], Dict)\r
1450 \r
1451 ## Create code for ModuleUnloadImage\r
1452 #\r
1453 #   @param      Info        The ModuleBuildInfo object\r
1454 #   @param      AutoGenC    The TemplateString object for C code\r
1455 #   @param      AutoGenH    The TemplateString object for header file\r
1456 #\r
1457 def CreateModuleUnloadImageCode(Info, AutoGenC, AutoGenH):\r
1458     if Info.IsLibrary or Info.ModuleType == "USER_DEFINED":\r
1459         return\r
1460     #\r
1461     # Unload Image Handlers\r
1462     #\r
1463     NumUnloadImage = len(Info.Module.ModuleUnloadImageList)\r
1464     Dict = {'Count':NumUnloadImage, 'Function':Info.Module.ModuleUnloadImageList}\r
1465     if NumUnloadImage < 2:\r
1466         AutoGenC.Append(gUefiUnloadImageString[NumUnloadImage], Dict)\r
1467     else:\r
1468         AutoGenC.Append(gUefiUnloadImageString[2], Dict)\r
1469 \r
1470 ## Create code for GUID\r
1471 #\r
1472 #   @param      Info        The ModuleBuildInfo object\r
1473 #   @param      AutoGenC    The TemplateString object for C code\r
1474 #   @param      AutoGenH    The TemplateString object for header file\r
1475 #\r
1476 def CreateGuidDefinitionCode(Info, AutoGenC, AutoGenH):\r
1477     if Info.IsLibrary:\r
1478         return\r
1479 \r
1480     if Info.ModuleType in ["USER_DEFINED", "BASE"]:\r
1481         GuidType = "GUID"\r
1482     else:\r
1483         GuidType = "EFI_GUID"\r
1484 \r
1485     #\r
1486     # GUIDs\r
1487     #\r
1488     for Key in Info.GuidList:\r
1489         AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.GuidList[Key]))\r
1490 \r
1491 ## Create code for protocol\r
1492 #\r
1493 #   @param      Info        The ModuleBuildInfo object\r
1494 #   @param      AutoGenC    The TemplateString object for C code\r
1495 #   @param      AutoGenH    The TemplateString object for header file\r
1496 #\r
1497 def CreateProtocolDefinitionCode(Info, AutoGenC, AutoGenH):\r
1498     if Info.IsLibrary:\r
1499         return\r
1500 \r
1501     if Info.ModuleType in ["USER_DEFINED", "BASE"]:\r
1502         GuidType = "GUID"\r
1503     else:\r
1504         GuidType = "EFI_GUID"\r
1505 \r
1506     #\r
1507     # Protocol GUIDs\r
1508     #\r
1509     for Key in Info.ProtocolList:\r
1510         AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.ProtocolList[Key]))\r
1511 \r
1512 ## Create code for PPI\r
1513 #\r
1514 #   @param      Info        The ModuleBuildInfo object\r
1515 #   @param      AutoGenC    The TemplateString object for C code\r
1516 #   @param      AutoGenH    The TemplateString object for header file\r
1517 #\r
1518 def CreatePpiDefinitionCode(Info, AutoGenC, AutoGenH):\r
1519     if Info.IsLibrary:\r
1520         return\r
1521 \r
1522     if Info.ModuleType in ["USER_DEFINED", "BASE"]:\r
1523         GuidType = "GUID"\r
1524     else:\r
1525         GuidType = "EFI_GUID"\r
1526 \r
1527     #\r
1528     # PPI GUIDs\r
1529     #\r
1530     for Key in Info.PpiList:\r
1531         AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.PpiList[Key]))\r
1532 \r
1533 ## Create code for PCD\r
1534 #\r
1535 #   @param      Info        The ModuleBuildInfo object\r
1536 #   @param      AutoGenC    The TemplateString object for C code\r
1537 #   @param      AutoGenH    The TemplateString object for header file\r
1538 #\r
1539 def CreatePcdCode(Info, AutoGenC, AutoGenH):\r
1540     if Info.IsLibrary:\r
1541         for Pcd in Info.PcdList:\r
1542             CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd)\r
1543     else:\r
1544         for Pcd in Info.PcdList:\r
1545             CreateModulePcdCode(Info, AutoGenC, AutoGenH, Pcd)\r
1546     CreatePcdDatabaseCode(Info, AutoGenC, AutoGenH)\r
1547 \r
1548 ## Create code for unicode string definition\r
1549 #\r
1550 #   @param      Info        The ModuleBuildInfo object\r
1551 #   @param      AutoGenC    The TemplateString object for C code\r
1552 #   @param      AutoGenH    The TemplateString object for header file\r
1553 #\r
1554 def CreateUnicodeStringCode(Info, AutoGenC, AutoGenH):\r
1555     if len(Info.UnicodeFileList) == 0:\r
1556         return\r
1557 \r
1558     WorkingDir = os.getcwd()\r
1559     os.chdir(Info.WorkspaceDir)\r
1560 \r
1561     IncList = [os.path.join(Info.WorkspaceDir, Inc) for Inc in Info.IncludePathList]\r
1562     Header, Code = GetStringFiles(Info.UnicodeFileList, IncList, [], Info.Name)\r
1563     AutoGenC.Append("\n//\n//Unicode String Pack Definition\n//\n")\r
1564     AutoGenC.Append(Code)\r
1565     AutoGenC.Append("\n")\r
1566     AutoGenH.Append("\n//\n//Unicode String ID\n//\n")\r
1567     AutoGenH.Append(Header)\r
1568     AutoGenH.Append("\n#define STRING_ARRAY_NAME %sStrings\n" % Info.Name)\r
1569     os.chdir(WorkingDir)\r
1570 \r
1571 ## Create common code\r
1572 #\r
1573 #   @param      Info        The ModuleBuildInfo object\r
1574 #   @param      AutoGenC    The TemplateString object for C code\r
1575 #   @param      AutoGenH    The TemplateString object for header file\r
1576 #\r
1577 def CreateHeaderCode(Info, AutoGenC, AutoGenH):\r
1578     # file header\r
1579     AutoGenH.Append(gAutoGenHeaderString,   {'FileName':'AutoGen.h'})\r
1580     # header file Prologue\r
1581     AutoGenH.Append(gAutoGenHPrologueString,{'Guid':Info.Guid.replace('-','_')})\r
1582     if Info.AutoGenVersion >= 0x00010005:\r
1583         # specification macros\r
1584         AutoGenH.Append(gSpecificationString,   {'SpecificationName':Info.Macro.keys(), \r
1585                                                  'SpecificationValue':Info.Macro.values()})\r
1586         # header files includes\r
1587         AutoGenH.Append("#include <%s>\n\n" % gBasicHeaderFile)\r
1588         AutoGenH.Append('\nextern GUID  gEfiCallerIdGuid;\n\n')\r
1589     \r
1590         if Info.IsLibrary:\r
1591             return\r
1592     \r
1593         AutoGenH.Append("#define EFI_CALLER_ID_GUID \\\n  %s\n" % GuidStringToGuidStructureString(Info.Guid))\r
1594     \r
1595     if Info.IsLibrary:\r
1596         return\r
1597     # C file header\r
1598     AutoGenC.Append(gAutoGenHeaderString, {'FileName':'AutoGen.c'})\r
1599     if Info.AutoGenVersion >= 0x00010005:\r
1600         # C file header files includes\r
1601         for Inc in gModuleTypeHeaderFile[Info.ModuleType]:\r
1602             AutoGenC.Append("#include <%s>\n" % Inc)\r
1603     \r
1604         #\r
1605         # Publish the CallerId Guid\r
1606         #\r
1607         AutoGenC.Append('\nGLOBAL_REMOVE_IF_UNREFERENCED GUID gEfiCallerIdGuid = %s;\n' % GuidStringToGuidStructureString(Info.Guid))\r
1608 \r
1609 ## Create common code for header file\r
1610 #\r
1611 #   @param      Info        The ModuleBuildInfo object\r
1612 #   @param      AutoGenC    The TemplateString object for C code\r
1613 #   @param      AutoGenH    The TemplateString object for header file\r
1614 #\r
1615 def CreateFooterCode(Info, AutoGenC, AutoGenH):\r
1616     AutoGenH.Append(gAutoGenHEpilogueString)\r
1617 \r
1618 ## Create code for a module\r
1619 #\r
1620 #   @param      Info        The ModuleBuildInfo object\r
1621 #   @param      AutoGenC    The TemplateString object for C code\r
1622 #   @param      AutoGenH    The TemplateString object for header file\r
1623 #\r
1624 def CreateCode(Info, AutoGenC, AutoGenH):\r
1625     CreateHeaderCode(Info, AutoGenC, AutoGenH)\r
1626 \r
1627     if Info.AutoGenVersion >= 0x00010005:\r
1628         CreateLibraryConstructorCode(Info, AutoGenC, AutoGenH)\r
1629         CreateLibraryDestructorCode(Info, AutoGenC, AutoGenH)\r
1630         CreateModuleEntryPointCode(Info, AutoGenC, AutoGenH)\r
1631         CreateModuleUnloadImageCode(Info, AutoGenC, AutoGenH)\r
1632         CreateGuidDefinitionCode(Info, AutoGenC, AutoGenH)\r
1633         CreateProtocolDefinitionCode(Info, AutoGenC, AutoGenH)\r
1634         CreatePpiDefinitionCode(Info, AutoGenC, AutoGenH)\r
1635         CreatePcdCode(Info, AutoGenC, AutoGenH)\r
1636     CreateUnicodeStringCode(Info, AutoGenC, AutoGenH)\r
1637 \r
1638     CreateFooterCode(Info, AutoGenC, AutoGenH)\r
1639 \r
1640 ## Create the code file\r
1641 #\r
1642 #   @param      FilePath    The path of code file\r
1643 #   @param      Content     The content of code file\r
1644 #\r
1645 #   @retval     True        If file content is changed or file doesn't exist\r
1646 #   @retval     False       If the file exists and the content is not changed\r
1647 #\r
1648 def Generate(FilePath, Content):\r
1649     return SaveFileOnChange(FilePath, Content)\r