c72d75ffaaad8fe956c064505d05cc4033d07824
[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 """\r
315 \r
316 gAutoGenHEpilogueString = """\r
317 #endif\r
318 """\r
319 \r
320 ## PEI Core Entry Point Templates\r
321 gPeiCoreEntryPointString = """\r
322 ${BEGIN}\r
323 EFI_STATUS\r
324 ${Function} (\r
325   IN CONST  EFI_SEC_PEI_HAND_OFF    *SecCoreData,\r
326   IN CONST  EFI_PEI_PPI_DESCRIPTOR  *PpiList,\r
327   IN VOID                           *OldCoreData\r
328   );\r
329 \r
330 EFI_STATUS\r
331 EFIAPI\r
332 ProcessModuleEntryPointList (\r
333   IN CONST  EFI_SEC_PEI_HAND_OFF    *SecCoreData,\r
334   IN CONST  EFI_PEI_PPI_DESCRIPTOR  *PpiList,\r
335   IN VOID                           *OldCoreData\r
336   )\r
337 \r
338 {\r
339   return ${Function} (SecCoreData, PpiList, OldCoreData);\r
340 }\r
341 ${END}\r
342 """\r
343 \r
344 \r
345 ## DXE Core Entry Point Templates\r
346 gDxeCoreEntryPointString = """\r
347 const UINT32 _gUefiDriverRevision = 0;\r
348 ${BEGIN}\r
349 VOID\r
350 ${Function} (\r
351   IN VOID  *HobStart\r
352   );\r
353 \r
354 VOID\r
355 EFIAPI\r
356 ProcessModuleEntryPointList (\r
357   IN VOID  *HobStart\r
358   )\r
359 \r
360 {\r
361   ${Function} (HobStart);\r
362 }\r
363 ${END}\r
364 """\r
365 \r
366 ## PEIM Entry Point Templates\r
367 gPeimEntryPointString = [\r
368 """\r
369 GLOBAL_REMOVE_IF_UNREFERENCED const UINT32 _gPeimRevision = 0;\r
370 \r
371 EFI_STATUS\r
372 EFIAPI\r
373 ProcessModuleEntryPointList (\r
374   IN EFI_PEI_FILE_HANDLE  FileHandle,\r
375   IN EFI_PEI_SERVICES     **PeiServices\r
376   )\r
377 \r
378 {\r
379   return EFI_SUCCESS;\r
380 }\r
381 """,\r
382 """\r
383 GLOBAL_REMOVE_IF_UNREFERENCED const UINT32 _gPeimRevision = 0;\r
384 ${BEGIN}\r
385 EFI_STATUS\r
386 ${Function} (\r
387   IN EFI_PEI_FILE_HANDLE  FileHandle,\r
388   IN EFI_PEI_SERVICES     **PeiServices\r
389   );\r
390 \r
391 EFI_STATUS\r
392 EFIAPI\r
393 ProcessModuleEntryPointList (\r
394   IN EFI_PEI_FILE_HANDLE  FileHandle,\r
395   IN EFI_PEI_SERVICES     **PeiServices\r
396   )\r
397 \r
398 {\r
399   return ${Function} (FileHandle, PeiServices);\r
400 }\r
401 ${END}\r
402 """,\r
403 """\r
404 GLOBAL_REMOVE_IF_UNREFERENCED const UINT32 _gPeimRevision = 0;\r
405 \r
406 ${BEGIN}\r
407 EFI_STATUS\r
408 ${Function} (\r
409   IN EFI_PEI_FILE_HANDLE  FileHandle,\r
410   IN EFI_PEI_SERVICES     **PeiServices\r
411   );\r
412 ${END}\r
413 \r
414 EFI_STATUS\r
415 EFIAPI\r
416 ProcessModuleEntryPointList (\r
417   IN EFI_PEI_FILE_HANDLE  FileHandle,\r
418   IN EFI_PEI_SERVICES     **PeiServices\r
419   )\r
420 \r
421 {\r
422   EFI_STATUS  Status;\r
423   EFI_STATUS  CombinedStatus;\r
424 \r
425   CombinedStatus = EFI_LOAD_ERROR;\r
426 ${BEGIN}\r
427   Status = ${Function} (FileHandle, PeiServices);\r
428   if (!EFI_ERROR (Status) || EFI_ERROR (CombinedStatus)) {\r
429     CombinedStatus = Status;\r
430   }\r
431 ${END}\r
432   return CombinedStatus;\r
433 }\r
434 """\r
435 ]\r
436 \r
437 ## DXE SMM Entry Point Templates\r
438 gDxeSmmEntryPointString = [\r
439 """\r
440 EFI_STATUS\r
441 EFIAPI\r
442 ProcessModuleEntryPointList (\r
443   IN EFI_HANDLE        ImageHandle,\r
444   IN EFI_SYSTEM_TABLE  *SystemTable\r
445   )\r
446 \r
447 {\r
448   return EFI_SUCCESS;\r
449 }\r
450 """,\r
451 """\r
452 ${BEGIN}\r
453 EFI_STATUS\r
454 ${Function} (\r
455   IN EFI_HANDLE        ImageHandle,\r
456   IN EFI_SYSTEM_TABLE  *SystemTable\r
457   );\r
458 ${END}\r
459 \r
460 static BASE_LIBRARY_JUMP_BUFFER  mJumpContext;\r
461 static EFI_STATUS  mDriverEntryPointStatus = EFI_LOAD_ERROR;\r
462 \r
463 VOID\r
464 EFIAPI\r
465 ExitDriver (\r
466   IN EFI_STATUS  Status\r
467   )\r
468 {\r
469   if (!EFI_ERROR (Status) || EFI_ERROR (mDriverEntryPointStatus)) {\r
470     mDriverEntryPointStatus = Status;\r
471   }\r
472   LongJump (&mJumpContext, (UINTN)-1);\r
473   ASSERT (FALSE);\r
474 }\r
475 \r
476 EFI_STATUS\r
477 EFIAPI\r
478 ProcessModuleEntryPointList (\r
479   IN EFI_HANDLE        ImageHandle,\r
480   IN EFI_SYSTEM_TABLE  *SystemTable\r
481   )\r
482 \r
483 {\r
484 ${BEGIN}\r
485   if (SetJump (&mJumpContext) == 0) {\r
486     ExitDriver (${Function} (ImageHandle, SystemTable));\r
487     ASSERT (FALSE);\r
488   }\r
489 ${END}\r
490 \r
491   return mDriverEntryPointStatus;\r
492 }\r
493 """\r
494 ]\r
495 \r
496 ## UEFI Entry Point Templates\r
497 gUefiEntryPointString = [\r
498 """\r
499 const UINT32 _gUefiDriverRevision = 0;\r
500 \r
501 EFI_STATUS\r
502 EFIAPI\r
503 ProcessModuleEntryPointList (\r
504   IN EFI_HANDLE        ImageHandle,\r
505   IN EFI_SYSTEM_TABLE  *SystemTable\r
506   )\r
507 {\r
508   return EFI_SUCCESS;\r
509 }\r
510 """,\r
511 """\r
512 const UINT32 _gUefiDriverRevision = 0;\r
513 ${BEGIN}\r
514 EFI_STATUS\r
515 ${Function} (\r
516   IN EFI_HANDLE        ImageHandle,\r
517   IN EFI_SYSTEM_TABLE  *SystemTable\r
518   );\r
519 \r
520 EFI_STATUS\r
521 EFIAPI\r
522 ProcessModuleEntryPointList (\r
523   IN EFI_HANDLE        ImageHandle,\r
524   IN EFI_SYSTEM_TABLE  *SystemTable\r
525   )\r
526 \r
527 {\r
528   return ${Function} (ImageHandle, SystemTable);\r
529 }\r
530 ${END}\r
531 VOID\r
532 EFIAPI\r
533 ExitDriver (\r
534   IN EFI_STATUS  Status\r
535   )\r
536 {\r
537   if (EFI_ERROR (Status)) {\r
538     ProcessLibraryDestructorList (gImageHandle, gST);\r
539   }\r
540   gBS->Exit (gImageHandle, Status, 0, NULL);\r
541 }\r
542 """,\r
543 """\r
544 const UINT32 _gUefiDriverRevision = 0;\r
545 \r
546 ${BEGIN}\r
547 EFI_STATUS\r
548 ${Function} (\r
549   IN EFI_HANDLE        ImageHandle,\r
550   IN EFI_SYSTEM_TABLE  *SystemTable\r
551   );\r
552 ${END}\r
553 \r
554 EFI_STATUS\r
555 EFIAPI\r
556 ProcessModuleEntryPointList (\r
557   IN EFI_HANDLE        ImageHandle,\r
558   IN EFI_SYSTEM_TABLE  *SystemTable\r
559   )\r
560 \r
561 {\r
562   ${BEGIN}\r
563   if (SetJump (&mJumpContext) == 0) {\r
564     ExitDriver (${Function} (ImageHandle, SystemTable));\r
565     ASSERT (FALSE);\r
566   }\r
567   ${END}\r
568   return mDriverEntryPointStatus;\r
569 }\r
570 \r
571 static BASE_LIBRARY_JUMP_BUFFER  mJumpContext;\r
572 static EFI_STATUS  mDriverEntryPointStatus = EFI_LOAD_ERROR;\r
573 \r
574 VOID\r
575 EFIAPI\r
576 ExitDriver (\r
577   IN EFI_STATUS  Status\r
578   )\r
579 {\r
580   if (!EFI_ERROR (Status) || EFI_ERROR (mDriverEntryPointStatus)) {\r
581     mDriverEntryPointStatus = Status;\r
582   }\r
583   LongJump (&mJumpContext, (UINTN)-1);\r
584   ASSERT (FALSE);\r
585 }\r
586 """\r
587 ]\r
588 \r
589 ## UEFI Unload Image Templates\r
590 gUefiUnloadImageString = [\r
591 """\r
592 GLOBAL_REMOVE_IF_UNREFERENCED const UINT8 _gDriverUnloadImageCount = ${Count};\r
593 \r
594 EFI_STATUS\r
595 EFIAPI\r
596 ProcessModuleUnloadList (\r
597   IN EFI_HANDLE        ImageHandle\r
598   )\r
599 {\r
600   return EFI_SUCCESS;\r
601 }\r
602 """,\r
603 """\r
604 GLOBAL_REMOVE_IF_UNREFERENCED const UINT8 _gDriverUnloadImageCount = ${Count};\r
605 \r
606 ${BEGIN}\r
607 EFI_STATUS\r
608 ${Function} (\r
609   IN EFI_HANDLE        ImageHandle\r
610   );\r
611 \r
612 EFI_STATUS\r
613 EFIAPI\r
614 ProcessModuleUnloadList (\r
615   IN EFI_HANDLE        ImageHandle\r
616   )\r
617 {\r
618   return ${Function} (ImageHandle);\r
619 }\r
620 ${END}\r
621 """,\r
622 """\r
623 GLOBAL_REMOVE_IF_UNREFERENCED const UINT8 _gDriverUnloadImageCount = ${Count};\r
624 \r
625 ${BEGIN}\r
626 EFI_STATUS\r
627 ${Function} (\r
628   IN EFI_HANDLE        ImageHandle\r
629   );\r
630 ${END}\r
631 \r
632 EFI_STATUS\r
633 EFIAPI\r
634 ProcessModuleUnloadList (\r
635   IN EFI_HANDLE        ImageHandle\r
636   )\r
637 {\r
638   EFI_STATUS  Status;\r
639 \r
640   Status = EFI_SUCCESS;\r
641 ${BEGIN}\r
642   if (EFI_ERROR (Status)) {\r
643     ${Function} (ImageHandle);\r
644   } else {\r
645     Status = ${Function} (ImageHandle);\r
646   }\r
647 ${END}\r
648   return Status;\r
649 }\r
650 """\r
651 ]\r
652 \r
653 gLibraryStructorPrototype = {\r
654 'BASE'  : """${BEGIN}\r
655 EFI_STATUS\r
656 EFIAPI\r
657 ${Function} (\r
658   VOID\r
659   );${END}\r
660 """,\r
661 \r
662 'PEI'   : """${BEGIN}\r
663 EFI_STATUS\r
664 EFIAPI\r
665 ${Function} (\r
666   IN EFI_PEI_FILE_HANDLE       FileHandle,\r
667   IN EFI_PEI_SERVICES          **PeiServices\r
668   );${END}\r
669 """,\r
670 \r
671 'DXE'   : """${BEGIN}\r
672 EFI_STATUS\r
673 EFIAPI\r
674 ${Function} (\r
675   IN EFI_HANDLE        ImageHandle,\r
676   IN EFI_SYSTEM_TABLE  *SystemTable\r
677   );${END}\r
678 """,\r
679 }\r
680 \r
681 gLibraryStructorCall = {\r
682 'BASE'  : """${BEGIN}\r
683   Status = ${Function} ();\r
684   ASSERT_EFI_ERROR (Status);${END}\r
685 """,\r
686 \r
687 'PEI'   : """${BEGIN}\r
688   Status = ${Function} (FileHandle, PeiServices);\r
689   ASSERT_EFI_ERROR (Status);${END}\r
690 """,\r
691 \r
692 'DXE'   : """${BEGIN}\r
693   Status = ${Function} (ImageHandle, SystemTable);\r
694   ASSERT_EFI_ERROR (Status);${END}\r
695 """,\r
696 }\r
697 \r
698 ## Library Constructor and Destructor Templates\r
699 gLibraryString = {\r
700 'BASE'  :   """\r
701 ${BEGIN}${FunctionPrototype}${END}\r
702 \r
703 VOID\r
704 EFIAPI\r
705 ProcessLibrary${Type}List (\r
706   VOID\r
707   )\r
708 {\r
709 ${BEGIN}  EFI_STATUS  Status;\r
710 ${FunctionCall}${END}\r
711 }\r
712 """,\r
713 \r
714 'PEI'   :   """\r
715 ${BEGIN}${FunctionPrototype}${END}\r
716 \r
717 VOID\r
718 EFIAPI\r
719 ProcessLibrary${Type}List (\r
720   IN EFI_PEI_FILE_HANDLE       FileHandle,\r
721   IN EFI_PEI_SERVICES          **PeiServices\r
722   )\r
723 {\r
724 ${BEGIN}  EFI_STATUS  Status;\r
725 ${FunctionCall}${END}\r
726 }\r
727 """,\r
728 \r
729 'DXE'   :   """\r
730 ${BEGIN}${FunctionPrototype}${END}\r
731 \r
732 VOID\r
733 EFIAPI\r
734 ProcessLibrary${Type}List (\r
735   IN EFI_HANDLE        ImageHandle,\r
736   IN EFI_SYSTEM_TABLE  *SystemTable\r
737   )\r
738 {\r
739 ${BEGIN}  EFI_STATUS  Status;\r
740 ${FunctionCall}${END}\r
741 }\r
742 """,\r
743 }\r
744 \r
745 gSpecificationString = """\r
746 ${BEGIN}\r
747 #undef ${SpecificationName}\r
748 #define ${SpecificationName} ${SpecificationValue}\r
749 ${END}\r
750 """\r
751 \r
752 gBasicHeaderFile = "Base.h"\r
753 \r
754 gModuleTypeHeaderFile = {\r
755     "BASE"              :   [gBasicHeaderFile],\r
756     "SEC"               :   ["PiPei.h", "Library/DebugLib.h"],\r
757     "PEI_CORE"          :   ["PiPei.h", "Library/DebugLib.h"],\r
758     "PEIM"              :   ["PiPei.h", "Library/DebugLib.h"],\r
759     "DXE_CORE"          :   ["PiDxe.h", "Library/DebugLib.h"],\r
760     "DXE_DRIVER"        :   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h"],\r
761     "DXE_SMM_DRIVER"    :   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h"],\r
762     "DXE_RUNTIME_DRIVER":   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h"],\r
763     "DXE_SAL_DRIVER"    :   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h"],\r
764     "UEFI_DRIVER"       :   ["Uefi.h",  "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h"],\r
765     "UEFI_APPLICATION"  :   ["Uefi.h",  "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h"],\r
766     "USER_DEFINED"      :   [gBasicHeaderFile]\r
767 }\r
768 \r
769 ## Create code for module PCDs\r
770 #\r
771 #   @param      Info        The ModuleBuildInfo object\r
772 #   @param      AutoGenC    The TemplateString object for C code\r
773 #   @param      AutoGenH    The TemplateString object for header file\r
774 #   @param      Pcd         The PCD object\r
775 #\r
776 def CreateModulePcdCode(Info, AutoGenC, AutoGenH, Pcd):\r
777     TokenSpaceGuidValue = Pcd.TokenSpaceGuidValue   #Info.GuidList[Pcd.TokenSpaceGuidCName]\r
778     PcdTokenNumber = Info.PlatformInfo.PcdTokenNumber\r
779     #\r
780     # Write PCDs\r
781     #\r
782     PcdTokenName = '_PCD_TOKEN_' + Pcd.TokenCName\r
783     if Pcd.Type in gDynamicExPcd:\r
784         TokenNumber = int(Pcd.TokenValue, 0)\r
785     else:\r
786         if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in PcdTokenNumber:\r
787             EdkLogger.error("AutoGen", AUTOGEN_ERROR, "No generated token number for %s|%s\n" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
788         TokenNumber = PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName]\r
789     AutoGenH.Append('#define %s  %d\n' % (PcdTokenName, TokenNumber))\r
790 \r
791     EdkLogger.debug(EdkLogger.DEBUG_3, "Creating code for " + Pcd.TokenCName + "|" + Pcd.TokenSpaceGuidCName)\r
792     if Pcd.Type not in gItemTypeStringDatabase:\r
793         EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Unknown PCD type [%s] of PCD %s|%s" % (Pcd.Type, Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
794     if Pcd.DatumType not in gDatumSizeStringDatabase:\r
795         EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Unknown datum type [%s] of PCD %s|%s" % (Pcd.DatumType, Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
796 \r
797     DatumSize = gDatumSizeStringDatabase[Pcd.DatumType]\r
798     DatumSizeLib = gDatumSizeStringDatabaseLib[Pcd.DatumType]\r
799     GetModeName = '_PCD_GET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + Pcd.TokenCName\r
800     SetModeName = '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + Pcd.TokenCName\r
801 \r
802     if Pcd.Type in gDynamicExPcd:\r
803         AutoGenH.Append('#define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))\r
804         if Pcd.DatumType == 'VOID*':\r
805             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))\r
806         else:\r
807             AutoGenH.Append('#define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))\r
808     elif Pcd.Type in gDynamicPcd:\r
809         AutoGenH.Append('#define %s  LibPcdGet%s(%s)\n' % (GetModeName, DatumSizeLib, PcdTokenName))\r
810         if Pcd.DatumType == 'VOID*':\r
811             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSet%s(%s, (SizeOfBuffer), (Buffer))\n' %(SetModeName, DatumSizeLib, PcdTokenName))\r
812         else:\r
813             AutoGenH.Append('#define %s(Value)  LibPcdSet%s(%s, (Value))\n' % (SetModeName, DatumSizeLib, PcdTokenName))\r
814     else:\r
815         PcdVariableName = '_gPcd_' + gItemTypeStringDatabase[Pcd.Type] + '_' + Pcd.TokenCName\r
816         Const = 'const'\r
817         if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:\r
818             Const = ''\r
819         Type = ''\r
820         Array = ''\r
821         Value = Pcd.DefaultValue\r
822         if Pcd.DatumType == 'UINT64':\r
823             if not Value.endswith('ULL'):\r
824                 Value += 'ULL'\r
825         if Pcd.DatumType == 'VOID*':\r
826             if Pcd.MaxDatumSize == None or Pcd.MaxDatumSize == '':\r
827                 EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Unknown [MaxDatumSize] of PCD [%s.%s]" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName))\r
828 \r
829             ArraySize = int(Pcd.MaxDatumSize, 0)\r
830             if Value[0] == '{':\r
831                 Type = '(VOID *)'\r
832             else:\r
833                 Unicode = False\r
834                 if Value[0] == 'L':\r
835                     Unicode = True\r
836                 Value = Value.lstrip('L').strip('"')\r
837                 NewValue = '{'\r
838                 for Index in range(0,len(Value)):\r
839                     NewValue = NewValue + str(ord(Value[Index]) % 0x100) + ', '\r
840                     if Unicode:\r
841                         NewValue = NewValue + str(ord(Value[Index]) / 0x100) + ', '\r
842                 if Unicode:\r
843                     if ArraySize < (len(Value)*2 + 2):\r
844                         ArraySize = len(Value)*2 + 2\r
845                     NewValue = NewValue + '0, '\r
846                 else:\r
847                     if ArraySize < (len(Value) + 1):\r
848                         ArraySize = len(Value) + 1\r
849                 Value = NewValue + '0 }'\r
850             Array = '[%d]' % ArraySize\r
851 \r
852         PcdValueName = '_PCD_VALUE_' + Pcd.TokenCName\r
853         if Pcd.DatumType == 'VOID*' and Value[0] == '{':\r
854             AutoGenH.Append('#define _PCD_PATCHABLE_%s_SIZE %s\n' % (Pcd.TokenCName, Pcd.MaxDatumSize))\r
855             AutoGenH.Append('#define %s  %s%s\n' %(PcdValueName, Type, PcdVariableName))\r
856             AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s UINT8 %s%s = %s;\n' % (Const, PcdVariableName, Array, Value))\r
857             AutoGenH.Append('extern %s UINT8 %s%s;\n' %(Const, PcdVariableName, Array))\r
858             AutoGenH.Append('#define %s  %s%s\n' %(GetModeName, Type, PcdVariableName))\r
859         else:\r
860             AutoGenH.Append('#define %s  %s\n' %(PcdValueName, Value))\r
861             AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s %s = %s;\n' %(Const, Pcd.DatumType, PcdVariableName, PcdValueName))\r
862             AutoGenH.Append('extern %s  %s  %s%s;\n' % (Const, Pcd.DatumType, PcdVariableName, Array))\r
863             AutoGenH.Append('#define %s  %s%s\n' % (GetModeName, Type, PcdVariableName))\r
864 \r
865         if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:\r
866             if Pcd.DatumType == 'VOID*':\r
867                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPatchPcdSetPtr(_gPcd_BinaryPatch_%s, (UINTN)_PCD_PATCHABLE_%s_SIZE, (SizeOfBuffer), (Buffer))\n' % (SetModeName, Pcd.TokenCName, Pcd.TokenCName))\r
868             else:\r
869                 AutoGenH.Append('#define %s(Value)  (%s = (Value))\n' % (SetModeName, PcdVariableName))\r
870         else:\r
871             AutoGenH.Append('//#define %s  ASSERT(FALSE)  // It is not allowed to set value for a FIXED_AT_BUILD PCD\n' % SetModeName)\r
872 \r
873 ## Create code for library module PCDs\r
874 #\r
875 #   @param      Info        The ModuleBuildInfo object\r
876 #   @param      AutoGenC    The TemplateString object for C code\r
877 #   @param      AutoGenH    The TemplateString object for header file\r
878 #   @param      Pcd         The PCD object\r
879 #\r
880 def CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd):\r
881     PcdTokenNumber = Info.PlatformInfo.PcdTokenNumber\r
882     TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName\r
883     TokenCName  = Pcd.TokenCName\r
884     TokenSpaceGuidValue = Pcd.TokenSpaceGuidValue   #Info.GuidList[TokenSpaceGuidCName]\r
885     if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in PcdTokenNumber:\r
886         EdkLogger.error("AutoGen", AUTOGEN_ERROR, "No generated token number for %s|%s\n" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
887     TokenNumber = PcdTokenNumber[TokenCName, TokenSpaceGuidCName]\r
888 \r
889     if Pcd.Type not in gItemTypeStringDatabase:\r
890         EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Unknown PCD type [%s] of PCD %s|%s" % (Pcd.Type, Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
891     if Pcd.DatumType not in gDatumSizeStringDatabase:\r
892         EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Unknown datum type [%s] of PCD %s|%s" % (Pcd.DatumType, Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
893 \r
894     DatumType   = Pcd.DatumType\r
895     DatumSize   = gDatumSizeStringDatabaseH[DatumType]\r
896     DatumSizeLib= gDatumSizeStringDatabaseLib[DatumType]\r
897     GetModeName = '_PCD_GET_MODE_' + DatumSize + '_' + TokenCName\r
898     SetModeName = '_PCD_SET_MODE_' + DatumSize + '_' + TokenCName\r
899 \r
900     Type = ''\r
901     Array = ''\r
902     if Pcd.DatumType == 'VOID*':\r
903         Type = '(VOID *)'\r
904         Array = '[]'\r
905 \r
906     AutoGenH.Append('#define _PCD_TOKEN_%s  %d\n' % (TokenCName, TokenNumber))\r
907 \r
908     PcdItemType = Pcd.Type\r
909     #if PcdItemType in gDynamicPcd:\r
910     #    PcdItemType = TAB_PCDS_FIXED_AT_BUILD\r
911     #    if (TokenCName, TokenSpaceGuidCName) in Info.PlatformInfo.Platform.Pcds:\r
912     #        PcdItemType  = Info.PlatformInfo.Platform.Pcds[TokenCName, TokenSpaceGuidCName].Type\r
913     if PcdItemType in gDynamicExPcd:\r
914         PcdTokenName = '_PCD_TOKEN_' + TokenCName\r
915         AutoGenH.Append('#define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, TokenSpaceGuidCName, PcdTokenName))\r
916         if DatumType == 'VOID*':\r
917             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName,DatumSizeLib, TokenSpaceGuidCName, PcdTokenName))\r
918         else:\r
919             AutoGenH.Append('#define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, TokenSpaceGuidCName, PcdTokenName))\r
920     if PcdItemType in gDynamicPcd:\r
921         PcdTokenName = '_PCD_TOKEN_' + TokenCName\r
922         AutoGenH.Append('#define %s  LibPcdGet%s(%s)\n' % (GetModeName, DatumSizeLib, PcdTokenName))\r
923         if DatumType == 'VOID*':\r
924             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSet%s(%s, (SizeOfBuffer), (Buffer))\n' %(SetModeName, DatumSizeLib, PcdTokenName))\r
925         else:\r
926             AutoGenH.Append('#define %s(Value)  LibPcdSet%s(%s, (Value))\n' % (SetModeName, DatumSizeLib, PcdTokenName))\r
927     if PcdItemType == TAB_PCDS_PATCHABLE_IN_MODULE:\r
928         PcdVariableName = '_gPcd_' + gItemTypeStringDatabase[TAB_PCDS_PATCHABLE_IN_MODULE] + '_' + TokenCName\r
929         AutoGenH.Append('extern %s _gPcd_BinaryPatch_%s%s;\n' %(DatumType, TokenCName, Array) )\r
930         AutoGenH.Append('#define %s  %s_gPcd_BinaryPatch_%s\n' %(GetModeName, Type, TokenCName))\r
931         AutoGenH.Append('#define %s(Value)  (%s = (Value))\n' % (SetModeName, PcdVariableName))\r
932     if PcdItemType == TAB_PCDS_FIXED_AT_BUILD or PcdItemType == TAB_PCDS_FEATURE_FLAG:\r
933         AutoGenH.Append('extern const %s _gPcd_FixedAtBuild_%s%s;\n' %(DatumType, TokenCName, Array))\r
934         #AutoGenH.Append('#define _PCD_VALUE_%s  _gPcd_FixedAtBuild_%s\n' %(TokenCName, TokenCName))\r
935         AutoGenH.Append('#define %s  %s_gPcd_FixedAtBuild_%s\n' %(GetModeName, Type, TokenCName))\r
936         AutoGenH.Append('//#define %s  ASSERT(FALSE)  // It is not allowed to set value for a FIXED_AT_BUILD PCD\n' % SetModeName)\r
937 \r
938 ## Create code for PCD database in DXE or PEI phase\r
939 #\r
940 #   @param      Platform    The platform object\r
941 #   @retval     tuple       Two TemplateString objects for C code and header file,\r
942 #                           respectively\r
943 #\r
944 def CreatePcdDatabasePhaseSpecificAutoGen (Platform, Phase):\r
945     AutoGenC = TemplateString()\r
946     AutoGenH = TemplateString()\r
947 \r
948     Dict = {\r
949         'PHASE'                         : Phase,\r
950         'GUID_TABLE_SIZE'               : '1',\r
951         'STRING_TABLE_SIZE'             : '1',\r
952         'SKUID_TABLE_SIZE'              : '1',\r
953         'LOCAL_TOKEN_NUMBER_TABLE_SIZE' : '1',\r
954         'LOCAL_TOKEN_NUMBER'            : '0',\r
955         'EXMAPPING_TABLE_SIZE'          : '1',\r
956         'EX_TOKEN_NUMBER'               : '0',\r
957         'SIZE_TABLE_SIZE'               : '2',\r
958         'GUID_TABLE_EMPTY'              : 'TRUE',\r
959         'STRING_TABLE_EMPTY'            : 'TRUE',\r
960         'SKUID_TABLE_EMPTY'             : 'TRUE',\r
961         'DATABASE_EMPTY'                : 'TRUE',\r
962         'EXMAP_TABLE_EMPTY'             : 'TRUE',\r
963         'PCD_DATABASE_UNINIT_EMPTY'     : '  UINT8  dummy; /* PCD_DATABASE_UNINIT is emptry */',\r
964         'SYSTEM_SKU_ID'                 : '  SKU_ID             SystemSkuId;',\r
965         'SYSTEM_SKU_ID_VALUE'           : '0'\r
966     }\r
967 \r
968     for DatumType in ['UINT64','UINT32','UINT16','UINT8','BOOLEAN']:\r
969         Dict['VARDEF_CNAME_' + DatumType] = []\r
970         Dict['VARDEF_GUID_' + DatumType]  = []\r
971         Dict['VARDEF_SKUID_' + DatumType] = []\r
972         Dict['VARDEF_VALUE_' + DatumType] = []\r
973         for Init in ['INIT','UNINIT']:\r
974             Dict[Init+'_CNAME_DECL_' + DatumType]   = []\r
975             Dict[Init+'_GUID_DECL_' + DatumType]    = []\r
976             Dict[Init+'_NUMSKUS_DECL_' + DatumType] = []\r
977             Dict[Init+'_VALUE_' + DatumType]        = []\r
978 \r
979     for Type in ['STRING_HEAD','VPD_HEAD','VARIABLE_HEAD']:\r
980         Dict[Type + '_CNAME_DECL']   = []\r
981         Dict[Type + '_GUID_DECL']    = []\r
982         Dict[Type + '_NUMSKUS_DECL'] = []\r
983         Dict[Type + '_VALUE'] = []\r
984 \r
985     Dict['STRING_TABLE_INDEX'] = []\r
986     Dict['STRING_TABLE_LENGTH']  = []\r
987     Dict['STRING_TABLE_CNAME'] = []\r
988     Dict['STRING_TABLE_GUID']  = []\r
989     Dict['STRING_TABLE_VALUE'] = []\r
990 \r
991     Dict['SIZE_TABLE_CNAME'] = []\r
992     Dict['SIZE_TABLE_GUID']  = []\r
993     Dict['SIZE_TABLE_CURRENT_LENGTH']  = []\r
994     Dict['SIZE_TABLE_MAXIMUM_LENGTH']  = []\r
995 \r
996     Dict['EXMAPPING_TABLE_EXTOKEN'] = []\r
997     Dict['EXMAPPING_TABLE_LOCAL_TOKEN'] = []\r
998     Dict['EXMAPPING_TABLE_GUID_INDEX'] = []\r
999 \r
1000     Dict['GUID_STRUCTURE'] = []\r
1001 \r
1002     Dict['SKUID_VALUE'] = []\r
1003 \r
1004     if Phase == 'DXE':\r
1005         Dict['SYSTEM_SKU_ID'] = ''\r
1006         Dict['SYSTEM_SKU_ID_VALUE'] = ''\r
1007 \r
1008     StringTableIndex = 0\r
1009     StringTableSize = 0\r
1010     NumberOfLocalTokens = 0\r
1011     NumberOfPeiLocalTokens = 0\r
1012     NumberOfDxeLocalTokens = 0\r
1013     NumberOfExTokens = 0\r
1014     NumberOfSizeItems = 0\r
1015     GuidList = []\r
1016 \r
1017     for Pcd in Platform.DynamicPcdList:\r
1018         CName = Pcd.TokenCName\r
1019         TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName\r
1020 \r
1021         EdkLogger.debug(EdkLogger.DEBUG_3, "PCD: %s %s (%s : %s)" % (CName, TokenSpaceGuidCName, Pcd.Phase, Phase))\r
1022         if Pcd.DatumType not in gDatumSizeStringDatabase:\r
1023             EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Unknown datum type [%s] of PCD %s|%s" % (Pcd.DatumType, Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
1024 \r
1025         if Pcd.Phase == 'PEI':\r
1026             NumberOfPeiLocalTokens += 1\r
1027         if Pcd.Phase == 'DXE':\r
1028             NumberOfDxeLocalTokens += 1\r
1029         if Pcd.Phase != Phase:\r
1030             continue\r
1031 \r
1032         #\r
1033         # TODO: need GetGuidValue() definition\r
1034         #\r
1035         TokenSpaceGuidStructure = Pcd.TokenSpaceGuidValue\r
1036         TokenSpaceGuid = GuidStructureStringToGuidValueName(TokenSpaceGuidStructure)\r
1037         if Pcd.Type in gDynamicExPcd:\r
1038             if TokenSpaceGuid not in GuidList:\r
1039                 GuidList += [TokenSpaceGuid]\r
1040                 Dict['GUID_STRUCTURE'].append(TokenSpaceGuidStructure)\r
1041             NumberOfExTokens += 1\r
1042 \r
1043         ValueList = []\r
1044         StringHeadOffsetList = []\r
1045         VpdHeadOffsetList = []\r
1046         VariableHeadValueList = []\r
1047         Pcd.InitString = 'UNINIT'\r
1048 \r
1049         if Pcd.DatumType == 'VOID*':\r
1050             Pcd.TokenTypeList = ['PCD_DATUM_TYPE_POINTER']\r
1051         elif Pcd.DatumType == 'BOOLEAN':\r
1052             Pcd.TokenTypeList = ['PCD_DATUM_TYPE_UINT8']\r
1053         else:\r
1054             Pcd.TokenTypeList = ['PCD_DATUM_TYPE_' + Pcd.DatumType]\r
1055 \r
1056         if len(Pcd.SkuInfoList) > 1:\r
1057             Pcd.TokenTypeList += ['PCD_TYPE_SKU_ENABLED']\r
1058 \r
1059         for SkuName in Pcd.SkuInfoList:\r
1060             Sku = Pcd.SkuInfoList[SkuName]\r
1061             SkuId = Sku.SkuId\r
1062             if SkuId == None or SkuId == '':\r
1063                 continue\r
1064 \r
1065             if SkuId not in Dict['SKUID_VALUE']:\r
1066                 Dict['SKUID_VALUE'].append(SkuId)\r
1067 \r
1068             SkuIdIndex =   Dict['SKUID_VALUE'].index(SkuId)\r
1069             if len(Sku.VariableName) > 0:\r
1070                 Pcd.TokenTypeList += ['PCD_TYPE_HII']\r
1071                 Pcd.InitString = 'INIT'\r
1072                 VariableNameStructure = '{' + ', '.join(Sku.VariableName.split(" ")) + ', 0x0000}'\r
1073                 if VariableNameStructure not in Dict['STRING_TABLE_VALUE']:\r
1074                     Dict['STRING_TABLE_CNAME'].append(CName)\r
1075                     Dict['STRING_TABLE_GUID'].append(TokenSpaceGuid)\r
1076                     if StringTableIndex == 0:\r
1077                         Dict['STRING_TABLE_INDEX'].append('')\r
1078                     else:\r
1079                         Dict['STRING_TABLE_INDEX'].append('_%d' % StringTableIndex)\r
1080 \r
1081                     Dict['STRING_TABLE_LENGTH'].append(len(Sku.VariableName) + 1)\r
1082                     Dict['STRING_TABLE_VALUE'].append(VariableNameStructure)\r
1083                     StringTableIndex += 1\r
1084                     StringTableSize += len(Sku.VariableName) + 1\r
1085 \r
1086                 VariableHeadStringIndex = 0\r
1087                 for Index in range(Dict['STRING_TABLE_VALUE'].index(VariableNameStructure)):\r
1088                     VariableHeadStringIndex += Dict['STRING_TABLE_LENGTH'][Index]\r
1089 \r
1090                 VariableGuidStructure = Sku.VariableGuidValue\r
1091                 VariableGuid = GuidStructureStringToGuidValueName(VariableGuidStructure)\r
1092                 if VariableGuid not in GuidList:\r
1093                     GuidList += [VariableGuid]\r
1094                     Dict['GUID_STRUCTURE'].append(VariableGuidStructure)\r
1095                 VariableHeadGuidIndex = GuidList.index(VariableGuid)\r
1096 \r
1097                 VariableHeadValueList.append('%d, %d, %s, offsetof(${PHASE}_PCD_DATABASE, Init.%s_%s_VariableDefault_%s)' %\r
1098                                              (VariableHeadGuidIndex, VariableHeadStringIndex, Sku.VariableOffset, CName, TokenSpaceGuid, SkuIdIndex))\r
1099                 Dict['VARDEF_CNAME_'+Pcd.DatumType].append(CName)\r
1100                 Dict['VARDEF_GUID_'+Pcd.DatumType].append(TokenSpaceGuid)\r
1101                 Dict['VARDEF_SKUID_'+Pcd.DatumType].append(SkuIdIndex)\r
1102                 Dict['VARDEF_VALUE_'+Pcd.DatumType].append(Sku.HiiDefaultValue)\r
1103             elif Sku.VpdOffset != '':\r
1104                 Pcd.TokenTypeList += ['PCD_TYPE_VPD']\r
1105                 Pcd.InitString = 'INIT'\r
1106                 VpdHeadOffsetList.append(Sku.VpdOffset)\r
1107             else:\r
1108                 if Pcd.DatumType == 'VOID*':\r
1109                     Pcd.TokenTypeList += ['PCD_TYPE_STRING']\r
1110                     Pcd.InitString = 'INIT'\r
1111                     if Sku.DefaultValue != '':\r
1112                         NumberOfSizeItems += 1\r
1113                         Dict['STRING_TABLE_CNAME'].append(CName)\r
1114                         Dict['STRING_TABLE_GUID'].append(TokenSpaceGuid)\r
1115 \r
1116                         if StringTableIndex == 0:\r
1117                             Dict['STRING_TABLE_INDEX'].append('')\r
1118                         else:\r
1119                             Dict['STRING_TABLE_INDEX'].append('_%d' % StringTableIndex)\r
1120                         if Sku.DefaultValue[0] == 'L':\r
1121                             Size = (len(Sku.DefaultValue) - 3) * 2\r
1122                             Dict['STRING_TABLE_VALUE'].append(Sku.DefaultValue)\r
1123                         elif Sku.DefaultValue[0] == '"':\r
1124                             Size = len(Sku.DefaultValue) - 2\r
1125                             Dict['STRING_TABLE_VALUE'].append(Sku.DefaultValue)\r
1126                         elif Sku.DefaultValue[0] == '{':\r
1127                             Size = len(Sku.DefaultValue.replace(',',' ').split())\r
1128                             Dict['STRING_TABLE_VALUE'].append('{' + Sku.DefaultValue + '}')\r
1129 \r
1130                         StringHeadOffsetList.append(str(StringTableSize))\r
1131                         Dict['SIZE_TABLE_CNAME'].append(CName)\r
1132                         Dict['SIZE_TABLE_GUID'].append(TokenSpaceGuid)\r
1133                         Dict['SIZE_TABLE_CURRENT_LENGTH'].append(Size)\r
1134                         Dict['SIZE_TABLE_MAXIMUM_LENGTH'].append(Pcd.MaxDatumSize)\r
1135                         if Pcd.MaxDatumSize != '':\r
1136                             MaxDatumSize = int(Pcd.MaxDatumSize, 0)\r
1137                             if MaxDatumSize > Size:\r
1138                                 Size = MaxDatumSize\r
1139                         Dict['STRING_TABLE_LENGTH'].append(Size / 2 + 1)\r
1140                         StringTableIndex += 1\r
1141                         StringTableSize += (Size / 2 + 1)\r
1142                 else:\r
1143                     Pcd.TokenTypeList += ['PCD_TYPE_DATA']\r
1144                     if Sku.DefaultValue == 'TRUE':\r
1145                         Pcd.InitString = 'INIT'\r
1146                     else:\r
1147                         try:\r
1148                             if int(Sku.DefaultValue, 0) != 0:\r
1149                                 Pcd.InitString = 'INIT'\r
1150                         except:\r
1151                             pass\r
1152                     ValueList.append(Sku.DefaultValue)\r
1153 \r
1154         Pcd.TokenTypeList = list(set(Pcd.TokenTypeList))\r
1155 \r
1156         if 'PCD_TYPE_HII' in Pcd.TokenTypeList:\r
1157             Dict['VARIABLE_HEAD_CNAME_DECL'].append(CName)\r
1158             Dict['VARIABLE_HEAD_GUID_DECL'].append(TokenSpaceGuid)\r
1159             Dict['VARIABLE_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))\r
1160             Dict['VARIABLE_HEAD_VALUE'].append('{ %s }\n' % ' },\n    { '.join(VariableHeadValueList))\r
1161         if 'PCD_TYPE_VPD' in Pcd.TokenTypeList:\r
1162             Dict['VPD_HEAD_CNAME_DECL'].append(CName)\r
1163             Dict['VPD_HEAD_GUID_DECL'].append(TokenSpaceGuid)\r
1164             Dict['VPD_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))\r
1165             Dict['VPD_HEAD_VALUE'].append('{ %s }' % ' }, { '.join(VpdHeadOffsetList))\r
1166         if 'PCD_TYPE_STRING' in Pcd.TokenTypeList:\r
1167             Dict['STRING_HEAD_CNAME_DECL'].append(CName)\r
1168             Dict['STRING_HEAD_GUID_DECL'].append(TokenSpaceGuid)\r
1169             Dict['STRING_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))\r
1170             Dict['STRING_HEAD_VALUE'].append(', '.join(StringHeadOffsetList))\r
1171         if 'PCD_TYPE_DATA' in Pcd.TokenTypeList:\r
1172             Dict[Pcd.InitString+'_CNAME_DECL_'+Pcd.DatumType].append(CName)\r
1173             Dict[Pcd.InitString+'_GUID_DECL_'+Pcd.DatumType].append(TokenSpaceGuid)\r
1174             Dict[Pcd.InitString+'_NUMSKUS_DECL_'+Pcd.DatumType].append(len(Pcd.SkuInfoList))\r
1175             if Pcd.InitString == 'UNINIT':\r
1176                 Dict['PCD_DATABASE_UNINIT_EMPTY'] = ''\r
1177             else:\r
1178                 Dict[Pcd.InitString+'_VALUE_'+Pcd.DatumType].append(', '.join(ValueList))\r
1179 \r
1180     if Phase == 'PEI':\r
1181         NumberOfLocalTokens = NumberOfPeiLocalTokens\r
1182     if Phase == 'DXE':\r
1183         NumberOfLocalTokens = NumberOfDxeLocalTokens\r
1184 \r
1185     Dict['TOKEN_INIT']       = ['' for x in range(NumberOfLocalTokens)]\r
1186     Dict['TOKEN_CNAME']      = ['' for x in range(NumberOfLocalTokens)]\r
1187     Dict['TOKEN_GUID']       = ['' for x in range(NumberOfLocalTokens)]\r
1188     Dict['TOKEN_TYPE']       = ['' for x in range(NumberOfLocalTokens)]\r
1189 \r
1190     for Pcd in Platform.DynamicPcdList:\r
1191         CName = Pcd.TokenCName\r
1192         TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName\r
1193         if Pcd.Phase != Phase:\r
1194             continue\r
1195 \r
1196         TokenSpaceGuid = GuidStructureStringToGuidValueName(Pcd.TokenSpaceGuidValue) #(Platform.PackageList, TokenSpaceGuidCName))\r
1197         GeneratedTokenNumber = Platform.PcdTokenNumber[CName, TokenSpaceGuidCName] - 1\r
1198         if Phase == 'DXE':\r
1199             GeneratedTokenNumber -= NumberOfPeiLocalTokens\r
1200 \r
1201         EdkLogger.debug(EdkLogger.DEBUG_1, "PCD = %s | %s" % (CName, TokenSpaceGuidCName))\r
1202         EdkLogger.debug(EdkLogger.DEBUG_1, "phase = %s" % Phase)\r
1203         EdkLogger.debug(EdkLogger.DEBUG_1, "GeneratedTokenNumber = %s" % str(GeneratedTokenNumber))\r
1204 \r
1205         Dict['TOKEN_INIT'][GeneratedTokenNumber] = 'Init'\r
1206         if Pcd.InitString == 'UNINIT':\r
1207             Dict['TOKEN_INIT'][GeneratedTokenNumber] = 'Uninit'\r
1208         Dict['TOKEN_CNAME'][GeneratedTokenNumber] = CName\r
1209         Dict['TOKEN_GUID'][GeneratedTokenNumber] = TokenSpaceGuid\r
1210         Dict['TOKEN_TYPE'][GeneratedTokenNumber] = ' | '.join(Pcd.TokenTypeList)\r
1211         if Pcd.Type in gDynamicExPcd:\r
1212             Dict['EXMAPPING_TABLE_EXTOKEN'].append(Pcd.TokenValue)\r
1213             if Phase == 'DXE':\r
1214                 GeneratedTokenNumber += NumberOfPeiLocalTokens\r
1215             Dict['EXMAPPING_TABLE_LOCAL_TOKEN'].append(GeneratedTokenNumber)\r
1216             Dict['EXMAPPING_TABLE_GUID_INDEX'].append(GuidList.index(TokenSpaceGuid))\r
1217 \r
1218     if GuidList != []:\r
1219         Dict['GUID_TABLE_EMPTY'] = 'FALSE'\r
1220         Dict['GUID_TABLE_SIZE'] = len(GuidList)\r
1221     else:\r
1222         Dict['GUID_STRUCTURE'] = [GuidStringToGuidStructureString('00000000-0000-0000-0000-000000000000')]\r
1223 \r
1224     if StringTableIndex == 0:\r
1225         Dict['STRING_TABLE_INDEX'].append('')\r
1226         Dict['STRING_TABLE_LENGTH'].append(1)\r
1227         Dict['STRING_TABLE_CNAME'].append('')\r
1228         Dict['STRING_TABLE_GUID'].append('')\r
1229         Dict['STRING_TABLE_VALUE'].append('{ 0 }')\r
1230     else:\r
1231         Dict['STRING_TABLE_EMPTY'] = 'FALSE'\r
1232         Dict['STRING_TABLE_SIZE'] = StringTableSize\r
1233 \r
1234     if Dict['SIZE_TABLE_CNAME'] == []:\r
1235         Dict['SIZE_TABLE_CNAME'].append('')\r
1236         Dict['SIZE_TABLE_GUID'].append('')\r
1237         Dict['SIZE_TABLE_CURRENT_LENGTH'].append(0)\r
1238         Dict['SIZE_TABLE_MAXIMUM_LENGTH'].append(0)\r
1239 \r
1240     if NumberOfLocalTokens != 0:\r
1241         Dict['DATABASE_EMPTY']                = 'FALSE'\r
1242         Dict['LOCAL_TOKEN_NUMBER_TABLE_SIZE'] = NumberOfLocalTokens\r
1243         Dict['LOCAL_TOKEN_NUMBER']            = NumberOfLocalTokens\r
1244 \r
1245     if NumberOfExTokens != 0:\r
1246         Dict['EXMAP_TABLE_EMPTY']    = 'FALSE'\r
1247         Dict['EXMAPPING_TABLE_SIZE'] = NumberOfExTokens\r
1248         Dict['EX_TOKEN_NUMBER']      = NumberOfExTokens\r
1249     else:\r
1250         Dict['EXMAPPING_TABLE_EXTOKEN'].append(0)\r
1251         Dict['EXMAPPING_TABLE_LOCAL_TOKEN'].append(0)\r
1252         Dict['EXMAPPING_TABLE_GUID_INDEX'].append(0)\r
1253 \r
1254     if NumberOfSizeItems != 0:\r
1255         Dict['SIZE_TABLE_SIZE'] = NumberOfSizeItems * 2\r
1256 \r
1257     AutoGenH.Append(gPcdDatabaseAutoGenH, Dict)\r
1258     if NumberOfLocalTokens == 0:\r
1259         AutoGenC.Append(gEmptyPcdDatabaseAutoGenC, Dict)\r
1260     else:\r
1261         AutoGenC.Append(gPcdDatabaseAutoGenC, Dict)\r
1262 \r
1263     return AutoGenH, AutoGenC\r
1264 \r
1265 ## Create code for PCD database\r
1266 #\r
1267 #   @param      Info        The ModuleBuildInfo object\r
1268 #   @param      AutoGenC    The TemplateString object for C code\r
1269 #   @param      AutoGenH    The TemplateString object for header file\r
1270 #\r
1271 def CreatePcdDatabaseCode (Info, AutoGenC, AutoGenH):\r
1272     if Info.PcdIsDriver == "":\r
1273         return\r
1274     if Info.PcdIsDriver not in gPcdPhaseMap:\r
1275         EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Not supported PcdIsDriver type:%s\n" % Info.PcdIsDriver)\r
1276 \r
1277     AutoGenH.Append(gPcdDatabaseCommonAutoGenH)\r
1278     AdditionalAutoGenH, AdditionalAutoGenC = CreatePcdDatabasePhaseSpecificAutoGen (Info.PlatformInfo, 'PEI')\r
1279     AutoGenH.Append(AdditionalAutoGenH.String)\r
1280 \r
1281     Phase = gPcdPhaseMap[Info.PcdIsDriver]\r
1282     if Phase == 'PEI':\r
1283         AutoGenC.Append(AdditionalAutoGenC.String)\r
1284 \r
1285     if Phase == 'DXE':\r
1286         AdditionalAutoGenH, AdditionalAutoGenC = CreatePcdDatabasePhaseSpecificAutoGen (Info.PlatformInfo, Phase)\r
1287         AutoGenH.Append(AdditionalAutoGenH.String)\r
1288         AutoGenC.Append(AdditionalAutoGenC.String)\r
1289         AutoGenH.Append(gPcdDatabaseEpilogueAutoGenH)\r
1290 \r
1291 ## Create code for library constructor\r
1292 #\r
1293 #   @param      Info        The ModuleBuildInfo object\r
1294 #   @param      AutoGenC    The TemplateString object for C code\r
1295 #   @param      AutoGenH    The TemplateString object for header file\r
1296 #\r
1297 def CreateLibraryConstructorCode(Info, AutoGenC, AutoGenH):\r
1298     if Info.IsLibrary:\r
1299         return\r
1300     #\r
1301     # Library Constructors\r
1302     #\r
1303     ConstructorPrototypeString = TemplateString()\r
1304     ConstructorCallingString = TemplateString()\r
1305     for Lib in Info.DependentLibraryList:\r
1306         if len(Lib.ConstructorList) <= 0:\r
1307             continue\r
1308         Dict = {'Function':Lib.ConstructorList}\r
1309         if Lib.ModuleType == 'BASE':\r
1310             ConstructorPrototypeString.Append(gLibraryStructorPrototype['BASE'], Dict)\r
1311             ConstructorCallingString.Append(gLibraryStructorCall['BASE'], Dict)\r
1312         elif Lib.ModuleType in ['PEI_CORE','PEIM']:\r
1313             ConstructorPrototypeString.Append(gLibraryStructorPrototype['PEI'], Dict)\r
1314             ConstructorCallingString.Append(gLibraryStructorCall['PEI'], Dict)\r
1315         elif Lib.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER','DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION']:\r
1316             ConstructorPrototypeString.Append(gLibraryStructorPrototype['DXE'], Dict)\r
1317             ConstructorCallingString.Append(gLibraryStructorCall['DXE'], Dict)\r
1318 \r
1319     if str(ConstructorPrototypeString) == '':\r
1320         ConstructorPrototypeList = []\r
1321     else:\r
1322         ConstructorPrototypeList = [str(ConstructorPrototypeString)]\r
1323     if str(ConstructorCallingString) == '':\r
1324         ConstructorCallingList = []\r
1325     else:\r
1326         ConstructorCallingList = [str(ConstructorCallingString)]\r
1327 \r
1328     Dict = {\r
1329         'Type'              :   'Constructor',\r
1330         'FunctionPrototype' :   ConstructorPrototypeList,\r
1331         'FunctionCall'      :   ConstructorCallingList\r
1332     }\r
1333     if Info.ModuleType == 'BASE':\r
1334         AutoGenC.Append(gLibraryString['BASE'], Dict)\r
1335     elif Info.ModuleType in ['PEI_CORE','PEIM']:\r
1336         AutoGenC.Append(gLibraryString['PEI'], Dict)\r
1337     elif Info.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER','DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION']:\r
1338         AutoGenC.Append(gLibraryString['DXE'], Dict)\r
1339 \r
1340 ## Create code for library destructor\r
1341 #\r
1342 #   @param      Info        The ModuleBuildInfo object\r
1343 #   @param      AutoGenC    The TemplateString object for C code\r
1344 #   @param      AutoGenH    The TemplateString object for header file\r
1345 #\r
1346 def CreateLibraryDestructorCode(Info, AutoGenC, AutoGenH):\r
1347     if Info.IsLibrary:\r
1348         return\r
1349     #\r
1350     # Library Destructors\r
1351     #\r
1352     DestructorPrototypeString = TemplateString()\r
1353     DestructorCallingString = TemplateString()\r
1354     for Index in range(len(Info.DependentLibraryList)-1, -1, -1):\r
1355         Lib = Info.DependentLibraryList[Index]\r
1356         if len(Lib.DestructorList) <= 0:\r
1357             continue\r
1358         Dict = {'Function':Lib.DestructorList}\r
1359         if Lib.ModuleType == 'BASE':\r
1360             DestructorPrototypeString.Append(gLibraryStructorPrototype['BASE'], Dict)\r
1361             DestructorCallingString.Append(gLibraryStructorCall['BASE'], Dict)\r
1362         elif Lib.ModuleType in ['PEI_CORE','PEIM']:\r
1363             DestructorPrototypeString.Append(gLibraryStructorPrototype['PEI'], Dict)\r
1364             DestructorCallingString.Append(gLibraryStructorCall['PEI'], Dict)\r
1365         elif Lib.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER','DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION']:\r
1366             DestructorPrototypeString.Append(gLibraryStructorPrototype['DXE'], Dict)\r
1367             DestructorCallingString.Append(gLibraryStructorCall['DXE'], Dict)\r
1368 \r
1369     if str(DestructorPrototypeString) == '':\r
1370         DestructorPrototypeList = []\r
1371     else:\r
1372         DestructorPrototypeList = [str(DestructorPrototypeString)]\r
1373     if str(DestructorCallingString) == '':\r
1374         DestructorCallingList = []\r
1375     else:\r
1376         DestructorCallingList = [str(DestructorCallingString)]\r
1377 \r
1378     Dict = {\r
1379         'Type'              :   'Destructor',\r
1380         'FunctionPrototype' :   DestructorPrototypeList,\r
1381         'FunctionCall'      :   DestructorCallingList\r
1382     }\r
1383     if Info.ModuleType == 'BASE':\r
1384         AutoGenC.Append(gLibraryString['BASE'], Dict)\r
1385     elif Info.ModuleType in ['PEI_CORE','PEIM']:\r
1386         AutoGenC.Append(gLibraryString['PEI'], Dict)\r
1387     elif Info.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER','DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION']:\r
1388         AutoGenC.Append(gLibraryString['DXE'], Dict)\r
1389 \r
1390 \r
1391 ## Create code for ModuleEntryPoint\r
1392 #\r
1393 #   @param      Info        The ModuleBuildInfo object\r
1394 #   @param      AutoGenC    The TemplateString object for C code\r
1395 #   @param      AutoGenH    The TemplateString object for header file\r
1396 #\r
1397 def CreateModuleEntryPointCode(Info, AutoGenC, AutoGenH):\r
1398     if Info.IsLibrary or Info.ModuleType == "USER_DEFINED":\r
1399         return\r
1400     #\r
1401     # Module Entry Points\r
1402     #\r
1403     NumEntryPoints = len(Info.Module.ModuleEntryPointList)\r
1404     Dict = {'Function':Info.Module.ModuleEntryPointList}\r
1405 \r
1406     if Info.ModuleType in ['PEI_CORE', 'DXE_CORE']:\r
1407         if NumEntryPoints != 1:\r
1408             EdkLogger.error("AutoGen", AUTOGEN_ERROR, '%s must have exactly one entry point' % Info.ModuleType,\r
1409                             ExtraData=", ".join(Info.Module.ModuleEntryPointList))\r
1410     if Info.ModuleType == 'PEI_CORE':\r
1411         AutoGenC.Append(gPeiCoreEntryPointString, Dict)\r
1412     elif Info.ModuleType == 'DXE_CORE':\r
1413         AutoGenC.Append(gDxeCoreEntryPointString, Dict)\r
1414     elif Info.ModuleType == 'PEIM':\r
1415         if NumEntryPoints < 2:\r
1416             AutoGenC.Append(gPeimEntryPointString[NumEntryPoints], Dict)\r
1417         else:\r
1418             AutoGenC.Append(gPeimEntryPointString[2], Dict)\r
1419     elif Info.ModuleType in ['DXE_RUNTIME_DRIVER','DXE_DRIVER','DXE_SMM_DRIVER', 'DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION']:\r
1420         if Info.ModuleType == 'DXE_SMM_DRIVER':\r
1421             if NumEntryPoints == 0:\r
1422                 AutoGenC.Append(gDxeSmmEntryPointString[0], Dict)\r
1423             else:\r
1424                 AutoGenC.Append(gDxeSmmEntryPointString[1], Dict)\r
1425         else:\r
1426             if NumEntryPoints < 2:\r
1427                 AutoGenC.Append(gUefiEntryPointString[NumEntryPoints], Dict)\r
1428             else:\r
1429                 AutoGenC.Append(gUefiEntryPointString[2], Dict)\r
1430 \r
1431 ## Create code for ModuleUnloadImage\r
1432 #\r
1433 #   @param      Info        The ModuleBuildInfo object\r
1434 #   @param      AutoGenC    The TemplateString object for C code\r
1435 #   @param      AutoGenH    The TemplateString object for header file\r
1436 #\r
1437 def CreateModuleUnloadImageCode(Info, AutoGenC, AutoGenH):\r
1438     if Info.IsLibrary or Info.ModuleType == "USER_DEFINED":\r
1439         return\r
1440     #\r
1441     # Unload Image Handlers\r
1442     #\r
1443     NumUnloadImage = len(Info.Module.ModuleUnloadImageList)\r
1444     Dict = {'Count':NumUnloadImage, 'Function':Info.Module.ModuleUnloadImageList}\r
1445     if NumUnloadImage < 2:\r
1446         AutoGenC.Append(gUefiUnloadImageString[NumUnloadImage], Dict)\r
1447     else:\r
1448         AutoGenC.Append(gUefiUnloadImageString[2], Dict)\r
1449 \r
1450 ## Create code for GUID\r
1451 #\r
1452 #   @param      Info        The ModuleBuildInfo object\r
1453 #   @param      AutoGenC    The TemplateString object for C code\r
1454 #   @param      AutoGenH    The TemplateString object for header file\r
1455 #\r
1456 def CreateGuidDefinitionCode(Info, AutoGenC, AutoGenH):\r
1457     if Info.IsLibrary:\r
1458         return\r
1459 \r
1460     if Info.ModuleType in ["USER_DEFINED", "BASE"]:\r
1461         GuidType = "GUID"\r
1462     else:\r
1463         GuidType = "EFI_GUID"\r
1464 \r
1465     #\r
1466     # GUIDs\r
1467     #\r
1468     for Key in Info.GuidList:\r
1469         AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.GuidList[Key]))\r
1470 \r
1471 ## Create code for protocol\r
1472 #\r
1473 #   @param      Info        The ModuleBuildInfo object\r
1474 #   @param      AutoGenC    The TemplateString object for C code\r
1475 #   @param      AutoGenH    The TemplateString object for header file\r
1476 #\r
1477 def CreateProtocolDefinitionCode(Info, AutoGenC, AutoGenH):\r
1478     if Info.IsLibrary:\r
1479         return\r
1480 \r
1481     if Info.ModuleType in ["USER_DEFINED", "BASE"]:\r
1482         GuidType = "GUID"\r
1483     else:\r
1484         GuidType = "EFI_GUID"\r
1485 \r
1486     #\r
1487     # Protocol GUIDs\r
1488     #\r
1489     for Key in Info.ProtocolList:\r
1490         AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.ProtocolList[Key]))\r
1491 \r
1492 ## Create code for PPI\r
1493 #\r
1494 #   @param      Info        The ModuleBuildInfo object\r
1495 #   @param      AutoGenC    The TemplateString object for C code\r
1496 #   @param      AutoGenH    The TemplateString object for header file\r
1497 #\r
1498 def CreatePpiDefinitionCode(Info, AutoGenC, AutoGenH):\r
1499     if Info.IsLibrary:\r
1500         return\r
1501 \r
1502     if Info.ModuleType in ["USER_DEFINED", "BASE"]:\r
1503         GuidType = "GUID"\r
1504     else:\r
1505         GuidType = "EFI_GUID"\r
1506 \r
1507     #\r
1508     # PPI GUIDs\r
1509     #\r
1510     for Key in Info.PpiList:\r
1511         AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.PpiList[Key]))\r
1512 \r
1513 ## Create code for PCD\r
1514 #\r
1515 #   @param      Info        The ModuleBuildInfo object\r
1516 #   @param      AutoGenC    The TemplateString object for C code\r
1517 #   @param      AutoGenH    The TemplateString object for header file\r
1518 #\r
1519 def CreatePcdCode(Info, AutoGenC, AutoGenH):\r
1520     if Info.IsLibrary:\r
1521         for Pcd in Info.PcdList:\r
1522             CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd)\r
1523     else:\r
1524         for Pcd in Info.PcdList:\r
1525             CreateModulePcdCode(Info, AutoGenC, AutoGenH, Pcd)\r
1526     CreatePcdDatabaseCode(Info, AutoGenC, AutoGenH)\r
1527 \r
1528 ## Create code for unicode string definition\r
1529 #\r
1530 #   @param      Info        The ModuleBuildInfo object\r
1531 #   @param      AutoGenC    The TemplateString object for C code\r
1532 #   @param      AutoGenH    The TemplateString object for header file\r
1533 #\r
1534 def CreateUnicodeStringCode(Info, AutoGenC, AutoGenH):\r
1535     if len(Info.UnicodeFileList) == 0:\r
1536         return\r
1537 \r
1538     WorkingDir = os.getcwd()\r
1539     os.chdir(Info.WorkspaceDir)\r
1540 \r
1541     #IncList = [os.path.join(Info.WorkspaceDir, Inc) for Inc in Info.IncludePathList]\r
1542     IncList = [Info.SourceDir]\r
1543     SrcList = [F[0] for F in Info.SourceFileList]\r
1544     Header, Code = GetStringFiles(Info.UnicodeFileList, SrcList, IncList, ['.uni'], Info.Name)\r
1545     AutoGenC.Append("\n//\n//Unicode String Pack Definition\n//\n")\r
1546     AutoGenC.Append(Code)\r
1547     AutoGenC.Append("\n")\r
1548     AutoGenH.Append("\n//\n//Unicode String ID\n//\n")\r
1549     AutoGenH.Append(Header)\r
1550     AutoGenH.Append("\n#define STRING_ARRAY_NAME %sStrings\n" % Info.Name)\r
1551     os.chdir(WorkingDir)\r
1552 \r
1553 ## Create common code\r
1554 #\r
1555 #   @param      Info        The ModuleBuildInfo object\r
1556 #   @param      AutoGenC    The TemplateString object for C code\r
1557 #   @param      AutoGenH    The TemplateString object for header file\r
1558 #\r
1559 def CreateHeaderCode(Info, AutoGenC, AutoGenH):\r
1560     # file header\r
1561     AutoGenH.Append(gAutoGenHeaderString,   {'FileName':'AutoGen.h'})\r
1562     # header file Prologue\r
1563     AutoGenH.Append(gAutoGenHPrologueString,{'Guid':Info.Guid.replace('-','_')})\r
1564     if Info.AutoGenVersion >= 0x00010005:\r
1565         # specification macros\r
1566         AutoGenH.Append(gSpecificationString,   {'SpecificationName':Info.Macro.keys(), \r
1567                                                  'SpecificationValue':Info.Macro.values()})\r
1568         # header files includes\r
1569         AutoGenH.Append("#include <%s>\n\n" % gBasicHeaderFile)\r
1570         AutoGenH.Append('\nextern GUID  gEfiCallerIdGuid;\n\n')\r
1571     \r
1572         if Info.IsLibrary:\r
1573             return\r
1574     \r
1575         AutoGenH.Append("#define EFI_CALLER_ID_GUID \\\n  %s\n" % GuidStringToGuidStructureString(Info.Guid))\r
1576     \r
1577     if Info.IsLibrary:\r
1578         return\r
1579     # C file header\r
1580     AutoGenC.Append(gAutoGenHeaderString, {'FileName':'AutoGen.c'})\r
1581     if Info.AutoGenVersion >= 0x00010005:\r
1582         # C file header files includes\r
1583         for Inc in gModuleTypeHeaderFile[Info.ModuleType]:\r
1584             AutoGenC.Append("#include <%s>\n" % Inc)\r
1585     \r
1586         #\r
1587         # Publish the CallerId Guid\r
1588         #\r
1589         AutoGenC.Append('\nGLOBAL_REMOVE_IF_UNREFERENCED GUID gEfiCallerIdGuid = %s;\n' % GuidStringToGuidStructureString(Info.Guid))\r
1590     else:\r
1591         # R8 modules my have nothing in the AutoGen.c. So it needs following line\r
1592         AutoGenC.Append('\nextern int __make_me_compile_correctly;\n\n')\r
1593 \r
1594 \r
1595 ## Create common code for header file\r
1596 #\r
1597 #   @param      Info        The ModuleBuildInfo object\r
1598 #   @param      AutoGenC    The TemplateString object for C code\r
1599 #   @param      AutoGenH    The TemplateString object for header file\r
1600 #\r
1601 def CreateFooterCode(Info, AutoGenC, AutoGenH):\r
1602     AutoGenH.Append(gAutoGenHEpilogueString)\r
1603 \r
1604 ## Create code for a module\r
1605 #\r
1606 #   @param      Info        The ModuleBuildInfo object\r
1607 #   @param      AutoGenC    The TemplateString object for C code\r
1608 #   @param      AutoGenH    The TemplateString object for header file\r
1609 #\r
1610 def CreateCode(Info, AutoGenC, AutoGenH):\r
1611     CreateHeaderCode(Info, AutoGenC, AutoGenH)\r
1612 \r
1613     if Info.AutoGenVersion >= 0x00010005:\r
1614         CreateLibraryConstructorCode(Info, AutoGenC, AutoGenH)\r
1615         CreateLibraryDestructorCode(Info, AutoGenC, AutoGenH)\r
1616         CreateModuleEntryPointCode(Info, AutoGenC, AutoGenH)\r
1617         CreateModuleUnloadImageCode(Info, AutoGenC, AutoGenH)\r
1618         CreateGuidDefinitionCode(Info, AutoGenC, AutoGenH)\r
1619         CreateProtocolDefinitionCode(Info, AutoGenC, AutoGenH)\r
1620         CreatePpiDefinitionCode(Info, AutoGenC, AutoGenH)\r
1621         CreatePcdCode(Info, AutoGenC, AutoGenH)\r
1622     CreateUnicodeStringCode(Info, AutoGenC, AutoGenH)\r
1623 \r
1624     CreateFooterCode(Info, AutoGenC, AutoGenH)\r
1625 \r
1626 ## Create the code file\r
1627 #\r
1628 #   @param      FilePath    The path of code file\r
1629 #   @param      Content     The content of code file\r
1630 #\r
1631 #   @retval     True        If file content is changed or file doesn't exist\r
1632 #   @retval     False       If the file exists and the content is not changed\r
1633 #\r
1634 def Generate(FilePath, Content):\r
1635     return SaveFileOnChange(FilePath, Content)\r