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