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


8053202289077a130654133ba245afa5bb14e946
[mirror_edk2.git] / BaseTools / Source / Python / AutoGen / GenPcdDb.py
1 ## @file
2 # Routines for generating Pcd Database
3 #
4 # Copyright (c) 2013 - 2018, Intel Corporation. All rights reserved.<BR>
5 # This program and the accompanying materials
6 # are licensed and made available under the terms and conditions of the BSD License
7 # which accompanies this distribution. The full text of the license may be found at
8 # http://opensource.org/licenses/bsd-license.php
9 #
10 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12 #
13 from StringIO import StringIO
14 from Common.Misc import *
15 from Common.String import StringToArray
16 from struct import pack
17 from ValidCheckingInfoObject import VAR_CHECK_PCD_VARIABLE_TAB_CONTAINER
18 from ValidCheckingInfoObject import VAR_CHECK_PCD_VARIABLE_TAB
19 from ValidCheckingInfoObject import GetValidationObject
20 from Common.VariableAttributes import VariableAttributes
21 import copy
22 from struct import unpack
23 from Common.DataType import *
24
25 DATABASE_VERSION = 7
26
27 gPcdDatabaseAutoGenC = TemplateString("""
28 //
29 // External PCD database debug information
30 //
31 #if 0
32 ${PHASE}_PCD_DATABASE_INIT g${PHASE}PcdDbInit = {
33 /* SkuIdTable */
34 { ${BEGIN}${SKUID_VALUE}, ${END} },
35 ${BEGIN} { ${INIT_VALUE_UINT64} }, /* ${INIT_CNAME_DECL_UINT64}_${INIT_GUID_DECL_UINT64}[${INIT_NUMSKUS_DECL_UINT64}] */
36 ${END}
37 ${BEGIN} ${VARDEF_VALUE_UINT64}, /* ${VARDEF_CNAME_UINT64}_${VARDEF_GUID_UINT64}_VariableDefault_${VARDEF_SKUID_UINT64} */
38 ${END}
39 ${BEGIN} { ${INIT_VALUE_UINT32} }, /* ${INIT_CNAME_DECL_UINT32}_${INIT_GUID_DECL_UINT32}[${INIT_NUMSKUS_DECL_UINT32}] */
40 ${END}
41 ${BEGIN} ${VARDEF_VALUE_UINT32}, /* ${VARDEF_CNAME_UINT32}_${VARDEF_GUID_UINT32}_VariableDefault_${VARDEF_SKUID_UINT32} */
42 ${END}
43 /* VPD */
44 ${BEGIN} { ${VPD_HEAD_VALUE} }, /* ${VPD_HEAD_CNAME_DECL}_${VPD_HEAD_GUID_DECL}[${VPD_HEAD_NUMSKUS_DECL}] */
45 ${END}
46 /* ExMapTable */
47 {
48 ${BEGIN} { ${EXMAPPING_TABLE_EXTOKEN}, ${EXMAPPING_TABLE_LOCAL_TOKEN}, ${EXMAPPING_TABLE_GUID_INDEX} },
49 ${END}
50 },
51 /* LocalTokenNumberTable */
52 {
53 ${BEGIN} offsetof(${PHASE}_PCD_DATABASE, ${TOKEN_INIT}.${TOKEN_CNAME}_${TOKEN_GUID}${VARDEF_HEADER}) | ${TOKEN_TYPE},
54 ${END}
55 },
56 /* GuidTable */
57 {
58 ${BEGIN} ${GUID_STRUCTURE},
59 ${END}
60 },
61 ${BEGIN} { ${STRING_HEAD_VALUE} }, /* ${STRING_HEAD_CNAME_DECL}_${STRING_HEAD_GUID_DECL}[${STRING_HEAD_NUMSKUS_DECL}] */
62 ${END}
63 ${BEGIN} /* ${VARIABLE_HEAD_CNAME_DECL}_${VARIABLE_HEAD_GUID_DECL}_Variable_Header[${VARIABLE_HEAD_NUMSKUS_DECL}] */
64 {
65 ${VARIABLE_HEAD_VALUE}
66 },
67 ${END}
68 /* SkuHead */
69 {
70 ${BEGIN} offsetof (${PHASE}_PCD_DATABASE, ${TOKEN_INIT}.${TOKEN_CNAME}_${TOKEN_GUID}${VARDEF_HEADER}) | ${TOKEN_TYPE}, /* */
71 offsetof (${PHASE}_PCD_DATABASE, ${TOKEN_INIT}.SkuHead) /* */
72 ${END}
73 },
74 /* StringTable */
75 ${BEGIN} ${STRING_TABLE_VALUE}, /* ${STRING_TABLE_CNAME}_${STRING_TABLE_GUID} */
76 ${END}
77 /* SizeTable */
78 {
79 ${BEGIN} ${SIZE_TABLE_MAXIMUM_LENGTH}, ${SIZE_TABLE_CURRENT_LENGTH}, /* ${SIZE_TABLE_CNAME}_${SIZE_TABLE_GUID} */
80 ${END}
81 },
82 ${BEGIN} { ${INIT_VALUE_UINT16} }, /* ${INIT_CNAME_DECL_UINT16}_${INIT_GUID_DECL_UINT16}[${INIT_NUMSKUS_DECL_UINT16}] */
83 ${END}
84 ${BEGIN} ${VARDEF_VALUE_UINT16}, /* ${VARDEF_CNAME_UINT16}_${VARDEF_GUID_UINT16}_VariableDefault_${VARDEF_SKUID_UINT16} */
85 ${END}
86 ${BEGIN} { ${INIT_VALUE_UINT8} }, /* ${INIT_CNAME_DECL_UINT8}_${INIT_GUID_DECL_UINT8}[${INIT_NUMSKUS_DECL_UINT8}] */
87 ${END}
88 ${BEGIN} ${VARDEF_VALUE_UINT8}, /* ${VARDEF_CNAME_UINT8}_${VARDEF_GUID_UINT8}_VariableDefault_${VARDEF_SKUID_UINT8} */
89 ${END}
90 ${BEGIN} { ${INIT_VALUE_BOOLEAN} }, /* ${INIT_CNAME_DECL_BOOLEAN}_${INIT_GUID_DECL_BOOLEAN}[${INIT_NUMSKUS_DECL_BOOLEAN}] */
91 ${END}
92 ${BEGIN} ${VARDEF_VALUE_BOOLEAN}, /* ${VARDEF_CNAME_BOOLEAN}_${VARDEF_GUID_BOOLEAN}_VariableDefault_${VARDEF_SKUID_BOOLEAN} */
93 ${END}
94 ${SYSTEM_SKU_ID_VALUE}
95 };
96 #endif
97 """)
98
99 ## Mapping between PCD driver type and EFI phase
100 gPcdPhaseMap = {
101 "PEI_PCD_DRIVER" : "PEI",
102 "DXE_PCD_DRIVER" : "DXE"
103 }
104
105 gPcdDatabaseAutoGenH = TemplateString("""
106 #define PCD_${PHASE}_SERVICE_DRIVER_VERSION ${SERVICE_DRIVER_VERSION}
107
108 //
109 // External PCD database debug information
110 //
111 #if 0
112 #define ${PHASE}_GUID_TABLE_SIZE ${GUID_TABLE_SIZE}
113 #define ${PHASE}_STRING_TABLE_SIZE ${STRING_TABLE_SIZE}
114 #define ${PHASE}_SKUID_TABLE_SIZE ${SKUID_TABLE_SIZE}
115 #define ${PHASE}_LOCAL_TOKEN_NUMBER_TABLE_SIZE ${LOCAL_TOKEN_NUMBER_TABLE_SIZE}
116 #define ${PHASE}_LOCAL_TOKEN_NUMBER ${LOCAL_TOKEN_NUMBER}
117 #define ${PHASE}_EXMAPPING_TABLE_SIZE ${EXMAPPING_TABLE_SIZE}
118 #define ${PHASE}_EX_TOKEN_NUMBER ${EX_TOKEN_NUMBER}
119 #define ${PHASE}_SIZE_TABLE_SIZE ${SIZE_TABLE_SIZE}
120 #define ${PHASE}_GUID_TABLE_EMPTY ${GUID_TABLE_EMPTY}
121 #define ${PHASE}_STRING_TABLE_EMPTY ${STRING_TABLE_EMPTY}
122 #define ${PHASE}_SKUID_TABLE_EMPTY ${SKUID_TABLE_EMPTY}
123 #define ${PHASE}_DATABASE_EMPTY ${DATABASE_EMPTY}
124 #define ${PHASE}_EXMAP_TABLE_EMPTY ${EXMAP_TABLE_EMPTY}
125
126 typedef struct {
127 UINT64 SkuIdTable[${PHASE}_SKUID_TABLE_SIZE];
128 ${BEGIN} UINT64 ${INIT_CNAME_DECL_UINT64}_${INIT_GUID_DECL_UINT64}[${INIT_NUMSKUS_DECL_UINT64}];
129 ${END}
130 ${BEGIN} UINT64 ${VARDEF_CNAME_UINT64}_${VARDEF_GUID_UINT64}_VariableDefault_${VARDEF_SKUID_UINT64};
131 ${END}
132 ${BEGIN} UINT32 ${INIT_CNAME_DECL_UINT32}_${INIT_GUID_DECL_UINT32}[${INIT_NUMSKUS_DECL_UINT32}];
133 ${END}
134 ${BEGIN} UINT32 ${VARDEF_CNAME_UINT32}_${VARDEF_GUID_UINT32}_VariableDefault_${VARDEF_SKUID_UINT32};
135 ${END}
136 ${BEGIN} VPD_HEAD ${VPD_HEAD_CNAME_DECL}_${VPD_HEAD_GUID_DECL}[${VPD_HEAD_NUMSKUS_DECL}];
137 ${END}
138 DYNAMICEX_MAPPING ExMapTable[${PHASE}_EXMAPPING_TABLE_SIZE];
139 UINT32 LocalTokenNumberTable[${PHASE}_LOCAL_TOKEN_NUMBER_TABLE_SIZE];
140 GUID GuidTable[${PHASE}_GUID_TABLE_SIZE];
141 ${BEGIN} STRING_HEAD ${STRING_HEAD_CNAME_DECL}_${STRING_HEAD_GUID_DECL}[${STRING_HEAD_NUMSKUS_DECL}];
142 ${END}
143 ${BEGIN} VARIABLE_HEAD ${VARIABLE_HEAD_CNAME_DECL}_${VARIABLE_HEAD_GUID_DECL}_Variable_Header[${VARIABLE_HEAD_NUMSKUS_DECL}];
144 ${BEGIN} UINT8 StringTable${STRING_TABLE_INDEX}[${STRING_TABLE_LENGTH}]; /* ${STRING_TABLE_CNAME}_${STRING_TABLE_GUID} */
145 ${END}
146 SIZE_INFO SizeTable[${PHASE}_SIZE_TABLE_SIZE];
147 ${BEGIN} UINT16 ${INIT_CNAME_DECL_UINT16}_${INIT_GUID_DECL_UINT16}[${INIT_NUMSKUS_DECL_UINT16}];
148 ${END}
149 ${BEGIN} UINT16 ${VARDEF_CNAME_UINT16}_${VARDEF_GUID_UINT16}_VariableDefault_${VARDEF_SKUID_UINT16};
150 ${END}
151 ${BEGIN} UINT8 ${INIT_CNAME_DECL_UINT8}_${INIT_GUID_DECL_UINT8}[${INIT_NUMSKUS_DECL_UINT8}];
152 ${END}
153 ${BEGIN} UINT8 ${VARDEF_CNAME_UINT8}_${VARDEF_GUID_UINT8}_VariableDefault_${VARDEF_SKUID_UINT8};
154 ${END}
155 ${BEGIN} BOOLEAN ${INIT_CNAME_DECL_BOOLEAN}_${INIT_GUID_DECL_BOOLEAN}[${INIT_NUMSKUS_DECL_BOOLEAN}];
156 ${END}
157 ${BEGIN} BOOLEAN ${VARDEF_CNAME_BOOLEAN}_${VARDEF_GUID_BOOLEAN}_VariableDefault_${VARDEF_SKUID_BOOLEAN};
158 ${END}
159 ${SYSTEM_SKU_ID}
160 } ${PHASE}_PCD_DATABASE_INIT;
161
162 typedef struct {
163 ${PCD_DATABASE_UNINIT_EMPTY}
164 ${BEGIN} UINT64 ${UNINIT_CNAME_DECL_UINT64}_${UNINIT_GUID_DECL_UINT64}[${UNINIT_NUMSKUS_DECL_UINT64}];
165 ${END}
166 ${BEGIN} UINT32 ${UNINIT_CNAME_DECL_UINT32}_${UNINIT_GUID_DECL_UINT32}[${UNINIT_NUMSKUS_DECL_UINT32}];
167 ${END}
168 ${BEGIN} UINT16 ${UNINIT_CNAME_DECL_UINT16}_${UNINIT_GUID_DECL_UINT16}[${UNINIT_NUMSKUS_DECL_UINT16}];
169 ${END}
170 ${BEGIN} UINT8 ${UNINIT_CNAME_DECL_UINT8}_${UNINIT_GUID_DECL_UINT8}[${UNINIT_NUMSKUS_DECL_UINT8}];
171 ${END}
172 ${BEGIN} BOOLEAN ${UNINIT_CNAME_DECL_BOOLEAN}_${UNINIT_GUID_DECL_BOOLEAN}[${UNINIT_NUMSKUS_DECL_BOOLEAN}];
173 ${END}
174 } ${PHASE}_PCD_DATABASE_UNINIT;
175
176 typedef struct {
177 //GUID Signature; // PcdDataBaseGuid
178 //UINT32 BuildVersion;
179 //UINT32 Length;
180 //SKU_ID SystemSkuId; // Current SkuId value.
181 //UINT32 LengthForAllSkus; // Length of all SKU PCD DB
182 //UINT32 UninitDataBaseSize;// Total size for PCD those default value with 0.
183 //TABLE_OFFSET LocalTokenNumberTableOffset;
184 //TABLE_OFFSET ExMapTableOffset;
185 //TABLE_OFFSET GuidTableOffset;
186 //TABLE_OFFSET StringTableOffset;
187 //TABLE_OFFSET SizeTableOffset;
188 //TABLE_OFFSET SkuIdTableOffset;
189 //TABLE_OFFSET PcdNameTableOffset;
190 //UINT16 LocalTokenCount; // LOCAL_TOKEN_NUMBER for all
191 //UINT16 ExTokenCount; // EX_TOKEN_NUMBER for DynamicEx
192 //UINT16 GuidTableCount; // The Number of Guid in GuidTable
193 //UINT8 Pad[6];
194 ${PHASE}_PCD_DATABASE_INIT Init;
195 ${PHASE}_PCD_DATABASE_UNINIT Uninit;
196 } ${PHASE}_PCD_DATABASE;
197
198 #define ${PHASE}_NEX_TOKEN_NUMBER (${PHASE}_LOCAL_TOKEN_NUMBER - ${PHASE}_EX_TOKEN_NUMBER)
199 #endif
200 """)
201
202
203 gEmptyPcdDatabaseAutoGenC = TemplateString("""
204 //
205 // External PCD database debug information
206 //
207 #if 0
208 ${PHASE}_PCD_DATABASE_INIT g${PHASE}PcdDbInit = {
209 /* SkuIdTable */
210 { 0 },
211 /* ExMapTable */
212 {
213 {0, 0, 0}
214 },
215 /* LocalTokenNumberTable */
216 {
217 0
218 },
219 /* GuidTable */
220 {
221 {0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}
222 },
223 /* StringTable */
224 { 0 },
225 /* SkuHead */
226 {
227 0, 0
228 },
229 /* SizeTable */
230 {
231 0, 0
232 },
233 ${SYSTEM_SKU_ID_VALUE}
234 };
235 #endif
236 """)
237
238 ## DbItemList
239 #
240 # The class holds the Pcd database items. ItemSize if not zero should match the item datum type in the C structure.
241 # When the structure is changed, remember to check the ItemSize and the related PackStr in PackData()
242 # RawDataList is the RawData that may need some kind of calculation or transformation,
243 # the DataList corresponds to the data that need to be written to database. If DataList is not present, then RawDataList
244 # will be written to the database.
245 #
246 class DbItemList:
247 def __init__(self, ItemSize, DataList=None, RawDataList=None):
248 self.ItemSize = ItemSize
249 self.DataList = DataList if DataList else []
250 self.RawDataList = RawDataList if RawDataList else []
251 self.ListSize = 0
252
253 def GetInterOffset(self, Index):
254 Offset = 0
255 if self.ItemSize == 0:
256 #
257 # Variable length, need to calculate one by one
258 #
259 assert(Index < len(self.RawDataList))
260 for ItemIndex in xrange(Index):
261 Offset += len(self.RawDataList[ItemIndex])
262 else:
263 Offset = self.ItemSize * Index
264
265 return Offset
266
267 def GetListSize(self):
268 if self.ListSize:
269 return self.ListSize
270 if len(self.RawDataList) == 0:
271 self.ListSize = 0
272 return self.ListSize
273 if self.ItemSize == 0:
274 self.ListSize = self.GetInterOffset(len(self.RawDataList) - 1) + len(self.RawDataList[len(self.RawDataList)-1])
275 else:
276 self.ListSize = self.ItemSize * len(self.RawDataList)
277 return self.ListSize
278
279 def PackData(self):
280 ## PackGuid
281 #
282 # Pack the GUID value in C structure format into data array
283 #
284 # @param GuidStructureValue: The GUID value in C structure format
285 #
286 # @retval Buffer: a data array contains the Guid
287 #
288 def PackGuid(GuidStructureValue):
289 GuidString = GuidStructureStringToGuidString(GuidStructureValue)
290 Guid = GuidString.split('-')
291 Buffer = pack('=LHHBBBBBBBB',
292 int(Guid[0], 16),
293 int(Guid[1], 16),
294 int(Guid[2], 16),
295 int(Guid[3][-4:-2], 16),
296 int(Guid[3][-2:], 16),
297 int(Guid[4][-12:-10], 16),
298 int(Guid[4][-10:-8], 16),
299 int(Guid[4][-8:-6], 16),
300 int(Guid[4][-6:-4], 16),
301 int(Guid[4][-4:-2], 16),
302 int(Guid[4][-2:], 16)
303 )
304 return Buffer
305
306 if self.ItemSize == 8:
307 PackStr = "=Q"
308 elif self.ItemSize == 4:
309 PackStr = "=L"
310 elif self.ItemSize == 2:
311 PackStr = "=H"
312 elif self.ItemSize == 1:
313 PackStr = "=B"
314 elif self.ItemSize == 0:
315 PackStr = "=B"
316 elif self.ItemSize == 16:
317 # pack Guid
318 PackStr = ''
319 else:
320 # should not reach here
321 assert(False)
322
323 Buffer = ''
324 for Datas in self.RawDataList:
325 if type(Datas) in (list, tuple):
326 for Data in Datas:
327 if PackStr:
328 Buffer += pack(PackStr, GetIntegerValue(Data))
329 else:
330 Buffer += PackGuid(Data)
331 else:
332 if PackStr:
333 Buffer += pack(PackStr, GetIntegerValue(Datas))
334 else:
335 Buffer += PackGuid(Datas)
336
337 return Buffer
338
339 ## DbExMapTblItemList
340 #
341 # The class holds the ExMap table
342 #
343 class DbExMapTblItemList (DbItemList):
344 def __init__(self, ItemSize, DataList=None, RawDataList=None):
345 DbItemList.__init__(self, ItemSize, DataList, RawDataList)
346
347 def PackData(self):
348 Buffer = ''
349 PackStr = "=LHH"
350 for Datas in self.RawDataList:
351 Buffer += pack(PackStr,
352 GetIntegerValue(Datas[0]),
353 GetIntegerValue(Datas[1]),
354 GetIntegerValue(Datas[2]))
355 return Buffer
356
357 ## DbComItemList
358 #
359 # The DbComItemList is a special kind of DbItemList in case that the size of the List can not be computed by the
360 # ItemSize multiply the ItemCount.
361 #
362 class DbComItemList (DbItemList):
363 def __init__(self, ItemSize, DataList=None, RawDataList=None):
364 DbItemList.__init__(self, ItemSize, DataList, RawDataList)
365
366 def GetInterOffset(self, Index):
367 Offset = 0
368 if self.ItemSize == 0:
369 #
370 # Variable length, need to calculte one by one
371 # The only variable table is stringtable, it is not Composite item, should not reach here
372 #
373 assert(False)
374 else:
375 assert(Index < len(self.RawDataList))
376 for ItemIndex in xrange(Index):
377 Offset += len(self.RawDataList[ItemIndex]) * self.ItemSize
378
379 return Offset
380
381 def GetListSize(self):
382 if self.ListSize:
383 return self.ListSize
384 if self.ItemSize == 0:
385 assert(False)
386 else:
387 if len(self.RawDataList) == 0:
388 self.ListSize = 0
389 else:
390 self.ListSize = self.GetInterOffset(len(self.RawDataList) - 1) + len(self.RawDataList[len(self.RawDataList)-1]) * self.ItemSize
391
392 return self.ListSize
393
394 def PackData(self):
395 if self.ItemSize == 8:
396 PackStr = "=Q"
397 elif self.ItemSize == 4:
398 PackStr = "=L"
399 elif self.ItemSize == 2:
400 PackStr = "=H"
401 elif self.ItemSize == 1:
402 PackStr = "=B"
403 elif self.ItemSize == 0:
404 PackStr = "=B"
405 else:
406 assert(False)
407
408 Buffer = ''
409 for DataList in self.RawDataList:
410 for Data in DataList:
411 if type(Data) in (list, tuple):
412 for SingleData in Data:
413 Buffer += pack(PackStr, GetIntegerValue(SingleData))
414 else:
415 Buffer += pack(PackStr, GetIntegerValue(Data))
416
417 return Buffer
418
419 ## DbVariableTableItemList
420 #
421 # The class holds the Variable header value table
422 #
423 class DbVariableTableItemList (DbComItemList):
424 def __init__(self, ItemSize, DataList=None, RawDataList=None):
425 DbComItemList.__init__(self, ItemSize, DataList, RawDataList)
426
427 def PackData(self):
428 PackStr = "=LLHHLHH"
429 Buffer = ''
430 for DataList in self.RawDataList:
431 for Data in DataList:
432 Buffer += pack(PackStr,
433 GetIntegerValue(Data[0]),
434 GetIntegerValue(Data[1]),
435 GetIntegerValue(Data[2]),
436 GetIntegerValue(Data[3]),
437 GetIntegerValue(Data[4]),
438 GetIntegerValue(Data[5]),
439 GetIntegerValue(0))
440 return Buffer
441
442 class DbStringHeadTableItemList(DbItemList):
443 def __init__(self,ItemSize,DataList=None,RawDataList=None):
444 DbItemList.__init__(self, ItemSize, DataList, RawDataList)
445
446 def GetInterOffset(self, Index):
447 Offset = 0
448 if self.ItemSize == 0:
449 #
450 # Variable length, need to calculate one by one
451 #
452 assert(Index < len(self.RawDataList))
453 for ItemIndex in xrange(Index):
454 Offset += len(self.RawDataList[ItemIndex])
455 else:
456 for innerIndex in range(Index):
457 if type(self.RawDataList[innerIndex]) in (list, tuple):
458 Offset += len(self.RawDataList[innerIndex]) * self.ItemSize
459 else:
460 Offset += self.ItemSize
461
462 return Offset
463
464 def GetListSize(self):
465 if self.ListSize:
466 return self.ListSize
467 if len(self.RawDataList) == 0:
468 self.ListSize = 0
469 return self.ListSize
470 if self.ItemSize == 0:
471 self.ListSize = self.GetInterOffset(len(self.RawDataList) - 1) + len(self.RawDataList[len(self.RawDataList)-1])
472 else:
473 for Datas in self.RawDataList:
474 if type(Datas) in (list, tuple):
475 self.ListSize += len(Datas) * self.ItemSize
476 else:
477 self.ListSize += self.ItemSize
478 return self.ListSize
479
480 ## DbSkuHeadTableItemList
481 #
482 # The class holds the Sku header value table
483 #
484 class DbSkuHeadTableItemList (DbItemList):
485 def __init__(self, ItemSize, DataList=None, RawDataList=None):
486 DbItemList.__init__(self, ItemSize, DataList, RawDataList)
487
488 def PackData(self):
489 PackStr = "=LL"
490 Buffer = ''
491 for Data in self.RawDataList:
492 Buffer += pack(PackStr,
493 GetIntegerValue(Data[0]),
494 GetIntegerValue(Data[1]))
495 return Buffer
496
497 ## DbSizeTableItemList
498 #
499 # The class holds the size table
500 #
501 class DbSizeTableItemList (DbItemList):
502 def __init__(self, ItemSize, DataList=None, RawDataList=None):
503 DbItemList.__init__(self, ItemSize, DataList, RawDataList)
504
505 def GetListSize(self):
506 length = 0
507 for Data in self.RawDataList:
508 length += (1 + len(Data[1]))
509 return length * self.ItemSize
510 def PackData(self):
511 PackStr = "=H"
512 Buffer = ''
513 for Data in self.RawDataList:
514 Buffer += pack(PackStr,
515 GetIntegerValue(Data[0]))
516 for subData in Data[1]:
517 Buffer += pack(PackStr,
518 GetIntegerValue(subData))
519 return Buffer
520
521 ## DbStringItemList
522 #
523 # The class holds the string table
524 #
525 class DbStringItemList (DbComItemList):
526 def __init__(self, ItemSize, DataList=None, RawDataList=None, LenList=None):
527 if DataList is None:
528 DataList = []
529 if RawDataList is None:
530 RawDataList = []
531 if LenList is None:
532 LenList = []
533
534 assert(len(RawDataList) == len(LenList))
535 DataList = []
536 # adjust DataList according to the LenList
537 for Index in xrange(len(RawDataList)):
538 Len = LenList[Index]
539 RawDatas = RawDataList[Index]
540 assert(Len >= len(RawDatas))
541 ActualDatas = []
542 for i in xrange(len(RawDatas)):
543 ActualDatas.append(RawDatas[i])
544 for i in xrange(len(RawDatas), Len):
545 ActualDatas.append(0)
546 DataList.append(ActualDatas)
547 self.LenList = LenList
548 DbComItemList.__init__(self, ItemSize, DataList, RawDataList)
549 def GetInterOffset(self, Index):
550 Offset = 0
551
552 assert(Index < len(self.LenList))
553 for ItemIndex in xrange(Index):
554 Offset += self.LenList[ItemIndex]
555
556 return Offset
557
558 def GetListSize(self):
559 if self.ListSize:
560 return self.ListSize
561
562 if len(self.LenList) == 0:
563 self.ListSize = 0
564 else:
565 self.ListSize = self.GetInterOffset(len(self.LenList) - 1) + self.LenList[len(self.LenList)-1]
566
567 return self.ListSize
568
569 def PackData(self):
570 self.RawDataList = self.DataList
571 return DbComItemList.PackData(self)
572
573
574
575 ## Find the index in two list where the item matches the key separately
576 #
577 # @param Key1 The key used to search the List1
578 # @param List1 The list that Key1 will be searched
579 # @param Key2 The key used to search the List2
580 # @param List2 The list that Key2 will be searched
581 #
582 # @retval Index The position inside the list where list1[Index] == Key1 and list2[Index] == Key2
583 #
584 def GetMatchedIndex(Key1, List1, Key2, List2):
585 StartPos = 0
586 while StartPos < len(List1):
587 Index = List1.index(Key1, StartPos)
588 if List2[Index] == Key2:
589 return Index
590 else:
591 StartPos = Index + 1
592
593 return -1
594
595
596 ## convert StringArray like {0x36, 0x00, 0x34, 0x00, 0x21, 0x00, 0x36, 0x00, 0x34, 0x00, 0x00, 0x00}
597 # to List like [0x36, 0x00, 0x34, 0x00, 0x21, 0x00, 0x36, 0x00, 0x34, 0x00, 0x00, 0x00]
598 #
599 # @param StringArray A string array like {0x36, 0x00, 0x34, 0x00, 0x21, 0x00, 0x36, 0x00, 0x34, 0x00, 0x00, 0x00}
600 #
601 # @retval A list object of integer items
602 #
603 def StringArrayToList(StringArray):
604 StringArray = StringArray[1:-1]
605 StringArray = '[' + StringArray + ']'
606 return eval(StringArray)
607
608
609 ## Convert TokenType String like "PCD_DATUM_TYPE_UINT32 | PCD_TYPE_HII" to TokenType value
610 #
611 # @param TokenType A TokenType string like "PCD_DATUM_TYPE_UINT32 | PCD_TYPE_HII"
612 #
613 # @retval A integer representation of the TokenType
614 #
615 def GetTokenTypeValue(TokenType):
616 TokenTypeDict = {
617 "PCD_TYPE_SHIFT":28,
618 "PCD_TYPE_DATA":(0x0 << 28),
619 "PCD_TYPE_HII":(0x8 << 28),
620 "PCD_TYPE_VPD":(0x4 << 28),
621 # "PCD_TYPE_SKU_ENABLED":(0x2 << 28),
622 "PCD_TYPE_STRING":(0x1 << 28),
623
624 "PCD_DATUM_TYPE_SHIFT":24,
625 "PCD_DATUM_TYPE_POINTER":(0x0 << 24),
626 "PCD_DATUM_TYPE_UINT8":(0x1 << 24),
627 "PCD_DATUM_TYPE_UINT16":(0x2 << 24),
628 "PCD_DATUM_TYPE_UINT32":(0x4 << 24),
629 "PCD_DATUM_TYPE_UINT64":(0x8 << 24),
630
631 "PCD_DATUM_TYPE_SHIFT2":20,
632 "PCD_DATUM_TYPE_UINT8_BOOLEAN":(0x1 << 20 | 0x1 << 24),
633 }
634 return eval(TokenType, TokenTypeDict)
635
636 ## construct the external Pcd database using data from Dict
637 #
638 # @param Dict A dictionary contains Pcd related tables
639 #
640 # @retval Buffer A byte stream of the Pcd database
641 #
642 def BuildExDataBase(Dict):
643 # init Db items
644 InitValueUint64 = Dict['INIT_DB_VALUE_UINT64']
645 DbInitValueUint64 = DbComItemList(8, RawDataList = InitValueUint64)
646 VardefValueUint64 = Dict['VARDEF_DB_VALUE_UINT64']
647 DbVardefValueUint64 = DbItemList(8, RawDataList = VardefValueUint64)
648 InitValueUint32 = Dict['INIT_DB_VALUE_UINT32']
649 DbInitValueUint32 = DbComItemList(4, RawDataList = InitValueUint32)
650 VardefValueUint32 = Dict['VARDEF_DB_VALUE_UINT32']
651 DbVardefValueUint32 = DbItemList(4, RawDataList = VardefValueUint32)
652 VpdHeadValue = Dict['VPD_DB_VALUE']
653 DbVpdHeadValue = DbComItemList(4, RawDataList = VpdHeadValue)
654 ExMapTable = zip(Dict['EXMAPPING_TABLE_EXTOKEN'], Dict['EXMAPPING_TABLE_LOCAL_TOKEN'], Dict['EXMAPPING_TABLE_GUID_INDEX'])
655 DbExMapTable = DbExMapTblItemList(8, RawDataList = ExMapTable)
656 LocalTokenNumberTable = Dict['LOCAL_TOKEN_NUMBER_DB_VALUE']
657 DbLocalTokenNumberTable = DbItemList(4, RawDataList = LocalTokenNumberTable)
658 GuidTable = Dict['GUID_STRUCTURE']
659 DbGuidTable = DbItemList(16, RawDataList = GuidTable)
660 StringHeadValue = Dict['STRING_DB_VALUE']
661 # DbItemList to DbStringHeadTableItemList
662 DbStringHeadValue = DbStringHeadTableItemList(4, RawDataList = StringHeadValue)
663 VariableTable = Dict['VARIABLE_DB_VALUE']
664 DbVariableTable = DbVariableTableItemList(20, RawDataList = VariableTable)
665 NumberOfSkuEnabledPcd = GetIntegerValue(Dict['SKU_HEAD_SIZE'])
666
667 Dict['STRING_TABLE_DB_VALUE'] = [StringArrayToList(x) for x in Dict['STRING_TABLE_VALUE']]
668
669 StringTableValue = Dict['STRING_TABLE_DB_VALUE']
670 # when calcute the offset, should use StringTableLen instead of StringTableValue, as string maxium len may be different with actual len
671 StringTableLen = Dict['STRING_TABLE_LENGTH']
672 DbStringTableLen = DbStringItemList(0, RawDataList = StringTableValue, LenList = StringTableLen)
673
674
675 PcdTokenTable = Dict['PCD_TOKENSPACE']
676 PcdTokenLen = Dict['PCD_TOKENSPACE_LENGTH']
677 PcdTokenTableValue = [StringArrayToList(x) for x in Dict['PCD_TOKENSPACE']]
678 DbPcdTokenTable = DbStringItemList(0, RawDataList = PcdTokenTableValue, LenList = PcdTokenLen)
679
680 PcdCNameTable = Dict['PCD_CNAME']
681 PcdCNameLen = Dict['PCD_CNAME_LENGTH']
682 PcdCNameTableValue = [StringArrayToList(x) for x in Dict['PCD_CNAME']]
683 DbPcdCNameTable = DbStringItemList(0, RawDataList = PcdCNameTableValue, LenList = PcdCNameLen)
684
685 PcdNameOffsetTable = Dict['PCD_NAME_OFFSET']
686 DbPcdNameOffsetTable = DbItemList(4,RawDataList = PcdNameOffsetTable)
687
688 SizeTableValue = zip(Dict['SIZE_TABLE_MAXIMUM_LENGTH'], Dict['SIZE_TABLE_CURRENT_LENGTH'])
689 DbSizeTableValue = DbSizeTableItemList(2, RawDataList = SizeTableValue)
690 InitValueUint16 = Dict['INIT_DB_VALUE_UINT16']
691 DbInitValueUint16 = DbComItemList(2, RawDataList = InitValueUint16)
692 VardefValueUint16 = Dict['VARDEF_DB_VALUE_UINT16']
693 DbVardefValueUint16 = DbItemList(2, RawDataList = VardefValueUint16)
694 InitValueUint8 = Dict['INIT_DB_VALUE_UINT8']
695 DbInitValueUint8 = DbComItemList(1, RawDataList = InitValueUint8)
696 VardefValueUint8 = Dict['VARDEF_DB_VALUE_UINT8']
697 DbVardefValueUint8 = DbItemList(1, RawDataList = VardefValueUint8)
698 InitValueBoolean = Dict['INIT_DB_VALUE_BOOLEAN']
699 DbInitValueBoolean = DbComItemList(1, RawDataList = InitValueBoolean)
700 VardefValueBoolean = Dict['VARDEF_DB_VALUE_BOOLEAN']
701 DbVardefValueBoolean = DbItemList(1, RawDataList = VardefValueBoolean)
702 SkuidValue = Dict['SKUID_VALUE']
703 DbSkuidValue = DbItemList(8, RawDataList = SkuidValue)
704
705
706
707 # Unit Db Items
708 UnInitValueUint64 = Dict['UNINIT_GUID_DECL_UINT64']
709 DbUnInitValueUint64 = DbItemList(8, RawDataList = UnInitValueUint64)
710 UnInitValueUint32 = Dict['UNINIT_GUID_DECL_UINT32']
711 DbUnInitValueUint32 = DbItemList(4, RawDataList = UnInitValueUint32)
712 UnInitValueUint16 = Dict['UNINIT_GUID_DECL_UINT16']
713 DbUnInitValueUint16 = DbItemList(2, RawDataList = UnInitValueUint16)
714 UnInitValueUint8 = Dict['UNINIT_GUID_DECL_UINT8']
715 DbUnInitValueUint8 = DbItemList(1, RawDataList = UnInitValueUint8)
716 UnInitValueBoolean = Dict['UNINIT_GUID_DECL_BOOLEAN']
717 DbUnInitValueBoolean = DbItemList(1, RawDataList = UnInitValueBoolean)
718 PcdTokenNumberMap = Dict['PCD_ORDER_TOKEN_NUMBER_MAP']
719
720 DbNameTotle = ["SkuidValue", "InitValueUint64", "VardefValueUint64", "InitValueUint32", "VardefValueUint32", "VpdHeadValue", "ExMapTable",
721 "LocalTokenNumberTable", "GuidTable", "StringHeadValue", "PcdNameOffsetTable","VariableTable", "StringTableLen", "PcdTokenTable", "PcdCNameTable",
722 "SizeTableValue", "InitValueUint16", "VardefValueUint16", "InitValueUint8", "VardefValueUint8", "InitValueBoolean",
723 "VardefValueBoolean", "UnInitValueUint64", "UnInitValueUint32", "UnInitValueUint16", "UnInitValueUint8", "UnInitValueBoolean"]
724
725 DbTotal = [SkuidValue, InitValueUint64, VardefValueUint64, InitValueUint32, VardefValueUint32, VpdHeadValue, ExMapTable,
726 LocalTokenNumberTable, GuidTable, StringHeadValue, PcdNameOffsetTable,VariableTable, StringTableLen, PcdTokenTable,PcdCNameTable,
727 SizeTableValue, InitValueUint16, VardefValueUint16, InitValueUint8, VardefValueUint8, InitValueBoolean,
728 VardefValueBoolean, UnInitValueUint64, UnInitValueUint32, UnInitValueUint16, UnInitValueUint8, UnInitValueBoolean]
729 DbItemTotal = [DbSkuidValue, DbInitValueUint64, DbVardefValueUint64, DbInitValueUint32, DbVardefValueUint32, DbVpdHeadValue, DbExMapTable,
730 DbLocalTokenNumberTable, DbGuidTable, DbStringHeadValue, DbPcdNameOffsetTable,DbVariableTable, DbStringTableLen, DbPcdTokenTable, DbPcdCNameTable,
731 DbSizeTableValue, DbInitValueUint16, DbVardefValueUint16, DbInitValueUint8, DbVardefValueUint8, DbInitValueBoolean,
732 DbVardefValueBoolean, DbUnInitValueUint64, DbUnInitValueUint32, DbUnInitValueUint16, DbUnInitValueUint8, DbUnInitValueBoolean]
733
734 # VardefValueBoolean is the last table in the init table items
735 InitTableNum = DbNameTotle.index("VardefValueBoolean") + 1
736 # The FixedHeader length of the PCD_DATABASE_INIT, from Signature to Pad
737 FixedHeaderLen = 80
738
739 # Get offset of SkuId table in the database
740 SkuIdTableOffset = FixedHeaderLen
741 for DbIndex in xrange(len(DbTotal)):
742 if DbTotal[DbIndex] is SkuidValue:
743 break
744 SkuIdTableOffset += DbItemTotal[DbIndex].GetListSize()
745
746
747 # Get offset of SkuValue table in the database
748
749 # Fix up the LocalTokenNumberTable, SkuHeader table
750 for (LocalTokenNumberTableIndex, (Offset, Table)) in enumerate(LocalTokenNumberTable):
751 DbIndex = 0
752 DbOffset = FixedHeaderLen
753 for DbIndex in xrange(len(DbTotal)):
754 if DbTotal[DbIndex] is Table:
755 DbOffset += DbItemTotal[DbIndex].GetInterOffset(Offset)
756 break
757 DbOffset += DbItemTotal[DbIndex].GetListSize()
758 if DbIndex + 1 == InitTableNum:
759 if DbOffset % 8:
760 DbOffset += (8 - DbOffset % 8)
761 else:
762 assert(False)
763
764 TokenTypeValue = Dict['TOKEN_TYPE'][LocalTokenNumberTableIndex]
765 TokenTypeValue = GetTokenTypeValue(TokenTypeValue)
766 LocalTokenNumberTable[LocalTokenNumberTableIndex] = DbOffset|int(TokenTypeValue)
767 # if PCD_TYPE_SKU_ENABLED, then we need to fix up the SkuTable
768
769
770
771
772 # resolve variable table offset
773 for VariableEntries in VariableTable:
774 skuindex = 0
775 for VariableEntryPerSku in VariableEntries:
776 (VariableHeadGuidIndex, VariableHeadStringIndex, SKUVariableOffset, VariableOffset, VariableRefTable, VariableAttribute) = VariableEntryPerSku[:]
777 DbIndex = 0
778 DbOffset = FixedHeaderLen
779 for DbIndex in xrange(len(DbTotal)):
780 if DbTotal[DbIndex] is VariableRefTable:
781 DbOffset += DbItemTotal[DbIndex].GetInterOffset(VariableOffset)
782 break
783 DbOffset += DbItemTotal[DbIndex].GetListSize()
784 if DbIndex + 1 == InitTableNum:
785 if DbOffset % 8:
786 DbOffset += (8 - DbOffset % 8)
787 else:
788 assert(False)
789 if isinstance(VariableRefTable[0],list):
790 DbOffset += skuindex * 4
791 skuindex += 1
792 if DbIndex >= InitTableNum:
793 assert(False)
794 VarAttr, VarProp = VariableAttributes.GetVarAttributes(VariableAttribute)
795 VariableEntryPerSku[:] = (VariableHeadStringIndex, DbOffset, VariableHeadGuidIndex, SKUVariableOffset, VarAttr, VarProp)
796
797 # calculate various table offset now
798 DbTotalLength = FixedHeaderLen
799 for DbIndex in xrange(len(DbItemTotal)):
800 if DbItemTotal[DbIndex] is DbLocalTokenNumberTable:
801 LocalTokenNumberTableOffset = DbTotalLength
802 elif DbItemTotal[DbIndex] is DbExMapTable:
803 ExMapTableOffset = DbTotalLength
804 elif DbItemTotal[DbIndex] is DbGuidTable:
805 GuidTableOffset = DbTotalLength
806 elif DbItemTotal[DbIndex] is DbStringTableLen:
807 StringTableOffset = DbTotalLength
808 elif DbItemTotal[DbIndex] is DbSizeTableValue:
809 SizeTableOffset = DbTotalLength
810 elif DbItemTotal[DbIndex] is DbSkuidValue:
811 SkuIdTableOffset = DbTotalLength
812 elif DbItemTotal[DbIndex] is DbPcdNameOffsetTable:
813 DbPcdNameOffset = DbTotalLength
814
815
816 DbTotalLength += DbItemTotal[DbIndex].GetListSize()
817 if not Dict['PCD_INFO_FLAG']:
818 DbPcdNameOffset = 0
819 LocalTokenCount = GetIntegerValue(Dict['LOCAL_TOKEN_NUMBER'])
820 ExTokenCount = GetIntegerValue(Dict['EX_TOKEN_NUMBER'])
821 GuidTableCount = GetIntegerValue(Dict['GUID_TABLE_SIZE'])
822 SystemSkuId = GetIntegerValue(Dict['SYSTEM_SKU_ID_VALUE'])
823 Pad = 0xDA
824
825 UninitDataBaseSize = 0
826 for Item in (DbUnInitValueUint64, DbUnInitValueUint32, DbUnInitValueUint16, DbUnInitValueUint8, DbUnInitValueBoolean):
827 UninitDataBaseSize += Item.GetListSize()
828
829 if (DbTotalLength - UninitDataBaseSize) % 8:
830 DbTotalLength += (8 - (DbTotalLength - UninitDataBaseSize) % 8)
831 # Construct the database buffer
832 Guid = "{0x3c7d193c, 0x682c, 0x4c14, 0xa6, 0x8f, 0x55, 0x2d, 0xea, 0x4f, 0x43, 0x7e}"
833 Guid = StringArrayToList(Guid)
834 Buffer = pack('=LHHBBBBBBBB',
835 Guid[0],
836 Guid[1],
837 Guid[2],
838 Guid[3],
839 Guid[4],
840 Guid[5],
841 Guid[6],
842 Guid[7],
843 Guid[8],
844 Guid[9],
845 Guid[10],
846 )
847
848 b = pack("=L", DATABASE_VERSION)
849 Buffer += b
850
851 b = pack('=L', DbTotalLength - UninitDataBaseSize)
852
853 Buffer += b
854 b = pack('=Q', SystemSkuId)
855
856 Buffer += b
857 b = pack('=L', 0)
858
859 Buffer += b
860 b = pack('=L', UninitDataBaseSize)
861
862 Buffer += b
863 b = pack('=L', LocalTokenNumberTableOffset)
864
865 Buffer += b
866 b = pack('=L', ExMapTableOffset)
867
868 Buffer += b
869 b = pack('=L', GuidTableOffset)
870
871 Buffer += b
872 b = pack('=L', StringTableOffset)
873
874 Buffer += b
875 b = pack('=L', SizeTableOffset)
876
877 Buffer += b
878 b = pack('=L', SkuIdTableOffset)
879
880 Buffer += b
881 b = pack('=L', DbPcdNameOffset)
882
883 Buffer += b
884 b = pack('=H', LocalTokenCount)
885
886 Buffer += b
887 b = pack('=H', ExTokenCount)
888
889 Buffer += b
890 b = pack('=H', GuidTableCount)
891
892 Buffer += b
893 b = pack('=B', Pad)
894 Buffer += b
895 Buffer += b
896 Buffer += b
897 Buffer += b
898 Buffer += b
899 Buffer += b
900
901 Index = 0
902 for Item in DbItemTotal:
903 Index +=1
904 b = Item.PackData()
905 Buffer += b
906 if Index == InitTableNum:
907 if len(Buffer) % 8:
908 for num in range(8 - len(Buffer) % 8):
909 b = pack('=B', Pad)
910 Buffer += b
911 break
912 return Buffer
913
914 ## Create code for PCD database
915 #
916 # @param Info The ModuleAutoGen object
917 # @param AutoGenC The TemplateString object for C code
918 # @param AutoGenH The TemplateString object for header file
919 #
920 def CreatePcdDatabaseCode (Info, AutoGenC, AutoGenH):
921 if Info.PcdIsDriver == "":
922 return
923 if Info.PcdIsDriver not in gPcdPhaseMap:
924 EdkLogger.error("build", AUTOGEN_ERROR, "Not supported PcdIsDriver type:%s" % Info.PcdIsDriver,
925 ExtraData="[%s]" % str(Info))
926
927 AdditionalAutoGenH, AdditionalAutoGenC, PcdDbBuffer = NewCreatePcdDatabasePhaseSpecificAutoGen (Info.PlatformInfo, 'PEI')
928 AutoGenH.Append(AdditionalAutoGenH.String)
929
930 Phase = gPcdPhaseMap[Info.PcdIsDriver]
931 if Phase == 'PEI':
932 AutoGenC.Append(AdditionalAutoGenC.String)
933
934 if Phase == 'DXE':
935 AdditionalAutoGenH, AdditionalAutoGenC, PcdDbBuffer = NewCreatePcdDatabasePhaseSpecificAutoGen (Info.PlatformInfo, Phase)
936 AutoGenH.Append(AdditionalAutoGenH.String)
937 AutoGenC.Append(AdditionalAutoGenC.String)
938
939 if Info.IsBinaryModule:
940 DbFileName = os.path.join(Info.PlatformInfo.BuildDir, TAB_FV_DIRECTORY, Phase + "PcdDataBase.raw")
941 else:
942 DbFileName = os.path.join(Info.OutputDir, Phase + "PcdDataBase.raw")
943 DbFile = StringIO()
944 DbFile.write(PcdDbBuffer)
945 Changed = SaveFileOnChange(DbFileName, DbFile.getvalue(), True)
946 def CreatePcdDataBase(PcdDBData):
947 delta = {}
948 for skuname,skuid in PcdDBData:
949 if len(PcdDBData[(skuname,skuid)][1]) != len(PcdDBData[(TAB_DEFAULT,"0")][1]):
950 EdkLogger.ERROR("The size of each sku in one pcd are not same")
951 for skuname,skuid in PcdDBData:
952 if skuname == TAB_DEFAULT:
953 continue
954 delta[(skuname,skuid)] = [(index,data,hex(data)) for index,data in enumerate(PcdDBData[(skuname,skuid)][1]) if PcdDBData[(skuname,skuid)][1][index] != PcdDBData[(TAB_DEFAULT,"0")][1][index]]
955 databasebuff = PcdDBData[(TAB_DEFAULT,"0")][0]
956
957 for skuname,skuid in delta:
958 # 8 byte align
959 if len(databasebuff) % 8 > 0:
960 for i in range(8 - (len(databasebuff) % 8)):
961 databasebuff += pack("=B",0)
962 databasebuff += pack('=Q', int(skuid))
963 databasebuff += pack('=Q', 0)
964 databasebuff += pack('=L', 8+8+4+4*len(delta[(skuname,skuid)]))
965 for item in delta[(skuname,skuid)]:
966 databasebuff += pack("=L",item[0])
967 databasebuff = databasebuff[:-1] + pack("=B",item[1])
968 totallen = len(databasebuff)
969 totallenbuff = pack("=L",totallen)
970 newbuffer = databasebuff[:32]
971 for i in range(4):
972 newbuffer += totallenbuff[i]
973 for i in range(36,totallen):
974 newbuffer += databasebuff[i]
975
976 return newbuffer
977
978 def CreateVarCheckBin(VarCheckTab):
979 return VarCheckTab[(TAB_DEFAULT,"0")]
980
981 def CreateAutoGen(PcdDriverAutoGenData):
982 autogenC = TemplateString()
983 for skuname,skuid in PcdDriverAutoGenData:
984 autogenC.Append("//SKUID: %s" % skuname)
985 autogenC.Append(PcdDriverAutoGenData[(skuname,skuid)][1].String)
986 return (PcdDriverAutoGenData[(skuname,skuid)][0],autogenC)
987 def NewCreatePcdDatabasePhaseSpecificAutoGen(Platform,Phase):
988 def prune_sku(pcd,skuname):
989 new_pcd = copy.deepcopy(pcd)
990 new_pcd.SkuInfoList = {skuname:pcd.SkuInfoList[skuname]}
991 new_pcd.isinit = 'INIT'
992 if new_pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:
993 for skuobj in pcd.SkuInfoList.values():
994 if skuobj.DefaultValue:
995 defaultvalue = int(skuobj.DefaultValue,16) if skuobj.DefaultValue.upper().startswith("0X") else int(skuobj.DefaultValue,10)
996 if defaultvalue != 0:
997 new_pcd.isinit = "INIT"
998 break
999 elif skuobj.VariableName:
1000 new_pcd.isinit = "INIT"
1001 break
1002 else:
1003 new_pcd.isinit = "UNINIT"
1004 return new_pcd
1005 DynamicPcds = Platform.DynamicPcdList
1006 DynamicPcdSet_Sku = {(SkuName,skuobj.SkuId):[] for pcd in DynamicPcds for (SkuName,skuobj) in pcd.SkuInfoList.items() }
1007 for skuname,skuid in DynamicPcdSet_Sku:
1008 DynamicPcdSet_Sku[(skuname,skuid)] = [prune_sku(pcd,skuname) for pcd in DynamicPcds]
1009 PcdDBData = {}
1010 PcdDriverAutoGenData = {}
1011 VarCheckTableData = {}
1012 if DynamicPcdSet_Sku:
1013 for skuname,skuid in DynamicPcdSet_Sku:
1014 AdditionalAutoGenH, AdditionalAutoGenC, PcdDbBuffer,VarCheckTab = CreatePcdDatabasePhaseSpecificAutoGen (Platform,DynamicPcdSet_Sku[(skuname,skuid)], Phase)
1015 final_data = ()
1016 for item in PcdDbBuffer:
1017 final_data += unpack("B",item)
1018 PcdDBData[(skuname,skuid)] = (PcdDbBuffer, final_data)
1019 PcdDriverAutoGenData[(skuname,skuid)] = (AdditionalAutoGenH, AdditionalAutoGenC)
1020 VarCheckTableData[(skuname,skuid)] = VarCheckTab
1021 if Platform.Platform.VarCheckFlag:
1022 dest = os.path.join(Platform.BuildDir, TAB_FV_DIRECTORY)
1023 VarCheckTable = CreateVarCheckBin(VarCheckTableData)
1024 VarCheckTable.dump(dest, Phase)
1025 AdditionalAutoGenH, AdditionalAutoGenC = CreateAutoGen(PcdDriverAutoGenData)
1026 else:
1027 AdditionalAutoGenH, AdditionalAutoGenC, PcdDbBuffer,VarCheckTab = CreatePcdDatabasePhaseSpecificAutoGen (Platform,{}, Phase)
1028 final_data = ()
1029 for item in PcdDbBuffer:
1030 final_data += unpack("B",item)
1031 PcdDBData[(TAB_DEFAULT,"0")] = (PcdDbBuffer, final_data)
1032
1033 return AdditionalAutoGenH, AdditionalAutoGenC, CreatePcdDataBase(PcdDBData)
1034 ## Create PCD database in DXE or PEI phase
1035 #
1036 # @param Platform The platform object
1037 # @retval tuple Two TemplateString objects for C code and header file,
1038 # respectively
1039 #
1040 def CreatePcdDatabasePhaseSpecificAutoGen (Platform, DynamicPcdList, Phase):
1041 AutoGenC = TemplateString()
1042 AutoGenH = TemplateString()
1043
1044 Dict = {
1045 'PHASE' : Phase,
1046 'SERVICE_DRIVER_VERSION' : DATABASE_VERSION,
1047 'GUID_TABLE_SIZE' : '1U',
1048 'STRING_TABLE_SIZE' : '1U',
1049 'SKUID_TABLE_SIZE' : '1U',
1050 'LOCAL_TOKEN_NUMBER_TABLE_SIZE' : '0U',
1051 'LOCAL_TOKEN_NUMBER' : '0U',
1052 'EXMAPPING_TABLE_SIZE' : '1U',
1053 'EX_TOKEN_NUMBER' : '0U',
1054 'SIZE_TABLE_SIZE' : '2U',
1055 'SKU_HEAD_SIZE' : '1U',
1056 'GUID_TABLE_EMPTY' : 'TRUE',
1057 'STRING_TABLE_EMPTY' : 'TRUE',
1058 'SKUID_TABLE_EMPTY' : 'TRUE',
1059 'DATABASE_EMPTY' : 'TRUE',
1060 'EXMAP_TABLE_EMPTY' : 'TRUE',
1061 'PCD_DATABASE_UNINIT_EMPTY' : ' UINT8 dummy; /* PCD_DATABASE_UNINIT is emptry */',
1062 'SYSTEM_SKU_ID' : ' SKU_ID SystemSkuId;',
1063 'SYSTEM_SKU_ID_VALUE' : '0U'
1064 }
1065
1066 SkuObj = Platform.Platform.SkuIdMgr
1067 Dict['SYSTEM_SKU_ID_VALUE'] = 0 if SkuObj.SkuUsageType == SkuObj.SINGLE else Platform.Platform.SkuIds[SkuObj.SystemSkuId][0]
1068
1069 Dict['PCD_INFO_FLAG'] = Platform.Platform.PcdInfoFlag
1070
1071 for DatumType in TAB_PCD_NUMERIC_TYPES_VOID:
1072 Dict['VARDEF_CNAME_' + DatumType] = []
1073 Dict['VARDEF_GUID_' + DatumType] = []
1074 Dict['VARDEF_SKUID_' + DatumType] = []
1075 Dict['VARDEF_VALUE_' + DatumType] = []
1076 Dict['VARDEF_DB_VALUE_' + DatumType] = []
1077 for Init in ['INIT','UNINIT']:
1078 Dict[Init+'_CNAME_DECL_' + DatumType] = []
1079 Dict[Init+'_GUID_DECL_' + DatumType] = []
1080 Dict[Init+'_NUMSKUS_DECL_' + DatumType] = []
1081 Dict[Init+'_VALUE_' + DatumType] = []
1082 Dict[Init+'_DB_VALUE_'+DatumType] = []
1083
1084 for Type in ['STRING_HEAD','VPD_HEAD','VARIABLE_HEAD']:
1085 Dict[Type + '_CNAME_DECL'] = []
1086 Dict[Type + '_GUID_DECL'] = []
1087 Dict[Type + '_NUMSKUS_DECL'] = []
1088 Dict[Type + '_VALUE'] = []
1089
1090 Dict['STRING_DB_VALUE'] = []
1091 Dict['VPD_DB_VALUE'] = []
1092 Dict['VARIABLE_DB_VALUE'] = []
1093
1094 Dict['STRING_TABLE_INDEX'] = []
1095 Dict['STRING_TABLE_LENGTH'] = []
1096 Dict['STRING_TABLE_CNAME'] = []
1097 Dict['STRING_TABLE_GUID'] = []
1098 Dict['STRING_TABLE_VALUE'] = []
1099 Dict['STRING_TABLE_DB_VALUE'] = []
1100
1101 Dict['SIZE_TABLE_CNAME'] = []
1102 Dict['SIZE_TABLE_GUID'] = []
1103 Dict['SIZE_TABLE_CURRENT_LENGTH'] = []
1104 Dict['SIZE_TABLE_MAXIMUM_LENGTH'] = []
1105
1106 Dict['EXMAPPING_TABLE_EXTOKEN'] = []
1107 Dict['EXMAPPING_TABLE_LOCAL_TOKEN'] = []
1108 Dict['EXMAPPING_TABLE_GUID_INDEX'] = []
1109
1110 Dict['GUID_STRUCTURE'] = []
1111 Dict['SKUID_VALUE'] = [0] # init Dict length
1112 Dict['VARDEF_HEADER'] = []
1113
1114 Dict['LOCAL_TOKEN_NUMBER_DB_VALUE'] = []
1115 Dict['VARIABLE_DB_VALUE'] = []
1116
1117 Dict['PCD_TOKENSPACE'] = []
1118 Dict['PCD_CNAME'] = []
1119 Dict['PCD_TOKENSPACE_LENGTH'] = []
1120 Dict['PCD_CNAME_LENGTH'] = []
1121 Dict['PCD_TOKENSPACE_OFFSET'] = []
1122 Dict['PCD_CNAME_OFFSET'] = []
1123 Dict['PCD_TOKENSPACE_MAP'] = []
1124 Dict['PCD_NAME_OFFSET'] = []
1125
1126 Dict['PCD_ORDER_TOKEN_NUMBER_MAP'] = {}
1127 PCD_STRING_INDEX_MAP = {}
1128
1129 StringTableIndex = 0
1130 StringTableSize = 0
1131 NumberOfLocalTokens = 0
1132 NumberOfPeiLocalTokens = 0
1133 NumberOfDxeLocalTokens = 0
1134 NumberOfExTokens = 0
1135 NumberOfSizeItems = 0
1136 NumberOfSkuEnabledPcd = 0
1137 GuidList = []
1138 VarCheckTab = VAR_CHECK_PCD_VARIABLE_TAB_CONTAINER()
1139 i = 0
1140 ReorderedDynPcdList = GetOrderedDynamicPcdList(DynamicPcdList, Platform.PcdTokenNumber)
1141 for item in ReorderedDynPcdList:
1142 if item.DatumType not in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]:
1143 item.DatumType = TAB_VOID
1144 for Pcd in ReorderedDynPcdList:
1145 VoidStarTypeCurrSize = []
1146 i += 1
1147 CName = Pcd.TokenCName
1148 TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName
1149
1150 for PcdItem in GlobalData.MixedPcd:
1151 if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:
1152 CName = PcdItem[0]
1153
1154 EdkLogger.debug(EdkLogger.DEBUG_3, "PCD: %s %s (%s : %s)" % (CName, TokenSpaceGuidCName, Pcd.Phase, Phase))
1155
1156 if Pcd.Phase == 'PEI':
1157 NumberOfPeiLocalTokens += 1
1158 if Pcd.Phase == 'DXE':
1159 NumberOfDxeLocalTokens += 1
1160 if Pcd.Phase != Phase:
1161 continue
1162
1163 #
1164 # TODO: need GetGuidValue() definition
1165 #
1166 TokenSpaceGuidStructure = Pcd.TokenSpaceGuidValue
1167 TokenSpaceGuid = GuidStructureStringToGuidValueName(TokenSpaceGuidStructure)
1168 if Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:
1169 if TokenSpaceGuid not in GuidList:
1170 GuidList += [TokenSpaceGuid]
1171 Dict['GUID_STRUCTURE'].append(TokenSpaceGuidStructure)
1172 NumberOfExTokens += 1
1173
1174 ValueList = []
1175 DbValueList = []
1176 StringHeadOffsetList = []
1177 StringDbOffsetList = []
1178 VpdHeadOffsetList = []
1179 VpdDbOffsetList = []
1180 VariableHeadValueList = []
1181 VariableDbValueList = []
1182 Pcd.InitString = 'UNINIT'
1183
1184 if Pcd.DatumType == TAB_VOID:
1185 if Pcd.Type not in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD]:
1186 Pcd.TokenTypeList = ['PCD_TYPE_STRING']
1187 else:
1188 Pcd.TokenTypeList = []
1189 elif Pcd.DatumType == 'BOOLEAN':
1190 Pcd.TokenTypeList = ['PCD_DATUM_TYPE_UINT8_BOOLEAN']
1191 else:
1192 Pcd.TokenTypeList = ['PCD_DATUM_TYPE_' + Pcd.DatumType]
1193
1194 if len(Pcd.SkuInfoList) > 1:
1195 # Pcd.TokenTypeList += ['PCD_TYPE_SKU_ENABLED']
1196 NumberOfSkuEnabledPcd += 1
1197
1198 SkuIdIndex = 1
1199 VariableHeadList = []
1200 for SkuName in Pcd.SkuInfoList:
1201 Sku = Pcd.SkuInfoList[SkuName]
1202 SkuId = Sku.SkuId
1203 if SkuId is None or SkuId == '':
1204 continue
1205
1206
1207 SkuIdIndex += 1
1208
1209 if len(Sku.VariableName) > 0:
1210 VariableGuidStructure = Sku.VariableGuidValue
1211 VariableGuid = GuidStructureStringToGuidValueName(VariableGuidStructure)
1212 if Platform.Platform.VarCheckFlag:
1213 var_check_obj = VAR_CHECK_PCD_VARIABLE_TAB(VariableGuidStructure, StringToArray(Sku.VariableName))
1214 try:
1215 var_check_obj.push_back(GetValidationObject(Pcd, Sku.VariableOffset))
1216 VarAttr, _ = VariableAttributes.GetVarAttributes(Sku.VariableAttribute)
1217 var_check_obj.SetAttributes(VarAttr)
1218 var_check_obj.UpdateSize()
1219 VarCheckTab.push_back(var_check_obj)
1220 except Exception:
1221 ValidInfo = ''
1222 if Pcd.validateranges:
1223 ValidInfo = Pcd.validateranges[0]
1224 if Pcd.validlists:
1225 ValidInfo = Pcd.validlists[0]
1226 if ValidInfo:
1227 EdkLogger.error("build", PCD_VALIDATION_INFO_ERROR,
1228 "The PCD '%s.%s' Validation information defined in DEC file has incorrect format." % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
1229 ExtraData = "[%s]" % str(ValidInfo))
1230 else:
1231 EdkLogger.error("build", PCD_VALIDATION_INFO_ERROR,
1232 "The PCD '%s.%s' Validation information defined in DEC file has incorrect format." % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
1233 Pcd.TokenTypeList += ['PCD_TYPE_HII']
1234 Pcd.InitString = 'INIT'
1235 # Store all variable names of one HII PCD under different SKU to stringTable
1236 # and calculate the VariableHeadStringIndex
1237
1238 VariableNameStructure = StringToArray(Sku.VariableName)
1239 if VariableNameStructure not in Dict['STRING_TABLE_VALUE']:
1240 Dict['STRING_TABLE_CNAME'].append(CName)
1241 Dict['STRING_TABLE_GUID'].append(TokenSpaceGuid)
1242 if StringTableIndex == 0:
1243 Dict['STRING_TABLE_INDEX'].append('')
1244 else:
1245 Dict['STRING_TABLE_INDEX'].append('_%d' % StringTableIndex)
1246 VarNameSize = len(VariableNameStructure.replace(',',' ').split())
1247 Dict['STRING_TABLE_LENGTH'].append(VarNameSize )
1248 Dict['STRING_TABLE_VALUE'].append(VariableNameStructure)
1249 StringHeadOffsetList.append(str(StringTableSize) + 'U')
1250 VarStringDbOffsetList = []
1251 VarStringDbOffsetList.append(StringTableSize)
1252 Dict['STRING_DB_VALUE'].append(VarStringDbOffsetList)
1253 StringTableIndex += 1
1254 StringTableSize += len(VariableNameStructure.replace(',',' ').split())
1255 VariableHeadStringIndex = 0
1256 for Index in range(Dict['STRING_TABLE_VALUE'].index(VariableNameStructure)):
1257 VariableHeadStringIndex += Dict['STRING_TABLE_LENGTH'][Index]
1258 VariableHeadList.append(VariableHeadStringIndex)
1259
1260 VariableHeadStringIndex = VariableHeadList[SkuIdIndex - 2]
1261 # store VariableGuid to GuidTable and get the VariableHeadGuidIndex
1262
1263 if VariableGuid not in GuidList:
1264 GuidList += [VariableGuid]
1265 Dict['GUID_STRUCTURE'].append(VariableGuidStructure)
1266 VariableHeadGuidIndex = GuidList.index(VariableGuid)
1267
1268 if "PCD_TYPE_STRING" in Pcd.TokenTypeList:
1269 VariableHeadValueList.append('%dU, offsetof(%s_PCD_DATABASE, Init.%s_%s), %dU, %sU' %
1270 (VariableHeadStringIndex, Phase, CName, TokenSpaceGuid,
1271 VariableHeadGuidIndex, Sku.VariableOffset))
1272 else:
1273 VariableHeadValueList.append('%dU, offsetof(%s_PCD_DATABASE, Init.%s_%s_VariableDefault_%s), %dU, %sU' %
1274 (VariableHeadStringIndex, Phase, CName, TokenSpaceGuid, SkuIdIndex,
1275 VariableHeadGuidIndex, Sku.VariableOffset))
1276 Dict['VARDEF_CNAME_'+Pcd.DatumType].append(CName)
1277 Dict['VARDEF_GUID_'+Pcd.DatumType].append(TokenSpaceGuid)
1278 Dict['VARDEF_SKUID_'+Pcd.DatumType].append(SkuIdIndex)
1279 if "PCD_TYPE_STRING" in Pcd.TokenTypeList:
1280 Dict['VARDEF_VALUE_' + Pcd.DatumType].append("%s_%s[%d]" % (Pcd.TokenCName, TokenSpaceGuid, SkuIdIndex))
1281 else:
1282 #
1283 # ULL (for UINT64) or U(other integer type) should be append to avoid
1284 # warning under linux building environment.
1285 #
1286 Dict['VARDEF_DB_VALUE_'+Pcd.DatumType].append(Sku.HiiDefaultValue)
1287
1288 if Pcd.DatumType == TAB_UINT64:
1289 Dict['VARDEF_VALUE_'+Pcd.DatumType].append(Sku.HiiDefaultValue + "ULL")
1290 elif Pcd.DatumType in (TAB_UINT32, TAB_UINT16, TAB_UINT8):
1291 Dict['VARDEF_VALUE_'+Pcd.DatumType].append(Sku.HiiDefaultValue + "U")
1292 elif Pcd.DatumType == "BOOLEAN":
1293 if eval(Sku.HiiDefaultValue) in [1,0]:
1294 Dict['VARDEF_VALUE_'+Pcd.DatumType].append(str(eval(Sku.HiiDefaultValue)) + "U")
1295 else:
1296 Dict['VARDEF_VALUE_'+Pcd.DatumType].append(Sku.HiiDefaultValue)
1297
1298 # construct the VariableHeader value
1299 if "PCD_TYPE_STRING" in Pcd.TokenTypeList:
1300 VariableHeadValueList.append('%dU, %dU, %sU, offsetof(%s_PCD_DATABASE, Init.%s_%s)' %
1301 (VariableHeadGuidIndex, VariableHeadStringIndex, Sku.VariableOffset,
1302 Phase, CName, TokenSpaceGuid))
1303 # the Pcd default value will be filled later on
1304 VariableOffset = len(Dict['STRING_DB_VALUE'])
1305 VariableRefTable = Dict['STRING_DB_VALUE']
1306 else:
1307 VariableHeadValueList.append('%dU, %dU, %sU, offsetof(%s_PCD_DATABASE, Init.%s_%s_VariableDefault_%s)' %
1308 (VariableHeadGuidIndex, VariableHeadStringIndex, Sku.VariableOffset,
1309 Phase, CName, TokenSpaceGuid, SkuIdIndex))
1310 # the Pcd default value was filled before
1311 VariableOffset = len(Dict['VARDEF_DB_VALUE_' + Pcd.DatumType]) - 1
1312 VariableRefTable = Dict['VARDEF_DB_VALUE_' + Pcd.DatumType]
1313 VariableDbValueList.append([VariableHeadGuidIndex, VariableHeadStringIndex, Sku.VariableOffset, VariableOffset, VariableRefTable, Sku.VariableAttribute])
1314
1315 elif Sku.VpdOffset != '':
1316 Pcd.TokenTypeList += ['PCD_TYPE_VPD']
1317 Pcd.InitString = 'INIT'
1318 VpdHeadOffsetList.append(str(Sku.VpdOffset) + 'U')
1319 VpdDbOffsetList.append(Sku.VpdOffset)
1320 # Also add the VOID* string of VPD PCD to SizeTable
1321 if Pcd.DatumType == TAB_VOID:
1322 NumberOfSizeItems += 1
1323 # For VPD type of PCD, its current size is equal to its MAX size.
1324 VoidStarTypeCurrSize = [str(Pcd.MaxDatumSize) + 'U']
1325 continue
1326
1327 if Pcd.DatumType == TAB_VOID:
1328 Pcd.TokenTypeList += ['PCD_TYPE_STRING']
1329 Pcd.InitString = 'INIT'
1330 if Sku.HiiDefaultValue != '' and Sku.DefaultValue == '':
1331 Sku.DefaultValue = Sku.HiiDefaultValue
1332 if Sku.DefaultValue != '':
1333 NumberOfSizeItems += 1
1334 Dict['STRING_TABLE_CNAME'].append(CName)
1335 Dict['STRING_TABLE_GUID'].append(TokenSpaceGuid)
1336
1337 if StringTableIndex == 0:
1338 Dict['STRING_TABLE_INDEX'].append('')
1339 else:
1340 Dict['STRING_TABLE_INDEX'].append('_%d' % StringTableIndex)
1341 if Sku.DefaultValue[0] == 'L':
1342 DefaultValueBinStructure = StringToArray(Sku.DefaultValue)
1343 Size = len(DefaultValueBinStructure.replace(',',' ').split())
1344 Dict['STRING_TABLE_VALUE'].append(DefaultValueBinStructure)
1345 elif Sku.DefaultValue[0] == '"':
1346 DefaultValueBinStructure = StringToArray(Sku.DefaultValue)
1347 Size = len(Sku.DefaultValue) - 2 + 1
1348 Dict['STRING_TABLE_VALUE'].append(DefaultValueBinStructure)
1349 elif Sku.DefaultValue[0] == '{':
1350 DefaultValueBinStructure = StringToArray(Sku.DefaultValue)
1351 Size = len(Sku.DefaultValue.split(","))
1352 Dict['STRING_TABLE_VALUE'].append(DefaultValueBinStructure)
1353
1354 StringHeadOffsetList.append(str(StringTableSize) + 'U')
1355 StringDbOffsetList.append(StringTableSize)
1356 if Pcd.MaxDatumSize != '':
1357 MaxDatumSize = int(Pcd.MaxDatumSize, 0)
1358 if MaxDatumSize < Size:
1359 if Pcd.MaxSizeUserSet:
1360 EdkLogger.error("build", AUTOGEN_ERROR,
1361 "The maximum size of VOID* type PCD '%s.%s' is less than its actual size occupied." % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
1362 ExtraData="[%s]" % str(Platform))
1363 else:
1364 MaxDatumSize = Size
1365 else:
1366 MaxDatumSize = Size
1367 StringTabLen = MaxDatumSize
1368 if StringTabLen % 2:
1369 StringTabLen += 1
1370 if Sku.VpdOffset == '':
1371 VoidStarTypeCurrSize.append(str(Size) + 'U')
1372 Dict['STRING_TABLE_LENGTH'].append(StringTabLen)
1373 StringTableIndex += 1
1374 StringTableSize += (StringTabLen)
1375 else:
1376 if "PCD_TYPE_HII" not in Pcd.TokenTypeList:
1377 Pcd.TokenTypeList += ['PCD_TYPE_DATA']
1378 if Sku.DefaultValue == 'TRUE':
1379 Pcd.InitString = 'INIT'
1380 else:
1381 Pcd.InitString = Pcd.isinit
1382 #
1383 # For UNIT64 type PCD's value, ULL should be append to avoid
1384 # warning under linux building environment.
1385 #
1386 if Pcd.DatumType == TAB_UINT64:
1387 ValueList.append(Sku.DefaultValue + "ULL")
1388 elif Pcd.DatumType in (TAB_UINT32, TAB_UINT16, TAB_UINT8):
1389 ValueList.append(Sku.DefaultValue + "U")
1390 elif Pcd.DatumType == "BOOLEAN":
1391 if Sku.DefaultValue in ["1", "0"]:
1392 ValueList.append(Sku.DefaultValue + "U")
1393 else:
1394 ValueList.append(Sku.DefaultValue)
1395
1396 DbValueList.append(Sku.DefaultValue)
1397
1398 Pcd.TokenTypeList = list(set(Pcd.TokenTypeList))
1399 if Pcd.DatumType == TAB_VOID:
1400 Dict['SIZE_TABLE_CNAME'].append(CName)
1401 Dict['SIZE_TABLE_GUID'].append(TokenSpaceGuid)
1402 Dict['SIZE_TABLE_MAXIMUM_LENGTH'].append(str(Pcd.MaxDatumSize) + 'U')
1403 Dict['SIZE_TABLE_CURRENT_LENGTH'].append(VoidStarTypeCurrSize)
1404
1405
1406
1407 if 'PCD_TYPE_HII' in Pcd.TokenTypeList:
1408 Dict['VARIABLE_HEAD_CNAME_DECL'].append(CName)
1409 Dict['VARIABLE_HEAD_GUID_DECL'].append(TokenSpaceGuid)
1410 Dict['VARIABLE_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))
1411 Dict['VARIABLE_HEAD_VALUE'].append('{ %s }\n' % ' },\n { '.join(VariableHeadValueList))
1412 Dict['VARDEF_HEADER'].append('_Variable_Header')
1413 Dict['VARIABLE_DB_VALUE'].append(VariableDbValueList)
1414 else:
1415 Dict['VARDEF_HEADER'].append('')
1416 if 'PCD_TYPE_VPD' in Pcd.TokenTypeList:
1417 Dict['VPD_HEAD_CNAME_DECL'].append(CName)
1418 Dict['VPD_HEAD_GUID_DECL'].append(TokenSpaceGuid)
1419 Dict['VPD_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))
1420 Dict['VPD_HEAD_VALUE'].append('{ %s }' % ' }, { '.join(VpdHeadOffsetList))
1421 Dict['VPD_DB_VALUE'].append(VpdDbOffsetList)
1422 if 'PCD_TYPE_STRING' in Pcd.TokenTypeList:
1423 Dict['STRING_HEAD_CNAME_DECL'].append(CName)
1424 Dict['STRING_HEAD_GUID_DECL'].append(TokenSpaceGuid)
1425 Dict['STRING_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))
1426 Dict['STRING_HEAD_VALUE'].append(', '.join(StringHeadOffsetList))
1427 Dict['STRING_DB_VALUE'].append(StringDbOffsetList)
1428 PCD_STRING_INDEX_MAP[len(Dict['STRING_HEAD_CNAME_DECL']) -1 ] = len(Dict['STRING_DB_VALUE']) -1
1429 if 'PCD_TYPE_DATA' in Pcd.TokenTypeList:
1430 Dict[Pcd.InitString+'_CNAME_DECL_'+Pcd.DatumType].append(CName)
1431 Dict[Pcd.InitString+'_GUID_DECL_'+Pcd.DatumType].append(TokenSpaceGuid)
1432 Dict[Pcd.InitString+'_NUMSKUS_DECL_'+Pcd.DatumType].append(len(Pcd.SkuInfoList))
1433 if Pcd.InitString == 'UNINIT':
1434 Dict['PCD_DATABASE_UNINIT_EMPTY'] = ''
1435 else:
1436 Dict[Pcd.InitString+'_VALUE_'+Pcd.DatumType].append(', '.join(ValueList))
1437 Dict[Pcd.InitString+'_DB_VALUE_'+Pcd.DatumType].append(DbValueList)
1438
1439 if Phase == 'PEI':
1440 NumberOfLocalTokens = NumberOfPeiLocalTokens
1441 if Phase == 'DXE':
1442 NumberOfLocalTokens = NumberOfDxeLocalTokens
1443
1444 Dict['TOKEN_INIT'] = ['' for x in range(NumberOfLocalTokens)]
1445 Dict['TOKEN_CNAME'] = ['' for x in range(NumberOfLocalTokens)]
1446 Dict['TOKEN_GUID'] = ['' for x in range(NumberOfLocalTokens)]
1447 Dict['TOKEN_TYPE'] = ['' for x in range(NumberOfLocalTokens)]
1448 Dict['LOCAL_TOKEN_NUMBER_DB_VALUE'] = ['' for x in range(NumberOfLocalTokens)]
1449 Dict['PCD_CNAME'] = ['' for x in range(NumberOfLocalTokens)]
1450 Dict['PCD_TOKENSPACE_MAP'] = ['' for x in range(NumberOfLocalTokens)]
1451 Dict['PCD_CNAME_LENGTH'] = [0 for x in range(NumberOfLocalTokens)]
1452 SkuEnablePcdIndex = 0
1453 for Pcd in ReorderedDynPcdList:
1454 CName = Pcd.TokenCName
1455 TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName
1456 if Pcd.Phase != Phase:
1457 continue
1458
1459 TokenSpaceGuid = GuidStructureStringToGuidValueName(Pcd.TokenSpaceGuidValue) #(Platform.PackageList, TokenSpaceGuidCName))
1460 GeneratedTokenNumber = Platform.PcdTokenNumber[CName, TokenSpaceGuidCName] - 1
1461 if Phase == 'DXE':
1462 GeneratedTokenNumber -= NumberOfPeiLocalTokens
1463
1464 if len(Pcd.SkuInfoList) > 1:
1465 Dict['PCD_ORDER_TOKEN_NUMBER_MAP'][GeneratedTokenNumber] = SkuEnablePcdIndex
1466 SkuEnablePcdIndex += 1
1467
1468 for PcdItem in GlobalData.MixedPcd:
1469 if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:
1470 CName = PcdItem[0]
1471
1472 EdkLogger.debug(EdkLogger.DEBUG_1, "PCD = %s.%s" % (CName, TokenSpaceGuidCName))
1473 EdkLogger.debug(EdkLogger.DEBUG_1, "phase = %s" % Phase)
1474 EdkLogger.debug(EdkLogger.DEBUG_1, "GeneratedTokenNumber = %s" % str(GeneratedTokenNumber))
1475
1476 #
1477 # following four Dict items hold the information for LocalTokenNumberTable
1478 #
1479 Dict['TOKEN_INIT'][GeneratedTokenNumber] = 'Init'
1480 if Pcd.InitString == 'UNINIT':
1481 Dict['TOKEN_INIT'][GeneratedTokenNumber] = 'Uninit'
1482
1483 Dict['TOKEN_CNAME'][GeneratedTokenNumber] = CName
1484 Dict['TOKEN_GUID'][GeneratedTokenNumber] = TokenSpaceGuid
1485 Dict['TOKEN_TYPE'][GeneratedTokenNumber] = ' | '.join(Pcd.TokenTypeList)
1486
1487 if Platform.Platform.PcdInfoFlag:
1488 TokenSpaceGuidCNameArray = StringToArray('"' + TokenSpaceGuidCName + '"' )
1489 if TokenSpaceGuidCNameArray not in Dict['PCD_TOKENSPACE']:
1490 Dict['PCD_TOKENSPACE'].append(TokenSpaceGuidCNameArray)
1491 Dict['PCD_TOKENSPACE_LENGTH'].append( len(TokenSpaceGuidCNameArray.split(",")) )
1492 Dict['PCD_TOKENSPACE_MAP'][GeneratedTokenNumber] = Dict['PCD_TOKENSPACE'].index(TokenSpaceGuidCNameArray)
1493 CNameBinArray = StringToArray('"' + CName + '"' )
1494 Dict['PCD_CNAME'][GeneratedTokenNumber] = CNameBinArray
1495
1496 Dict['PCD_CNAME_LENGTH'][GeneratedTokenNumber] = len(CNameBinArray.split(","))
1497
1498
1499 Pcd.TokenTypeList = list(set(Pcd.TokenTypeList))
1500
1501 # search the Offset and Table, used by LocalTokenNumberTableOffset
1502 if 'PCD_TYPE_HII' in Pcd.TokenTypeList:
1503 # Find index by CName, TokenSpaceGuid
1504 Offset = GetMatchedIndex(CName, Dict['VARIABLE_HEAD_CNAME_DECL'], TokenSpaceGuid, Dict['VARIABLE_HEAD_GUID_DECL'])
1505 assert(Offset != -1)
1506 Table = Dict['VARIABLE_DB_VALUE']
1507 if 'PCD_TYPE_VPD' in Pcd.TokenTypeList:
1508 Offset = GetMatchedIndex(CName, Dict['VPD_HEAD_CNAME_DECL'], TokenSpaceGuid, Dict['VPD_HEAD_GUID_DECL'])
1509 assert(Offset != -1)
1510 Table = Dict['VPD_DB_VALUE']
1511 if 'PCD_TYPE_STRING' in Pcd.TokenTypeList and 'PCD_TYPE_HII' not in Pcd.TokenTypeList:
1512 # Find index by CName, TokenSpaceGuid
1513 Offset = GetMatchedIndex(CName, Dict['STRING_HEAD_CNAME_DECL'], TokenSpaceGuid, Dict['STRING_HEAD_GUID_DECL'])
1514 Offset = PCD_STRING_INDEX_MAP[Offset]
1515 assert(Offset != -1)
1516 Table = Dict['STRING_DB_VALUE']
1517 if 'PCD_TYPE_DATA' in Pcd.TokenTypeList:
1518 # need to store whether it is in init table or not
1519 Offset = GetMatchedIndex(CName, Dict[Pcd.InitString+'_CNAME_DECL_'+Pcd.DatumType], TokenSpaceGuid, Dict[Pcd.InitString+'_GUID_DECL_'+Pcd.DatumType])
1520 assert(Offset != -1)
1521 if Pcd.InitString == 'UNINIT':
1522 Table = Dict[Pcd.InitString+'_GUID_DECL_'+Pcd.DatumType]
1523 else:
1524 Table = Dict[Pcd.InitString+'_DB_VALUE_'+Pcd.DatumType]
1525 Dict['LOCAL_TOKEN_NUMBER_DB_VALUE'][GeneratedTokenNumber] = (Offset, Table)
1526
1527 #
1528 # Update VARDEF_HEADER
1529 #
1530 if 'PCD_TYPE_HII' in Pcd.TokenTypeList:
1531 Dict['VARDEF_HEADER'][GeneratedTokenNumber] = '_Variable_Header'
1532 else:
1533 Dict['VARDEF_HEADER'][GeneratedTokenNumber] = ''
1534
1535
1536 if Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:
1537
1538 if Phase == 'DXE':
1539 GeneratedTokenNumber += NumberOfPeiLocalTokens
1540 #
1541 # Per, PCD architecture specification, PCD Token Number is 1 based and 0 is defined as invalid token number.
1542 # For each EX type PCD, a PCD Token Number is assigned. When the
1543 # PCD Driver/PEIM map EX_GUID and EX_TOKEN_NUMBER to the PCD Token Number,
1544 # the non-EX Protocol/PPI interface can be called to get/set the value. This assumption is made by
1545 # Pcd Driver/PEIM in MdeModulePkg.
1546 # Therefore, 1 is added to GeneratedTokenNumber to generate a PCD Token Number before being inserted
1547 # to the EXMAPPING_TABLE.
1548 #
1549
1550
1551 Dict['EXMAPPING_TABLE_EXTOKEN'].append(str(Pcd.TokenValue) + 'U')
1552 Dict['EXMAPPING_TABLE_LOCAL_TOKEN'].append(str(GeneratedTokenNumber + 1) + 'U')
1553 Dict['EXMAPPING_TABLE_GUID_INDEX'].append(str(GuidList.index(TokenSpaceGuid)) + 'U')
1554
1555 if Platform.Platform.PcdInfoFlag:
1556 for index in range(len(Dict['PCD_TOKENSPACE_MAP'])):
1557 TokenSpaceIndex = StringTableSize
1558 for i in range(Dict['PCD_TOKENSPACE_MAP'][index]):
1559 TokenSpaceIndex += Dict['PCD_TOKENSPACE_LENGTH'][i]
1560 Dict['PCD_TOKENSPACE_OFFSET'].append(TokenSpaceIndex)
1561 for index in range(len(Dict['PCD_TOKENSPACE'])):
1562 StringTableSize += Dict['PCD_TOKENSPACE_LENGTH'][index]
1563 StringTableIndex += 1
1564 for index in range(len(Dict['PCD_CNAME'])):
1565 Dict['PCD_CNAME_OFFSET'].append(StringTableSize)
1566 Dict['PCD_NAME_OFFSET'].append(Dict['PCD_TOKENSPACE_OFFSET'][index])
1567 Dict['PCD_NAME_OFFSET'].append(StringTableSize)
1568 StringTableSize += Dict['PCD_CNAME_LENGTH'][index]
1569 StringTableIndex += 1
1570 if GuidList != []:
1571 Dict['GUID_TABLE_EMPTY'] = 'FALSE'
1572 Dict['GUID_TABLE_SIZE'] = str(len(GuidList)) + 'U'
1573 else:
1574 Dict['GUID_STRUCTURE'] = [GuidStringToGuidStructureString('00000000-0000-0000-0000-000000000000')]
1575
1576 if StringTableIndex == 0:
1577 Dict['STRING_TABLE_INDEX'].append('')
1578 Dict['STRING_TABLE_LENGTH'].append(1)
1579 Dict['STRING_TABLE_CNAME'].append('')
1580 Dict['STRING_TABLE_GUID'].append('')
1581 Dict['STRING_TABLE_VALUE'].append('{ 0 }')
1582 else:
1583 Dict['STRING_TABLE_EMPTY'] = 'FALSE'
1584 Dict['STRING_TABLE_SIZE'] = str(StringTableSize) + 'U'
1585
1586 if Dict['SIZE_TABLE_CNAME'] == []:
1587 Dict['SIZE_TABLE_CNAME'].append('')
1588 Dict['SIZE_TABLE_GUID'].append('')
1589 Dict['SIZE_TABLE_CURRENT_LENGTH'].append(['0U'])
1590 Dict['SIZE_TABLE_MAXIMUM_LENGTH'].append('0U')
1591
1592 if NumberOfLocalTokens != 0:
1593 Dict['DATABASE_EMPTY'] = 'FALSE'
1594 Dict['LOCAL_TOKEN_NUMBER_TABLE_SIZE'] = NumberOfLocalTokens
1595 Dict['LOCAL_TOKEN_NUMBER'] = NumberOfLocalTokens
1596
1597 if NumberOfExTokens != 0:
1598 Dict['EXMAP_TABLE_EMPTY'] = 'FALSE'
1599 Dict['EXMAPPING_TABLE_SIZE'] = str(NumberOfExTokens) + 'U'
1600 Dict['EX_TOKEN_NUMBER'] = str(NumberOfExTokens) + 'U'
1601 else:
1602 Dict['EXMAPPING_TABLE_EXTOKEN'].append('0U')
1603 Dict['EXMAPPING_TABLE_LOCAL_TOKEN'].append('0U')
1604 Dict['EXMAPPING_TABLE_GUID_INDEX'].append('0U')
1605
1606 if NumberOfSizeItems != 0:
1607 Dict['SIZE_TABLE_SIZE'] = str(NumberOfSizeItems * 2) + 'U'
1608
1609 if NumberOfSkuEnabledPcd != 0:
1610 Dict['SKU_HEAD_SIZE'] = str(NumberOfSkuEnabledPcd) + 'U'
1611
1612 for AvailableSkuNumber in SkuObj.SkuIdNumberSet:
1613 if AvailableSkuNumber not in Dict['SKUID_VALUE']:
1614 Dict['SKUID_VALUE'].append(AvailableSkuNumber)
1615 Dict['SKUID_VALUE'][0] = len(Dict['SKUID_VALUE']) - 1
1616
1617 AutoGenH.Append(gPcdDatabaseAutoGenH.Replace(Dict))
1618 if NumberOfLocalTokens == 0:
1619 AutoGenC.Append(gEmptyPcdDatabaseAutoGenC.Replace(Dict))
1620 else:
1621 #
1622 # Update Size Table to the right order, it should be same with LocalTokenNumberTable
1623 #
1624 SizeCNameTempList = []
1625 SizeGuidTempList = []
1626 SizeCurLenTempList = []
1627 SizeMaxLenTempList = []
1628 ReOrderFlag = True
1629
1630 if len(Dict['SIZE_TABLE_CNAME']) == 1:
1631 if not (Dict['SIZE_TABLE_CNAME'][0] and Dict['SIZE_TABLE_GUID'][0]):
1632 ReOrderFlag = False
1633
1634 if ReOrderFlag:
1635 for Count in range(len(Dict['TOKEN_CNAME'])):
1636 for Count1 in range(len(Dict['SIZE_TABLE_CNAME'])):
1637 if Dict['TOKEN_CNAME'][Count] == Dict['SIZE_TABLE_CNAME'][Count1] and \
1638 Dict['TOKEN_GUID'][Count] == Dict['SIZE_TABLE_GUID'][Count1]:
1639 SizeCNameTempList.append(Dict['SIZE_TABLE_CNAME'][Count1])
1640 SizeGuidTempList.append(Dict['SIZE_TABLE_GUID'][Count1])
1641 SizeCurLenTempList.append(Dict['SIZE_TABLE_CURRENT_LENGTH'][Count1])
1642 SizeMaxLenTempList.append(Dict['SIZE_TABLE_MAXIMUM_LENGTH'][Count1])
1643
1644 for Count in range(len(Dict['SIZE_TABLE_CNAME'])):
1645 Dict['SIZE_TABLE_CNAME'][Count] = SizeCNameTempList[Count]
1646 Dict['SIZE_TABLE_GUID'][Count] = SizeGuidTempList[Count]
1647 Dict['SIZE_TABLE_CURRENT_LENGTH'][Count] = SizeCurLenTempList[Count]
1648 Dict['SIZE_TABLE_MAXIMUM_LENGTH'][Count] = SizeMaxLenTempList[Count]
1649
1650 AutoGenC.Append(gPcdDatabaseAutoGenC.Replace(Dict))
1651
1652
1653 # print Phase
1654 Buffer = BuildExDataBase(Dict)
1655 return AutoGenH, AutoGenC, Buffer,VarCheckTab
1656
1657 def GetOrderedDynamicPcdList(DynamicPcdList, PcdTokenNumberList):
1658 ReorderedDyPcdList = [None for i in range(len(DynamicPcdList))]
1659 for Pcd in DynamicPcdList:
1660 if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in PcdTokenNumberList:
1661 ReorderedDyPcdList[PcdTokenNumberList[Pcd.TokenCName, Pcd.TokenSpaceGuidCName]-1] = Pcd
1662 return ReorderedDyPcdList
1663
EFI Development Kit II mirror for PVE