a. Added binary file support during AutoGen
[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 ## Find value for the given GUID C name\r
770 #\r
771 #   @param      Packages    The list of package object\r
772 #   @param      CName       The C name of the GUID\r
773 #   @retval     string      The value string of given GUID\r
774 #\r
775 def GetGuidValue(Packages, CName):\r
776     for P in Packages:\r
777         if CName in P.Guids:\r
778             return P.Guids[CName]\r
779         if CName in P.Protocols:\r
780             return P.Protocols[CName]\r
781         if CName in P.Ppis:\r
782             return P.Ppis[CName]\r
783     else:\r
784         PackageListString = "\t" + "\n\t".join([str(P) for P in Packages])\r
785         EdkLogger.error("AutoGen", AUTOGEN_ERROR,\r
786                         "Cannot find GUID value for %s in all given packages" % CName,\r
787                         ExtraData=PackageListString)\r
788 \r
789 ## Create code for module PCDs\r
790 #\r
791 #   @param      Info        The ModuleBuildInfo object\r
792 #   @param      AutoGenC    The TemplateString object for C code\r
793 #   @param      AutoGenH    The TemplateString object for header file\r
794 #   @param      Pcd         The PCD object\r
795 #\r
796 def CreateModulePcdCode(Info, AutoGenC, AutoGenH, Pcd):\r
797     TokenSpaceGuidValue = GetGuidValue(Info.PlatformInfo.PackageList, Pcd.TokenSpaceGuidCName)\r
798     PcdTokenNumber = Info.PlatformInfo.PcdTokenNumber\r
799     #\r
800     # Write PCDs\r
801     #\r
802     PcdTokenName = '_PCD_TOKEN_' + Pcd.TokenCName\r
803     if Pcd.Type in gDynamicExPcd:\r
804         TokenNumber = int(Pcd.TokenValue, 0)\r
805     else:\r
806         if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in PcdTokenNumber:\r
807             EdkLogger.error("AutoGen", AUTOGEN_ERROR, "No generated token number for %s|%s\n" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
808         TokenNumber = PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName]\r
809     AutoGenH.Append('#define %s  %d\n' % (PcdTokenName, TokenNumber))\r
810 \r
811     EdkLogger.debug(EdkLogger.DEBUG_3, "Creating code for " + Pcd.TokenCName + "|" + Pcd.TokenSpaceGuidCName)\r
812     if Pcd.Type not in gItemTypeStringDatabase:\r
813         EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Unknown PCD type [%s] of PCD %s|%s" % (Pcd.Type, Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
814     if Pcd.DatumType not in gDatumSizeStringDatabase:\r
815         EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Unknown datum type [%s] of PCD %s|%s" % (Pcd.DatumType, Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
816 \r
817     DatumSize = gDatumSizeStringDatabase[Pcd.DatumType]\r
818     DatumSizeLib = gDatumSizeStringDatabaseLib[Pcd.DatumType]\r
819     GetModeName = '_PCD_GET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + Pcd.TokenCName\r
820     SetModeName = '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + Pcd.TokenCName\r
821 \r
822     if Pcd.Type in gDynamicExPcd:\r
823         AutoGenH.Append('#define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))\r
824         if Pcd.DatumType == 'VOID*':\r
825             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))\r
826         else:\r
827             AutoGenH.Append('#define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))\r
828     elif Pcd.Type in gDynamicPcd:\r
829         AutoGenH.Append('#define %s  LibPcdGet%s(%s)\n' % (GetModeName, DatumSizeLib, PcdTokenName))\r
830         if Pcd.DatumType == 'VOID*':\r
831             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSet%s(%s, (SizeOfBuffer), (Buffer))\n' %(SetModeName, DatumSizeLib, PcdTokenName))\r
832         else:\r
833             AutoGenH.Append('#define %s(Value)  LibPcdSet%s(%s, (Value))\n' % (SetModeName, DatumSizeLib, PcdTokenName))\r
834     else:\r
835         PcdVariableName = '_gPcd_' + gItemTypeStringDatabase[Pcd.Type] + '_' + Pcd.TokenCName\r
836         Const = 'const'\r
837         if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:\r
838             Const = ''\r
839         Type = ''\r
840         Array = ''\r
841         Value = Pcd.DefaultValue\r
842         if Pcd.DatumType == 'UINT64':\r
843             if not Value.endswith('ULL'):\r
844                 Value += 'ULL'\r
845         if Pcd.DatumType == 'VOID*':\r
846             if Pcd.MaxDatumSize == None or Pcd.MaxDatumSize == '':\r
847                 EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Unknown [MaxDatumSize] of PCD [%s.%s]" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName))\r
848 \r
849             ArraySize = int(Pcd.MaxDatumSize, 0)\r
850             if Value[0] == '{':\r
851                 Type = '(VOID *)'\r
852             else:\r
853                 Unicode = False\r
854                 if Value[0] == 'L':\r
855                     Unicode = True\r
856                 Value = Value.lstrip('L').strip('"')\r
857                 NewValue = '{'\r
858                 for Index in range(0,len(Value)):\r
859                     NewValue = NewValue + str(ord(Value[Index]) % 0x100) + ', '\r
860                     if Unicode:\r
861                         NewValue = NewValue + str(ord(Value[Index]) / 0x100) + ', '\r
862                 if Unicode:\r
863                     if ArraySize < (len(Value)*2 + 2):\r
864                         ArraySize = len(Value)*2 + 2\r
865                     NewValue = NewValue + '0, '\r
866                 else:\r
867                     if ArraySize < (len(Value) + 1):\r
868                         ArraySize = len(Value) + 1\r
869                 Value = NewValue + '0 }'\r
870             Array = '[%d]' % ArraySize\r
871 \r
872         PcdValueName = '_PCD_VALUE_' + Pcd.TokenCName\r
873         if Pcd.DatumType == 'VOID*' and Value[0] == '{':\r
874             AutoGenH.Append('#define _PCD_PATCHABLE_%s_SIZE %s\n' % (Pcd.TokenCName, Pcd.MaxDatumSize))\r
875             AutoGenH.Append('#define %s  %s%s\n' %(PcdValueName, Type, PcdVariableName))\r
876             AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s UINT8 %s%s = %s;\n' % (Const, PcdVariableName, Array, Value))\r
877             AutoGenH.Append('extern %s UINT8 %s%s;\n' %(Const, PcdVariableName, Array))\r
878             AutoGenH.Append('#define %s  %s%s\n' %(GetModeName, Type, PcdVariableName))\r
879         else:\r
880             AutoGenH.Append('#define %s  %s\n' %(PcdValueName, Value))\r
881             AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s %s = %s;\n' %(Const, Pcd.DatumType, PcdVariableName, PcdValueName))\r
882             AutoGenH.Append('extern %s  %s  %s%s;\n' % (Const, Pcd.DatumType, PcdVariableName, Array))\r
883             AutoGenH.Append('#define %s  %s%s\n' % (GetModeName, Type, PcdVariableName))\r
884 \r
885         if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:\r
886             if Pcd.DatumType == 'VOID*':\r
887                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPatchPcdSetPtr(_gPcd_BinaryPatch_%s, (UINTN)_PCD_PATCHABLE_%s_SIZE, (SizeOfBuffer), (Buffer))\n' % (SetModeName, Pcd.TokenCName, Pcd.TokenCName))\r
888             else:\r
889                 AutoGenH.Append('#define %s(Value)  (%s = (Value))\n' % (SetModeName, PcdVariableName))\r
890         else:\r
891             AutoGenH.Append('//#define %s  ASSERT(FALSE)  // It is not allowed to set value for a FIXED_AT_BUILD PCD\n' % SetModeName)\r
892 \r
893 ## Create code for library module PCDs\r
894 #\r
895 #   @param      Info        The ModuleBuildInfo object\r
896 #   @param      AutoGenC    The TemplateString object for C code\r
897 #   @param      AutoGenH    The TemplateString object for header file\r
898 #   @param      Pcd         The PCD object\r
899 #\r
900 def CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd):\r
901     PcdTokenNumber = Info.PlatformInfo.PcdTokenNumber\r
902     TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName\r
903     TokenCName  = Pcd.TokenCName\r
904     TokenSpaceGuidValue = GetGuidValue(Info.PlatformInfo.PackageList, TokenSpaceGuidCName)\r
905     if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in PcdTokenNumber:\r
906         EdkLogger.error("AutoGen", AUTOGEN_ERROR, "No generated token number for %s|%s\n" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
907     TokenNumber = PcdTokenNumber[TokenCName, TokenSpaceGuidCName]\r
908 \r
909     if Pcd.Type not in gItemTypeStringDatabase:\r
910         EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Unknown PCD type [%s] of PCD %s|%s" % (Pcd.Type, Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
911     if Pcd.DatumType not in gDatumSizeStringDatabase:\r
912         EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Unknown datum type [%s] of PCD %s|%s" % (Pcd.DatumType, Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
913 \r
914     DatumType   = Pcd.DatumType\r
915     DatumSize   = gDatumSizeStringDatabaseH[DatumType]\r
916     DatumSizeLib= gDatumSizeStringDatabaseLib[DatumType]\r
917     GetModeName = '_PCD_GET_MODE_' + DatumSize + '_' + TokenCName\r
918     SetModeName = '_PCD_SET_MODE_' + DatumSize + '_' + TokenCName\r
919 \r
920     Type = ''\r
921     Array = ''\r
922     if Pcd.DatumType == 'VOID*':\r
923         Type = '(VOID *)'\r
924         Array = '[]'\r
925 \r
926     AutoGenH.Append('#define _PCD_TOKEN_%s  %d\n' % (TokenCName, TokenNumber))\r
927 \r
928     PcdItemType = Pcd.Type\r
929     #if PcdItemType in gDynamicPcd:\r
930     #    PcdItemType = TAB_PCDS_FIXED_AT_BUILD\r
931     #    if (TokenCName, TokenSpaceGuidCName) in Info.PlatformInfo.Platform.Pcds:\r
932     #        PcdItemType  = Info.PlatformInfo.Platform.Pcds[TokenCName, TokenSpaceGuidCName].Type\r
933     if PcdItemType in gDynamicExPcd:\r
934         PcdTokenName = '_PCD_TOKEN_' + TokenCName\r
935         AutoGenH.Append('#define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, TokenSpaceGuidCName, PcdTokenName))\r
936         if DatumType == 'VOID*':\r
937             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName,DatumSizeLib, TokenSpaceGuidCName, PcdTokenName))\r
938         else:\r
939             AutoGenH.Append('#define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, TokenSpaceGuidCName, PcdTokenName))\r
940     if PcdItemType in gDynamicPcd:\r
941         PcdTokenName = '_PCD_TOKEN_' + TokenCName\r
942         AutoGenH.Append('#define %s  LibPcdGet%s(%s)\n' % (GetModeName, DatumSizeLib, PcdTokenName))\r
943         if DatumType == 'VOID*':\r
944             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSet%s(%s, (SizeOfBuffer), (Buffer))\n' %(SetModeName, DatumSizeLib, PcdTokenName))\r
945         else:\r
946             AutoGenH.Append('#define %s(Value)  LibPcdSet%s(%s, (Value))\n' % (SetModeName, DatumSizeLib, PcdTokenName))\r
947     if PcdItemType == TAB_PCDS_PATCHABLE_IN_MODULE:\r
948         PcdVariableName = '_gPcd_' + gItemTypeStringDatabase[TAB_PCDS_PATCHABLE_IN_MODULE] + '_' + TokenCName\r
949         AutoGenH.Append('extern %s _gPcd_BinaryPatch_%s%s;\n' %(DatumType, TokenCName, Array) )\r
950         AutoGenH.Append('#define %s  %s_gPcd_BinaryPatch_%s\n' %(GetModeName, Type, TokenCName))\r
951         AutoGenH.Append('#define %s(Value)  (%s = (Value))\n' % (SetModeName, PcdVariableName))\r
952     if PcdItemType == TAB_PCDS_FIXED_AT_BUILD or PcdItemType == TAB_PCDS_FEATURE_FLAG:\r
953         AutoGenH.Append('extern const %s _gPcd_FixedAtBuild_%s%s;\n' %(DatumType, TokenCName, Array))\r
954         AutoGenH.Append('#define %s  %s_gPcd_FixedAtBuild_%s\n' %(GetModeName, Type, TokenCName))\r
955         AutoGenH.Append('//#define %s  ASSERT(FALSE)  // It is not allowed to set value for a FIXED_AT_BUILD PCD\n' % SetModeName)\r
956 \r
957 ## Create code for PCD database in DXE or PEI phase\r
958 #\r
959 #   @param      Platform    The platform object\r
960 #   @retval     tuple       Two TemplateString objects for C code and header file,\r
961 #                           respectively\r
962 #\r
963 def CreatePcdDatabasePhaseSpecificAutoGen (Platform, Phase):\r
964     AutoGenC = TemplateString()\r
965     AutoGenH = TemplateString()\r
966 \r
967     Dict = {\r
968         'PHASE'                         : Phase,\r
969         'GUID_TABLE_SIZE'               : '1',\r
970         'STRING_TABLE_SIZE'             : '1',\r
971         'SKUID_TABLE_SIZE'              : '1',\r
972         'LOCAL_TOKEN_NUMBER_TABLE_SIZE' : '1',\r
973         'LOCAL_TOKEN_NUMBER'            : '0',\r
974         'EXMAPPING_TABLE_SIZE'          : '1',\r
975         'EX_TOKEN_NUMBER'               : '0',\r
976         'SIZE_TABLE_SIZE'               : '2',\r
977         'GUID_TABLE_EMPTY'              : 'TRUE',\r
978         'STRING_TABLE_EMPTY'            : 'TRUE',\r
979         'SKUID_TABLE_EMPTY'             : 'TRUE',\r
980         'DATABASE_EMPTY'                : 'TRUE',\r
981         'EXMAP_TABLE_EMPTY'             : 'TRUE',\r
982         'PCD_DATABASE_UNINIT_EMPTY'     : '  UINT8  dummy; /* PCD_DATABASE_UNINIT is emptry */',\r
983         'SYSTEM_SKU_ID'                 : '  SKU_ID             SystemSkuId;',\r
984         'SYSTEM_SKU_ID_VALUE'           : '0'\r
985     }\r
986 \r
987     for DatumType in ['UINT64','UINT32','UINT16','UINT8','BOOLEAN']:\r
988         Dict['VARDEF_CNAME_' + DatumType] = []\r
989         Dict['VARDEF_GUID_' + DatumType]  = []\r
990         Dict['VARDEF_SKUID_' + DatumType] = []\r
991         Dict['VARDEF_VALUE_' + DatumType] = []\r
992         for Init in ['INIT','UNINIT']:\r
993             Dict[Init+'_CNAME_DECL_' + DatumType]   = []\r
994             Dict[Init+'_GUID_DECL_' + DatumType]    = []\r
995             Dict[Init+'_NUMSKUS_DECL_' + DatumType] = []\r
996             Dict[Init+'_VALUE_' + DatumType]        = []\r
997 \r
998     for Type in ['STRING_HEAD','VPD_HEAD','VARIABLE_HEAD']:\r
999         Dict[Type + '_CNAME_DECL']   = []\r
1000         Dict[Type + '_GUID_DECL']    = []\r
1001         Dict[Type + '_NUMSKUS_DECL'] = []\r
1002         Dict[Type + '_VALUE'] = []\r
1003 \r
1004     Dict['STRING_TABLE_INDEX'] = []\r
1005     Dict['STRING_TABLE_LENGTH']  = []\r
1006     Dict['STRING_TABLE_CNAME'] = []\r
1007     Dict['STRING_TABLE_GUID']  = []\r
1008     Dict['STRING_TABLE_VALUE'] = []\r
1009 \r
1010     Dict['SIZE_TABLE_CNAME'] = []\r
1011     Dict['SIZE_TABLE_GUID']  = []\r
1012     Dict['SIZE_TABLE_CURRENT_LENGTH']  = []\r
1013     Dict['SIZE_TABLE_MAXIMUM_LENGTH']  = []\r
1014 \r
1015     Dict['EXMAPPING_TABLE_EXTOKEN'] = []\r
1016     Dict['EXMAPPING_TABLE_LOCAL_TOKEN'] = []\r
1017     Dict['EXMAPPING_TABLE_GUID_INDEX'] = []\r
1018 \r
1019     Dict['GUID_STRUCTURE'] = []\r
1020 \r
1021     Dict['SKUID_VALUE'] = []\r
1022 \r
1023     if Phase == 'DXE':\r
1024         Dict['SYSTEM_SKU_ID'] = ''\r
1025         Dict['SYSTEM_SKU_ID_VALUE'] = ''\r
1026 \r
1027     StringTableIndex = 0\r
1028     StringTableSize = 0\r
1029     NumberOfLocalTokens = 0\r
1030     NumberOfPeiLocalTokens = 0\r
1031     NumberOfDxeLocalTokens = 0\r
1032     NumberOfExTokens = 0\r
1033     NumberOfSizeItems = 0\r
1034     GuidList = []\r
1035 \r
1036     for Pcd in Platform.DynamicPcdList:\r
1037         CName = Pcd.TokenCName\r
1038         TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName\r
1039 \r
1040         EdkLogger.debug(EdkLogger.DEBUG_3, "PCD: %s %s (%s : %s)" % (CName, TokenSpaceGuidCName, Pcd.Phase, Phase))\r
1041         if Pcd.DatumType not in gDatumSizeStringDatabase:\r
1042             EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Unknown datum type [%s] of PCD %s|%s" % (Pcd.DatumType, Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
1043 \r
1044         if Pcd.Phase == 'PEI':\r
1045             NumberOfPeiLocalTokens += 1\r
1046         if Pcd.Phase == 'DXE':\r
1047             NumberOfDxeLocalTokens += 1\r
1048         if Pcd.Phase != Phase:\r
1049             continue\r
1050 \r
1051         #\r
1052         # TODO: need GetGuidValue() definition\r
1053         #\r
1054         TokenSpaceGuidStructure = GetGuidValue(Platform.PackageList, TokenSpaceGuidCName)\r
1055         TokenSpaceGuid = GuidStructureStringToGuidValueName(TokenSpaceGuidStructure)\r
1056         if Pcd.Type in gDynamicExPcd:\r
1057             if TokenSpaceGuid not in GuidList:\r
1058                 GuidList += [TokenSpaceGuid]\r
1059                 Dict['GUID_STRUCTURE'].append(TokenSpaceGuidStructure)\r
1060             NumberOfExTokens += 1\r
1061 \r
1062         ValueList = []\r
1063         StringHeadOffsetList = []\r
1064         VpdHeadOffsetList = []\r
1065         VariableHeadValueList = []\r
1066         Pcd.InitString = 'UNINIT'\r
1067 \r
1068         if Pcd.DatumType == 'VOID*':\r
1069             Pcd.TokenTypeList = ['PCD_DATUM_TYPE_POINTER']\r
1070         elif Pcd.DatumType == 'BOOLEAN':\r
1071             Pcd.TokenTypeList = ['PCD_DATUM_TYPE_UINT8']\r
1072         else:\r
1073             Pcd.TokenTypeList = ['PCD_DATUM_TYPE_' + Pcd.DatumType]\r
1074 \r
1075         if len(Pcd.SkuInfoList) > 1:\r
1076             Pcd.TokenTypeList += ['PCD_TYPE_SKU_ENABLED']\r
1077 \r
1078         for SkuName in Pcd.SkuInfoList:\r
1079             Sku = Pcd.SkuInfoList[SkuName]\r
1080             SkuId = Sku.SkuId\r
1081             if SkuId == None or SkuId == '':\r
1082                 continue\r
1083 \r
1084             if SkuId not in Dict['SKUID_VALUE']:\r
1085                 Dict['SKUID_VALUE'].append(SkuId)\r
1086 \r
1087             SkuIdIndex =   Dict['SKUID_VALUE'].index(SkuId)\r
1088             if len(Sku.VariableName) > 0:\r
1089                 Pcd.TokenTypeList += ['PCD_TYPE_HII']\r
1090                 Pcd.InitString = 'INIT'\r
1091                 VariableNameStructure = '{' + ', '.join(Sku.VariableName.split(" ")) + ', 0x0000}'\r
1092                 if VariableNameStructure not in Dict['STRING_TABLE_VALUE']:\r
1093                     Dict['STRING_TABLE_CNAME'].append(CName)\r
1094                     Dict['STRING_TABLE_GUID'].append(TokenSpaceGuid)\r
1095                     if StringTableIndex == 0:\r
1096                         Dict['STRING_TABLE_INDEX'].append('')\r
1097                     else:\r
1098                         Dict['STRING_TABLE_INDEX'].append('_%d' % StringTableIndex)\r
1099 \r
1100                     Dict['STRING_TABLE_LENGTH'].append(len(Sku.VariableName) + 1)\r
1101                     Dict['STRING_TABLE_VALUE'].append(VariableNameStructure)\r
1102                     StringTableIndex += 1\r
1103                     StringTableSize += len(Sku.VariableName) + 1\r
1104 \r
1105                 VariableHeadStringIndex = 0\r
1106                 for Index in range(Dict['STRING_TABLE_VALUE'].index(VariableNameStructure)):\r
1107                     VariableHeadStringIndex += Dict['STRING_TABLE_LENGTH'][Index]\r
1108 \r
1109                 VariableGuidStructure = GetGuidValue(Platform.PackageList, Sku.VariableGuid)\r
1110                 VariableGuid = GuidStructureStringToGuidValueName(VariableGuidStructure)\r
1111                 if VariableGuid not in GuidList:\r
1112                     GuidList += [VariableGuid]\r
1113                     Dict['GUID_STRUCTURE'].append(VariableGuidStructure)\r
1114                 VariableHeadGuidIndex = GuidList.index(VariableGuid)\r
1115 \r
1116                 VariableHeadValueList.append('%d, %d, %s, offsetof(${PHASE}_PCD_DATABASE, Init.%s_%s_VariableDefault_%s)' %\r
1117                                              (VariableHeadGuidIndex, VariableHeadStringIndex, Sku.VariableOffset, CName, TokenSpaceGuid, SkuIdIndex))\r
1118                 Dict['VARDEF_CNAME_'+Pcd.DatumType].append(CName)\r
1119                 Dict['VARDEF_GUID_'+Pcd.DatumType].append(TokenSpaceGuid)\r
1120                 Dict['VARDEF_SKUID_'+Pcd.DatumType].append(SkuIdIndex)\r
1121                 Dict['VARDEF_VALUE_'+Pcd.DatumType].append(Sku.HiiDefaultValue)\r
1122             elif Sku.VpdOffset != '':\r
1123                 Pcd.TokenTypeList += ['PCD_TYPE_VPD']\r
1124                 Pcd.InitString = 'INIT'\r
1125                 VpdHeadOffsetList.append(Sku.VpdOffset)\r
1126             else:\r
1127                 if Pcd.DatumType == 'VOID*':\r
1128                     Pcd.TokenTypeList += ['PCD_TYPE_STRING']\r
1129                     Pcd.InitString = 'INIT'\r
1130                     if Sku.DefaultValue != '':\r
1131                         NumberOfSizeItems += 1\r
1132                         Dict['STRING_TABLE_CNAME'].append(CName)\r
1133                         Dict['STRING_TABLE_GUID'].append(TokenSpaceGuid)\r
1134 \r
1135                         if StringTableIndex == 0:\r
1136                             Dict['STRING_TABLE_INDEX'].append('')\r
1137                         else:\r
1138                             Dict['STRING_TABLE_INDEX'].append('_%d' % StringTableIndex)\r
1139                         if Sku.DefaultValue[0] == 'L':\r
1140                             Size = (len(Sku.DefaultValue) - 3) * 2\r
1141                             Dict['STRING_TABLE_VALUE'].append(Sku.DefaultValue)\r
1142                         elif Sku.DefaultValue[0] == '"':\r
1143                             Size = len(Sku.DefaultValue) - 2\r
1144                             Dict['STRING_TABLE_VALUE'].append(Sku.DefaultValue)\r
1145                         elif Sku.DefaultValue[0] == '{':\r
1146                             Size = len(Sku.DefaultValue.replace(',',' ').split())\r
1147                             Dict['STRING_TABLE_VALUE'].append('{' + Sku.DefaultValue + '}')\r
1148 \r
1149                         StringHeadOffsetList.append(str(StringTableSize))\r
1150                         Dict['SIZE_TABLE_CNAME'].append(CName)\r
1151                         Dict['SIZE_TABLE_GUID'].append(TokenSpaceGuid)\r
1152                         Dict['SIZE_TABLE_CURRENT_LENGTH'].append(Size)\r
1153                         Dict['SIZE_TABLE_MAXIMUM_LENGTH'].append(Pcd.MaxDatumSize)\r
1154                         if Pcd.MaxDatumSize != '':\r
1155                             MaxDatumSize = int(Pcd.MaxDatumSize, 0)\r
1156                             if MaxDatumSize > Size:\r
1157                                 Size = MaxDatumSize\r
1158                         Dict['STRING_TABLE_LENGTH'].append(Size / 2 + 1)\r
1159                         StringTableIndex += 1\r
1160                         StringTableSize += (Size / 2 + 1)\r
1161                 else:\r
1162                     Pcd.TokenTypeList += ['PCD_TYPE_DATA']\r
1163                     if Sku.DefaultValue == 'TRUE':\r
1164                         Pcd.InitString = 'INIT'\r
1165                     else:\r
1166                         try:\r
1167                             if int(Sku.DefaultValue, 0) != 0:\r
1168                                 Pcd.InitString = 'INIT'\r
1169                         except:\r
1170                             pass\r
1171                     ValueList.append(Sku.DefaultValue)\r
1172 \r
1173         Pcd.TokenTypeList = list(set(Pcd.TokenTypeList))\r
1174 \r
1175         if 'PCD_TYPE_HII' in Pcd.TokenTypeList:\r
1176             Dict['VARIABLE_HEAD_CNAME_DECL'].append(CName)\r
1177             Dict['VARIABLE_HEAD_GUID_DECL'].append(TokenSpaceGuid)\r
1178             Dict['VARIABLE_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))\r
1179             Dict['VARIABLE_HEAD_VALUE'].append('{ %s }\n' % ' },\n    { '.join(VariableHeadValueList))\r
1180         if 'PCD_TYPE_VPD' in Pcd.TokenTypeList:\r
1181             Dict['VPD_HEAD_CNAME_DECL'].append(CName)\r
1182             Dict['VPD_HEAD_GUID_DECL'].append(TokenSpaceGuid)\r
1183             Dict['VPD_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))\r
1184             Dict['VPD_HEAD_VALUE'].append('{ %s }' % ' }, { '.join(VpdHeadOffsetList))\r
1185         if 'PCD_TYPE_STRING' in Pcd.TokenTypeList:\r
1186             Dict['STRING_HEAD_CNAME_DECL'].append(CName)\r
1187             Dict['STRING_HEAD_GUID_DECL'].append(TokenSpaceGuid)\r
1188             Dict['STRING_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))\r
1189             Dict['STRING_HEAD_VALUE'].append(', '.join(StringHeadOffsetList))\r
1190         if 'PCD_TYPE_DATA' in Pcd.TokenTypeList:\r
1191             Dict[Pcd.InitString+'_CNAME_DECL_'+Pcd.DatumType].append(CName)\r
1192             Dict[Pcd.InitString+'_GUID_DECL_'+Pcd.DatumType].append(TokenSpaceGuid)\r
1193             Dict[Pcd.InitString+'_NUMSKUS_DECL_'+Pcd.DatumType].append(len(Pcd.SkuInfoList))\r
1194             if Pcd.InitString == 'UNINIT':\r
1195                 Dict['PCD_DATABASE_UNINIT_EMPTY'] = ''\r
1196             else:\r
1197                 Dict[Pcd.InitString+'_VALUE_'+Pcd.DatumType].append(', '.join(ValueList))\r
1198 \r
1199     if Phase == 'PEI':\r
1200         NumberOfLocalTokens = NumberOfPeiLocalTokens\r
1201     if Phase == 'DXE':\r
1202         NumberOfLocalTokens = NumberOfDxeLocalTokens\r
1203 \r
1204     Dict['TOKEN_INIT']       = ['' for x in range(NumberOfLocalTokens)]\r
1205     Dict['TOKEN_CNAME']      = ['' for x in range(NumberOfLocalTokens)]\r
1206     Dict['TOKEN_GUID']       = ['' for x in range(NumberOfLocalTokens)]\r
1207     Dict['TOKEN_TYPE']       = ['' for x in range(NumberOfLocalTokens)]\r
1208 \r
1209     for Pcd in Platform.DynamicPcdList:\r
1210         CName = Pcd.TokenCName\r
1211         TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName\r
1212         if Pcd.Phase != Phase:\r
1213             continue\r
1214 \r
1215         TokenSpaceGuid = GuidStructureStringToGuidValueName(GetGuidValue(Platform.PackageList, TokenSpaceGuidCName))\r
1216         GeneratedTokenNumber = Platform.PcdTokenNumber[CName, TokenSpaceGuidCName] - 1\r
1217         if Phase == 'DXE':\r
1218             GeneratedTokenNumber -= NumberOfPeiLocalTokens\r
1219 \r
1220         EdkLogger.debug(EdkLogger.DEBUG_1, "PCD = %s | %s" % (CName, TokenSpaceGuidCName))\r
1221         EdkLogger.debug(EdkLogger.DEBUG_1, "phase = %s" % Phase)\r
1222         EdkLogger.debug(EdkLogger.DEBUG_1, "GeneratedTokenNumber = %s" % str(GeneratedTokenNumber))\r
1223 \r
1224         Dict['TOKEN_INIT'][GeneratedTokenNumber] = 'Init'\r
1225         if Pcd.InitString == 'UNINIT':\r
1226             Dict['TOKEN_INIT'][GeneratedTokenNumber] = 'Uninit'\r
1227         Dict['TOKEN_CNAME'][GeneratedTokenNumber] = CName\r
1228         Dict['TOKEN_GUID'][GeneratedTokenNumber] = TokenSpaceGuid\r
1229         Dict['TOKEN_TYPE'][GeneratedTokenNumber] = ' | '.join(Pcd.TokenTypeList)\r
1230         if Pcd.Type in gDynamicExPcd:\r
1231             Dict['EXMAPPING_TABLE_EXTOKEN'].append(Pcd.TokenValue)\r
1232             if Phase == 'DXE':\r
1233                 GeneratedTokenNumber += NumberOfPeiLocalTokens\r
1234             Dict['EXMAPPING_TABLE_LOCAL_TOKEN'].append(GeneratedTokenNumber)\r
1235             Dict['EXMAPPING_TABLE_GUID_INDEX'].append(GuidList.index(TokenSpaceGuid))\r
1236 \r
1237     if GuidList != []:\r
1238         Dict['GUID_TABLE_EMPTY'] = 'FALSE'\r
1239         Dict['GUID_TABLE_SIZE'] = len(GuidList)\r
1240     else:\r
1241         Dict['GUID_STRUCTURE'] = [GuidStringToGuidStructureString('00000000-0000-0000-0000-000000000000')]\r
1242 \r
1243     if StringTableIndex == 0:\r
1244         Dict['STRING_TABLE_INDEX'].append('')\r
1245         Dict['STRING_TABLE_LENGTH'].append(1)\r
1246         Dict['STRING_TABLE_CNAME'].append('')\r
1247         Dict['STRING_TABLE_GUID'].append('')\r
1248         Dict['STRING_TABLE_VALUE'].append('{ 0 }')\r
1249     else:\r
1250         Dict['STRING_TABLE_EMPTY'] = 'FALSE'\r
1251         Dict['STRING_TABLE_SIZE'] = StringTableSize\r
1252 \r
1253     if Dict['SIZE_TABLE_CNAME'] == []:\r
1254         Dict['SIZE_TABLE_CNAME'].append('')\r
1255         Dict['SIZE_TABLE_GUID'].append('')\r
1256         Dict['SIZE_TABLE_CURRENT_LENGTH'].append(0)\r
1257         Dict['SIZE_TABLE_MAXIMUM_LENGTH'].append(0)\r
1258 \r
1259     if NumberOfLocalTokens != 0:\r
1260         Dict['DATABASE_EMPTY']                = 'FALSE'\r
1261         Dict['LOCAL_TOKEN_NUMBER_TABLE_SIZE'] = NumberOfLocalTokens\r
1262         Dict['LOCAL_TOKEN_NUMBER']            = NumberOfLocalTokens\r
1263 \r
1264     if NumberOfExTokens != 0:\r
1265         Dict['EXMAP_TABLE_EMPTY']    = 'FALSE'\r
1266         Dict['EXMAPPING_TABLE_SIZE'] = NumberOfExTokens\r
1267         Dict['EX_TOKEN_NUMBER']      = NumberOfExTokens\r
1268     else:\r
1269         Dict['EXMAPPING_TABLE_EXTOKEN'].append(0)\r
1270         Dict['EXMAPPING_TABLE_LOCAL_TOKEN'].append(0)\r
1271         Dict['EXMAPPING_TABLE_GUID_INDEX'].append(0)\r
1272 \r
1273     if NumberOfSizeItems != 0:\r
1274         Dict['SIZE_TABLE_SIZE'] = NumberOfSizeItems * 2\r
1275 \r
1276     AutoGenH.Append(gPcdDatabaseAutoGenH, Dict)\r
1277     if NumberOfLocalTokens == 0:\r
1278         AutoGenC.Append(gEmptyPcdDatabaseAutoGenC, Dict)\r
1279     else:\r
1280         AutoGenC.Append(gPcdDatabaseAutoGenC, Dict)\r
1281 \r
1282     return AutoGenH, AutoGenC\r
1283 \r
1284 ## Create code for PCD database\r
1285 #\r
1286 #   @param      Info        The ModuleBuildInfo object\r
1287 #   @param      AutoGenC    The TemplateString object for C code\r
1288 #   @param      AutoGenH    The TemplateString object for header file\r
1289 #\r
1290 def CreatePcdDatabaseCode (Info, AutoGenC, AutoGenH):\r
1291     if Info.PcdIsDriver == "":\r
1292         return\r
1293     if Info.PcdIsDriver not in gPcdPhaseMap:\r
1294         EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Not supported PcdIsDriver type:%s\n" % Info.PcdIsDriver)\r
1295 \r
1296     AutoGenH.Append(gPcdDatabaseCommonAutoGenH)\r
1297     AdditionalAutoGenH, AdditionalAutoGenC = CreatePcdDatabasePhaseSpecificAutoGen (Info.PlatformInfo, 'PEI')\r
1298     AutoGenH.Append(AdditionalAutoGenH.String)\r
1299 \r
1300     Phase = gPcdPhaseMap[Info.PcdIsDriver]\r
1301     if Phase == 'PEI':\r
1302         AutoGenC.Append(AdditionalAutoGenC.String)\r
1303 \r
1304     if Phase == 'DXE':\r
1305         AdditionalAutoGenH, AdditionalAutoGenC = CreatePcdDatabasePhaseSpecificAutoGen (Info.PlatformInfo, Phase)\r
1306         AutoGenH.Append(AdditionalAutoGenH.String)\r
1307         AutoGenC.Append(AdditionalAutoGenC.String)\r
1308         AutoGenH.Append(gPcdDatabaseEpilogueAutoGenH)\r
1309 \r
1310 ## Create code for library constructor\r
1311 #\r
1312 #   @param      Info        The ModuleBuildInfo object\r
1313 #   @param      AutoGenC    The TemplateString object for C code\r
1314 #   @param      AutoGenH    The TemplateString object for header file\r
1315 #\r
1316 def CreateLibraryConstructorCode(Info, AutoGenC, AutoGenH):\r
1317     if Info.IsLibrary:\r
1318         return\r
1319     #\r
1320     # Library Constructors\r
1321     #\r
1322     ConstructorPrototypeString = TemplateString()\r
1323     ConstructorCallingString = TemplateString()\r
1324     for Lib in Info.DependentLibraryList:\r
1325         if len(Lib.ConstructorList) <= 0:\r
1326             continue\r
1327         Dict = {'Function':Lib.ConstructorList}\r
1328         if Lib.ModuleType == 'BASE':\r
1329             ConstructorPrototypeString.Append(gLibraryStructorPrototype['BASE'], Dict)\r
1330             ConstructorCallingString.Append(gLibraryStructorCall['BASE'], Dict)\r
1331         elif Lib.ModuleType in ['PEI_CORE','PEIM']:\r
1332             ConstructorPrototypeString.Append(gLibraryStructorPrototype['PEI'], Dict)\r
1333             ConstructorCallingString.Append(gLibraryStructorCall['PEI'], Dict)\r
1334         elif Lib.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER','DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION']:\r
1335             ConstructorPrototypeString.Append(gLibraryStructorPrototype['DXE'], Dict)\r
1336             ConstructorCallingString.Append(gLibraryStructorCall['DXE'], Dict)\r
1337 \r
1338     if str(ConstructorPrototypeString) == '':\r
1339         ConstructorPrototypeList = []\r
1340     else:\r
1341         ConstructorPrototypeList = [str(ConstructorPrototypeString)]\r
1342     if str(ConstructorCallingString) == '':\r
1343         ConstructorCallingList = []\r
1344     else:\r
1345         ConstructorCallingList = [str(ConstructorCallingString)]\r
1346 \r
1347     Dict = {\r
1348         'Type'              :   'Constructor',\r
1349         'FunctionPrototype' :   ConstructorPrototypeList,\r
1350         'FunctionCall'      :   ConstructorCallingList\r
1351     }\r
1352     if Info.ModuleType == 'BASE':\r
1353         AutoGenC.Append(gLibraryString['BASE'], Dict)\r
1354     elif Info.ModuleType in ['PEI_CORE','PEIM']:\r
1355         AutoGenC.Append(gLibraryString['PEI'], Dict)\r
1356     elif Info.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER','DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION']:\r
1357         AutoGenC.Append(gLibraryString['DXE'], Dict)\r
1358 \r
1359 ## Create code for library destructor\r
1360 #\r
1361 #   @param      Info        The ModuleBuildInfo object\r
1362 #   @param      AutoGenC    The TemplateString object for C code\r
1363 #   @param      AutoGenH    The TemplateString object for header file\r
1364 #\r
1365 def CreateLibraryDestructorCode(Info, AutoGenC, AutoGenH):\r
1366     if Info.IsLibrary:\r
1367         return\r
1368     #\r
1369     # Library Destructors\r
1370     #\r
1371     DestructorPrototypeString = TemplateString()\r
1372     DestructorCallingString = TemplateString()\r
1373     for Index in range(len(Info.DependentLibraryList)-1, -1, -1):\r
1374         Lib = Info.DependentLibraryList[Index]\r
1375         if len(Lib.DestructorList) <= 0:\r
1376             continue\r
1377         Dict = {'Function':Lib.DestructorList}\r
1378         if Lib.ModuleType == 'BASE':\r
1379             DestructorPrototypeString.Append(gLibraryStructorPrototype['BASE'], Dict)\r
1380             DestructorCallingString.Append(gLibraryStructorCall['BASE'], Dict)\r
1381         elif Lib.ModuleType in ['PEI_CORE','PEIM']:\r
1382             DestructorPrototypeString.Append(gLibraryStructorPrototype['PEI'], Dict)\r
1383             DestructorCallingString.Append(gLibraryStructorCall['PEI'], Dict)\r
1384         elif Lib.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER','DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION']:\r
1385             DestructorPrototypeString.Append(gLibraryStructorPrototype['DXE'], Dict)\r
1386             DestructorCallingString.Append(gLibraryStructorCall['DXE'], Dict)\r
1387 \r
1388     if str(DestructorPrototypeString) == '':\r
1389         DestructorPrototypeList = []\r
1390     else:\r
1391         DestructorPrototypeList = [str(DestructorPrototypeString)]\r
1392     if str(DestructorCallingString) == '':\r
1393         DestructorCallingList = []\r
1394     else:\r
1395         DestructorCallingList = [str(DestructorCallingString)]\r
1396 \r
1397     Dict = {\r
1398         'Type'              :   'Destructor',\r
1399         'FunctionPrototype' :   DestructorPrototypeList,\r
1400         'FunctionCall'      :   DestructorCallingList\r
1401     }\r
1402     if Info.ModuleType == 'BASE':\r
1403         AutoGenC.Append(gLibraryString['BASE'], Dict)\r
1404     elif Info.ModuleType in ['PEI_CORE','PEIM']:\r
1405         AutoGenC.Append(gLibraryString['PEI'], Dict)\r
1406     elif Info.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER','DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION']:\r
1407         AutoGenC.Append(gLibraryString['DXE'], Dict)\r
1408 \r
1409 \r
1410 ## Create code for ModuleEntryPoint\r
1411 #\r
1412 #   @param      Info        The ModuleBuildInfo object\r
1413 #   @param      AutoGenC    The TemplateString object for C code\r
1414 #   @param      AutoGenH    The TemplateString object for header file\r
1415 #\r
1416 def CreateModuleEntryPointCode(Info, AutoGenC, AutoGenH):\r
1417     if Info.IsLibrary or Info.ModuleType == "USER_DEFINED":\r
1418         return\r
1419     #\r
1420     # Module Entry Points\r
1421     #\r
1422     NumEntryPoints = len(Info.Module.ModuleEntryPointList)\r
1423     Dict = {'Function':Info.Module.ModuleEntryPointList}\r
1424 \r
1425     if Info.ModuleType in ['PEI_CORE', 'DXE_CORE']:\r
1426         if NumEntryPoints != 1:\r
1427             EdkLogger.error("AutoGen", AUTOGEN_ERROR, '%s must have exactly one entry point' % Info.ModuleType,\r
1428                             ExtraData=", ".join(Info.Module.ModuleEntryPointList))\r
1429     if Info.ModuleType == 'PEI_CORE':\r
1430         AutoGenC.Append(gPeiCoreEntryPointString, Dict)\r
1431     elif Info.ModuleType == 'DXE_CORE':\r
1432         AutoGenC.Append(gDxeCoreEntryPointString, Dict)\r
1433     elif Info.ModuleType == 'PEIM':\r
1434         if NumEntryPoints < 2:\r
1435             AutoGenC.Append(gPeimEntryPointString[NumEntryPoints], Dict)\r
1436         else:\r
1437             AutoGenC.Append(gPeimEntryPointString[2], Dict)\r
1438     elif Info.ModuleType in ['DXE_RUNTIME_DRIVER','DXE_DRIVER','DXE_SMM_DRIVER', 'DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION']:\r
1439         if Info.ModuleType == 'DXE_SMM_DRIVER':\r
1440             if NumEntryPoints == 0:\r
1441                 AutoGenC.Append(gDxeSmmEntryPointString[0], Dict)\r
1442             else:\r
1443                 AutoGenC.Append(gDxeSmmEntryPointString[1], Dict)\r
1444         else:\r
1445             if NumEntryPoints < 2:\r
1446                 AutoGenC.Append(gUefiEntryPointString[NumEntryPoints], Dict)\r
1447             else:\r
1448                 AutoGenC.Append(gUefiEntryPointString[2], Dict)\r
1449 \r
1450 ## Create code for ModuleUnloadImage\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 CreateModuleUnloadImageCode(Info, AutoGenC, AutoGenH):\r
1457     if Info.IsLibrary or Info.ModuleType == "USER_DEFINED":\r
1458         return\r
1459     #\r
1460     # Unload Image Handlers\r
1461     #\r
1462     NumUnloadImage = len(Info.Module.ModuleUnloadImageList)\r
1463     Dict = {'Count':NumUnloadImage, 'Function':Info.Module.ModuleUnloadImageList}\r
1464     if NumUnloadImage < 2:\r
1465         AutoGenC.Append(gUefiUnloadImageString[NumUnloadImage], Dict)\r
1466     else:\r
1467         AutoGenC.Append(gUefiUnloadImageString[2], Dict)\r
1468 \r
1469 ## Create code for GUID\r
1470 #\r
1471 #   @param      Info        The ModuleBuildInfo object\r
1472 #   @param      AutoGenC    The TemplateString object for C code\r
1473 #   @param      AutoGenH    The TemplateString object for header file\r
1474 #\r
1475 def CreateGuidDefinitionCode(Info, AutoGenC, AutoGenH):\r
1476     if Info.IsLibrary:\r
1477         return\r
1478 \r
1479     if Info.ModuleType in ["USER_DEFINED", "BASE"]:\r
1480         GuidType = "GUID"\r
1481     else:\r
1482         GuidType = "EFI_GUID"\r
1483 \r
1484     #\r
1485     # GUIDs\r
1486     #\r
1487     for Key in Info.GuidList:\r
1488         AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.GuidList[Key]))\r
1489 \r
1490 ## Create code for protocol\r
1491 #\r
1492 #   @param      Info        The ModuleBuildInfo object\r
1493 #   @param      AutoGenC    The TemplateString object for C code\r
1494 #   @param      AutoGenH    The TemplateString object for header file\r
1495 #\r
1496 def CreateProtocolDefinitionCode(Info, AutoGenC, AutoGenH):\r
1497     if Info.IsLibrary:\r
1498         return\r
1499 \r
1500     if Info.ModuleType in ["USER_DEFINED", "BASE"]:\r
1501         GuidType = "GUID"\r
1502     else:\r
1503         GuidType = "EFI_GUID"\r
1504 \r
1505     #\r
1506     # Protocol GUIDs\r
1507     #\r
1508     for Key in Info.ProtocolList:\r
1509         AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.ProtocolList[Key]))\r
1510 \r
1511 ## Create code for PPI\r
1512 #\r
1513 #   @param      Info        The ModuleBuildInfo object\r
1514 #   @param      AutoGenC    The TemplateString object for C code\r
1515 #   @param      AutoGenH    The TemplateString object for header file\r
1516 #\r
1517 def CreatePpiDefinitionCode(Info, AutoGenC, AutoGenH):\r
1518     if Info.IsLibrary:\r
1519         return\r
1520 \r
1521     if Info.ModuleType in ["USER_DEFINED", "BASE"]:\r
1522         GuidType = "GUID"\r
1523     else:\r
1524         GuidType = "EFI_GUID"\r
1525 \r
1526     #\r
1527     # PPI GUIDs\r
1528     #\r
1529     for Key in Info.PpiList:\r
1530         AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.PpiList[Key]))\r
1531 \r
1532 ## Create code for PCD\r
1533 #\r
1534 #   @param      Info        The ModuleBuildInfo object\r
1535 #   @param      AutoGenC    The TemplateString object for C code\r
1536 #   @param      AutoGenH    The TemplateString object for header file\r
1537 #\r
1538 def CreatePcdCode(Info, AutoGenC, AutoGenH):\r
1539     if Info.IsLibrary:\r
1540         for Pcd in Info.PcdList:\r
1541             CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd)\r
1542     else:\r
1543         for Pcd in Info.PcdList:\r
1544             CreateModulePcdCode(Info, AutoGenC, AutoGenH, Pcd)\r
1545     CreatePcdDatabaseCode(Info, AutoGenC, AutoGenH)\r
1546 \r
1547 ## Create code for unicode string definition\r
1548 #\r
1549 #   @param      Info        The ModuleBuildInfo object\r
1550 #   @param      AutoGenC    The TemplateString object for C code\r
1551 #   @param      AutoGenH    The TemplateString object for header file\r
1552 #\r
1553 def CreateUnicodeStringCode(Info, AutoGenC, AutoGenH):\r
1554     if len(Info.UnicodeFileList) == 0:\r
1555         return\r
1556 \r
1557     WorkingDir = os.getcwd()\r
1558     os.chdir(Info.WorkspaceDir)\r
1559 \r
1560     IncList = [os.path.join(Info.WorkspaceDir, Inc) for Inc in Info.IncludePathList]\r
1561     Header, Code = GetStringFiles(Info.UnicodeFileList, IncList, [], Info.Name)\r
1562     AutoGenC.Append("\n//\n//Unicode String Pack Definition\n//\n")\r
1563     AutoGenC.Append(Code)\r
1564     AutoGenC.Append("\n")\r
1565     AutoGenH.Append("\n//\n//Unicode String ID\n//\n")\r
1566     AutoGenH.Append(Header)\r
1567     AutoGenH.Append("\n#define STRING_ARRAY_NAME %sStrings\n" % Info.Name)\r
1568     os.chdir(WorkingDir)\r
1569 \r
1570 ## Create common code\r
1571 #\r
1572 #   @param      Info        The ModuleBuildInfo object\r
1573 #   @param      AutoGenC    The TemplateString object for C code\r
1574 #   @param      AutoGenH    The TemplateString object for header file\r
1575 #\r
1576 def CreateHeaderCode(Info, AutoGenC, AutoGenH):\r
1577     # file header\r
1578     AutoGenH.Append(gAutoGenHeaderString,   {'FileName':'AutoGen.h'})\r
1579     # header file Prologue\r
1580     AutoGenH.Append(gAutoGenHPrologueString,{'Guid':Info.Guid.replace('-','_')})\r
1581     if Info.AutoGenVersion >= 0x00010005:\r
1582         # specification macros\r
1583         AutoGenH.Append(gSpecificationString,   {'SpecificationName':Info.Macro.keys(), \r
1584                                                  'SpecificationValue':Info.Macro.values()})\r
1585         # header files includes\r
1586         AutoGenH.Append("#include <%s>\n\n" % gBasicHeaderFile)\r
1587         AutoGenH.Append('\nextern GUID  gEfiCallerIdGuid;\n\n')\r
1588     \r
1589         if Info.IsLibrary:\r
1590             return\r
1591     \r
1592         AutoGenH.Append("#define EFI_CALLER_ID_GUID \\\n  %s\n" % GuidStringToGuidStructureString(Info.Guid))\r
1593     \r
1594     if Info.IsLibrary:\r
1595         return\r
1596     # C file header\r
1597     AutoGenC.Append(gAutoGenHeaderString, {'FileName':'AutoGen.c'})\r
1598     if Info.AutoGenVersion >= 0x00010005:\r
1599         # C file header files includes\r
1600         for Inc in gModuleTypeHeaderFile[Info.ModuleType]:\r
1601             AutoGenC.Append("#include <%s>\n" % Inc)\r
1602     \r
1603         #\r
1604         # Publish the CallerId Guid\r
1605         #\r
1606         AutoGenC.Append('\nGLOBAL_REMOVE_IF_UNREFERENCED GUID gEfiCallerIdGuid = %s;\n' % GuidStringToGuidStructureString(Info.Guid))\r
1607 \r
1608 ## Create common code for header file\r
1609 #\r
1610 #   @param      Info        The ModuleBuildInfo object\r
1611 #   @param      AutoGenC    The TemplateString object for C code\r
1612 #   @param      AutoGenH    The TemplateString object for header file\r
1613 #\r
1614 def CreateFooterCode(Info, AutoGenC, AutoGenH):\r
1615     AutoGenH.Append(gAutoGenHEpilogueString)\r
1616 \r
1617 ## Create code for a module\r
1618 #\r
1619 #   @param      Info        The ModuleBuildInfo object\r
1620 #   @param      AutoGenC    The TemplateString object for C code\r
1621 #   @param      AutoGenH    The TemplateString object for header file\r
1622 #\r
1623 def CreateCode(Info, AutoGenC, AutoGenH):\r
1624     CreateHeaderCode(Info, AutoGenC, AutoGenH)\r
1625 \r
1626     if Info.AutoGenVersion >= 0x00010005:\r
1627         CreateLibraryConstructorCode(Info, AutoGenC, AutoGenH)\r
1628         CreateLibraryDestructorCode(Info, AutoGenC, AutoGenH)\r
1629         CreateModuleEntryPointCode(Info, AutoGenC, AutoGenH)\r
1630         CreateModuleUnloadImageCode(Info, AutoGenC, AutoGenH)\r
1631         CreateGuidDefinitionCode(Info, AutoGenC, AutoGenH)\r
1632         CreateProtocolDefinitionCode(Info, AutoGenC, AutoGenH)\r
1633         CreatePpiDefinitionCode(Info, AutoGenC, AutoGenH)\r
1634         CreatePcdCode(Info, AutoGenC, AutoGenH)\r
1635     CreateUnicodeStringCode(Info, AutoGenC, AutoGenH)\r
1636 \r
1637     CreateFooterCode(Info, AutoGenC, AutoGenH)\r
1638 \r
1639 ## Create the code file\r
1640 #\r
1641 #   @param      FilePath    The path of code file\r
1642 #   @param      Content     The content of code file\r
1643 #\r
1644 #   @retval     True        If file content is changed or file doesn't exist\r
1645 #   @retval     False       If the file exists and the content is not changed\r
1646 #\r
1647 def Generate(FilePath, Content):\r
1648     return SaveFileOnChange(FilePath, Content)\r