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