66f1faf5f36461921ad3cffa064146d2b1f69037
[mirror_edk2.git] / BaseTools / Source / Python / Workspace / DscBuildData.py
1 ## @file
2 # This file is used to create a database used by build tool
3 #
4 # Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>
5 # (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>
6 # This program and the accompanying materials
7 # are licensed and made available under the terms and conditions of the BSD License
8 # which accompanies this distribution. The full text of the license may be found at
9 # http://opensource.org/licenses/bsd-license.php
10 #
11 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13 #
14
15 ## Platform build information from DSC file
16 #
17 # This class is used to retrieve information stored in database and convert them
18 # into PlatformBuildClassObject form for easier use for AutoGen.
19 #
20 from Common.String import *
21 from Common.DataType import *
22 from Common.Misc import *
23 from types import *
24
25 from CommonDataClass.CommonClass import SkuInfoClass
26
27 from MetaDataTable import *
28 from MetaFileTable import *
29 from MetaFileParser import *
30
31 from WorkspaceCommon import GetDeclaredPcd
32 from Common.Misc import AnalyzeDscPcd
33 from Common.Misc import ProcessDuplicatedInf
34 import re
35 from Common.Parsing import IsValidWord
36 from Common.VariableAttributes import VariableAttributes
37 import Common.GlobalData as GlobalData
38 import subprocess
39 from Workspace.BuildClassObject import PlatformBuildClassObject, StructurePcd, PcdClassObject, ModuleBuildClassObject
40
41 #
42 # Treat CHAR16 as a synonym for UINT16. CHAR16 support is required for VFR C structs
43 #
44 PcdValueInitName = 'PcdValueInit'
45 PcdSupportedBaseTypes = ['BOOLEAN', 'UINT8', 'UINT16', 'UINT32', 'UINT64', 'CHAR16']
46 PcdSupportedBaseTypeWidth = {'BOOLEAN':8, 'UINT8':8, 'UINT16':16, 'UINT32':32, 'UINT64':64}
47 PcdUnsupportedBaseTypes = ['INT8', 'INT16', 'INT32', 'INT64', 'CHAR8', 'UINTN', 'INTN', 'VOID']
48
49 PcdMainCHeader = '''
50 /**
51 DO NOT EDIT
52 FILE auto-generated
53 **/
54
55 #include <stdio.h>
56 #include <stdlib.h>
57 #include <string.h>
58 #include <PcdValueCommon.h>
59 '''
60
61 PcdMainCEntry = '''
62 int
63 main (
64 int argc,
65 char *argv[]
66 )
67 {
68 return PcdValueMain (argc, argv);
69 }
70 '''
71
72 PcdMakefileHeader = '''
73 #
74 # DO NOT EDIT
75 # This file is auto-generated by build utility
76 #
77
78 '''
79
80 PcdMakefileEnd = '''
81 !INCLUDE $(BASE_TOOLS_PATH)\Source\C\Makefiles\ms.common
82
83 CFLAGS = $(CFLAGS) /wd4200 /wd4034 /wd4101
84
85 LIBS = $(LIB_PATH)\Common.lib
86
87 !INCLUDE $(BASE_TOOLS_PATH)\Source\C\Makefiles\ms.app
88 '''
89
90 PcdGccMakefile = '''
91 ARCH ?= IA32
92 MAKEROOT ?= $(EDK_TOOLS_PATH)/Source/C
93 LIBS = -lCommon
94 '''
95
96 class DscBuildData(PlatformBuildClassObject):
97 # dict used to convert PCD type in database to string used by build tool
98 _PCD_TYPE_STRING_ = {
99 MODEL_PCD_FIXED_AT_BUILD : "FixedAtBuild",
100 MODEL_PCD_PATCHABLE_IN_MODULE : "PatchableInModule",
101 MODEL_PCD_FEATURE_FLAG : "FeatureFlag",
102 MODEL_PCD_DYNAMIC : "Dynamic",
103 MODEL_PCD_DYNAMIC_DEFAULT : "Dynamic",
104 MODEL_PCD_DYNAMIC_HII : "DynamicHii",
105 MODEL_PCD_DYNAMIC_VPD : "DynamicVpd",
106 MODEL_PCD_DYNAMIC_EX : "DynamicEx",
107 MODEL_PCD_DYNAMIC_EX_DEFAULT : "DynamicEx",
108 MODEL_PCD_DYNAMIC_EX_HII : "DynamicExHii",
109 MODEL_PCD_DYNAMIC_EX_VPD : "DynamicExVpd",
110 }
111
112 # dict used to convert part of [Defines] to members of DscBuildData directly
113 _PROPERTY_ = {
114 #
115 # Required Fields
116 #
117 TAB_DSC_DEFINES_PLATFORM_NAME : "_PlatformName",
118 TAB_DSC_DEFINES_PLATFORM_GUID : "_Guid",
119 TAB_DSC_DEFINES_PLATFORM_VERSION : "_Version",
120 TAB_DSC_DEFINES_DSC_SPECIFICATION : "_DscSpecification",
121 # TAB_DSC_DEFINES_OUTPUT_DIRECTORY : "_OutputDirectory",
122 # TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES : "_SupArchList",
123 # TAB_DSC_DEFINES_BUILD_TARGETS : "_BuildTargets",
124 TAB_DSC_DEFINES_SKUID_IDENTIFIER : "_SkuName",
125 # TAB_DSC_DEFINES_FLASH_DEFINITION : "_FlashDefinition",
126 TAB_DSC_DEFINES_BUILD_NUMBER : "_BuildNumber",
127 TAB_DSC_DEFINES_MAKEFILE_NAME : "_MakefileName",
128 TAB_DSC_DEFINES_BS_BASE_ADDRESS : "_BsBaseAddress",
129 TAB_DSC_DEFINES_RT_BASE_ADDRESS : "_RtBaseAddress",
130 # TAB_DSC_DEFINES_RFC_LANGUAGES : "_RFCLanguages",
131 # TAB_DSC_DEFINES_ISO_LANGUAGES : "_ISOLanguages",
132 }
133
134 # used to compose dummy library class name for those forced library instances
135 _NullLibraryNumber = 0
136
137 ## Constructor of DscBuildData
138 #
139 # Initialize object of DscBuildData
140 #
141 # @param FilePath The path of platform description file
142 # @param RawData The raw data of DSC file
143 # @param BuildDataBase Database used to retrieve module/package information
144 # @param Arch The target architecture
145 # @param Platform (not used for DscBuildData)
146 # @param Macros Macros used for replacement in DSC file
147 #
148 def __init__(self, FilePath, RawData, BuildDataBase, Arch='COMMON', Target=None, Toolchain=None):
149 self.MetaFile = FilePath
150 self._RawData = RawData
151 self._Bdb = BuildDataBase
152 self._Arch = Arch
153 self._Target = Target
154 self._Toolchain = Toolchain
155 self._Clear()
156 self._HandleOverridePath()
157 if os.getenv("WORKSPACE"):
158 self.OutputPath = os.path.join(os.getenv("WORKSPACE"), 'Build', PcdValueInitName)
159 else:
160 self.OutputPath = os.path.dirname(self.DscFile)
161 self.DefaultStores = None
162 self.SkuIdMgr = SkuClass(self.SkuName, self.SkuIds)
163 arraystr = self.SkuIdMgr.DumpSkuIdArrary()
164
165 ## XXX[key] = value
166 def __setitem__(self, key, value):
167 self.__dict__[self._PROPERTY_[key]] = value
168
169 ## value = XXX[key]
170 def __getitem__(self, key):
171 return self.__dict__[self._PROPERTY_[key]]
172
173 ## "in" test support
174 def __contains__(self, key):
175 return key in self._PROPERTY_
176
177 ## Set all internal used members of DscBuildData to None
178 def _Clear(self):
179 self._Header = None
180 self._PlatformName = None
181 self._Guid = None
182 self._Version = None
183 self._DscSpecification = None
184 self._OutputDirectory = None
185 self._SupArchList = None
186 self._BuildTargets = None
187 self._SkuName = None
188 self._PcdInfoFlag = None
189 self._VarCheckFlag = None
190 self._FlashDefinition = None
191 self._Prebuild = None
192 self._Postbuild = None
193 self._BuildNumber = None
194 self._MakefileName = None
195 self._BsBaseAddress = None
196 self._RtBaseAddress = None
197 self._SkuIds = None
198 self._Modules = None
199 self._LibraryInstances = None
200 self._LibraryClasses = None
201 self._Pcds = None
202 self._DecPcds = None
203 self._BuildOptions = None
204 self._ModuleTypeOptions = None
205 self._LoadFixAddress = None
206 self._RFCLanguages = None
207 self._ISOLanguages = None
208 self._VpdToolGuid = None
209 self.__Macros = None
210 self.DefaultStores = None
211
212
213 ## handle Override Path of Module
214 def _HandleOverridePath(self):
215 RecordList = self._RawData[MODEL_META_DATA_COMPONENT, self._Arch]
216 Macros = self._Macros
217 Macros["EDK_SOURCE"] = GlobalData.gEcpSource
218 for Record in RecordList:
219 ModuleId = Record[6]
220 LineNo = Record[7]
221 ModuleFile = PathClass(NormPath(Record[0]), GlobalData.gWorkspace, Arch=self._Arch)
222 RecordList = self._RawData[MODEL_META_DATA_COMPONENT_SOURCE_OVERRIDE_PATH, self._Arch, None, ModuleId]
223 if RecordList != []:
224 SourceOverridePath = mws.join(GlobalData.gWorkspace, NormPath(RecordList[0][0]))
225
226 # Check if the source override path exists
227 if not os.path.isdir(SourceOverridePath):
228 EdkLogger.error('build', FILE_NOT_FOUND, Message='Source override path does not exist:', File=self.MetaFile, ExtraData=SourceOverridePath, Line=LineNo)
229
230 # Add to GlobalData Variables
231 GlobalData.gOverrideDir[ModuleFile.Key] = SourceOverridePath
232
233 ## Get current effective macros
234 def _GetMacros(self):
235 if self.__Macros == None:
236 self.__Macros = {}
237 self.__Macros.update(GlobalData.gPlatformDefines)
238 self.__Macros.update(GlobalData.gGlobalDefines)
239 self.__Macros.update(GlobalData.gCommandLineDefines)
240 return self.__Macros
241
242 ## Get architecture
243 def _GetArch(self):
244 return self._Arch
245
246 ## Set architecture
247 #
248 # Changing the default ARCH to another may affect all other information
249 # because all information in a platform may be ARCH-related. That's
250 # why we need to clear all internal used members, in order to cause all
251 # information to be re-retrieved.
252 #
253 # @param Value The value of ARCH
254 #
255 def _SetArch(self, Value):
256 if self._Arch == Value:
257 return
258 self._Arch = Value
259 self._Clear()
260
261 ## Retrieve all information in [Defines] section
262 #
263 # (Retriving all [Defines] information in one-shot is just to save time.)
264 #
265 def _GetHeaderInfo(self):
266 RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch]
267 for Record in RecordList:
268 Name = Record[1]
269 # items defined _PROPERTY_ don't need additional processing
270
271 # some special items in [Defines] section need special treatment
272 if Name == TAB_DSC_DEFINES_OUTPUT_DIRECTORY:
273 self._OutputDirectory = NormPath(Record[2], self._Macros)
274 if ' ' in self._OutputDirectory:
275 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in OUTPUT_DIRECTORY",
276 File=self.MetaFile, Line=Record[-1],
277 ExtraData=self._OutputDirectory)
278 elif Name == TAB_DSC_DEFINES_FLASH_DEFINITION:
279 self._FlashDefinition = PathClass(NormPath(Record[2], self._Macros), GlobalData.gWorkspace)
280 ErrorCode, ErrorInfo = self._FlashDefinition.Validate('.fdf')
281 if ErrorCode != 0:
282 EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=Record[-1],
283 ExtraData=ErrorInfo)
284 elif Name == TAB_DSC_PREBUILD:
285 PrebuildValue = Record[2]
286 if Record[2][0] == '"':
287 if Record[2][-1] != '"':
288 EdkLogger.error('build', FORMAT_INVALID, 'Missing double quotes in the end of %s statement.' % TAB_DSC_PREBUILD,
289 File=self.MetaFile, Line=Record[-1])
290 PrebuildValue = Record[2][1:-1]
291 self._Prebuild = PrebuildValue
292 elif Name == TAB_DSC_POSTBUILD:
293 PostbuildValue = Record[2]
294 if Record[2][0] == '"':
295 if Record[2][-1] != '"':
296 EdkLogger.error('build', FORMAT_INVALID, 'Missing double quotes in the end of %s statement.' % TAB_DSC_POSTBUILD,
297 File=self.MetaFile, Line=Record[-1])
298 PostbuildValue = Record[2][1:-1]
299 self._Postbuild = PostbuildValue
300 elif Name == TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES:
301 self._SupArchList = GetSplitValueList(Record[2], TAB_VALUE_SPLIT)
302 elif Name == TAB_DSC_DEFINES_BUILD_TARGETS:
303 self._BuildTargets = GetSplitValueList(Record[2])
304 elif Name == TAB_DSC_DEFINES_SKUID_IDENTIFIER:
305 if self._SkuName == None:
306 self._SkuName = Record[2]
307 if GlobalData.gSKUID_CMD:
308 self._SkuName = GlobalData.gSKUID_CMD
309 elif Name == TAB_DSC_DEFINES_PCD_INFO_GENERATION:
310 self._PcdInfoFlag = Record[2]
311 elif Name == TAB_DSC_DEFINES_PCD_VAR_CHECK_GENERATION:
312 self._VarCheckFlag = Record[2]
313 elif Name == TAB_FIX_LOAD_TOP_MEMORY_ADDRESS:
314 try:
315 self._LoadFixAddress = int (Record[2], 0)
316 except:
317 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS %s is not valid dec or hex string" % (Record[2]))
318 elif Name == TAB_DSC_DEFINES_RFC_LANGUAGES:
319 if not Record[2] or Record[2][0] != '"' or Record[2][-1] != '"' or len(Record[2]) == 1:
320 EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'language code for RFC_LANGUAGES must have double quotes around it, for example: RFC_LANGUAGES = "en-us;zh-hans"',
321 File=self.MetaFile, Line=Record[-1])
322 LanguageCodes = Record[2][1:-1]
323 if not LanguageCodes:
324 EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'one or more RFC4646 format language code must be provided for RFC_LANGUAGES statement',
325 File=self.MetaFile, Line=Record[-1])
326 LanguageList = GetSplitValueList(LanguageCodes, TAB_SEMI_COLON_SPLIT)
327 # check whether there is empty entries in the list
328 if None in LanguageList:
329 EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'one or more empty language code is in RFC_LANGUAGES statement',
330 File=self.MetaFile, Line=Record[-1])
331 self._RFCLanguages = LanguageList
332 elif Name == TAB_DSC_DEFINES_ISO_LANGUAGES:
333 if not Record[2] or Record[2][0] != '"' or Record[2][-1] != '"' or len(Record[2]) == 1:
334 EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'language code for ISO_LANGUAGES must have double quotes around it, for example: ISO_LANGUAGES = "engchn"',
335 File=self.MetaFile, Line=Record[-1])
336 LanguageCodes = Record[2][1:-1]
337 if not LanguageCodes:
338 EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'one or more ISO639-2 format language code must be provided for ISO_LANGUAGES statement',
339 File=self.MetaFile, Line=Record[-1])
340 if len(LanguageCodes) % 3:
341 EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'bad ISO639-2 format for ISO_LANGUAGES',
342 File=self.MetaFile, Line=Record[-1])
343 LanguageList = []
344 for i in range(0, len(LanguageCodes), 3):
345 LanguageList.append(LanguageCodes[i:i + 3])
346 self._ISOLanguages = LanguageList
347 elif Name == TAB_DSC_DEFINES_VPD_TOOL_GUID:
348 #
349 # try to convert GUID to a real UUID value to see whether the GUID is format
350 # for VPD_TOOL_GUID is correct.
351 #
352 try:
353 uuid.UUID(Record[2])
354 except:
355 EdkLogger.error("build", FORMAT_INVALID, "Invalid GUID format for VPD_TOOL_GUID", File=self.MetaFile)
356 self._VpdToolGuid = Record[2]
357 elif Name in self:
358 self[Name] = Record[2]
359 # set _Header to non-None in order to avoid database re-querying
360 self._Header = 'DUMMY'
361
362 ## Retrieve platform name
363 def _GetPlatformName(self):
364 if self._PlatformName == None:
365 if self._Header == None:
366 self._GetHeaderInfo()
367 if self._PlatformName == None:
368 EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No PLATFORM_NAME", File=self.MetaFile)
369 return self._PlatformName
370
371 ## Retrieve file guid
372 def _GetFileGuid(self):
373 if self._Guid == None:
374 if self._Header == None:
375 self._GetHeaderInfo()
376 if self._Guid == None:
377 EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No PLATFORM_GUID", File=self.MetaFile)
378 return self._Guid
379
380 ## Retrieve platform version
381 def _GetVersion(self):
382 if self._Version == None:
383 if self._Header == None:
384 self._GetHeaderInfo()
385 if self._Version == None:
386 EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No PLATFORM_VERSION", File=self.MetaFile)
387 return self._Version
388
389 ## Retrieve platform description file version
390 def _GetDscSpec(self):
391 if self._DscSpecification == None:
392 if self._Header == None:
393 self._GetHeaderInfo()
394 if self._DscSpecification == None:
395 EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No DSC_SPECIFICATION", File=self.MetaFile)
396 return self._DscSpecification
397
398 ## Retrieve OUTPUT_DIRECTORY
399 def _GetOutpuDir(self):
400 if self._OutputDirectory == None:
401 if self._Header == None:
402 self._GetHeaderInfo()
403 if self._OutputDirectory == None:
404 self._OutputDirectory = os.path.join("Build", self._PlatformName)
405 return self._OutputDirectory
406
407 ## Retrieve SUPPORTED_ARCHITECTURES
408 def _GetSupArch(self):
409 if self._SupArchList == None:
410 if self._Header == None:
411 self._GetHeaderInfo()
412 if self._SupArchList == None:
413 EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No SUPPORTED_ARCHITECTURES", File=self.MetaFile)
414 return self._SupArchList
415
416 ## Retrieve BUILD_TARGETS
417 def _GetBuildTarget(self):
418 if self._BuildTargets == None:
419 if self._Header == None:
420 self._GetHeaderInfo()
421 if self._BuildTargets == None:
422 EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No BUILD_TARGETS", File=self.MetaFile)
423 return self._BuildTargets
424
425 def _GetPcdInfoFlag(self):
426 if self._PcdInfoFlag == None or self._PcdInfoFlag.upper() == 'FALSE':
427 return False
428 elif self._PcdInfoFlag.upper() == 'TRUE':
429 return True
430 else:
431 return False
432 def _GetVarCheckFlag(self):
433 if self._VarCheckFlag == None or self._VarCheckFlag.upper() == 'FALSE':
434 return False
435 elif self._VarCheckFlag.upper() == 'TRUE':
436 return True
437 else:
438 return False
439
440 # # Retrieve SKUID_IDENTIFIER
441 def _GetSkuName(self):
442 if self._SkuName == None:
443 if self._Header == None:
444 self._GetHeaderInfo()
445 if self._SkuName == None:
446 self._SkuName = 'DEFAULT'
447 return self._SkuName
448
449 ## Override SKUID_IDENTIFIER
450 def _SetSkuName(self, Value):
451 self._SkuName = Value
452 self._Pcds = None
453
454 def _GetFdfFile(self):
455 if self._FlashDefinition == None:
456 if self._Header == None:
457 self._GetHeaderInfo()
458 if self._FlashDefinition == None:
459 self._FlashDefinition = ''
460 return self._FlashDefinition
461
462 def _GetPrebuild(self):
463 if self._Prebuild == None:
464 if self._Header == None:
465 self._GetHeaderInfo()
466 if self._Prebuild == None:
467 self._Prebuild = ''
468 return self._Prebuild
469
470 def _GetPostbuild(self):
471 if self._Postbuild == None:
472 if self._Header == None:
473 self._GetHeaderInfo()
474 if self._Postbuild == None:
475 self._Postbuild = ''
476 return self._Postbuild
477
478 ## Retrieve FLASH_DEFINITION
479 def _GetBuildNumber(self):
480 if self._BuildNumber == None:
481 if self._Header == None:
482 self._GetHeaderInfo()
483 if self._BuildNumber == None:
484 self._BuildNumber = ''
485 return self._BuildNumber
486
487 ## Retrieve MAKEFILE_NAME
488 def _GetMakefileName(self):
489 if self._MakefileName == None:
490 if self._Header == None:
491 self._GetHeaderInfo()
492 if self._MakefileName == None:
493 self._MakefileName = ''
494 return self._MakefileName
495
496 ## Retrieve BsBaseAddress
497 def _GetBsBaseAddress(self):
498 if self._BsBaseAddress == None:
499 if self._Header == None:
500 self._GetHeaderInfo()
501 if self._BsBaseAddress == None:
502 self._BsBaseAddress = ''
503 return self._BsBaseAddress
504
505 ## Retrieve RtBaseAddress
506 def _GetRtBaseAddress(self):
507 if self._RtBaseAddress == None:
508 if self._Header == None:
509 self._GetHeaderInfo()
510 if self._RtBaseAddress == None:
511 self._RtBaseAddress = ''
512 return self._RtBaseAddress
513
514 ## Retrieve the top address for the load fix address
515 def _GetLoadFixAddress(self):
516 if self._LoadFixAddress == None:
517 if self._Header == None:
518 self._GetHeaderInfo()
519
520 if self._LoadFixAddress == None:
521 self._LoadFixAddress = self._Macros.get(TAB_FIX_LOAD_TOP_MEMORY_ADDRESS, '0')
522
523 try:
524 self._LoadFixAddress = int (self._LoadFixAddress, 0)
525 except:
526 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS %s is not valid dec or hex string" % (self._LoadFixAddress))
527
528 #
529 # If command line defined, should override the value in DSC file.
530 #
531 if 'FIX_LOAD_TOP_MEMORY_ADDRESS' in GlobalData.gCommandLineDefines.keys():
532 try:
533 self._LoadFixAddress = int(GlobalData.gCommandLineDefines['FIX_LOAD_TOP_MEMORY_ADDRESS'], 0)
534 except:
535 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS %s is not valid dec or hex string" % (GlobalData.gCommandLineDefines['FIX_LOAD_TOP_MEMORY_ADDRESS']))
536
537 if self._LoadFixAddress < 0:
538 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS is set to the invalid negative value 0x%x" % (self._LoadFixAddress))
539 if self._LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self._LoadFixAddress % 0x1000 != 0:
540 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS is set to the invalid unaligned 4K value 0x%x" % (self._LoadFixAddress))
541
542 return self._LoadFixAddress
543
544 ## Retrieve RFCLanguage filter
545 def _GetRFCLanguages(self):
546 if self._RFCLanguages == None:
547 if self._Header == None:
548 self._GetHeaderInfo()
549 if self._RFCLanguages == None:
550 self._RFCLanguages = []
551 return self._RFCLanguages
552
553 ## Retrieve ISOLanguage filter
554 def _GetISOLanguages(self):
555 if self._ISOLanguages == None:
556 if self._Header == None:
557 self._GetHeaderInfo()
558 if self._ISOLanguages == None:
559 self._ISOLanguages = []
560 return self._ISOLanguages
561 ## Retrieve the GUID string for VPD tool
562 def _GetVpdToolGuid(self):
563 if self._VpdToolGuid == None:
564 if self._Header == None:
565 self._GetHeaderInfo()
566 if self._VpdToolGuid == None:
567 self._VpdToolGuid = ''
568 return self._VpdToolGuid
569
570 ## Retrieve [SkuIds] section information
571 def _GetSkuIds(self):
572 if self._SkuIds == None:
573 self._SkuIds = sdict()
574 RecordList = self._RawData[MODEL_EFI_SKU_ID, self._Arch]
575 for Record in RecordList:
576 if Record[0] in [None, '']:
577 EdkLogger.error('build', FORMAT_INVALID, 'No Sku ID number',
578 File=self.MetaFile, Line=Record[-1])
579 if Record[1] in [None, '']:
580 EdkLogger.error('build', FORMAT_INVALID, 'No Sku ID name',
581 File=self.MetaFile, Line=Record[-1])
582 Pattern = re.compile('^[1-9]\d*|0$')
583 if Pattern.match(Record[0]) == None:
584 EdkLogger.error('build', FORMAT_INVALID, "The format of the Sku ID number is invalid. The correct format is '{(0-9)} {(1-9)(0-9)+}'",
585 File=self.MetaFile, Line=Record[-1])
586 if not IsValidWord(Record[1]):
587 EdkLogger.error('build', FORMAT_INVALID, "The format of the Sku ID name is invalid. The correct format is '(a-zA-Z0-9_)(a-zA-Z0-9_-.)*'",
588 File=self.MetaFile, Line=Record[-1])
589 self._SkuIds[Record[1].upper()] = (Record[0], Record[1].upper(), Record[2].upper())
590 if 'DEFAULT' not in self._SkuIds:
591 self._SkuIds['DEFAULT'] = ("0","DEFAULT","DEFAULT")
592 if 'COMMON' not in self._SkuIds:
593 self._SkuIds['COMMON'] = ("0","DEFAULT","DEFAULT")
594 return self._SkuIds
595 def ToInt(self,intstr):
596 return int(intstr,16) if intstr.upper().startswith("0X") else int(intstr)
597 def _GetDefaultStores(self):
598 if self.DefaultStores == None:
599 self.DefaultStores = sdict()
600 RecordList = self._RawData[MODEL_EFI_DEFAULT_STORES, self._Arch]
601 for Record in RecordList:
602 if Record[0] in [None, '']:
603 EdkLogger.error('build', FORMAT_INVALID, 'No DefaultStores ID number',
604 File=self.MetaFile, Line=Record[-1])
605 if Record[1] in [None, '']:
606 EdkLogger.error('build', FORMAT_INVALID, 'No DefaultStores ID name',
607 File=self.MetaFile, Line=Record[-1])
608 self.DefaultStores[Record[1].upper()] = (self.ToInt(Record[0]),Record[1].upper())
609 if TAB_DEFAULT_STORES_DEFAULT not in self.DefaultStores:
610 self.DefaultStores[TAB_DEFAULT_STORES_DEFAULT] = (0,TAB_DEFAULT_STORES_DEFAULT)
611 GlobalData.gDefaultStores = self.DefaultStores.keys()
612 if GlobalData.gDefaultStores:
613 GlobalData.gDefaultStores.sort()
614 return self.DefaultStores
615
616 ## Retrieve [Components] section information
617 def _GetModules(self):
618 if self._Modules != None:
619 return self._Modules
620
621 self._Modules = sdict()
622 RecordList = self._RawData[MODEL_META_DATA_COMPONENT, self._Arch]
623 Macros = self._Macros
624 Macros["EDK_SOURCE"] = GlobalData.gEcpSource
625 for Record in RecordList:
626 DuplicatedFile = False
627
628 ModuleFile = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)
629 ModuleId = Record[6]
630 LineNo = Record[7]
631
632 # check the file validation
633 ErrorCode, ErrorInfo = ModuleFile.Validate('.inf')
634 if ErrorCode != 0:
635 EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,
636 ExtraData=ErrorInfo)
637 # Check duplication
638 # If arch is COMMON, no duplicate module is checked since all modules in all component sections are selected
639 if self._Arch != 'COMMON' and ModuleFile in self._Modules:
640 DuplicatedFile = True
641
642 Module = ModuleBuildClassObject()
643 Module.MetaFile = ModuleFile
644
645 # get module private library instance
646 RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, None, ModuleId]
647 for Record in RecordList:
648 LibraryClass = Record[0]
649 LibraryPath = PathClass(NormPath(Record[1], Macros), GlobalData.gWorkspace, Arch=self._Arch)
650 LineNo = Record[-1]
651
652 # check the file validation
653 ErrorCode, ErrorInfo = LibraryPath.Validate('.inf')
654 if ErrorCode != 0:
655 EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,
656 ExtraData=ErrorInfo)
657
658 if LibraryClass == '' or LibraryClass == 'NULL':
659 self._NullLibraryNumber += 1
660 LibraryClass = 'NULL%d' % self._NullLibraryNumber
661 EdkLogger.verbose("Found forced library for %s\n\t%s [%s]" % (ModuleFile, LibraryPath, LibraryClass))
662 Module.LibraryClasses[LibraryClass] = LibraryPath
663 if LibraryPath not in self.LibraryInstances:
664 self.LibraryInstances.append(LibraryPath)
665
666 # get module private PCD setting
667 for Type in [MODEL_PCD_FIXED_AT_BUILD, MODEL_PCD_PATCHABLE_IN_MODULE, \
668 MODEL_PCD_FEATURE_FLAG, MODEL_PCD_DYNAMIC, MODEL_PCD_DYNAMIC_EX]:
669 RecordList = self._RawData[Type, self._Arch, None, ModuleId]
670 for TokenSpaceGuid, PcdCName, Setting, Dummy1, Dummy2, Dummy3, Dummy4,Dummy5 in RecordList:
671 TokenList = GetSplitValueList(Setting)
672 DefaultValue = TokenList[0]
673 if len(TokenList) > 1:
674 MaxDatumSize = TokenList[1]
675 else:
676 MaxDatumSize = ''
677 TypeString = self._PCD_TYPE_STRING_[Type]
678 Pcd = PcdClassObject(
679 PcdCName,
680 TokenSpaceGuid,
681 TypeString,
682 '',
683 DefaultValue,
684 '',
685 MaxDatumSize,
686 {},
687 False,
688 None
689 )
690 Module.Pcds[PcdCName, TokenSpaceGuid] = Pcd
691
692 # get module private build options
693 RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, None, ModuleId]
694 for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4,Dummy5 in RecordList:
695 if (ToolChainFamily, ToolChain) not in Module.BuildOptions:
696 Module.BuildOptions[ToolChainFamily, ToolChain] = Option
697 else:
698 OptionString = Module.BuildOptions[ToolChainFamily, ToolChain]
699 Module.BuildOptions[ToolChainFamily, ToolChain] = OptionString + " " + Option
700
701 RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, None, ModuleId]
702 if DuplicatedFile and not RecordList:
703 EdkLogger.error('build', FILE_DUPLICATED, File=self.MetaFile, ExtraData=str(ModuleFile), Line=LineNo)
704 if RecordList:
705 if len(RecordList) != 1:
706 EdkLogger.error('build', OPTION_UNKNOWN, 'Only FILE_GUID can be listed in <Defines> section.',
707 File=self.MetaFile, ExtraData=str(ModuleFile), Line=LineNo)
708 ModuleFile = ProcessDuplicatedInf(ModuleFile, RecordList[0][2], GlobalData.gWorkspace)
709 ModuleFile.Arch = self._Arch
710
711 self._Modules[ModuleFile] = Module
712 return self._Modules
713
714 ## Retrieve all possible library instances used in this platform
715 def _GetLibraryInstances(self):
716 if self._LibraryInstances == None:
717 self._GetLibraryClasses()
718 return self._LibraryInstances
719
720 ## Retrieve [LibraryClasses] information
721 def _GetLibraryClasses(self):
722 if self._LibraryClasses == None:
723 self._LibraryInstances = []
724 #
725 # tdict is a special dict kind of type, used for selecting correct
726 # library instance for given library class and module type
727 #
728 LibraryClassDict = tdict(True, 3)
729 # track all library class names
730 LibraryClassSet = set()
731 RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, None, -1]
732 Macros = self._Macros
733 for Record in RecordList:
734 LibraryClass, LibraryInstance, Dummy, Arch, ModuleType, Dummy,Dummy, LineNo = Record
735 if LibraryClass == '' or LibraryClass == 'NULL':
736 self._NullLibraryNumber += 1
737 LibraryClass = 'NULL%d' % self._NullLibraryNumber
738 EdkLogger.verbose("Found forced library for arch=%s\n\t%s [%s]" % (Arch, LibraryInstance, LibraryClass))
739 LibraryClassSet.add(LibraryClass)
740 LibraryInstance = PathClass(NormPath(LibraryInstance, Macros), GlobalData.gWorkspace, Arch=self._Arch)
741 # check the file validation
742 ErrorCode, ErrorInfo = LibraryInstance.Validate('.inf')
743 if ErrorCode != 0:
744 EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,
745 ExtraData=ErrorInfo)
746
747 if ModuleType != 'COMMON' and ModuleType not in SUP_MODULE_LIST:
748 EdkLogger.error('build', OPTION_UNKNOWN, "Unknown module type [%s]" % ModuleType,
749 File=self.MetaFile, ExtraData=LibraryInstance, Line=LineNo)
750 LibraryClassDict[Arch, ModuleType, LibraryClass] = LibraryInstance
751 if LibraryInstance not in self._LibraryInstances:
752 self._LibraryInstances.append(LibraryInstance)
753
754 # resolve the specific library instance for each class and each module type
755 self._LibraryClasses = tdict(True)
756 for LibraryClass in LibraryClassSet:
757 # try all possible module types
758 for ModuleType in SUP_MODULE_LIST:
759 LibraryInstance = LibraryClassDict[self._Arch, ModuleType, LibraryClass]
760 if LibraryInstance == None:
761 continue
762 self._LibraryClasses[LibraryClass, ModuleType] = LibraryInstance
763
764 # for Edk style library instances, which are listed in different section
765 Macros["EDK_SOURCE"] = GlobalData.gEcpSource
766 RecordList = self._RawData[MODEL_EFI_LIBRARY_INSTANCE, self._Arch]
767 for Record in RecordList:
768 File = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)
769 LineNo = Record[-1]
770 # check the file validation
771 ErrorCode, ErrorInfo = File.Validate('.inf')
772 if ErrorCode != 0:
773 EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,
774 ExtraData=ErrorInfo)
775 if File not in self._LibraryInstances:
776 self._LibraryInstances.append(File)
777 #
778 # we need the module name as the library class name, so we have
779 # to parse it here. (self._Bdb[] will trigger a file parse if it
780 # hasn't been parsed)
781 #
782 Library = self._Bdb[File, self._Arch, self._Target, self._Toolchain]
783 self._LibraryClasses[Library.BaseName, ':dummy:'] = Library
784 return self._LibraryClasses
785
786 def _ValidatePcd(self, PcdCName, TokenSpaceGuid, Setting, PcdType, LineNo):
787 if self._DecPcds == None:
788
789 FdfInfList = []
790 if GlobalData.gFdfParser:
791 FdfInfList = GlobalData.gFdfParser.Profile.InfList
792
793 PkgSet = set()
794 for Inf in FdfInfList:
795 ModuleFile = PathClass(NormPath(Inf), GlobalData.gWorkspace, Arch=self._Arch)
796 if ModuleFile in self._Modules:
797 continue
798 ModuleData = self._Bdb[ModuleFile, self._Arch, self._Target, self._Toolchain]
799 PkgSet.update(ModuleData.Packages)
800
801 self._DecPcds = GetDeclaredPcd(self, self._Bdb, self._Arch, self._Target, self._Toolchain,PkgSet)
802
803
804 if (PcdCName, TokenSpaceGuid) not in self._DecPcds:
805 EdkLogger.error('build', PARSER_ERROR,
806 "Pcd (%s.%s) defined in DSC is not declared in DEC files. Arch: ['%s']" % (TokenSpaceGuid, PcdCName, self._Arch),
807 File=self.MetaFile, Line=LineNo)
808 ValueList, IsValid, Index = AnalyzeDscPcd(Setting, PcdType, self._DecPcds[PcdCName, TokenSpaceGuid].DatumType)
809 if not IsValid:
810 if PcdType not in [MODEL_PCD_FEATURE_FLAG, MODEL_PCD_FIXED_AT_BUILD]:
811 EdkLogger.error('build', FORMAT_INVALID, "Pcd format incorrect.", File=self.MetaFile, Line=LineNo,
812 ExtraData="%s.%s|%s" % (TokenSpaceGuid, PcdCName, Setting))
813 else:
814 if ValueList[2] == '-1':
815 EdkLogger.error('build', FORMAT_INVALID, "Pcd format incorrect.", File=self.MetaFile, Line=LineNo,
816 ExtraData="%s.%s|%s" % (TokenSpaceGuid, PcdCName, Setting))
817 if ValueList[Index] and PcdType not in [MODEL_PCD_FEATURE_FLAG, MODEL_PCD_FIXED_AT_BUILD]:
818 try:
819 ValueList[Index] = ValueExpression(ValueList[Index], GlobalData.gPlatformPcds)(True)
820 except WrnExpression, Value:
821 ValueList[Index] = Value.result
822 except EvaluationException, Excpt:
823 if hasattr(Excpt, 'Pcd'):
824 if Excpt.Pcd in GlobalData.gPlatformOtherPcds:
825 EdkLogger.error('Parser', FORMAT_INVALID, "Cannot use this PCD (%s) in an expression as"
826 " it must be defined in a [PcdsFixedAtBuild] or [PcdsFeatureFlag] section"
827 " of the DSC file" % Excpt.Pcd,
828 File=self.MetaFile, Line=LineNo)
829 else:
830 EdkLogger.error('Parser', FORMAT_INVALID, "PCD (%s) is not defined in DSC file" % Excpt.Pcd,
831 File=self.MetaFile, Line=LineNo)
832 else:
833 EdkLogger.error('Parser', FORMAT_INVALID, "Invalid expression: %s" % str(Excpt),
834 File=self.MetaFile, Line=LineNo)
835 if ValueList[Index] == 'True':
836 ValueList[Index] = '1'
837 elif ValueList[Index] == 'False':
838 ValueList[Index] = '0'
839 if ValueList[Index]:
840 Valid, ErrStr = CheckPcdDatum(self._DecPcds[PcdCName, TokenSpaceGuid].DatumType, ValueList[Index])
841 if not Valid:
842 EdkLogger.error('build', FORMAT_INVALID, ErrStr, File=self.MetaFile, Line=LineNo,
843 ExtraData="%s.%s" % (TokenSpaceGuid, PcdCName))
844 if PcdType in (MODEL_PCD_DYNAMIC_DEFAULT, MODEL_PCD_DYNAMIC_EX_DEFAULT):
845 if self._DecPcds[PcdCName, TokenSpaceGuid].DatumType.strip() != ValueList[1].strip():
846 EdkLogger.error('build', FORMAT_INVALID, ErrStr , File=self.MetaFile, Line=LineNo,
847 ExtraData="%s.%s|%s" % (TokenSpaceGuid, PcdCName, Setting))
848 return ValueList
849
850 def _FilterPcdBySkuUsage(self,Pcds):
851 available_sku = self.SkuIdMgr.AvailableSkuIdSet
852 sku_usage = self.SkuIdMgr.SkuUsageType
853 if sku_usage == SkuClass.SINGLE:
854 for pcdname in Pcds:
855 pcd = Pcds[pcdname]
856 Pcds[pcdname].SkuInfoList = {"DEFAULT":pcd.SkuInfoList[skuid] for skuid in pcd.SkuInfoList if skuid in available_sku}
857 if type(pcd) is StructurePcd and pcd.SkuOverrideValues:
858 Pcds[pcdname].SkuOverrideValues = {"DEFAULT":pcd.SkuOverrideValues[skuid] for skuid in pcd.SkuOverrideValues if skuid in available_sku}
859 else:
860 for pcdname in Pcds:
861 pcd = Pcds[pcdname]
862 Pcds[pcdname].SkuInfoList = {skuid:pcd.SkuInfoList[skuid] for skuid in pcd.SkuInfoList if skuid in available_sku}
863 if type(pcd) is StructurePcd and pcd.SkuOverrideValues:
864 Pcds[pcdname].SkuOverrideValues = {skuid:pcd.SkuOverrideValues[skuid] for skuid in pcd.SkuOverrideValues if skuid in available_sku}
865 return Pcds
866 def CompleteHiiPcdsDefaultStores(self,Pcds):
867 HiiPcd = [Pcds[pcd] for pcd in Pcds if Pcds[pcd].Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]]
868 DefaultStoreMgr = DefaultStore(self.DefaultStores)
869 for pcd in HiiPcd:
870 for skuid in pcd.SkuInfoList:
871 skuobj = pcd.SkuInfoList.get(skuid)
872 if "STANDARD" not in skuobj.DefaultStoreDict:
873 PcdDefaultStoreSet = set([defaultstorename for defaultstorename in skuobj.DefaultStoreDict])
874 mindefaultstorename = DefaultStoreMgr.GetMin(PcdDefaultStoreSet)
875 skuobj.DefaultStoreDict['STANDARD'] = copy.deepcopy(skuobj.DefaultStoreDict[mindefaultstorename])
876 return Pcds
877
878 ## Retrieve all PCD settings in platform
879 def _GetPcds(self):
880 if self._Pcds == None:
881 self._Pcds = sdict()
882 self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))
883 self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))
884 self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))
885 self._Pcds.update(self._GetDynamicPcd(MODEL_PCD_DYNAMIC_DEFAULT))
886 self._Pcds.update(self._GetDynamicHiiPcd(MODEL_PCD_DYNAMIC_HII))
887 self._Pcds.update(self._GetDynamicVpdPcd(MODEL_PCD_DYNAMIC_VPD))
888 self._Pcds.update(self._GetDynamicPcd(MODEL_PCD_DYNAMIC_EX_DEFAULT))
889 self._Pcds.update(self._GetDynamicHiiPcd(MODEL_PCD_DYNAMIC_EX_HII))
890 self._Pcds.update(self._GetDynamicVpdPcd(MODEL_PCD_DYNAMIC_EX_VPD))
891
892 self._Pcds = self.CompletePcdValues(self._Pcds)
893 self._Pcds = self.UpdateStructuredPcds(MODEL_PCD_TYPE_LIST, self._Pcds)
894 self._Pcds = self.CompleteHiiPcdsDefaultStores(self._Pcds)
895 self._Pcds = self._FilterPcdBySkuUsage(self._Pcds)
896 return self._Pcds
897
898 def _dumpPcdInfo(self,Pcds):
899 for pcd in Pcds:
900 pcdobj = Pcds[pcd]
901 if not pcdobj.TokenCName.startswith("Test"):
902 continue
903 for skuid in pcdobj.SkuInfoList:
904 if pcdobj.Type in (self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII],self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]):
905 for storename in pcdobj.SkuInfoList[skuid].DefaultStoreDict:
906 print "PcdCName: %s, SkuName: %s, StoreName: %s, Value: %s" % (".".join((pcdobj.TokenSpaceGuidCName, pcdobj.TokenCName)), skuid,storename,str(pcdobj.SkuInfoList[skuid].DefaultStoreDict[storename]))
907 else:
908 print "PcdCName: %s, SkuName: %s, Value: %s" % (".".join((pcdobj.TokenSpaceGuidCName, pcdobj.TokenCName)), skuid,str(pcdobj.SkuInfoList[skuid].DefaultValue))
909 ## Retrieve [BuildOptions]
910 def _GetBuildOptions(self):
911 if self._BuildOptions == None:
912 self._BuildOptions = sdict()
913 #
914 # Retrieve build option for EDKII and EDK style module
915 #
916 for CodeBase in (EDKII_NAME, EDK_NAME):
917 RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, CodeBase]
918 for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4,Dummy5 in RecordList:
919 CurKey = (ToolChainFamily, ToolChain, CodeBase)
920 #
921 # Only flags can be appended
922 #
923 if CurKey not in self._BuildOptions or not ToolChain.endswith('_FLAGS') or Option.startswith('='):
924 self._BuildOptions[CurKey] = Option
925 else:
926 self._BuildOptions[CurKey] += ' ' + Option
927 return self._BuildOptions
928
929 def GetBuildOptionsByModuleType(self, Edk, ModuleType):
930 if self._ModuleTypeOptions == None:
931 self._ModuleTypeOptions = sdict()
932 if (Edk, ModuleType) not in self._ModuleTypeOptions:
933 options = sdict()
934 self._ModuleTypeOptions[Edk, ModuleType] = options
935 DriverType = '%s.%s' % (Edk, ModuleType)
936 CommonDriverType = '%s.%s' % ('COMMON', ModuleType)
937 RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, DriverType]
938 for ToolChainFamily, ToolChain, Option, Arch, Type, Dummy3, Dummy4,Dummy5 in RecordList:
939 if Type == DriverType or Type == CommonDriverType:
940 Key = (ToolChainFamily, ToolChain, Edk)
941 if Key not in options or not ToolChain.endswith('_FLAGS') or Option.startswith('='):
942 options[Key] = Option
943 else:
944 options[Key] += ' ' + Option
945 return self._ModuleTypeOptions[Edk, ModuleType]
946
947 def GetStructurePcdInfo(self, PcdSet):
948 structure_pcd_data = {}
949 for item in PcdSet:
950 if (item[0],item[1]) not in structure_pcd_data:
951 structure_pcd_data[(item[0],item[1])] = []
952 structure_pcd_data[(item[0],item[1])].append(item)
953
954 return structure_pcd_data
955
956 def UpdateStructuredPcds(self, TypeList, AllPcds):
957
958 DynamicPcdType = [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_DEFAULT],
959 self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII],
960 self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_VPD],
961 self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_DEFAULT],
962 self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII],
963 self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_VPD]]
964
965 Pcds = AllPcds
966 DefaultStoreMgr = DefaultStore(self.DefaultStores)
967 SkuIds = self.SkuIdMgr.AvailableSkuIdSet
968 SkuIds.update({'DEFAULT':0})
969 DefaultStores = set([storename for pcdobj in AllPcds.values() for skuobj in pcdobj.SkuInfoList.values() for storename in skuobj.DefaultStoreDict.keys()])
970
971 S_PcdSet = []
972 # Find out all possible PCD candidates for self._Arch
973 RecordList = []
974
975 for Type in TypeList:
976 RecordList.extend(self._RawData[Type, self._Arch])
977
978 for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, default_store, Dummy4,Dummy5 in RecordList:
979 SkuName = SkuName.upper()
980 default_store = default_store.upper()
981 SkuName = 'DEFAULT' if SkuName == 'COMMON' else SkuName
982 if SkuName not in SkuIds:
983 continue
984
985 if SkuName in SkuIds and "." in TokenSpaceGuid:
986 S_PcdSet.append(( TokenSpaceGuid.split(".")[0],TokenSpaceGuid.split(".")[1], PcdCName,SkuName, default_store,Dummy5, AnalyzePcdExpression(Setting)[0]))
987
988 # handle pcd value override
989 StrPcdSet = self.GetStructurePcdInfo(S_PcdSet)
990 S_pcd_set = {}
991 for str_pcd in StrPcdSet:
992 str_pcd_obj = Pcds.get((str_pcd[1], str_pcd[0]), None)
993 str_pcd_dec = self._DecPcds.get((str_pcd[1], str_pcd[0]), None)
994 if str_pcd_dec:
995 str_pcd_obj_str = StructurePcd()
996 str_pcd_obj_str.copy(str_pcd_dec)
997 if str_pcd_obj:
998 str_pcd_obj_str.copy(str_pcd_obj)
999 if str_pcd_obj.DefaultValue:
1000 str_pcd_obj_str.DefaultFromDSC = str_pcd_obj.DefaultValue
1001 for str_pcd_data in StrPcdSet[str_pcd]:
1002 if str_pcd_data[3] in SkuIds:
1003 str_pcd_obj_str.AddOverrideValue(str_pcd_data[2], str(str_pcd_data[6]), 'DEFAULT' if str_pcd_data[3] == 'COMMON' else str_pcd_data[3],'STANDARD' if str_pcd_data[4] == 'COMMON' else str_pcd_data[4], self.MetaFile.File,LineNo=str_pcd_data[5])
1004 S_pcd_set[str_pcd[1], str_pcd[0]] = str_pcd_obj_str
1005 else:
1006 EdkLogger.error('build', PARSER_ERROR,
1007 "Pcd (%s.%s) defined in DSC is not declared in DEC files. Arch: ['%s']" % (str_pcd[0], str_pcd[1], self._Arch),
1008 File=self.MetaFile,Line = StrPcdSet[str_pcd][0][5])
1009 # Add the Structure PCD that only defined in DEC, don't have override in DSC file
1010 for Pcd in self._DecPcds:
1011 if type (self._DecPcds[Pcd]) is StructurePcd:
1012 if Pcd not in S_pcd_set:
1013 str_pcd_obj_str = StructurePcd()
1014 str_pcd_obj_str.copy(self._DecPcds[Pcd])
1015 str_pcd_obj = Pcds.get(Pcd, None)
1016 if str_pcd_obj:
1017 str_pcd_obj_str.copy(str_pcd_obj)
1018 if str_pcd_obj.DefaultValue:
1019 str_pcd_obj_str.DefaultFromDSC = str_pcd_obj.DefaultValue
1020 S_pcd_set[Pcd] = str_pcd_obj_str
1021 if S_pcd_set:
1022 GlobalData.gStructurePcd[self.Arch] = S_pcd_set
1023 for stru_pcd in S_pcd_set.values():
1024 if stru_pcd.Type not in DynamicPcdType:
1025 continue
1026 for skuid in SkuIds:
1027 if skuid in stru_pcd.SkuOverrideValues:
1028 continue
1029 nextskuid = self.SkuIdMgr.GetNextSkuId(skuid)
1030 NoDefault = False
1031 while nextskuid not in stru_pcd.SkuOverrideValues:
1032 if nextskuid == "DEFAULT":
1033 NoDefault = True
1034 break
1035 nextskuid = self.SkuIdMgr.GetNextSkuId(nextskuid)
1036 stru_pcd.SkuOverrideValues[skuid] = copy.deepcopy(stru_pcd.SkuOverrideValues[nextskuid]) if not NoDefault else copy.deepcopy({defaultstorename: stru_pcd.DefaultValues for defaultstorename in DefaultStores} if DefaultStores else {'STANDARD':stru_pcd.DefaultValues})
1037 if stru_pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
1038 for skuid in SkuIds:
1039 nextskuid = skuid
1040 NoDefault = False
1041 if skuid not in stru_pcd.SkuOverrideValues:
1042 while nextskuid not in stru_pcd.SkuOverrideValues:
1043 if nextskuid == "DEFAULT":
1044 NoDefault = True
1045 break
1046 nextskuid = self.SkuIdMgr.GetNextSkuId(nextskuid)
1047 if NoDefault:
1048 continue
1049 PcdDefaultStoreSet = set([defaultstorename for defaultstorename in stru_pcd.SkuOverrideValues[nextskuid]])
1050 mindefaultstorename = DefaultStoreMgr.GetMin(PcdDefaultStoreSet)
1051
1052 for defaultstoreid in DefaultStores:
1053 if defaultstoreid not in stru_pcd.SkuOverrideValues[skuid]:
1054 stru_pcd.SkuOverrideValues[skuid][defaultstoreid] = copy.deepcopy(stru_pcd.SkuOverrideValues[nextskuid][mindefaultstorename])
1055
1056 Str_Pcd_Values = self.GenerateByteArrayValue(S_pcd_set)
1057 if Str_Pcd_Values:
1058 for (skuname,StoreName,PcdGuid,PcdName,PcdValue) in Str_Pcd_Values:
1059 str_pcd_obj = S_pcd_set.get((PcdName, PcdGuid))
1060 if str_pcd_obj is None:
1061 print PcdName, PcdGuid
1062 raise
1063 if str_pcd_obj.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII],
1064 self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
1065 if skuname not in str_pcd_obj.SkuInfoList:
1066 str_pcd_obj.SkuInfoList[skuname] = SkuInfoClass(SkuIdName=skuname, SkuId=self.SkuIds[skuname][0], HiiDefaultValue=PcdValue, DefaultStore = {StoreName:PcdValue})
1067 else:
1068 str_pcd_obj.SkuInfoList[skuname].HiiDefaultValue = PcdValue
1069 str_pcd_obj.SkuInfoList[skuname].DefaultStoreDict.update({StoreName:PcdValue})
1070 elif str_pcd_obj.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],
1071 self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:
1072 if skuname in (self.SkuIdMgr.SystemSkuId, 'DEFAULT', 'COMMON'):
1073 str_pcd_obj.DefaultValue = PcdValue
1074 else:
1075 if skuname not in str_pcd_obj.SkuInfoList:
1076 nextskuid = self.SkuIdMgr.GetNextSkuId(skuname)
1077 NoDefault = False
1078 while nextskuid not in str_pcd_obj.SkuInfoList:
1079 if nextskuid == "DEFAULT":
1080 NoDefault = True
1081 break
1082 nextskuid = self.SkuIdMgr.GetNextSkuId(nextskuid)
1083 str_pcd_obj.SkuInfoList[skuname] = copy.deepcopy(str_pcd_obj.SkuInfoList[nextskuid]) if not NoDefault else SkuInfoClass(SkuIdName=skuname, SkuId=self.SkuIds[skuname][0], DefaultValue=PcdValue)
1084 str_pcd_obj.SkuInfoList[skuname].SkuId = self.SkuIds[skuname][0]
1085 str_pcd_obj.SkuInfoList[skuname].SkuIdName = skuname
1086 else:
1087 str_pcd_obj.SkuInfoList[skuname].DefaultValue = PcdValue
1088 for str_pcd_obj in S_pcd_set.values():
1089 if str_pcd_obj.Type not in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII],
1090 self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
1091 continue
1092 PcdDefaultStoreSet = set([defaultstorename for skuobj in str_pcd_obj.SkuInfoList.values() for defaultstorename in skuobj.DefaultStoreDict])
1093 DefaultStoreObj = DefaultStore(self._GetDefaultStores())
1094 mindefaultstorename = DefaultStoreObj.GetMin(PcdDefaultStoreSet)
1095 str_pcd_obj.SkuInfoList[self.SkuIdMgr.SystemSkuId].HiiDefaultValue = str_pcd_obj.SkuInfoList[self.SkuIdMgr.SystemSkuId].DefaultStoreDict[mindefaultstorename]
1096
1097 for str_pcd_obj in S_pcd_set.values():
1098
1099 str_pcd_obj.MaxDatumSize = self.GetStructurePcdMaxSize(str_pcd_obj)
1100 Pcds[str_pcd_obj.TokenCName, str_pcd_obj.TokenSpaceGuidCName] = str_pcd_obj
1101
1102 for pcdkey in Pcds:
1103 pcd = Pcds[pcdkey]
1104 if 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():
1105 pcd.SkuInfoList['DEFAULT'] = pcd.SkuInfoList['COMMON']
1106 del(pcd.SkuInfoList['COMMON'])
1107 elif 'DEFAULT' in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():
1108 del(pcd.SkuInfoList['COMMON'])
1109
1110 map(self.FilterSkuSettings,[Pcds[pcdkey] for pcdkey in Pcds if Pcds[pcdkey].Type in DynamicPcdType])
1111 return Pcds
1112
1113 ## Retrieve non-dynamic PCD settings
1114 #
1115 # @param Type PCD type
1116 #
1117 # @retval a dict object contains settings of given PCD type
1118 #
1119 def _GetPcd(self, Type):
1120 Pcds = sdict()
1121 #
1122 # tdict is a special dict kind of type, used for selecting correct
1123 # PCD settings for certain ARCH
1124 #
1125 AvailableSkuIdSet = copy.copy(self.SkuIds)
1126
1127 PcdDict = tdict(True, 3)
1128 PcdSet = set()
1129 # Find out all possible PCD candidates for self._Arch
1130 RecordList = self._RawData[Type, self._Arch]
1131 PcdValueDict = sdict()
1132 for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4,Dummy5 in RecordList:
1133 SkuName = SkuName.upper()
1134 SkuName = 'DEFAULT' if SkuName == 'COMMON' else SkuName
1135 if SkuName not in AvailableSkuIdSet:
1136 EdkLogger.error('build ', PARAMETER_INVALID, 'Sku %s is not defined in [SkuIds] section' % SkuName,
1137 File=self.MetaFile, Line=Dummy5)
1138 if SkuName in (self.SkuIdMgr.SystemSkuId, 'DEFAULT', 'COMMON'):
1139 if "." not in TokenSpaceGuid:
1140 PcdSet.add((PcdCName, TokenSpaceGuid, SkuName, Dummy4))
1141 PcdDict[Arch, PcdCName, TokenSpaceGuid, SkuName] = Setting
1142
1143 for PcdCName, TokenSpaceGuid, SkuName, Dummy4 in PcdSet:
1144 Setting = PcdDict[self._Arch, PcdCName, TokenSpaceGuid, SkuName]
1145 if Setting == None:
1146 continue
1147 PcdValue, DatumType, MaxDatumSize = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)
1148 if (PcdCName, TokenSpaceGuid) in PcdValueDict:
1149 PcdValueDict[PcdCName, TokenSpaceGuid][SkuName] = (PcdValue, DatumType, MaxDatumSize)
1150 else:
1151 PcdValueDict[PcdCName, TokenSpaceGuid] = {SkuName:(PcdValue, DatumType, MaxDatumSize)}
1152
1153 PcdsKeys = PcdValueDict.keys()
1154 for PcdCName, TokenSpaceGuid in PcdsKeys:
1155
1156 PcdSetting = PcdValueDict[PcdCName, TokenSpaceGuid]
1157 PcdValue = None
1158 DatumType = None
1159 MaxDatumSize = None
1160 if 'COMMON' in PcdSetting:
1161 PcdValue, DatumType, MaxDatumSize = PcdSetting['COMMON']
1162 if 'DEFAULT' in PcdSetting:
1163 PcdValue, DatumType, MaxDatumSize = PcdSetting['DEFAULT']
1164 if self.SkuIdMgr.SystemSkuId in PcdSetting:
1165 PcdValue, DatumType, MaxDatumSize = PcdSetting[self.SkuIdMgr.SystemSkuId]
1166
1167 Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
1168 PcdCName,
1169 TokenSpaceGuid,
1170 self._PCD_TYPE_STRING_[Type],
1171 DatumType,
1172 PcdValue,
1173 '',
1174 MaxDatumSize,
1175 {},
1176 False,
1177 None,
1178 IsDsc=True)
1179
1180
1181 return Pcds
1182
1183 def __UNICODE2OCTList(self,Value):
1184 Value = Value.strip()
1185 Value = Value[2:-1]
1186 List = []
1187 for Item in Value:
1188 Temp = '%04X' % ord(Item)
1189 List.append('0x' + Temp[2:4])
1190 List.append('0x' + Temp[0:2])
1191 List.append('0x00')
1192 List.append('0x00')
1193 return List
1194 def __STRING2OCTList(self,Value):
1195 OCTList = []
1196 Value = Value.strip('"')
1197 for char in Value:
1198 Temp = '%02X' % ord(char)
1199 OCTList.append('0x' + Temp)
1200 OCTList.append('0x00')
1201 return OCTList
1202
1203 def GetStructurePcdMaxSize(self, str_pcd):
1204 pcd_default_value = str_pcd.DefaultValue
1205 sku_values = [skuobj.HiiDefaultValue if str_pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]] else skuobj.DefaultValue for skuobj in str_pcd.SkuInfoList.values()]
1206 sku_values.append(pcd_default_value)
1207
1208 def get_length(value):
1209 Value = value.strip()
1210 if len(value) > 1:
1211 if Value.startswith('GUID') and Value.endswith(')'):
1212 return 16
1213 if Value.startswith('L"') and Value.endswith('"'):
1214 return len(Value[2:-1])
1215 if Value[0] == '"' and Value[-1] == '"':
1216 return len(Value) - 2
1217 if Value[0] == '{' and Value[-1] == '}':
1218 return len(Value.split(","))
1219 if Value.startswith("L'") and Value.endswith("'") and len(list(Value[2:-1])) > 1:
1220 return len(list(Value[2:-1]))
1221 if Value[0] == "'" and Value[-1] == "'" and len(list(Value[1:-1])) > 1:
1222 return len(Value) - 2
1223 return len(Value)
1224
1225 return str(max([pcd_size for pcd_size in [get_length(item) for item in sku_values]]))
1226
1227 def IsFieldValueAnArray (self, Value):
1228 Value = Value.strip()
1229 if Value.startswith('GUID') and Value.endswith(')'):
1230 return True
1231 if Value.startswith('L"') and Value.endswith('"') and len(list(Value[2:-1])) > 1:
1232 return True
1233 if Value[0] == '"' and Value[-1] == '"' and len(list(Value[1:-1])) > 1:
1234 return True
1235 if Value[0] == '{' and Value[-1] == '}':
1236 return True
1237 if Value.startswith("L'") and Value.endswith("'") and len(list(Value[2:-1])) > 1:
1238 print 'foo = ', list(Value[2:-1])
1239 return True
1240 if Value[0] == "'" and Value[-1] == "'" and len(list(Value[1:-1])) > 1:
1241 print 'bar = ', list(Value[1:-1])
1242 return True
1243 return False
1244
1245 def ExecuteCommand (self, Command):
1246 try:
1247 Process = subprocess.Popen(Command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
1248 except:
1249 print 'ERROR: Can not execute command:', Command
1250 sys.exit(1)
1251 Result = Process.communicate()
1252 if Process.returncode <> 0:
1253 print 'ERROR: Can not collect output from command:', Command
1254 return Result[0], Result[1]
1255
1256 def IntToCString(self, Value, ValueSize):
1257 Result = '"'
1258 if not isinstance (Value, str):
1259 for Index in range(0, ValueSize):
1260 Result = Result + '\\x%02x' % (Value & 0xff)
1261 Value = Value >> 8
1262 Result = Result + '"'
1263 return Result
1264
1265 def GenerateInitializeFunc(self, SkuName, DefaultStoreName, Pcd, InitByteValue, CApp):
1266 OverrideValues = {DefaultStoreName:""}
1267 if Pcd.SkuOverrideValues:
1268 OverrideValues = Pcd.SkuOverrideValues[SkuName]
1269 for DefaultStoreName in OverrideValues.keys():
1270 CApp = CApp + 'void\n'
1271 CApp = CApp + 'Initialize_%s_%s_%s_%s(\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1272 CApp = CApp + ' void\n'
1273 CApp = CApp + ' )\n'
1274 CApp = CApp + '{\n'
1275 CApp = CApp + ' UINT32 Size;\n'
1276 CApp = CApp + ' UINT32 FieldSize;\n'
1277 CApp = CApp + ' CHAR8 *Value;\n'
1278 CApp = CApp + ' UINT32 OriginalSize;\n'
1279 CApp = CApp + ' VOID *OriginalPcd;\n'
1280 CApp = CApp + ' %s *Pcd;\n' % (Pcd.DatumType)
1281 CApp = CApp + '\n'
1282
1283 Pcd.DefaultValue = Pcd.DefaultValue.strip()
1284 PcdDefaultValue = StringToArray(Pcd.DefaultValue)
1285
1286 InitByteValue += '%s.%s.%s.%s|%s|%s\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName, Pcd.DatumType, PcdDefaultValue)
1287
1288 #
1289 # Get current PCD value and size
1290 #
1291 CApp = CApp + ' OriginalPcd = PcdGetPtr (%s, %s, %s, %s, &OriginalSize);\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1292
1293 #
1294 # Determine the size of the PCD. For simple structures, sizeof(TYPE) provides
1295 # the correct value. For structures with a flexible array member, the flexible
1296 # array member is detected, and the size is based on the highest index used with
1297 # the flexible array member. The flexible array member must be the last field
1298 # in a structure. The size formula for this case is:
1299 # OFFSET_OF(FlexbleArrayField) + sizeof(FlexibleArray[0]) * (HighestIndex + 1)
1300 #
1301 CApp = CApp + ' Size = sizeof(%s);\n' % (Pcd.DatumType)
1302 for FieldList in [Pcd.DefaultValues, OverrideValues.get(DefaultStoreName)]:
1303 if not FieldList:
1304 continue
1305 for FieldName in FieldList:
1306 FieldName = "." + FieldName
1307 IsArray = self.IsFieldValueAnArray(FieldList[FieldName.strip(".")][0])
1308 if IsArray:
1309 Value, ValueSize = ParseFieldValue (FieldList[FieldName.strip(".")][0])
1310 CApp = CApp + ' __FLEXIBLE_SIZE(Size, %s, %s, %d / __ARRAY_ELEMENT_SIZE(%s, %s));\n' % (Pcd.DatumType, FieldName.strip("."), ValueSize, Pcd.DatumType, FieldName.strip("."));
1311 else:
1312 NewFieldName = ''
1313 while '[' in FieldName:
1314 NewFieldName = NewFieldName + FieldName.split('[', 1)[0] + '[0]'
1315 ArrayIndex = int(FieldName.split('[', 1)[1].split(']', 1)[0])
1316 FieldName = FieldName.split(']', 1)[1]
1317 FieldName = NewFieldName + FieldName
1318 while '[' in FieldName:
1319 FieldName = FieldName.rsplit('[', 1)[0]
1320 CApp = CApp + ' __FLEXIBLE_SIZE(Size, %s, %s, %d);\n' % (Pcd.DatumType, FieldName.strip("."), ArrayIndex + 1)
1321
1322 #
1323 # Allocate and zero buffer for the PCD
1324 # Must handle cases where current value is smaller, larger, or same size
1325 # Always keep that larger one as the current size
1326 #
1327 CApp = CApp + ' Size = (OriginalSize > Size ? OriginalSize : Size);\n'
1328 CApp = CApp + ' Pcd = (%s *)malloc (Size);\n' % (Pcd.DatumType)
1329 CApp = CApp + ' memset (Pcd, 0, Size);\n'
1330
1331 #
1332 # Copy current PCD value into allocated buffer.
1333 #
1334 CApp = CApp + ' memcpy (Pcd, OriginalPcd, OriginalSize);\n'
1335
1336 #
1337 # Assign field values in PCD
1338 #
1339 for FieldList in [Pcd.DefaultValues, Pcd.DefaultFromDSC,OverrideValues.get(DefaultStoreName)]:
1340 if not FieldList:
1341 continue
1342 if Pcd.DefaultFromDSC and FieldList == Pcd.DefaultFromDSC:
1343 IsArray = self.IsFieldValueAnArray(FieldList)
1344 Value, ValueSize = ParseFieldValue (FieldList)
1345 if isinstance(Value, str):
1346 CApp = CApp + ' Pcd = %s; // From DSC Default Value %s\n' % (Value, Pcd.DefaultFromDSC)
1347 elif IsArray:
1348 #
1349 # Use memcpy() to copy value into field
1350 #
1351 CApp = CApp + ' Value = %s; // From DSC Default Value %s\n' % (self.IntToCString(Value, ValueSize), Pcd.DefaultFromDSC)
1352 CApp = CApp + ' memcpy (Pcd, Value, %d);\n' % (ValueSize)
1353 continue
1354
1355 for FieldName in FieldList:
1356 IsArray = self.IsFieldValueAnArray(FieldList[FieldName][0])
1357 try:
1358 Value, ValueSize = ParseFieldValue (FieldList[FieldName][0])
1359 except Exception:
1360 print FieldList[FieldName][0]
1361 if isinstance(Value, str):
1362 CApp = CApp + ' Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1363 elif IsArray:
1364 #
1365 # Use memcpy() to copy value into field
1366 #
1367 CApp = CApp + ' FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd.DatumType, FieldName)
1368 CApp = CApp + ' Value = %s; // From %s Line %d Value %s\n' % (self.IntToCString(Value, ValueSize), FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1369 CApp = CApp + ' memcpy (&Pcd->%s[0], Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName, ValueSize, ValueSize)
1370 else:
1371 if ValueSize > 4:
1372 CApp = CApp + ' Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1373 else:
1374 CApp = CApp + ' Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1375
1376 #
1377 # Set new PCD value and size
1378 #
1379 CApp = CApp + ' PcdSetPtr (%s, %s, %s, %s, Size, (UINT8 *)Pcd);\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1380
1381 #
1382 # Free PCD
1383 #
1384 CApp = CApp + ' free (Pcd);\n'
1385 CApp = CApp + '}\n'
1386 CApp = CApp + '\n'
1387 return InitByteValue, CApp
1388
1389 def GenerateByteArrayValue (self, StructuredPcds):
1390 #
1391 # Generate/Compile/Run C application to determine if there are any flexible array members
1392 #
1393 if not StructuredPcds:
1394 return
1395
1396 InitByteValue = ""
1397 CApp = PcdMainCHeader
1398
1399 Includes = {}
1400 for PcdName in StructuredPcds:
1401 Pcd = StructuredPcds[PcdName]
1402 IncludeFile = Pcd.StructuredPcdIncludeFile
1403 if IncludeFile not in Includes:
1404 Includes[IncludeFile] = True
1405 CApp = CApp + '#include <%s>\n' % (IncludeFile)
1406 CApp = CApp + '\n'
1407
1408 for PcdName in StructuredPcds:
1409 Pcd = StructuredPcds[PcdName]
1410 if not Pcd.SkuOverrideValues:
1411 InitByteValue, CApp = self.GenerateInitializeFunc(self.SkuIdMgr.SystemSkuId, 'STANDARD', Pcd, InitByteValue, CApp)
1412 else:
1413 for SkuName in Pcd.SkuOverrideValues:
1414 for DefaultStoreName in Pcd.DefaultStoreName:
1415 Pcd = StructuredPcds[PcdName]
1416 InitByteValue, CApp = self.GenerateInitializeFunc(SkuName, DefaultStoreName, Pcd, InitByteValue, CApp)
1417
1418 CApp = CApp + 'VOID\n'
1419 CApp = CApp + 'PcdEntryPoint(\n'
1420 CApp = CApp + ' VOID\n'
1421 CApp = CApp + ' )\n'
1422 CApp = CApp + '{\n'
1423 for Pcd in StructuredPcds.values():
1424 if not Pcd.SkuOverrideValues:
1425 CApp = CApp + ' Initialize_%s_%s_%s_%s();\n' % (self.SkuIdMgr.SystemSkuId, 'STANDARD', Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1426 else:
1427 for SkuName in Pcd.SkuOverrideValues:
1428 for DefaultStoreName in Pcd.SkuOverrideValues[SkuName]:
1429 CApp = CApp + ' Initialize_%s_%s_%s_%s();\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1430 CApp = CApp + '}\n'
1431
1432 CApp = CApp + PcdMainCEntry + '\n'
1433
1434 if not os.path.exists(self.OutputPath):
1435 os.makedirs(self.OutputPath)
1436 CAppBaseFileName = os.path.join(self.OutputPath, PcdValueInitName)
1437 File = open (CAppBaseFileName + '.c', 'w')
1438 File.write(CApp)
1439 File.close()
1440
1441 MakeApp = PcdMakefileHeader
1442 if sys.platform == "win32":
1443 MakeApp = MakeApp + 'ARCH = IA32\nAPPNAME = %s\n' % (PcdValueInitName) + 'OBJECTS = %s\%s.obj\n' % (self.OutputPath, PcdValueInitName) + 'INC = '
1444 else:
1445 MakeApp = MakeApp + PcdGccMakefile
1446 MakeApp = MakeApp + 'APPNAME = %s\n' % (PcdValueInitName) + 'OBJECTS = %s/%s.o\n' % (self.OutputPath, PcdValueInitName) + \
1447 'include $(MAKEROOT)/Makefiles/app.makefile\n' + 'BUILD_CFLAGS += -Wno-pointer-to-int-cast -Wno-unused-variable\n' + 'INCLUDE +='
1448
1449 PlatformInc = {}
1450 for Cache in self._Bdb._CACHE_.values():
1451 if Cache.MetaFile.Ext.lower() != '.dec':
1452 continue
1453 if Cache.Includes:
1454 if str(Cache.MetaFile.Path) not in PlatformInc:
1455 PlatformInc[str(Cache.MetaFile.Path)] = Cache.Includes
1456
1457 PcdDependDEC = []
1458 for Pcd in StructuredPcds.values():
1459 for PackageDec in Pcd.PackageDecs:
1460 Package = os.path.normpath(mws.join(GlobalData.gWorkspace, PackageDec))
1461 if not os.path.exists(Package):
1462 EdkLogger.error('Build', RESOURCE_NOT_AVAILABLE, "The dependent Package %s of PCD %s.%s is not exist." % (PackageDec, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
1463 if Package not in PcdDependDEC:
1464 PcdDependDEC.append(Package)
1465
1466 if PlatformInc and PcdDependDEC:
1467 for pkg in PcdDependDEC:
1468 if pkg in PlatformInc:
1469 for inc in PlatformInc[pkg]:
1470 MakeApp += '-I' + str(inc) + ' '
1471 MakeApp = MakeApp + '\n'
1472 if sys.platform == "win32":
1473 MakeApp = MakeApp + PcdMakefileEnd
1474 MakeFileName = os.path.join(self.OutputPath, 'Makefile')
1475 File = open (MakeFileName, 'w')
1476 File.write(MakeApp)
1477 File.close()
1478
1479 InputValueFile = os.path.join(self.OutputPath, 'Input.txt')
1480 OutputValueFile = os.path.join(self.OutputPath, 'Output.txt')
1481 File = open (InputValueFile, 'w')
1482 File.write(InitByteValue)
1483 File.close()
1484
1485 Messages = ''
1486 if sys.platform == "win32":
1487 StdOut, StdErr = self.ExecuteCommand ('nmake clean & nmake -f %s' % (MakeFileName))
1488 Messages = StdOut
1489 else:
1490 StdOut, StdErr = self.ExecuteCommand ('make clean & make -f %s' % (MakeFileName))
1491 Messages = StdErr
1492 Messages = Messages.split('\n')
1493 for Message in Messages:
1494 if " error" in Message:
1495 FileInfo = Message.strip().split('(')
1496 if len (FileInfo) > 1:
1497 FileName = FileInfo [0]
1498 FileLine = FileInfo [1].split (')')[0]
1499 else:
1500 FileInfo = Message.strip().split(':')
1501 FileName = FileInfo [0]
1502 FileLine = FileInfo [1]
1503
1504 File = open (FileName, 'r')
1505 FileData = File.readlines()
1506 File.close()
1507 error_line = FileData[int (FileLine) - 1]
1508 if r"//" in error_line:
1509 c_line,dsc_line = error_line.split(r"//")
1510 else:
1511 dsc_line = error_line
1512
1513 message_itmes = Message.split(":")
1514 Index = 0
1515 for item in message_itmes:
1516 if "PcdValueInit.c" in item:
1517 Index = message_itmes.index(item)
1518 message_itmes[Index] = dsc_line.strip()
1519 break
1520
1521 EdkLogger.error("build", PCD_STRUCTURE_PCD_ERROR, ":".join(message_itmes[Index:]))
1522
1523 PcdValueInitExe = PcdValueInitName
1524 if not sys.platform == "win32":
1525 PcdValueInitExe = os.path.join(os.getenv("EDK_TOOLS_PATH"), 'Source', 'C', 'bin', PcdValueInitName)
1526
1527 StdOut, StdErr = self.ExecuteCommand (PcdValueInitExe + ' -i %s -o %s' % (InputValueFile, OutputValueFile))
1528 File = open (OutputValueFile, 'r')
1529 FileBuffer = File.readlines()
1530 File.close()
1531
1532 StructurePcdSet = []
1533 for Pcd in FileBuffer:
1534 PcdValue = Pcd.split ('|')
1535 PcdInfo = PcdValue[0].split ('.')
1536 StructurePcdSet.append((PcdInfo[0],PcdInfo[1], PcdInfo[2], PcdInfo[3], PcdValue[2].strip()))
1537 return StructurePcdSet
1538
1539 ## Retrieve dynamic PCD settings
1540 #
1541 # @param Type PCD type
1542 #
1543 # @retval a dict object contains settings of given PCD type
1544 #
1545 def _GetDynamicPcd(self, Type):
1546
1547
1548 Pcds = sdict()
1549 #
1550 # tdict is a special dict kind of type, used for selecting correct
1551 # PCD settings for certain ARCH and SKU
1552 #
1553 PcdDict = tdict(True, 4)
1554 PcdList = []
1555 # Find out all possible PCD candidates for self._Arch
1556 RecordList = self._RawData[Type, self._Arch]
1557 AvailableSkuIdSet = copy.copy(self.SkuIds)
1558
1559
1560 for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4,Dummy5 in RecordList:
1561 SkuName = SkuName.upper()
1562 SkuName = 'DEFAULT' if SkuName == 'COMMON' else SkuName
1563 if SkuName not in AvailableSkuIdSet:
1564 EdkLogger.error('build', PARAMETER_INVALID, 'Sku %s is not defined in [SkuIds] section' % SkuName,
1565 File=self.MetaFile, Line=Dummy5)
1566 if "." not in TokenSpaceGuid:
1567 PcdList.append((PcdCName, TokenSpaceGuid, SkuName, Dummy4))
1568 PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting
1569
1570 # Remove redundant PCD candidates, per the ARCH and SKU
1571 for PcdCName, TokenSpaceGuid, SkuName, Dummy4 in PcdList:
1572
1573 Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid]
1574 if Setting == None:
1575 continue
1576
1577 PcdValue, DatumType, MaxDatumSize = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)
1578 SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName][0], '', '', '', '', '', PcdValue)
1579 if (PcdCName, TokenSpaceGuid) in Pcds.keys():
1580 pcdObject = Pcds[PcdCName, TokenSpaceGuid]
1581 pcdObject.SkuInfoList[SkuName] = SkuInfo
1582 if MaxDatumSize.strip():
1583 CurrentMaxSize = int(MaxDatumSize.strip(), 0)
1584 else:
1585 CurrentMaxSize = 0
1586 if pcdObject.MaxDatumSize:
1587 PcdMaxSize = int(pcdObject.MaxDatumSize, 0)
1588 else:
1589 PcdMaxSize = 0
1590 if CurrentMaxSize > PcdMaxSize:
1591 pcdObject.MaxDatumSize = str(CurrentMaxSize)
1592 else:
1593 Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
1594 PcdCName,
1595 TokenSpaceGuid,
1596 self._PCD_TYPE_STRING_[Type],
1597 DatumType,
1598 PcdValue,
1599 '',
1600 MaxDatumSize,
1601 {SkuName : SkuInfo},
1602 False,
1603 None,
1604 IsDsc=True)
1605
1606 for pcd in Pcds.values():
1607 pcdDecObject = self._DecPcds[pcd.TokenCName, pcd.TokenSpaceGuidCName]
1608 # Only fix the value while no value provided in DSC file.
1609 for sku in pcd.SkuInfoList.values():
1610 if (sku.DefaultValue == "" or sku.DefaultValue==None):
1611 sku.DefaultValue = pcdDecObject.DefaultValue
1612 if 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' not in pcd.SkuInfoList.keys():
1613 valuefromDec = pcdDecObject.DefaultValue
1614 SkuInfo = SkuInfoClass('DEFAULT', '0', '', '', '', '', '', valuefromDec)
1615 pcd.SkuInfoList['DEFAULT'] = SkuInfo
1616 elif 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():
1617 pcd.SkuInfoList['DEFAULT'] = pcd.SkuInfoList['COMMON']
1618 del(pcd.SkuInfoList['COMMON'])
1619 elif 'DEFAULT' in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():
1620 del(pcd.SkuInfoList['COMMON'])
1621
1622 map(self.FilterSkuSettings,Pcds.values())
1623
1624 return Pcds
1625
1626 def FilterSkuSettings(self, PcdObj):
1627
1628 if self.SkuIdMgr.SkuUsageType == self.SkuIdMgr.SINGLE:
1629 if 'DEFAULT' in PcdObj.SkuInfoList.keys() and self.SkuIdMgr.SystemSkuId not in PcdObj.SkuInfoList.keys():
1630 PcdObj.SkuInfoList[self.SkuIdMgr.SystemSkuId] = PcdObj.SkuInfoList['DEFAULT']
1631 PcdObj.SkuInfoList = {'DEFAULT':PcdObj.SkuInfoList[self.SkuIdMgr.SystemSkuId]}
1632 PcdObj.SkuInfoList['DEFAULT'].SkuIdName = 'DEFAULT'
1633 PcdObj.SkuInfoList['DEFAULT'].SkuId = '0'
1634
1635 elif self.SkuIdMgr.SkuUsageType == self.SkuIdMgr.DEFAULT:
1636 PcdObj.SkuInfoList = {'DEFAULT':PcdObj.SkuInfoList['DEFAULT']}
1637
1638 return PcdObj
1639
1640
1641 def CompareVarAttr(self, Attr1, Attr2):
1642 if not Attr1 or not Attr2: # for empty string
1643 return True
1644 Attr1s = [attr.strip() for attr in Attr1.split(",")]
1645 Attr1Set = set(Attr1s)
1646 Attr2s = [attr.strip() for attr in Attr2.split(",")]
1647 Attr2Set = set(Attr2s)
1648 if Attr2Set == Attr1Set:
1649 return True
1650 else:
1651 return False
1652 def CompletePcdValues(self,PcdSet):
1653 Pcds = {}
1654 DefaultStoreObj = DefaultStore(self._GetDefaultStores())
1655 SkuIds = set([(skuid,skuobj.SkuId) for pcdobj in PcdSet.values() for skuid,skuobj in pcdobj.SkuInfoList.items()])
1656 SkuIds = self.SkuIdMgr.AvailableSkuIdSet
1657 DefaultStores = set([storename for pcdobj in PcdSet.values() for skuobj in pcdobj.SkuInfoList.values() for storename in skuobj.DefaultStoreDict.keys()])
1658 for PcdCName, TokenSpaceGuid in PcdSet:
1659 PcdObj = PcdSet[(PcdCName, TokenSpaceGuid)]
1660 if PcdObj.Type not in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_DEFAULT],
1661 self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII],
1662 self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_VPD],
1663 self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_DEFAULT],
1664 self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII],
1665 self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_VPD]]:
1666 Pcds[PcdCName, TokenSpaceGuid]= PcdObj
1667 continue
1668 PcdType = PcdObj.Type
1669 if PcdType in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
1670 for skuid in PcdObj.SkuInfoList:
1671 skuobj = PcdObj.SkuInfoList[skuid]
1672 mindefaultstorename = DefaultStoreObj.GetMin(set([defaultstorename for defaultstorename in skuobj.DefaultStoreDict]))
1673 for defaultstorename in DefaultStores:
1674 if defaultstorename not in skuobj.DefaultStoreDict:
1675 skuobj.DefaultStoreDict[defaultstorename] = copy.deepcopy(skuobj.DefaultStoreDict[mindefaultstorename])
1676 skuobj.HiiDefaultValue = skuobj.DefaultStoreDict[mindefaultstorename]
1677 for skuname,skuid in SkuIds.items():
1678 if skuname not in PcdObj.SkuInfoList:
1679 nextskuid = self.SkuIdMgr.GetNextSkuId(skuname)
1680 while nextskuid not in PcdObj.SkuInfoList:
1681 nextskuid = self.SkuIdMgr.GetNextSkuId(nextskuid)
1682 PcdObj.SkuInfoList[skuname] = copy.deepcopy(PcdObj.SkuInfoList[nextskuid])
1683 PcdObj.SkuInfoList[skuname].SkuId = skuid
1684 PcdObj.SkuInfoList[skuname].SkuIdName = skuname
1685 if PcdType in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
1686 PcdObj.DefaultValue = PcdObj.SkuInfoList.values()[0].HiiDefaultValue if self.SkuIdMgr.SkuUsageType == self.SkuIdMgr.SINGLE else PcdObj.SkuInfoList["DEFAULT"].HiiDefaultValue
1687 Pcds[PcdCName, TokenSpaceGuid]= PcdObj
1688 return Pcds
1689 ## Retrieve dynamic HII PCD settings
1690 #
1691 # @param Type PCD type
1692 #
1693 # @retval a dict object contains settings of given PCD type
1694 #
1695 def _GetDynamicHiiPcd(self, Type):
1696
1697 VariableAttrs = {}
1698
1699 Pcds = sdict()
1700 #
1701 # tdict is a special dict kind of type, used for selecting correct
1702 # PCD settings for certain ARCH and SKU
1703 #
1704 PcdDict = tdict(True, 5)
1705 PcdSet = set()
1706 RecordList = self._RawData[Type, self._Arch]
1707 # Find out all possible PCD candidates for self._Arch
1708 AvailableSkuIdSet = copy.copy(self.SkuIds)
1709 DefaultStoresDefine = self._GetDefaultStores()
1710
1711 for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, DefaultStore, Dummy4,Dummy5 in RecordList:
1712 SkuName = SkuName.upper()
1713 SkuName = 'DEFAULT' if SkuName == 'COMMON' else SkuName
1714 DefaultStore = DefaultStore.upper()
1715 if DefaultStore == "COMMON":
1716 DefaultStore = "STANDARD"
1717 if SkuName not in AvailableSkuIdSet:
1718 EdkLogger.error('build', PARAMETER_INVALID, 'Sku %s is not defined in [SkuIds] section' % SkuName,
1719 File=self.MetaFile, Line=Dummy5)
1720 if DefaultStore not in DefaultStoresDefine:
1721 EdkLogger.error('build', PARAMETER_INVALID, 'DefaultStores %s is not defined in [DefaultStores] section' % DefaultStore,
1722 File=self.MetaFile, Line=Dummy5)
1723 if "." not in TokenSpaceGuid:
1724 PcdSet.add((PcdCName, TokenSpaceGuid, SkuName,DefaultStore, Dummy4))
1725 PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid,DefaultStore] = Setting
1726
1727
1728 # Remove redundant PCD candidates, per the ARCH and SKU
1729 for PcdCName, TokenSpaceGuid, SkuName,DefaultStore, Dummy4 in PcdSet:
1730
1731 Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid,DefaultStore]
1732 if Setting == None:
1733 continue
1734 VariableName, VariableGuid, VariableOffset, DefaultValue, VarAttribute = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)
1735
1736 rt, Msg = VariableAttributes.ValidateVarAttributes(VarAttribute)
1737 if not rt:
1738 EdkLogger.error("build", PCD_VARIABLE_ATTRIBUTES_ERROR, "Variable attributes settings for %s is incorrect.\n %s" % (".".join((TokenSpaceGuid, PcdCName)), Msg),
1739 ExtraData="[%s]" % VarAttribute)
1740 ExceedMax = False
1741 FormatCorrect = True
1742 if VariableOffset.isdigit():
1743 if int(VariableOffset, 10) > 0xFFFF:
1744 ExceedMax = True
1745 elif re.match(r'[\t\s]*0[xX][a-fA-F0-9]+$', VariableOffset):
1746 if int(VariableOffset, 16) > 0xFFFF:
1747 ExceedMax = True
1748 # For Offset written in "A.B"
1749 elif VariableOffset.find('.') > -1:
1750 VariableOffsetList = VariableOffset.split(".")
1751 if not (len(VariableOffsetList) == 2
1752 and IsValidWord(VariableOffsetList[0])
1753 and IsValidWord(VariableOffsetList[1])):
1754 FormatCorrect = False
1755 else:
1756 FormatCorrect = False
1757 if not FormatCorrect:
1758 EdkLogger.error('Build', FORMAT_INVALID, "Invalid syntax or format of the variable offset value is incorrect for %s." % ".".join((TokenSpaceGuid, PcdCName)))
1759
1760 if ExceedMax:
1761 EdkLogger.error('Build', OPTION_VALUE_INVALID, "The variable offset value must not exceed the maximum value of 0xFFFF (UINT16) for %s." % ".".join((TokenSpaceGuid, PcdCName)))
1762 if (VariableName, VariableGuid) not in VariableAttrs:
1763 VariableAttrs[(VariableName, VariableGuid)] = VarAttribute
1764 else:
1765 if not self.CompareVarAttr(VariableAttrs[(VariableName, VariableGuid)], VarAttribute):
1766 EdkLogger.error('Build', PCD_VARIABLE_ATTRIBUTES_CONFLICT_ERROR, "The variable %s.%s for DynamicHii PCDs has conflicting attributes [%s] and [%s] " % (VariableGuid, VariableName, VarAttribute, VariableAttrs[(VariableName, VariableGuid)]))
1767
1768 pcdDecObject = self._DecPcds[PcdCName, TokenSpaceGuid]
1769 if (PcdCName, TokenSpaceGuid) in Pcds.keys():
1770 pcdObject = Pcds[PcdCName, TokenSpaceGuid]
1771 if SkuName in pcdObject.SkuInfoList:
1772 Skuitem = pcdObject.SkuInfoList[SkuName]
1773 Skuitem.DefaultStoreDict.update({DefaultStore:DefaultValue})
1774 else:
1775 SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName][0], VariableName, VariableGuid, VariableOffset, DefaultValue, VariableAttribute=VarAttribute,DefaultStore={DefaultStore:DefaultValue})
1776 pcdObject.SkuInfoList[SkuName] = SkuInfo
1777 else:
1778 SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName][0], VariableName, VariableGuid, VariableOffset, DefaultValue, VariableAttribute=VarAttribute,DefaultStore={DefaultStore:DefaultValue})
1779 Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
1780 PcdCName,
1781 TokenSpaceGuid,
1782 self._PCD_TYPE_STRING_[Type],
1783 '',
1784 DefaultValue,
1785 '',
1786 '',
1787 {SkuName : SkuInfo},
1788 False,
1789 None,
1790 pcdDecObject.validateranges,
1791 pcdDecObject.validlists,
1792 pcdDecObject.expressions,
1793 IsDsc=True)
1794
1795
1796 for pcd in Pcds.values():
1797 SkuInfoObj = pcd.SkuInfoList.values()[0]
1798 pcdDecObject = self._DecPcds[pcd.TokenCName, pcd.TokenSpaceGuidCName]
1799 # Only fix the value while no value provided in DSC file.
1800 for sku in pcd.SkuInfoList.values():
1801 if (sku.HiiDefaultValue == "" or sku.HiiDefaultValue == None):
1802 sku.HiiDefaultValue = pcdDecObject.DefaultValue
1803 if 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' not in pcd.SkuInfoList.keys():
1804 valuefromDec = pcdDecObject.DefaultValue
1805 SkuInfo = SkuInfoClass('DEFAULT', '0', SkuInfoObj.VariableName, SkuInfoObj.VariableGuid, SkuInfoObj.VariableOffset, valuefromDec,VariableAttribute=SkuInfoObj.VariableAttribute,DefaultStore={DefaultStore:valuefromDec})
1806 pcd.SkuInfoList['DEFAULT'] = SkuInfo
1807 elif 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():
1808 pcd.SkuInfoList['DEFAULT'] = pcd.SkuInfoList['COMMON']
1809 del(pcd.SkuInfoList['COMMON'])
1810 elif 'DEFAULT' in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():
1811 del(pcd.SkuInfoList['COMMON'])
1812
1813 if pcd.MaxDatumSize.strip():
1814 MaxSize = int(pcd.MaxDatumSize, 0)
1815 else:
1816 MaxSize = 0
1817 if pcdDecObject.DatumType == 'VOID*':
1818 for (_, skuobj) in pcd.SkuInfoList.items():
1819 datalen = 0
1820 skuobj.HiiDefaultValue = StringToArray(skuobj.HiiDefaultValue)
1821 datalen = len(skuobj.HiiDefaultValue.split(","))
1822 if datalen > MaxSize:
1823 MaxSize = datalen
1824 for defaultst in skuobj.DefaultStoreDict:
1825 skuobj.DefaultStoreDict[defaultst] = StringToArray(skuobj.DefaultStoreDict[defaultst])
1826 pcd.DefaultValue = StringToArray(pcd.DefaultValue)
1827 pcd.MaxDatumSize = str(MaxSize)
1828 rt, invalidhii = self.CheckVariableNameAssignment(Pcds)
1829 if not rt:
1830 invalidpcd = ",".join(invalidhii)
1831 EdkLogger.error('build', PCD_VARIABLE_INFO_ERROR, Message='The same HII PCD must map to the same EFI variable for all SKUs', File=self.MetaFile, ExtraData=invalidpcd)
1832
1833 map(self.FilterSkuSettings,Pcds.values())
1834
1835 return Pcds
1836
1837 def CheckVariableNameAssignment(self,Pcds):
1838 invalidhii = []
1839 for pcdname in Pcds:
1840 pcd = Pcds[pcdname]
1841 varnameset = set([sku.VariableName for (skuid,sku) in pcd.SkuInfoList.items()])
1842 if len(varnameset) > 1:
1843 invalidhii.append(".".join((pcdname[1],pcdname[0])))
1844 if len(invalidhii):
1845 return False,invalidhii
1846 else:
1847 return True, []
1848 ## Retrieve dynamic VPD PCD settings
1849 #
1850 # @param Type PCD type
1851 #
1852 # @retval a dict object contains settings of given PCD type
1853 #
1854 def _GetDynamicVpdPcd(self, Type):
1855
1856
1857 Pcds = sdict()
1858 #
1859 # tdict is a special dict kind of type, used for selecting correct
1860 # PCD settings for certain ARCH and SKU
1861 #
1862 PcdDict = tdict(True, 4)
1863 PcdList = []
1864
1865 # Find out all possible PCD candidates for self._Arch
1866 RecordList = self._RawData[Type, self._Arch]
1867 AvailableSkuIdSet = copy.copy(self.SkuIds)
1868
1869 for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4,Dummy5 in RecordList:
1870 SkuName = SkuName.upper()
1871 SkuName = 'DEFAULT' if SkuName == 'COMMON' else SkuName
1872 if SkuName not in AvailableSkuIdSet:
1873 EdkLogger.error('build', PARAMETER_INVALID, 'Sku %s is not defined in [SkuIds] section' % SkuName,
1874 File=self.MetaFile, Line=Dummy5)
1875 if "." not in TokenSpaceGuid:
1876 PcdList.append((PcdCName, TokenSpaceGuid, SkuName, Dummy4))
1877 PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting
1878
1879 # Remove redundant PCD candidates, per the ARCH and SKU
1880 for PcdCName, TokenSpaceGuid, SkuName, Dummy4 in PcdList:
1881 Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid]
1882 if Setting == None:
1883 continue
1884 #
1885 # For the VOID* type, it can have optional data of MaxDatumSize and InitialValue
1886 # For the Integer & Boolean type, the optional data can only be InitialValue.
1887 # At this point, we put all the data into the PcdClssObject for we don't know the PCD's datumtype
1888 # until the DEC parser has been called.
1889 #
1890 VpdOffset, MaxDatumSize, InitialValue = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)
1891 SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName][0], '', '', '', '', VpdOffset, InitialValue)
1892 if (PcdCName, TokenSpaceGuid) in Pcds.keys():
1893 pcdObject = Pcds[PcdCName, TokenSpaceGuid]
1894 pcdObject.SkuInfoList[SkuName] = SkuInfo
1895 if MaxDatumSize.strip():
1896 CurrentMaxSize = int(MaxDatumSize.strip(), 0)
1897 else:
1898 CurrentMaxSize = 0
1899 if pcdObject.MaxDatumSize:
1900 PcdMaxSize = int(pcdObject.MaxDatumSize, 0)
1901 else:
1902 PcdMaxSize = 0
1903 if CurrentMaxSize > PcdMaxSize:
1904 pcdObject.MaxDatumSize = str(CurrentMaxSize)
1905 else:
1906 Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
1907 PcdCName,
1908 TokenSpaceGuid,
1909 self._PCD_TYPE_STRING_[Type],
1910 '',
1911 InitialValue,
1912 '',
1913 MaxDatumSize,
1914 {SkuName : SkuInfo},
1915 False,
1916 None,
1917 IsDsc=True)
1918 for pcd in Pcds.values():
1919 SkuInfoObj = pcd.SkuInfoList.values()[0]
1920 pcdDecObject = self._DecPcds[pcd.TokenCName, pcd.TokenSpaceGuidCName]
1921 # Only fix the value while no value provided in DSC file.
1922 for sku in pcd.SkuInfoList.values():
1923 if (sku.DefaultValue == "" or sku.DefaultValue==None):
1924 sku.DefaultValue = pcdDecObject.DefaultValue
1925 if 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' not in pcd.SkuInfoList.keys():
1926 valuefromDec = pcdDecObject.DefaultValue
1927 SkuInfo = SkuInfoClass('DEFAULT', '0', '', '', '', '', SkuInfoObj.VpdOffset, valuefromDec)
1928 pcd.SkuInfoList['DEFAULT'] = SkuInfo
1929 elif 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():
1930 pcd.SkuInfoList['DEFAULT'] = pcd.SkuInfoList['COMMON']
1931 del(pcd.SkuInfoList['COMMON'])
1932 elif 'DEFAULT' in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():
1933 del(pcd.SkuInfoList['COMMON'])
1934
1935
1936 map(self.FilterSkuSettings,Pcds.values())
1937 return Pcds
1938
1939 ## Add external modules
1940 #
1941 # The external modules are mostly those listed in FDF file, which don't
1942 # need "build".
1943 #
1944 # @param FilePath The path of module description file
1945 #
1946 def AddModule(self, FilePath):
1947 FilePath = NormPath(FilePath)
1948 if FilePath not in self.Modules:
1949 Module = ModuleBuildClassObject()
1950 Module.MetaFile = FilePath
1951 self.Modules.append(Module)
1952
1953 ## Add external PCDs
1954 #
1955 # The external PCDs are mostly those listed in FDF file to specify address
1956 # or offset information.
1957 #
1958 # @param Name Name of the PCD
1959 # @param Guid Token space guid of the PCD
1960 # @param Value Value of the PCD
1961 #
1962 def AddPcd(self, Name, Guid, Value):
1963 if (Name, Guid) not in self.Pcds:
1964 self.Pcds[Name, Guid] = PcdClassObject(Name, Guid, '', '', '', '', '', {}, False, None)
1965 self.Pcds[Name, Guid].DefaultValue = Value
1966
1967 _Macros = property(_GetMacros)
1968 Arch = property(_GetArch, _SetArch)
1969 Platform = property(_GetPlatformName)
1970 PlatformName = property(_GetPlatformName)
1971 Guid = property(_GetFileGuid)
1972 Version = property(_GetVersion)
1973 DscSpecification = property(_GetDscSpec)
1974 OutputDirectory = property(_GetOutpuDir)
1975 SupArchList = property(_GetSupArch)
1976 BuildTargets = property(_GetBuildTarget)
1977 SkuName = property(_GetSkuName, _SetSkuName)
1978 PcdInfoFlag = property(_GetPcdInfoFlag)
1979 VarCheckFlag = property(_GetVarCheckFlag)
1980 FlashDefinition = property(_GetFdfFile)
1981 Prebuild = property(_GetPrebuild)
1982 Postbuild = property(_GetPostbuild)
1983 BuildNumber = property(_GetBuildNumber)
1984 MakefileName = property(_GetMakefileName)
1985 BsBaseAddress = property(_GetBsBaseAddress)
1986 RtBaseAddress = property(_GetRtBaseAddress)
1987 LoadFixAddress = property(_GetLoadFixAddress)
1988 RFCLanguages = property(_GetRFCLanguages)
1989 ISOLanguages = property(_GetISOLanguages)
1990 VpdToolGuid = property(_GetVpdToolGuid)
1991 SkuIds = property(_GetSkuIds)
1992 Modules = property(_GetModules)
1993 LibraryInstances = property(_GetLibraryInstances)
1994 LibraryClasses = property(_GetLibraryClasses)
1995 Pcds = property(_GetPcds)
1996 BuildOptions = property(_GetBuildOptions)