e8f159b2620450e4ec3ad0ee23efa52f46951f3b
[mirror_edk2.git] / BaseTools / Source / Python / Workspace / WorkspaceCommon.py
1 ## @file
2 # Common routines used by workspace
3 #
4 # Copyright (c) 2012 - 2018, Intel Corporation. All rights reserved.<BR>
5 # This program and the accompanying materials
6 # are licensed and made available under the terms and conditions of the BSD License
7 # which accompanies this distribution. The full text of the license may be found at
8 # http://opensource.org/licenses/bsd-license.php
9 #
10 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12 #
13
14 from collections import OrderedDict, defaultdict
15 from Common.DataType import SUP_MODULE_USER_DEFINED
16 from BuildClassObject import LibraryClassObject
17 import Common.GlobalData as GlobalData
18 from Workspace.BuildClassObject import StructurePcd
19 from Common.BuildToolError import RESOURCE_NOT_AVAILABLE
20 from Common.BuildToolError import OPTION_MISSING
21 from Common.BuildToolError import BUILD_ERROR
22
23 class OrderedListDict(OrderedDict, defaultdict):
24 def __init__(self, *args, **kwargs):
25 super(OrderedListDict, self).__init__(*args, **kwargs)
26 self.default_factory = list
27
28 ## Get all packages from platform for specified arch, target and toolchain
29 #
30 # @param Platform: DscBuildData instance
31 # @param BuildDatabase: The database saves all data for all metafiles
32 # @param Arch: Current arch
33 # @param Target: Current target
34 # @param Toolchain: Current toolchain
35 # @retval: List of packages which are DecBuildData instances
36 #
37 def GetPackageList(Platform, BuildDatabase, Arch, Target, Toolchain):
38 PkgSet = set()
39 for ModuleFile in Platform.Modules:
40 Data = BuildDatabase[ModuleFile, Arch, Target, Toolchain]
41 PkgSet.update(Data.Packages)
42 for Lib in GetLiabraryInstances(Data, Platform, BuildDatabase, Arch, Target, Toolchain):
43 PkgSet.update(Lib.Packages)
44 return list(PkgSet)
45
46 ## Get all declared PCD from platform for specified arch, target and toolchain
47 #
48 # @param Platform: DscBuildData instance
49 # @param BuildDatabase: The database saves all data for all metafiles
50 # @param Arch: Current arch
51 # @param Target: Current target
52 # @param Toolchain: Current toolchain
53 # @retval: A dictionary contains instances of PcdClassObject with key (PcdCName, TokenSpaceGuid)
54 # @retval: A dictionary contains real GUIDs of TokenSpaceGuid
55 #
56 def GetDeclaredPcd(Platform, BuildDatabase, Arch, Target, Toolchain, additionalPkgs):
57 PkgList = GetPackageList(Platform, BuildDatabase, Arch, Target, Toolchain)
58 PkgList = set(PkgList)
59 PkgList |= additionalPkgs
60 DecPcds = {}
61 GuidDict = {}
62 for Pkg in PkgList:
63 Guids = Pkg.Guids
64 GuidDict.update(Guids)
65 for Pcd in Pkg.Pcds:
66 PcdCName = Pcd[0]
67 PcdTokenName = Pcd[1]
68 if GlobalData.MixedPcd:
69 for PcdItem in GlobalData.MixedPcd:
70 if (PcdCName, PcdTokenName) in GlobalData.MixedPcd[PcdItem]:
71 PcdCName = PcdItem[0]
72 break
73 if (PcdCName, PcdTokenName) not in DecPcds:
74 DecPcds[PcdCName, PcdTokenName] = Pkg.Pcds[Pcd]
75 return DecPcds, GuidDict
76
77 ## Get all dependent libraries for a module
78 #
79 # @param Module: InfBuildData instance
80 # @param Platform: DscBuildData instance
81 # @param BuildDatabase: The database saves all data for all metafiles
82 # @param Arch: Current arch
83 # @param Target: Current target
84 # @param Toolchain: Current toolchain
85 # @retval: List of dependent libraries which are InfBuildData instances
86 #
87 def GetLiabraryInstances(Module, Platform, BuildDatabase, Arch, Target, Toolchain):
88 if Module.AutoGenVersion >= 0x00010005:
89 return GetModuleLibInstances(Module, Platform, BuildDatabase, Arch, Target, Toolchain)
90 else:
91 return _ResolveLibraryReference(Module, Platform)
92
93 def GetModuleLibInstances(Module, Platform, BuildDatabase, Arch, Target, Toolchain, FileName = '', EdkLogger = None):
94 ModuleType = Module.ModuleType
95
96 # add forced library instances (specified under LibraryClasses sections)
97 #
98 # If a module has a MODULE_TYPE of USER_DEFINED,
99 # do not link in NULL library class instances from the global [LibraryClasses.*] sections.
100 #
101 if Module.ModuleType != SUP_MODULE_USER_DEFINED:
102 for LibraryClass in Platform.LibraryClasses.GetKeys():
103 if LibraryClass.startswith("NULL") and Platform.LibraryClasses[LibraryClass, Module.ModuleType]:
104 Module.LibraryClasses[LibraryClass] = Platform.LibraryClasses[LibraryClass, Module.ModuleType]
105
106 # add forced library instances (specified in module overrides)
107 for LibraryClass in Platform.Modules[str(Module)].LibraryClasses:
108 if LibraryClass.startswith("NULL"):
109 Module.LibraryClasses[LibraryClass] = Platform.Modules[str(Module)].LibraryClasses[LibraryClass]
110
111 # EdkII module
112 LibraryConsumerList = [Module]
113 Constructor = []
114 ConsumedByList = OrderedListDict()
115 LibraryInstance = OrderedDict()
116
117 if FileName:
118 EdkLogger.verbose("")
119 EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), Arch))
120
121 while len(LibraryConsumerList) > 0:
122 M = LibraryConsumerList.pop()
123 for LibraryClassName in M.LibraryClasses:
124 if LibraryClassName not in LibraryInstance:
125 # override library instance for this module
126 if LibraryClassName in Platform.Modules[str(Module)].LibraryClasses:
127 LibraryPath = Platform.Modules[str(Module)].LibraryClasses[LibraryClassName]
128 else:
129 LibraryPath = Platform.LibraryClasses[LibraryClassName, ModuleType]
130 if LibraryPath is None or LibraryPath == "":
131 LibraryPath = M.LibraryClasses[LibraryClassName]
132 if LibraryPath is None or LibraryPath == "":
133 if FileName:
134 EdkLogger.error("build", RESOURCE_NOT_AVAILABLE,
135 "Instance of library class [%s] is not found" % LibraryClassName,
136 File=FileName,
137 ExtraData="in [%s] [%s]\n\tconsumed by module [%s]" % (str(M), Arch, str(Module)))
138 else:
139 return []
140
141 LibraryModule = BuildDatabase[LibraryPath, Arch, Target, Toolchain]
142 # for those forced library instance (NULL library), add a fake library class
143 if LibraryClassName.startswith("NULL"):
144 LibraryModule.LibraryClass.append(LibraryClassObject(LibraryClassName, [ModuleType]))
145 elif LibraryModule.LibraryClass is None \
146 or len(LibraryModule.LibraryClass) == 0 \
147 or (ModuleType != SUP_MODULE_USER_DEFINED
148 and ModuleType not in LibraryModule.LibraryClass[0].SupModList):
149 # only USER_DEFINED can link against any library instance despite of its SupModList
150 if FileName:
151 EdkLogger.error("build", OPTION_MISSING,
152 "Module type [%s] is not supported by library instance [%s]" \
153 % (ModuleType, LibraryPath), File=FileName,
154 ExtraData="consumed by [%s]" % str(Module))
155 else:
156 return []
157
158 LibraryInstance[LibraryClassName] = LibraryModule
159 LibraryConsumerList.append(LibraryModule)
160 if FileName:
161 EdkLogger.verbose("\t" + str(LibraryClassName) + " : " + str(LibraryModule))
162 else:
163 LibraryModule = LibraryInstance[LibraryClassName]
164
165 if LibraryModule is None:
166 continue
167
168 if LibraryModule.ConstructorList != [] and LibraryModule not in Constructor:
169 Constructor.append(LibraryModule)
170
171 # don't add current module itself to consumer list
172 if M != Module:
173 if M in ConsumedByList[LibraryModule]:
174 continue
175 ConsumedByList[LibraryModule].append(M)
176 #
177 # Initialize the sorted output list to the empty set
178 #
179 SortedLibraryList = []
180 #
181 # Q <- Set of all nodes with no incoming edges
182 #
183 LibraryList = [] #LibraryInstance.values()
184 Q = []
185 for LibraryClassName in LibraryInstance:
186 M = LibraryInstance[LibraryClassName]
187 LibraryList.append(M)
188 if not ConsumedByList[M]:
189 Q.append(M)
190
191 #
192 # start the DAG algorithm
193 #
194 while True:
195 EdgeRemoved = True
196 while Q == [] and EdgeRemoved:
197 EdgeRemoved = False
198 # for each node Item with a Constructor
199 for Item in LibraryList:
200 if Item not in Constructor:
201 continue
202 # for each Node without a constructor with an edge e from Item to Node
203 for Node in ConsumedByList[Item]:
204 if Node in Constructor:
205 continue
206 # remove edge e from the graph if Node has no constructor
207 ConsumedByList[Item].remove(Node)
208 EdgeRemoved = True
209 if not ConsumedByList[Item]:
210 # insert Item into Q
211 Q.insert(0, Item)
212 break
213 if Q != []:
214 break
215 # DAG is done if there's no more incoming edge for all nodes
216 if Q == []:
217 break
218
219 # remove node from Q
220 Node = Q.pop()
221 # output Node
222 SortedLibraryList.append(Node)
223
224 # for each node Item with an edge e from Node to Item do
225 for Item in LibraryList:
226 if Node not in ConsumedByList[Item]:
227 continue
228 # remove edge e from the graph
229 ConsumedByList[Item].remove(Node)
230
231 if ConsumedByList[Item]:
232 continue
233 # insert Item into Q, if Item has no other incoming edges
234 Q.insert(0, Item)
235
236 #
237 # if any remaining node Item in the graph has a constructor and an incoming edge, then the graph has a cycle
238 #
239 for Item in LibraryList:
240 if ConsumedByList[Item] and Item in Constructor and len(Constructor) > 1:
241 if FileName:
242 ErrorMessage = "\tconsumed by " + "\n\tconsumed by ".join(str(L) for L in ConsumedByList[Item])
243 EdkLogger.error("build", BUILD_ERROR, 'Library [%s] with constructors has a cycle' % str(Item),
244 ExtraData=ErrorMessage, File=FileName)
245 else:
246 return []
247 if Item not in SortedLibraryList:
248 SortedLibraryList.append(Item)
249
250 #
251 # Build the list of constructor and destructir names
252 # The DAG Topo sort produces the destructor order, so the list of constructors must generated in the reverse order
253 #
254 SortedLibraryList.reverse()
255 return SortedLibraryList
256
257 def _ResolveLibraryReference(Module, Platform):
258 LibraryConsumerList = [Module]
259
260 # "CompilerStub" is a must for Edk modules
261 if Module.Libraries:
262 Module.Libraries.append("CompilerStub")
263 LibraryList = []
264 while len(LibraryConsumerList) > 0:
265 M = LibraryConsumerList.pop()
266 for LibraryName in M.Libraries:
267 Library = Platform.LibraryClasses[LibraryName, ':dummy:']
268 if Library is None:
269 for Key in Platform.LibraryClasses.data:
270 if LibraryName.upper() == Key.upper():
271 Library = Platform.LibraryClasses[Key, ':dummy:']
272 break
273 if Library is None:
274 continue
275
276 if Library not in LibraryList:
277 LibraryList.append(Library)
278 LibraryConsumerList.append(Library)
279 return LibraryList