2 # This file include GenVpd class for fix the Vpd type PCD offset, and PcdEntry for describe
3 # and process each entry of vpd type PCD.
5 # Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved.<BR>
7 # This program and the accompanying materials
8 # are licensed and made available under the terms and conditions of the BSD License
9 # which accompanies this distribution. The full text of the license may be found at
10 # http://opensource.org/licenses/bsd-license.php
12 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
13 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
16 from __future__
import absolute_import
17 import Common
.LongFilePathOs
as os
18 from io
import BytesIO
19 from . import StringTable
as st
22 from Common
.LongFilePathSupport
import OpenLongFilePath
as open
24 import Common
.EdkLogger
as EdkLogger
25 import Common
.BuildToolError
as BuildToolError
27 _FORMAT_CHAR
= {1: 'B',
33 ## The VPD PCD data structure for store and process each VPD PCD entry.
35 # This class contain method to format and pack pcd's value.
38 def __init__(self
, PcdCName
, SkuId
,PcdOffset
, PcdSize
, PcdValue
, Lineno
=None, FileName
=None, PcdUnpackValue
=None,
39 PcdBinOffset
=None, PcdBinSize
=None, Alignment
=None):
40 self
.PcdCName
= PcdCName
.strip()
41 self
.SkuId
= SkuId
.strip()
42 self
.PcdOffset
= PcdOffset
.strip()
43 self
.PcdSize
= PcdSize
.strip()
44 self
.PcdValue
= PcdValue
.strip()
45 self
.Lineno
= Lineno
.strip()
46 self
.FileName
= FileName
.strip()
47 self
.PcdUnpackValue
= PcdUnpackValue
48 self
.PcdBinOffset
= PcdBinOffset
49 self
.PcdBinSize
= PcdBinSize
50 self
.Alignment
= Alignment
52 if self
.PcdValue
== '' :
53 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
,
54 "Invalid PCD format(Name: %s File: %s line: %s) , no Value specified!" % (self
.PcdCName
, self
.FileName
, self
.Lineno
))
56 if self
.PcdOffset
== '' :
57 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
,
58 "Invalid PCD format(Name: %s File: %s Line: %s) , no Offset specified!" % (self
.PcdCName
, self
.FileName
, self
.Lineno
))
60 if self
.PcdSize
== '' :
61 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
,
62 "Invalid PCD format(Name: %s File: %s Line: %s), no PcdSize specified!" % (self
.PcdCName
, self
.FileName
, self
.Lineno
))
64 self
._GenOffsetValue
()
66 ## Analyze the string value to judge the PCD's datum type equal to Boolean or not.
68 # @param ValueString PCD's value
69 # @param Size PCD's size
71 # @retval True PCD's datum type is Boolean
72 # @retval False PCD's datum type is not Boolean.
74 def _IsBoolean(self
, ValueString
, Size
):
76 if ValueString
.upper() in ["TRUE", "FALSE"]:
78 elif ValueString
in ["0", "1", "0x0", "0x1", "0x00", "0x01"]:
83 ## Convert the PCD's value from string to integer.
85 # This function will try to convert the Offset value form string to integer
86 # for both hexadecimal and decimal.
88 def _GenOffsetValue(self
):
89 if self
.PcdOffset
!= "*" :
91 self
.PcdBinOffset
= int (self
.PcdOffset
)
94 self
.PcdBinOffset
= int(self
.PcdOffset
, 16)
96 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
,
97 "Invalid offset value %s for PCD %s (File: %s Line: %s)" % (self
.PcdOffset
, self
.PcdCName
, self
.FileName
, self
.Lineno
))
99 ## Pack Boolean type VPD PCD's value form string to binary type.
101 # @param ValueString The boolean type string for pack.
104 def _PackBooleanValue(self
, ValueString
):
105 if ValueString
.upper() == "TRUE" or ValueString
in ["1", "0x1", "0x01"]:
107 self
.PcdValue
= pack(_FORMAT_CHAR
[1], 1)
109 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
,
110 "Invalid size or value for PCD %s to pack(File: %s Line: %s)." % (self
.PcdCName
, self
.FileName
, self
.Lineno
))
113 self
.PcdValue
= pack(_FORMAT_CHAR
[1], 0)
115 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
,
116 "Invalid size or value for PCD %s to pack(File: %s Line: %s)." % (self
.PcdCName
, self
.FileName
, self
.Lineno
))
118 ## Pack Integer type VPD PCD's value form string to binary type.
120 # @param ValueString The Integer type string for pack.
123 def _PackIntValue(self
, IntValue
, Size
):
124 if Size
not in _FORMAT_CHAR
:
125 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
,
126 "Invalid size %d for PCD %s in integer datum size(File: %s Line: %s)." % (Size
, self
.PcdCName
, self
.FileName
, self
.Lineno
))
130 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
,
131 "PCD can't be set to negative value %d for PCD %s in UINT8 datum type(File: %s Line: %s)." % (IntValue
, self
.PcdCName
, self
.FileName
, self
.Lineno
))
132 elif IntValue
>= 0x100:
133 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
,
134 "Too large PCD value %d for datum type UINT8 for PCD %s(File: %s Line: %s)." % (IntValue
, self
.PcdCName
, self
.FileName
, self
.Lineno
))
137 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
,
138 "PCD can't be set to negative value %d for PCD %s in UINT16 datum type(File: %s Line: %s)." % (IntValue
, self
.PcdCName
, self
.FileName
, self
.Lineno
))
139 elif IntValue
>= 0x10000:
140 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
,
141 "Too large PCD value %d for datum type UINT16 for PCD %s(File: %s Line: %s)." % (IntValue
, self
.PcdCName
, self
.FileName
, self
.Lineno
))
144 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
,
145 "PCD can't be set to negative value %d for PCD %s in UINT32 datum type(File: %s Line: %s)." % (IntValue
, self
.PcdCName
, self
.FileName
, self
.Lineno
))
146 elif IntValue
>= 0x100000000:
147 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
,
148 "Too large PCD value %d for datum type UINT32 for PCD %s(File: %s Line: %s)." % (IntValue
, self
.PcdCName
, self
.FileName
, self
.Lineno
))
151 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
,
152 "PCD can't be set to negative value %d for PCD %s in UINT32 datum type(File: %s Line: %s)." % (IntValue
, self
.PcdCName
, self
.FileName
, self
.Lineno
))
153 elif IntValue
>= 0x10000000000000000:
154 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
,
155 "Too large PCD value %d for datum type UINT32 for PCD %s(File: %s Line: %s)." % (IntValue
, self
.PcdCName
, self
.FileName
, self
.Lineno
))
157 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
,
158 "Invalid size %d for PCD %s in integer datum size(File: %s Line: %s)." % (Size
, self
.PcdCName
, self
.FileName
, self
.Lineno
))
161 self
.PcdValue
= pack(_FORMAT_CHAR
[Size
], IntValue
)
163 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
,
164 "Invalid size or value for PCD %s to pack(File: %s Line: %s)." % (self
.PcdCName
, self
.FileName
, self
.Lineno
))
166 ## Pack VOID* type VPD PCD's value form string to binary type.
168 # The VOID* type of string divided into 3 sub-type:
169 # 1: L"String"/L'String', Unicode type string.
170 # 2: "String"/'String', Ascii type string.
171 # 3: {bytearray}, only support byte-array.
173 # @param ValueString The Integer type string for pack.
175 def _PackPtrValue(self
, ValueString
, Size
):
176 if ValueString
.startswith('L"') or ValueString
.startswith("L'"):
177 self
._PackUnicode
(ValueString
, Size
)
178 elif ValueString
.startswith('{') and ValueString
.endswith('}'):
179 self
._PackByteArray
(ValueString
, Size
)
180 elif (ValueString
.startswith('"') and ValueString
.endswith('"')) or (ValueString
.startswith("'") and ValueString
.endswith("'")):
181 self
._PackString
(ValueString
, Size
)
183 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
,
184 "Invalid VOID* type PCD %s value %s (File: %s Line: %s)" % (self
.PcdCName
, ValueString
, self
.FileName
, self
.Lineno
))
186 ## Pack an Ascii PCD value.
188 # An Ascii string for a PCD should be in format as ""/''.
190 def _PackString(self
, ValueString
, Size
):
192 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
,
193 "Invalid parameter Size %s of PCD %s!(File: %s Line: %s)" % (self
.PcdBinSize
, self
.PcdCName
, self
.FileName
, self
.Lineno
))
194 if (ValueString
== ""):
195 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
, "Invalid parameter ValueString %s of PCD %s!(File: %s Line: %s)" % (self
.PcdUnpackValue
, self
.PcdCName
, self
.FileName
, self
.Lineno
))
198 if ValueString
.startswith("'"):
201 ValueString
= ValueString
[1:-1]
202 # No null-terminator in 'string'
203 if (QuotedFlag
and len(ValueString
) + 1 > Size
) or (not QuotedFlag
and len(ValueString
) > Size
):
204 EdkLogger
.error("BPDG", BuildToolError
.RESOURCE_OVERFLOW
,
205 "PCD value string %s is exceed to size %d(File: %s Line: %s)" % (ValueString
, Size
, self
.FileName
, self
.Lineno
))
207 self
.PcdValue
= pack('%ds' % Size
, ValueString
)
209 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
,
210 "Invalid size or value for PCD %s to pack(File: %s Line: %s)." % (self
.PcdCName
, self
.FileName
, self
.Lineno
))
212 ## Pack a byte-array PCD value.
214 # A byte-array for a PCD should be in format as {0x01, 0x02, ...}.
216 def _PackByteArray(self
, ValueString
, Size
):
218 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
, "Invalid parameter Size %s of PCD %s!(File: %s Line: %s)" % (self
.PcdBinSize
, self
.PcdCName
, self
.FileName
, self
.Lineno
))
219 if (ValueString
== ""):
220 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
, "Invalid parameter ValueString %s of PCD %s!(File: %s Line: %s)" % (self
.PcdUnpackValue
, self
.PcdCName
, self
.FileName
, self
.Lineno
))
222 ValueString
= ValueString
.strip()
223 ValueString
= ValueString
.lstrip('{').strip('}')
224 ValueList
= ValueString
.split(',')
225 ValueList
= [item
.strip() for item
in ValueList
]
227 if len(ValueList
) > Size
:
228 EdkLogger
.error("BPDG", BuildToolError
.RESOURCE_OVERFLOW
,
229 "The byte array %s is too large for size %d(File: %s Line: %s)" % (ValueString
, Size
, self
.FileName
, self
.Lineno
))
231 ReturnArray
= array
.array('B')
233 for Index
in xrange(len(ValueList
)):
235 if ValueList
[Index
].lower().startswith('0x'):
236 # translate hex value
238 Value
= int(ValueList
[Index
], 16)
240 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
,
241 "The value item %s in byte array %s is an invalid HEX value.(File: %s Line: %s)" % \
242 (ValueList
[Index
], ValueString
, self
.FileName
, self
.Lineno
))
244 # translate decimal value
246 Value
= int(ValueList
[Index
], 10)
248 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
,
249 "The value item %s in byte array %s is an invalid DECIMAL value.(File: %s Line: %s)" % \
250 (ValueList
[Index
], ValueString
, self
.FileName
, self
.Lineno
))
253 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
,
254 "The value item %s in byte array %s do not in range 0 ~ 0xFF(File: %s Line: %s)" % \
255 (ValueList
[Index
], ValueString
, self
.FileName
, self
.Lineno
))
257 ReturnArray
.append(Value
)
259 for Index
in xrange(len(ValueList
), Size
):
260 ReturnArray
.append(0)
262 self
.PcdValue
= ReturnArray
.tolist()
264 ## Pack a unicode PCD value into byte array.
266 # A unicode string for a PCD should be in format as L""/L''.
268 def _PackUnicode(self
, UnicodeString
, Size
):
270 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
, "Invalid parameter Size %s of PCD %s!(File: %s Line: %s)" % \
271 (self
.PcdBinSize
, self
.PcdCName
, self
.FileName
, self
.Lineno
))
274 if UnicodeString
.startswith("L'"):
276 UnicodeString
= UnicodeString
[2:-1]
278 # No null-terminator in L'string'
279 if (QuotedFlag
and (len(UnicodeString
) + 1) * 2 > Size
) or (not QuotedFlag
and len(UnicodeString
) * 2 > Size
):
280 EdkLogger
.error("BPDG", BuildToolError
.RESOURCE_OVERFLOW
,
281 "The size of unicode string %s is too larger for size %s(File: %s Line: %s)" % \
282 (UnicodeString
, Size
, self
.FileName
, self
.Lineno
))
284 ReturnArray
= array
.array('B')
285 for Value
in UnicodeString
:
287 ReturnArray
.append(ord(Value
))
288 ReturnArray
.append(0)
290 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
,
291 "Invalid unicode character %s in unicode string %s(File: %s Line: %s)" % \
292 (Value
, UnicodeString
, self
.FileName
, self
.Lineno
))
294 for Index
in xrange(len(UnicodeString
) * 2, Size
):
295 ReturnArray
.append(0)
297 self
.PcdValue
= ReturnArray
.tolist()
301 ## The class implementing the BPDG VPD PCD offset fix process
303 # The VPD PCD offset fix process includes:
304 # 1. Parse the input guided.txt file and store it in the data structure;
305 # 2. Format the input file data to remove unused lines;
306 # 3. Fixed offset if needed;
307 # 4. Generate output file, including guided.map and guided.bin file;
310 ## Constructor of DscBuildData
312 # Initialize object of GenVPD
313 # @Param InputFileName The filename include the vpd type pcd information
314 # @param MapFileName The filename of map file that stores vpd type pcd information.
315 # This file will be generated by the BPDG tool after fix the offset
316 # and adjust the offset to make the pcd data aligned.
317 # @param VpdFileName The filename of Vpd file that hold vpd pcd information.
319 def __init__(self
, InputFileName
, MapFileName
, VpdFileName
):
320 self
.InputFileName
= InputFileName
321 self
.MapFileName
= MapFileName
322 self
.VpdFileName
= VpdFileName
323 self
.FileLinesList
= []
324 self
.PcdFixedOffsetSizeList
= []
325 self
.PcdUnknownOffsetList
= []
327 fInputfile
= open(InputFileName
, "r", 0)
329 self
.FileLinesList
= fInputfile
.readlines()
331 EdkLogger
.error("BPDG", BuildToolError
.FILE_READ_FAILURE
, "File read failed for %s" % InputFileName
, None)
335 EdkLogger
.error("BPDG", BuildToolError
.FILE_OPEN_FAILURE
, "File open failed for %s" % InputFileName
, None)
338 # Parser the input file which is generated by the build tool. Convert the value of each pcd's
339 # from string to it's real format. Also remove the useless line in the input file.
341 def ParserInputFile (self
):
343 for line
in self
.FileLinesList
:
344 # Strip "\r\n" generated by readlines ().
346 line
= line
.rstrip(os
.linesep
)
348 # Skip the comment line
349 if (not line
.startswith("#")) and len(line
) > 1 :
351 # Enhanced for support "|" character in the string.
353 ValueList
= ['', '', '', '', '']
355 ValueRe
= re
.compile(r
'\s*L?\".*\|.*\"\s*$')
356 PtrValue
= ValueRe
.findall(line
)
358 ValueUpdateFlag
= False
360 if len(PtrValue
) >= 1:
361 line
= re
.sub(ValueRe
, '', line
)
362 ValueUpdateFlag
= True
364 TokenList
= line
.split('|')
365 ValueList
[0:len(TokenList
)] = TokenList
368 ValueList
[4] = PtrValue
[0]
369 self
.FileLinesList
[count
] = ValueList
370 # Store the line number
371 self
.FileLinesList
[count
].append(str(count
+ 1))
372 elif len(line
) <= 1 :
373 # Set the blank line to "None"
374 self
.FileLinesList
[count
] = None
376 # Set the comment line to "None"
377 self
.FileLinesList
[count
] = None
380 # The line count contain usage information
382 # Delete useless lines
385 if (self
.FileLinesList
[count
] is None) :
386 del(self
.FileLinesList
[count
])
392 # After remove the useless line, if there are no data remain in the file line list,
393 # Report warning messages to user's.
395 if len(self
.FileLinesList
) == 0 :
396 EdkLogger
.warn('BPDG', BuildToolError
.RESOURCE_NOT_AVAILABLE
,
397 "There are no VPD type pcds defined in DSC file, Please check it.")
399 # Process the pcds one by one base on the pcd's value and size
401 for line
in self
.FileLinesList
:
402 if line
is not None :
403 PCD
= PcdEntry(line
[0], line
[1], line
[2], line
[3], line
[4], line
[5], self
.InputFileName
)
404 # Strip the space char
405 PCD
.PcdCName
= PCD
.PcdCName
.strip(' ')
406 PCD
.SkuId
= PCD
.SkuId
.strip(' ')
407 PCD
.PcdOffset
= PCD
.PcdOffset
.strip(' ')
408 PCD
.PcdSize
= PCD
.PcdSize
.strip(' ')
409 PCD
.PcdValue
= PCD
.PcdValue
.strip(' ')
410 PCD
.Lineno
= PCD
.Lineno
.strip(' ')
413 # Store the original pcd value.
414 # This information will be useful while generate the output map file.
416 PCD
.PcdUnpackValue
= str(PCD
.PcdValue
)
419 # Translate PCD size string to an integer value.
422 PackSize
= int(PCD
.PcdSize
, 10)
423 PCD
.PcdBinSize
= PackSize
426 PackSize
= int(PCD
.PcdSize
, 16)
427 PCD
.PcdBinSize
= PackSize
429 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
, "Invalid PCD size value %s at file: %s line: %s" % (PCD
.PcdSize
, self
.InputFileName
, PCD
.Lineno
))
432 # If value is Unicode string (e.g. L""), then use 2-byte alignment
433 # If value is byte array (e.g. {}), then use 8-byte alignment
435 PCD
.PcdOccupySize
= PCD
.PcdBinSize
436 if PCD
.PcdUnpackValue
.startswith("{"):
438 elif PCD
.PcdUnpackValue
.startswith("L"):
443 PCD
.Alignment
= Alignment
444 if PCD
.PcdOffset
!= '*':
445 if PCD
.PcdOccupySize
% Alignment
!= 0:
446 if PCD
.PcdUnpackValue
.startswith("{"):
447 EdkLogger
.warn("BPDG", "The offset value of PCD %s is not 8-byte aligned!" %(PCD
.PcdCName
), File
=self
.InputFileName
)
449 EdkLogger
.error("BPDG", BuildToolError
.FORMAT_INVALID
, 'The offset value of PCD %s should be %s-byte aligned.' % (PCD
.PcdCName
, Alignment
))
451 if PCD
.PcdOccupySize
% Alignment
!= 0:
452 PCD
.PcdOccupySize
= (PCD
.PcdOccupySize
/ Alignment
+ 1) * Alignment
454 PackSize
= PCD
.PcdOccupySize
455 if PCD
._IsBoolean
(PCD
.PcdValue
, PCD
.PcdSize
):
456 PCD
._PackBooleanValue
(PCD
.PcdValue
)
457 self
.FileLinesList
[count
] = PCD
461 # Try to translate value to an integer firstly.
466 PackValue
= int(PCD
.PcdValue
)
469 PackValue
= int(PCD
.PcdValue
, 16)
474 PCD
._PackIntValue
(PackValue
, PackSize
)
476 PCD
._PackPtrValue
(PCD
.PcdValue
, PackSize
)
478 self
.FileLinesList
[count
] = PCD
484 # This function used to create a clean list only contain useful information and reorganized to make it
487 def FormatFileLine (self
) :
489 for eachPcd
in self
.FileLinesList
:
490 if eachPcd
.PcdOffset
!= '*' :
491 # Use pcd's Offset value as key, and pcd's Value as value
492 self
.PcdFixedOffsetSizeList
.append(eachPcd
)
494 # Use pcd's CName as key, and pcd's Size as value
495 self
.PcdUnknownOffsetList
.append(eachPcd
)
499 # This function is use to fix the offset value which the not specified in the map file.
500 # Usually it use the star (meaning any offset) character in the offset field
502 def FixVpdOffset (self
):
503 # At first, the offset should start at 0
504 # Sort fixed offset list in order to find out where has free spaces for the pcd's offset
505 # value is "*" to insert into.
507 self
.PcdFixedOffsetSizeList
.sort(key
=lambda x
: x
.PcdBinOffset
)
510 # Sort the un-fixed pcd's offset by it's size.
512 self
.PcdUnknownOffsetList
.sort(key
=lambda x
: x
.PcdBinSize
)
515 for pcd
in self
.PcdUnknownOffsetList
:
517 if pcd
.PcdCName
== ".".join(("gEfiMdeModulePkgTokenSpaceGuid", "PcdNvStoreDefaultValueBuffer")):
518 if index
!= len(self
.PcdUnknownOffsetList
):
519 for i
in range(len(self
.PcdUnknownOffsetList
) - index
):
520 self
.PcdUnknownOffsetList
[index
+i
-1 ], self
.PcdUnknownOffsetList
[index
+i
] = self
.PcdUnknownOffsetList
[index
+i
], self
.PcdUnknownOffsetList
[index
+i
-1]
523 # Process all Offset value are "*"
525 if (len(self
.PcdFixedOffsetSizeList
) == 0) and (len(self
.PcdUnknownOffsetList
) != 0) :
526 # The offset start from 0
528 for Pcd
in self
.PcdUnknownOffsetList
:
529 if NowOffset
% Pcd
.Alignment
!= 0:
530 NowOffset
= (NowOffset
/ Pcd
.Alignment
+ 1) * Pcd
.Alignment
531 Pcd
.PcdBinOffset
= NowOffset
532 Pcd
.PcdOffset
= str(hex(Pcd
.PcdBinOffset
))
533 NowOffset
+= Pcd
.PcdOccupySize
535 self
.PcdFixedOffsetSizeList
= self
.PcdUnknownOffsetList
538 # Check the offset of VPD type pcd's offset start from 0.
539 if self
.PcdFixedOffsetSizeList
[0].PcdBinOffset
!= 0 :
540 EdkLogger
.warn("BPDG", "The offset of VPD type pcd should start with 0, please check it.",
543 # Judge whether the offset in fixed pcd offset list is overlapped or not.
544 lenOfList
= len(self
.PcdFixedOffsetSizeList
)
546 while (count
< lenOfList
- 1) :
547 PcdNow
= self
.PcdFixedOffsetSizeList
[count
]
548 PcdNext
= self
.PcdFixedOffsetSizeList
[count
+1]
549 # Two pcd's offset is same
550 if PcdNow
.PcdBinOffset
== PcdNext
.PcdBinOffset
:
551 EdkLogger
.error("BPDG", BuildToolError
.ATTRIBUTE_GET_FAILURE
,
552 "The offset of %s at line: %s is same with %s at line: %s in file %s" % \
553 (PcdNow
.PcdCName
, PcdNow
.Lineno
, PcdNext
.PcdCName
, PcdNext
.Lineno
, PcdNext
.FileName
),
557 if PcdNow
.PcdBinOffset
+ PcdNow
.PcdOccupySize
> PcdNext
.PcdBinOffset
:
558 EdkLogger
.error("BPDG", BuildToolError
.ATTRIBUTE_GET_FAILURE
,
559 "The offset of %s at line: %s is overlapped with %s at line: %s in file %s" % \
560 (PcdNow
.PcdCName
, PcdNow
.Lineno
, PcdNext
.PcdCName
, PcdNext
.Lineno
, PcdNext
.FileName
),
563 # Has free space, raise a warning message
564 if PcdNow
.PcdBinOffset
+ PcdNow
.PcdOccupySize
< PcdNext
.PcdBinOffset
:
565 EdkLogger
.warn("BPDG", BuildToolError
.ATTRIBUTE_GET_FAILURE
,
566 "The offsets have free space of between %s at line: %s and %s at line: %s in file %s" % \
567 (PcdNow
.PcdCName
, PcdNow
.Lineno
, PcdNext
.PcdCName
, PcdNext
.Lineno
, PcdNext
.FileName
),
571 LastOffset
= self
.PcdFixedOffsetSizeList
[0].PcdBinOffset
572 FixOffsetSizeListCount
= 0
573 lenOfList
= len(self
.PcdFixedOffsetSizeList
)
574 lenOfUnfixedList
= len(self
.PcdUnknownOffsetList
)
577 # Insert the un-fixed offset pcd's list into fixed offset pcd's list if has free space between those pcds.
579 while (FixOffsetSizeListCount
< lenOfList
) :
581 eachFixedPcd
= self
.PcdFixedOffsetSizeList
[FixOffsetSizeListCount
]
582 NowOffset
= eachFixedPcd
.PcdBinOffset
585 if LastOffset
< NowOffset
:
586 if lenOfUnfixedList
!= 0 :
587 countOfUnfixedList
= 0
588 while(countOfUnfixedList
< lenOfUnfixedList
) :
589 eachUnfixedPcd
= self
.PcdUnknownOffsetList
[countOfUnfixedList
]
590 needFixPcdSize
= eachUnfixedPcd
.PcdOccupySize
592 if eachUnfixedPcd
.PcdOffset
== '*' :
593 if LastOffset
% eachUnfixedPcd
.Alignment
!= 0:
594 LastOffset
= (LastOffset
/ eachUnfixedPcd
.Alignment
+ 1) * eachUnfixedPcd
.Alignment
595 # The offset un-fixed pcd can write into this free space
596 if needFixPcdSize
<= (NowOffset
- LastOffset
) :
597 # Change the offset value of un-fixed pcd
598 eachUnfixedPcd
.PcdOffset
= str(hex(LastOffset
))
599 eachUnfixedPcd
.PcdBinOffset
= LastOffset
600 # Insert this pcd into fixed offset pcd list.
601 self
.PcdFixedOffsetSizeList
.insert(FixOffsetSizeListCount
, eachUnfixedPcd
)
603 # Delete the item's offset that has been fixed and added into fixed offset list
604 self
.PcdUnknownOffsetList
.pop(countOfUnfixedList
)
606 # After item added, should enlarge the length of fixed pcd offset list
608 FixOffsetSizeListCount
+= 1
610 # Decrease the un-fixed pcd offset list's length
611 lenOfUnfixedList
-= 1
613 # Modify the last offset value
614 LastOffset
+= needFixPcdSize
616 # It can not insert into those two pcds, need to check still has other space can store it.
617 LastOffset
= NowOffset
+ self
.PcdFixedOffsetSizeList
[FixOffsetSizeListCount
].PcdOccupySize
618 FixOffsetSizeListCount
+= 1
621 # Set the FixOffsetSizeListCount = lenOfList for quit the loop
623 FixOffsetSizeListCount
= lenOfList
625 # No free space, smoothly connect with previous pcd.
626 elif LastOffset
== NowOffset
:
627 LastOffset
= NowOffset
+ eachFixedPcd
.PcdOccupySize
628 FixOffsetSizeListCount
+= 1
629 # Usually it will not enter into this thunk, if so, means it overlapped.
631 EdkLogger
.error("BPDG", BuildToolError
.ATTRIBUTE_NOT_AVAILABLE
,
632 "The offset value definition has overlapped at pcd: %s, it's offset is: %s, in file: %s line: %s" % \
633 (eachFixedPcd
.PcdCName
, eachFixedPcd
.PcdOffset
, eachFixedPcd
.InputFileName
, eachFixedPcd
.Lineno
),
635 FixOffsetSizeListCount
+= 1
637 # Continue to process the un-fixed offset pcd's list, add this time, just append them behind the fixed pcd's offset list.
638 lenOfUnfixedList
= len(self
.PcdUnknownOffsetList
)
639 lenOfList
= len(self
.PcdFixedOffsetSizeList
)
640 while (lenOfUnfixedList
> 0) :
641 # Still has items need to process
642 # The last pcd instance
643 LastPcd
= self
.PcdFixedOffsetSizeList
[lenOfList
-1]
644 NeedFixPcd
= self
.PcdUnknownOffsetList
[0]
646 NeedFixPcd
.PcdBinOffset
= LastPcd
.PcdBinOffset
+ LastPcd
.PcdOccupySize
647 if NeedFixPcd
.PcdBinOffset
% NeedFixPcd
.Alignment
!= 0:
648 NeedFixPcd
.PcdBinOffset
= (NeedFixPcd
.PcdBinOffset
/ NeedFixPcd
.Alignment
+ 1) * NeedFixPcd
.Alignment
650 NeedFixPcd
.PcdOffset
= str(hex(NeedFixPcd
.PcdBinOffset
))
652 # Insert this pcd into fixed offset pcd list's tail.
653 self
.PcdFixedOffsetSizeList
.insert(lenOfList
, NeedFixPcd
)
654 # Delete the item's offset that has been fixed and added into fixed offset list
655 self
.PcdUnknownOffsetList
.pop(0)
658 lenOfUnfixedList
-= 1
660 # Write the final data into output files.
662 def GenerateVpdFile (self
, MapFileName
, BinFileName
):
663 #Open an VPD file to process
666 fVpdFile
= open(BinFileName
, "wb", 0)
669 EdkLogger
.error("BPDG", BuildToolError
.FILE_OPEN_FAILURE
, "File open failed for %s" % self
.VpdFileName
, None)
672 fMapFile
= open(MapFileName
, "w", 0)
675 EdkLogger
.error("BPDG", BuildToolError
.FILE_OPEN_FAILURE
, "File open failed for %s" % self
.MapFileName
, None)
677 # Use a instance of BytesIO to cache data
678 fStringIO
= BytesIO('')
680 # Write the header of map file.
682 fMapFile
.write (st
.MAP_FILE_COMMENT_TEMPLATE
+ "\n")
684 EdkLogger
.error("BPDG", BuildToolError
.FILE_WRITE_FAILURE
, "Write data to file %s failed, please check whether the file been locked or using by other applications." % self
.MapFileName
, None)
686 for eachPcd
in self
.PcdFixedOffsetSizeList
:
689 fMapFile
.write("%s | %s | %s | %s | %s \n" % (eachPcd
.PcdCName
, eachPcd
.SkuId
, eachPcd
.PcdOffset
, eachPcd
.PcdSize
, eachPcd
.PcdUnpackValue
))
691 EdkLogger
.error("BPDG", BuildToolError
.FILE_WRITE_FAILURE
, "Write data to file %s failed, please check whether the file been locked or using by other applications." % self
.MapFileName
, None)
693 # Write Vpd binary file
694 fStringIO
.seek (eachPcd
.PcdBinOffset
)
695 if isinstance(eachPcd
.PcdValue
, list):
696 ValueList
= [chr(Item
) for Item
in eachPcd
.PcdValue
]
697 fStringIO
.write(''.join(ValueList
))
699 fStringIO
.write (eachPcd
.PcdValue
)
702 fVpdFile
.write (fStringIO
.getvalue())
704 EdkLogger
.error("BPDG", BuildToolError
.FILE_WRITE_FAILURE
, "Write data to file %s failed, please check whether the file been locked or using by other applications." % self
.VpdFileName
, None)