]> git.proxmox.com Git - mirror_edk2.git/blame_incremental - BaseTools/Source/Python/build/build.py
projects / mirror_edk2.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Maintainers.txt: Change maintainer for Intel*Pkg.
[mirror_edk2.git] / BaseTools / Source / Python / build / build.py
... / ...
CommitLineData
1## @file\r
2# build a platform or a module\r
3#\r
4# Copyright (c) 2014, Hewlett-Packard Development Company, L.P.<BR>\r
5# Copyright (c) 2007 - 2017, Intel Corporation. All rights reserved.<BR>\r
6#\r
7# This program and the accompanying materials\r
8# are licensed and made available under the terms and conditions of the BSD License\r
9# which accompanies this distribution. The full text of the license may be found at\r
10# http://opensource.org/licenses/bsd-license.php\r
11#\r
12# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
13# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
14#\r
15\r
16##\r
17# Import Modules\r
18#\r
19import Common.LongFilePathOs as os\r
20import re\r
21import StringIO\r
22import sys\r
23import glob\r
24import time\r
25import platform\r
26import traceback\r
27import encodings.ascii\r
28import itertools\r
29\r
30from struct import *\r
31from threading import *\r
32from optparse import OptionParser\r
33from subprocess import *\r
34from Common import Misc as Utils\r
35\r
36from Common.LongFilePathSupport import OpenLongFilePath as open\r
37from Common.LongFilePathSupport import LongFilePath\r
38from Common.TargetTxtClassObject import *\r
39from Common.ToolDefClassObject import *\r
40from Common.DataType import *\r
41from Common.BuildVersion import gBUILD_VERSION\r
42from AutoGen.AutoGen import *\r
43from Common.BuildToolError import *\r
44from Workspace.WorkspaceDatabase import *\r
45from Common.MultipleWorkspace import MultipleWorkspace as mws\r
46\r
47from BuildReport import BuildReport\r
48from GenPatchPcdTable.GenPatchPcdTable import *\r
49from PatchPcdValue.PatchPcdValue import *\r
50\r
51import Common.EdkLogger\r
52import Common.GlobalData as GlobalData\r
53\r
54# Version and Copyright\r
55VersionNumber = "0.60" + ' ' + gBUILD_VERSION\r
56__version__ = "%prog Version " + VersionNumber\r
57__copyright__ = "Copyright (c) 2007 - 2017, Intel Corporation All rights reserved."\r
58\r
59## standard targets of build command\r
60gSupportedTarget = ['all', 'genc', 'genmake', 'modules', 'libraries', 'fds', 'clean', 'cleanall', 'cleanlib', 'run']\r
61\r
62## build configuration file\r
63gBuildConfiguration = "target.txt"\r
64gToolsDefinition = "tools_def.txt"\r
65\r
66TemporaryTablePattern = re.compile(r'^_\d+_\d+_[a-fA-F0-9]+$')\r
67TmpTableDict = {}\r
68\r
69## Check environment PATH variable to make sure the specified tool is found\r
70#\r
71# If the tool is found in the PATH, then True is returned\r
72# Otherwise, False is returned\r
73#\r
74def IsToolInPath(tool):\r
75 if os.environ.has_key('PATHEXT'):\r
76 extns = os.environ['PATHEXT'].split(os.path.pathsep)\r
77 else:\r
78 extns = ('',)\r
79 for pathDir in os.environ['PATH'].split(os.path.pathsep):\r
80 for ext in extns:\r
81 if os.path.exists(os.path.join(pathDir, tool + ext)):\r
82 return True\r
83 return False\r
84\r
85## Check environment variables\r
86#\r
87# Check environment variables that must be set for build. Currently they are\r
88#\r
89# WORKSPACE The directory all packages/platforms start from\r
90# EDK_TOOLS_PATH The directory contains all tools needed by the build\r
91# PATH $(EDK_TOOLS_PATH)/Bin/<sys> must be set in PATH\r
92#\r
93# If any of above environment variable is not set or has error, the build\r
94# will be broken.\r
95#\r
96def CheckEnvVariable():\r
97 # check WORKSPACE\r
98 if "WORKSPACE" not in os.environ:\r
99 EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "Environment variable not found",\r
100 ExtraData="WORKSPACE")\r
101\r
102 WorkspaceDir = os.path.normcase(os.path.normpath(os.environ["WORKSPACE"]))\r
103 if not os.path.exists(WorkspaceDir):\r
104 EdkLogger.error("build", FILE_NOT_FOUND, "WORKSPACE doesn't exist", ExtraData="%s" % WorkspaceDir)\r
105 elif ' ' in WorkspaceDir:\r
106 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in WORKSPACE path",\r
107 ExtraData=WorkspaceDir)\r
108 os.environ["WORKSPACE"] = WorkspaceDir\r
109 \r
110 # set multiple workspace\r
111 PackagesPath = os.getenv("PACKAGES_PATH")\r
112 mws.setWs(WorkspaceDir, PackagesPath)\r
113 if mws.PACKAGES_PATH:\r
114 for Path in mws.PACKAGES_PATH:\r
115 if not os.path.exists(Path):\r
116 EdkLogger.error("build", FILE_NOT_FOUND, "One Path in PACKAGES_PATH doesn't exist", ExtraData="%s" % Path)\r
117 elif ' ' in Path:\r
118 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in PACKAGES_PATH", ExtraData=Path)\r
119\r
120 #\r
121 # Check EFI_SOURCE (Edk build convention). EDK_SOURCE will always point to ECP\r
122 #\r
123 if "ECP_SOURCE" not in os.environ:\r
124 os.environ["ECP_SOURCE"] = mws.join(WorkspaceDir, GlobalData.gEdkCompatibilityPkg)\r
125 if "EFI_SOURCE" not in os.environ:\r
126 os.environ["EFI_SOURCE"] = os.environ["ECP_SOURCE"]\r
127 if "EDK_SOURCE" not in os.environ:\r
128 os.environ["EDK_SOURCE"] = os.environ["ECP_SOURCE"]\r
129\r
130 #\r
131 # Unify case of characters on case-insensitive systems\r
132 #\r
133 EfiSourceDir = os.path.normcase(os.path.normpath(os.environ["EFI_SOURCE"]))\r
134 EdkSourceDir = os.path.normcase(os.path.normpath(os.environ["EDK_SOURCE"]))\r
135 EcpSourceDir = os.path.normcase(os.path.normpath(os.environ["ECP_SOURCE"]))\r
136\r
137 os.environ["EFI_SOURCE"] = EfiSourceDir\r
138 os.environ["EDK_SOURCE"] = EdkSourceDir\r
139 os.environ["ECP_SOURCE"] = EcpSourceDir\r
140 os.environ["EDK_TOOLS_PATH"] = os.path.normcase(os.environ["EDK_TOOLS_PATH"])\r
141\r
142 if not os.path.exists(EcpSourceDir):\r
143 EdkLogger.verbose("ECP_SOURCE = %s doesn't exist. Edk modules could not be built." % EcpSourceDir)\r
144 elif ' ' in EcpSourceDir:\r
145 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in ECP_SOURCE path",\r
146 ExtraData=EcpSourceDir)\r
147 if not os.path.exists(EdkSourceDir):\r
148 if EdkSourceDir == EcpSourceDir:\r
149 EdkLogger.verbose("EDK_SOURCE = %s doesn't exist. Edk modules could not be built." % EdkSourceDir)\r
150 else:\r
151 EdkLogger.error("build", PARAMETER_INVALID, "EDK_SOURCE does not exist",\r
152 ExtraData=EdkSourceDir)\r
153 elif ' ' in EdkSourceDir:\r
154 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in EDK_SOURCE path",\r
155 ExtraData=EdkSourceDir)\r
156 if not os.path.exists(EfiSourceDir):\r
157 if EfiSourceDir == EcpSourceDir:\r
158 EdkLogger.verbose("EFI_SOURCE = %s doesn't exist. Edk modules could not be built." % EfiSourceDir)\r
159 else:\r
160 EdkLogger.error("build", PARAMETER_INVALID, "EFI_SOURCE does not exist",\r
161 ExtraData=EfiSourceDir)\r
162 elif ' ' in EfiSourceDir:\r
163 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in EFI_SOURCE path",\r
164 ExtraData=EfiSourceDir)\r
165\r
166 # check those variables on single workspace case\r
167 if not PackagesPath:\r
168 # change absolute path to relative path to WORKSPACE\r
169 if EfiSourceDir.upper().find(WorkspaceDir.upper()) != 0:\r
170 EdkLogger.error("build", PARAMETER_INVALID, "EFI_SOURCE is not under WORKSPACE",\r
171 ExtraData="WORKSPACE = %s\n EFI_SOURCE = %s" % (WorkspaceDir, EfiSourceDir))\r
172 if EdkSourceDir.upper().find(WorkspaceDir.upper()) != 0:\r
173 EdkLogger.error("build", PARAMETER_INVALID, "EDK_SOURCE is not under WORKSPACE",\r
174 ExtraData="WORKSPACE = %s\n EDK_SOURCE = %s" % (WorkspaceDir, EdkSourceDir))\r
175 if EcpSourceDir.upper().find(WorkspaceDir.upper()) != 0:\r
176 EdkLogger.error("build", PARAMETER_INVALID, "ECP_SOURCE is not under WORKSPACE",\r
177 ExtraData="WORKSPACE = %s\n ECP_SOURCE = %s" % (WorkspaceDir, EcpSourceDir))\r
178\r
179 # check EDK_TOOLS_PATH\r
180 if "EDK_TOOLS_PATH" not in os.environ:\r
181 EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "Environment variable not found",\r
182 ExtraData="EDK_TOOLS_PATH")\r
183\r
184 # check PATH\r
185 if "PATH" not in os.environ:\r
186 EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "Environment variable not found",\r
187 ExtraData="PATH")\r
188\r
189 GlobalData.gWorkspace = WorkspaceDir\r
190 GlobalData.gEfiSource = EfiSourceDir\r
191 GlobalData.gEdkSource = EdkSourceDir\r
192 GlobalData.gEcpSource = EcpSourceDir\r
193\r
194 GlobalData.gGlobalDefines["WORKSPACE"] = WorkspaceDir\r
195 GlobalData.gGlobalDefines["EFI_SOURCE"] = EfiSourceDir\r
196 GlobalData.gGlobalDefines["EDK_SOURCE"] = EdkSourceDir\r
197 GlobalData.gGlobalDefines["ECP_SOURCE"] = EcpSourceDir\r
198 GlobalData.gGlobalDefines["EDK_TOOLS_PATH"] = os.environ["EDK_TOOLS_PATH"]\r
199 \r
200## Get normalized file path\r
201#\r
202# Convert the path to be local format, and remove the WORKSPACE path at the\r
203# beginning if the file path is given in full path.\r
204#\r
205# @param FilePath File path to be normalized\r
206# @param Workspace Workspace path which the FilePath will be checked against\r
207#\r
208# @retval string The normalized file path\r
209#\r
210def NormFile(FilePath, Workspace):\r
211 # check if the path is absolute or relative\r
212 if os.path.isabs(FilePath):\r
213 FileFullPath = os.path.normpath(FilePath)\r
214 else:\r
215 FileFullPath = os.path.normpath(mws.join(Workspace, FilePath))\r
216 Workspace = mws.getWs(Workspace, FilePath)\r
217\r
218 # check if the file path exists or not\r
219 if not os.path.isfile(FileFullPath):\r
220 EdkLogger.error("build", FILE_NOT_FOUND, ExtraData="\t%s (Please give file in absolute path or relative to WORKSPACE)" % FileFullPath)\r
221\r
222 # remove workspace directory from the beginning part of the file path\r
223 if Workspace[-1] in ["\\", "/"]:\r
224 return FileFullPath[len(Workspace):]\r
225 else:\r
226 return FileFullPath[(len(Workspace) + 1):]\r
227\r
228## Get the output of an external program\r
229#\r
230# This is the entrance method of thread reading output of an external program and\r
231# putting them in STDOUT/STDERR of current program.\r
232#\r
233# @param From The stream message read from\r
234# @param To The stream message put on\r
235# @param ExitFlag The flag used to indicate stopping reading\r
236#\r
237def ReadMessage(From, To, ExitFlag):\r
238 while True:\r
239 # read one line a time\r
240 Line = From.readline()\r
241 # empty string means "end"\r
242 if Line != None and Line != "":\r
243 To(Line.rstrip())\r
244 else:\r
245 break\r
246 if ExitFlag.isSet():\r
247 break\r
248\r
249## Launch an external program\r
250#\r
251# This method will call subprocess.Popen to execute an external program with\r
252# given options in specified directory. Because of the dead-lock issue during\r
253# redirecting output of the external program, threads are used to to do the\r
254# redirection work.\r
255#\r
256# @param Command A list or string containing the call of the program\r
257# @param WorkingDir The directory in which the program will be running\r
258#\r
259def LaunchCommand(Command, WorkingDir):\r
260 # if working directory doesn't exist, Popen() will raise an exception\r
261 if not os.path.isdir(WorkingDir):\r
262 EdkLogger.error("build", FILE_NOT_FOUND, ExtraData=WorkingDir)\r
263 \r
264 # Command is used as the first Argument in following Popen().\r
265 # It could be a string or sequence. We find that if command is a string in following Popen(),\r
266 # ubuntu may fail with an error message that the command is not found.\r
267 # So here we may need convert command from string to list instance.\r
268 if platform.system() != 'Windows':\r
269 if not isinstance(Command, list):\r
270 Command = Command.split()\r
271 Command = ' '.join(Command)\r
272\r
273 Proc = None\r
274 EndOfProcedure = None\r
275 try:\r
276 # launch the command\r
277 Proc = Popen(Command, stdout=PIPE, stderr=PIPE, env=os.environ, cwd=WorkingDir, bufsize=-1, shell=True)\r
278\r
279 # launch two threads to read the STDOUT and STDERR\r
280 EndOfProcedure = Event()\r
281 EndOfProcedure.clear()\r
282 if Proc.stdout:\r
283 StdOutThread = Thread(target=ReadMessage, args=(Proc.stdout, EdkLogger.info, EndOfProcedure))\r
284 StdOutThread.setName("STDOUT-Redirector")\r
285 StdOutThread.setDaemon(False)\r
286 StdOutThread.start()\r
287\r
288 if Proc.stderr:\r
289 StdErrThread = Thread(target=ReadMessage, args=(Proc.stderr, EdkLogger.quiet, EndOfProcedure))\r
290 StdErrThread.setName("STDERR-Redirector")\r
291 StdErrThread.setDaemon(False)\r
292 StdErrThread.start()\r
293\r
294 # waiting for program exit\r
295 Proc.wait()\r
296 except: # in case of aborting\r
297 # terminate the threads redirecting the program output\r
298 EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())\r
299 if EndOfProcedure != None:\r
300 EndOfProcedure.set()\r
301 if Proc == None:\r
302 if type(Command) != type(""):\r
303 Command = " ".join(Command)\r
304 EdkLogger.error("build", COMMAND_FAILURE, "Failed to start command", ExtraData="%s [%s]" % (Command, WorkingDir))\r
305\r
306 if Proc.stdout:\r
307 StdOutThread.join()\r
308 if Proc.stderr:\r
309 StdErrThread.join()\r
310\r
311 # check the return code of the program\r
312 if Proc.returncode != 0:\r
313 if type(Command) != type(""):\r
314 Command = " ".join(Command)\r
315 # print out the Response file and its content when make failure\r
316 RespFile = os.path.join(WorkingDir, 'OUTPUT', 'respfilelist.txt')\r
317 if os.path.isfile(RespFile):\r
318 f = open(RespFile)\r
319 RespContent = f.read()\r
320 f.close()\r
321 EdkLogger.info(RespContent)\r
322\r
323 EdkLogger.error("build", COMMAND_FAILURE, ExtraData="%s [%s]" % (Command, WorkingDir))\r
324\r
325## The smallest unit that can be built in multi-thread build mode\r
326#\r
327# This is the base class of build unit. The "Obj" parameter must provide\r
328# __str__(), __eq__() and __hash__() methods. Otherwise there could be build units\r
329# missing build.\r
330#\r
331# Currently the "Obj" should be only ModuleAutoGen or PlatformAutoGen objects.\r
332#\r
333class BuildUnit:\r
334 ## The constructor\r
335 #\r
336 # @param self The object pointer\r
337 # @param Obj The object the build is working on\r
338 # @param Target The build target name, one of gSupportedTarget\r
339 # @param Dependency The BuildUnit(s) which must be completed in advance\r
340 # @param WorkingDir The directory build command starts in\r
341 #\r
342 def __init__(self, Obj, BuildCommand, Target, Dependency, WorkingDir="."):\r
343 self.BuildObject = Obj\r
344 self.Dependency = Dependency\r
345 self.WorkingDir = WorkingDir\r
346 self.Target = Target\r
347 self.BuildCommand = BuildCommand\r
348 if not BuildCommand:\r
349 EdkLogger.error("build", OPTION_MISSING,\r
350 "No build command found for this module. "\r
351 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %\r
352 (Obj.BuildTarget, Obj.ToolChain, Obj.Arch),\r
353 ExtraData=str(Obj))\r
354\r
355\r
356 ## str() method\r
357 #\r
358 # It just returns the string representation of self.BuildObject\r
359 #\r
360 # @param self The object pointer\r
361 #\r
362 def __str__(self):\r
363 return str(self.BuildObject)\r
364\r
365 ## "==" operator method\r
366 #\r
367 # It just compares self.BuildObject with "Other". So self.BuildObject must\r
368 # provide its own __eq__() method.\r
369 #\r
370 # @param self The object pointer\r
371 # @param Other The other BuildUnit object compared to\r
372 #\r
373 def __eq__(self, Other):\r
374 return Other != None and self.BuildObject == Other.BuildObject \\r
375 and self.BuildObject.Arch == Other.BuildObject.Arch\r
376\r
377 ## hash() method\r
378 #\r
379 # It just returns the hash value of self.BuildObject which must be hashable.\r
380 #\r
381 # @param self The object pointer\r
382 #\r
383 def __hash__(self):\r
384 return hash(self.BuildObject) + hash(self.BuildObject.Arch)\r
385\r
386 def __repr__(self):\r
387 return repr(self.BuildObject)\r
388\r
389## The smallest module unit that can be built by nmake/make command in multi-thread build mode\r
390#\r
391# This class is for module build by nmake/make build system. The "Obj" parameter\r
392# must provide __str__(), __eq__() and __hash__() methods. Otherwise there could\r
393# be make units missing build.\r
394#\r
395# Currently the "Obj" should be only ModuleAutoGen object.\r
396#\r
397class ModuleMakeUnit(BuildUnit):\r
398 ## The constructor\r
399 #\r
400 # @param self The object pointer\r
401 # @param Obj The ModuleAutoGen object the build is working on\r
402 # @param Target The build target name, one of gSupportedTarget\r
403 #\r
404 def __init__(self, Obj, Target):\r
405 Dependency = [ModuleMakeUnit(La, Target) for La in Obj.LibraryAutoGenList]\r
406 BuildUnit.__init__(self, Obj, Obj.BuildCommand, Target, Dependency, Obj.MakeFileDir)\r
407 if Target in [None, "", "all"]:\r
408 self.Target = "tbuild"\r
409\r
410## The smallest platform unit that can be built by nmake/make command in multi-thread build mode\r
411#\r
412# This class is for platform build by nmake/make build system. The "Obj" parameter\r
413# must provide __str__(), __eq__() and __hash__() methods. Otherwise there could\r
414# be make units missing build.\r
415#\r
416# Currently the "Obj" should be only PlatformAutoGen object.\r
417#\r
418class PlatformMakeUnit(BuildUnit):\r
419 ## The constructor\r
420 #\r
421 # @param self The object pointer\r
422 # @param Obj The PlatformAutoGen object the build is working on\r
423 # @param Target The build target name, one of gSupportedTarget\r
424 #\r
425 def __init__(self, Obj, Target):\r
426 Dependency = [ModuleMakeUnit(Lib, Target) for Lib in self.BuildObject.LibraryAutoGenList]\r
427 Dependency.extend([ModuleMakeUnit(Mod, Target) for Mod in self.BuildObject.ModuleAutoGenList])\r
428 BuildUnit.__init__(self, Obj, Obj.BuildCommand, Target, Dependency, Obj.MakeFileDir)\r
429\r
430## The class representing the task of a module build or platform build\r
431#\r
432# This class manages the build tasks in multi-thread build mode. Its jobs include\r
433# scheduling thread running, catching thread error, monitor the thread status, etc.\r
434#\r
435class BuildTask:\r
436 # queue for tasks waiting for schedule\r
437 _PendingQueue = sdict()\r
438 _PendingQueueLock = threading.Lock()\r
439\r
440 # queue for tasks ready for running\r
441 _ReadyQueue = sdict()\r
442 _ReadyQueueLock = threading.Lock()\r
443\r
444 # queue for run tasks\r
445 _RunningQueue = sdict()\r
446 _RunningQueueLock = threading.Lock()\r
447\r
448 # queue containing all build tasks, in case duplicate build\r
449 _TaskQueue = sdict()\r
450\r
451 # flag indicating error occurs in a running thread\r
452 _ErrorFlag = threading.Event()\r
453 _ErrorFlag.clear()\r
454 _ErrorMessage = ""\r
455\r
456 # BoundedSemaphore object used to control the number of running threads\r
457 _Thread = None\r
458\r
459 # flag indicating if the scheduler is started or not\r
460 _SchedulerStopped = threading.Event()\r
461 _SchedulerStopped.set()\r
462\r
463 ## Start the task scheduler thread\r
464 #\r
465 # @param MaxThreadNumber The maximum thread number\r
466 # @param ExitFlag Flag used to end the scheduler\r
467 #\r
468 @staticmethod\r
469 def StartScheduler(MaxThreadNumber, ExitFlag):\r
470 SchedulerThread = Thread(target=BuildTask.Scheduler, args=(MaxThreadNumber, ExitFlag))\r
471 SchedulerThread.setName("Build-Task-Scheduler")\r
472 SchedulerThread.setDaemon(False)\r
473 SchedulerThread.start()\r
474 # wait for the scheduler to be started, especially useful in Linux\r
475 while not BuildTask.IsOnGoing():\r
476 time.sleep(0.01)\r
477\r
478 ## Scheduler method\r
479 #\r
480 # @param MaxThreadNumber The maximum thread number\r
481 # @param ExitFlag Flag used to end the scheduler\r
482 #\r
483 @staticmethod\r
484 def Scheduler(MaxThreadNumber, ExitFlag):\r
485 BuildTask._SchedulerStopped.clear()\r
486 try:\r
487 # use BoundedSemaphore to control the maximum running threads\r
488 BuildTask._Thread = BoundedSemaphore(MaxThreadNumber)\r
489 #\r
490 # scheduling loop, which will exits when no pending/ready task and\r
491 # indicated to do so, or there's error in running thread\r
492 #\r
493 while (len(BuildTask._PendingQueue) > 0 or len(BuildTask._ReadyQueue) > 0 \\r
494 or not ExitFlag.isSet()) and not BuildTask._ErrorFlag.isSet():\r
495 EdkLogger.debug(EdkLogger.DEBUG_8, "Pending Queue (%d), Ready Queue (%d)"\r
496 % (len(BuildTask._PendingQueue), len(BuildTask._ReadyQueue)))\r
497\r
498 # get all pending tasks\r
499 BuildTask._PendingQueueLock.acquire()\r
500 BuildObjectList = BuildTask._PendingQueue.keys()\r
501 #\r
502 # check if their dependency is resolved, and if true, move them\r
503 # into ready queue\r
504 #\r
505 for BuildObject in BuildObjectList:\r
506 Bt = BuildTask._PendingQueue[BuildObject]\r
507 if Bt.IsReady():\r
508 BuildTask._ReadyQueue[BuildObject] = BuildTask._PendingQueue.pop(BuildObject)\r
509 BuildTask._PendingQueueLock.release()\r
510\r
511 # launch build thread until the maximum number of threads is reached\r
512 while not BuildTask._ErrorFlag.isSet():\r
513 # empty ready queue, do nothing further\r
514 if len(BuildTask._ReadyQueue) == 0:\r
515 break\r
516\r
517 # wait for active thread(s) exit\r
518 BuildTask._Thread.acquire(True)\r
519\r
520 # start a new build thread\r
521 Bo = BuildTask._ReadyQueue.keys()[0]\r
522 Bt = BuildTask._ReadyQueue.pop(Bo)\r
523\r
524 # move into running queue\r
525 BuildTask._RunningQueueLock.acquire()\r
526 BuildTask._RunningQueue[Bo] = Bt\r
527 BuildTask._RunningQueueLock.release()\r
528\r
529 Bt.Start()\r
530 # avoid tense loop\r
531 time.sleep(0.01)\r
532\r
533 # avoid tense loop\r
534 time.sleep(0.01)\r
535\r
536 # wait for all running threads exit\r
537 if BuildTask._ErrorFlag.isSet():\r
538 EdkLogger.quiet("\nWaiting for all build threads exit...")\r
539 # while not BuildTask._ErrorFlag.isSet() and \\r
540 while len(BuildTask._RunningQueue) > 0:\r
541 EdkLogger.verbose("Waiting for thread ending...(%d)" % len(BuildTask._RunningQueue))\r
542 EdkLogger.debug(EdkLogger.DEBUG_8, "Threads [%s]" % ", ".join([Th.getName() for Th in threading.enumerate()]))\r
543 # avoid tense loop\r
544 time.sleep(0.1)\r
545 except BaseException, X:\r
546 #\r
547 # TRICK: hide the output of threads left runing, so that the user can\r
548 # catch the error message easily\r
549 #\r
550 EdkLogger.SetLevel(EdkLogger.ERROR)\r
551 BuildTask._ErrorFlag.set()\r
552 BuildTask._ErrorMessage = "build thread scheduler error\n\t%s" % str(X)\r
553\r
554 BuildTask._PendingQueue.clear()\r
555 BuildTask._ReadyQueue.clear()\r
556 BuildTask._RunningQueue.clear()\r
557 BuildTask._TaskQueue.clear()\r
558 BuildTask._SchedulerStopped.set()\r
559\r
560 ## Wait for all running method exit\r
561 #\r
562 @staticmethod\r
563 def WaitForComplete():\r
564 BuildTask._SchedulerStopped.wait()\r
565\r
566 ## Check if the scheduler is running or not\r
567 #\r
568 @staticmethod\r
569 def IsOnGoing():\r
570 return not BuildTask._SchedulerStopped.isSet()\r
571\r
572 ## Abort the build\r
573 @staticmethod\r
574 def Abort():\r
575 if BuildTask.IsOnGoing():\r
576 BuildTask._ErrorFlag.set()\r
577 BuildTask.WaitForComplete()\r
578\r
579 ## Check if there's error in running thread\r
580 #\r
581 # Since the main thread cannot catch exceptions in other thread, we have to\r
582 # use threading.Event to communicate this formation to main thread.\r
583 #\r
584 @staticmethod\r
585 def HasError():\r
586 return BuildTask._ErrorFlag.isSet()\r
587\r
588 ## Get error message in running thread\r
589 #\r
590 # Since the main thread cannot catch exceptions in other thread, we have to\r
591 # use a static variable to communicate this message to main thread.\r
592 #\r
593 @staticmethod\r
594 def GetErrorMessage():\r
595 return BuildTask._ErrorMessage\r
596\r
597 ## Factory method to create a BuildTask object\r
598 #\r
599 # This method will check if a module is building or has been built. And if\r
600 # true, just return the associated BuildTask object in the _TaskQueue. If\r
601 # not, create and return a new BuildTask object. The new BuildTask object\r
602 # will be appended to the _PendingQueue for scheduling later.\r
603 #\r
604 # @param BuildItem A BuildUnit object representing a build object\r
605 # @param Dependency The dependent build object of BuildItem\r
606 #\r
607 @staticmethod\r
608 def New(BuildItem, Dependency=None):\r
609 if BuildItem in BuildTask._TaskQueue:\r
610 Bt = BuildTask._TaskQueue[BuildItem]\r
611 return Bt\r
612\r
613 Bt = BuildTask()\r
614 Bt._Init(BuildItem, Dependency)\r
615 BuildTask._TaskQueue[BuildItem] = Bt\r
616\r
617 BuildTask._PendingQueueLock.acquire()\r
618 BuildTask._PendingQueue[BuildItem] = Bt\r
619 BuildTask._PendingQueueLock.release()\r
620\r
621 return Bt\r
622\r
623 ## The real constructor of BuildTask\r
624 #\r
625 # @param BuildItem A BuildUnit object representing a build object\r
626 # @param Dependency The dependent build object of BuildItem\r
627 #\r
628 def _Init(self, BuildItem, Dependency=None):\r
629 self.BuildItem = BuildItem\r
630\r
631 self.DependencyList = []\r
632 if Dependency == None:\r
633 Dependency = BuildItem.Dependency\r
634 else:\r
635 Dependency.extend(BuildItem.Dependency)\r
636 self.AddDependency(Dependency)\r
637 # flag indicating build completes, used to avoid unnecessary re-build\r
638 self.CompleteFlag = False\r
639\r
640 ## Check if all dependent build tasks are completed or not\r
641 #\r
642 def IsReady(self):\r
643 ReadyFlag = True\r
644 for Dep in self.DependencyList:\r
645 if Dep.CompleteFlag == True:\r
646 continue\r
647 ReadyFlag = False\r
648 break\r
649\r
650 return ReadyFlag\r
651\r
652 ## Add dependent build task\r
653 #\r
654 # @param Dependency The list of dependent build objects\r
655 #\r
656 def AddDependency(self, Dependency):\r
657 for Dep in Dependency:\r
658 if not Dep.BuildObject.IsBinaryModule:\r
659 self.DependencyList.append(BuildTask.New(Dep)) # BuildTask list\r
660\r
661 ## The thread wrapper of LaunchCommand function\r
662 #\r
663 # @param Command A list or string contains the call of the command\r
664 # @param WorkingDir The directory in which the program will be running\r
665 #\r
666 def _CommandThread(self, Command, WorkingDir):\r
667 try:\r
668 LaunchCommand(Command, WorkingDir)\r
669 self.CompleteFlag = True\r
670 except:\r
671 #\r
672 # TRICK: hide the output of threads left runing, so that the user can\r
673 # catch the error message easily\r
674 #\r
675 if not BuildTask._ErrorFlag.isSet():\r
676 GlobalData.gBuildingModule = "%s [%s, %s, %s]" % (str(self.BuildItem.BuildObject),\r
677 self.BuildItem.BuildObject.Arch,\r
678 self.BuildItem.BuildObject.ToolChain,\r
679 self.BuildItem.BuildObject.BuildTarget\r
680 )\r
681 EdkLogger.SetLevel(EdkLogger.ERROR)\r
682 BuildTask._ErrorFlag.set()\r
683 BuildTask._ErrorMessage = "%s broken\n %s [%s]" % \\r
684 (threading.currentThread().getName(), Command, WorkingDir)\r
685 # indicate there's a thread is available for another build task\r
686 BuildTask._RunningQueueLock.acquire()\r
687 BuildTask._RunningQueue.pop(self.BuildItem)\r
688 BuildTask._RunningQueueLock.release()\r
689 BuildTask._Thread.release()\r
690\r
691 ## Start build task thread\r
692 #\r
693 def Start(self):\r
694 EdkLogger.quiet("Building ... %s" % repr(self.BuildItem))\r
695 Command = self.BuildItem.BuildCommand + [self.BuildItem.Target]\r
696 self.BuildTread = Thread(target=self._CommandThread, args=(Command, self.BuildItem.WorkingDir))\r
697 self.BuildTread.setName("build thread")\r
698 self.BuildTread.setDaemon(False)\r
699 self.BuildTread.start()\r
700\r
701## The class contains the information related to EFI image\r
702#\r
703class PeImageInfo():\r
704 ## Constructor\r
705 #\r
706 # Constructor will load all required image information.\r
707 #\r
708 # @param BaseName The full file path of image.\r
709 # @param Guid The GUID for image.\r
710 # @param Arch Arch of this image.\r
711 # @param OutputDir The output directory for image.\r
712 # @param DebugDir The debug directory for image.\r
713 # @param ImageClass PeImage Information\r
714 #\r
715 def __init__(self, BaseName, Guid, Arch, OutputDir, DebugDir, ImageClass):\r
716 self.BaseName = BaseName\r
717 self.Guid = Guid\r
718 self.Arch = Arch\r
719 self.OutputDir = OutputDir\r
720 self.DebugDir = DebugDir\r
721 self.Image = ImageClass\r
722 self.Image.Size = (self.Image.Size / 0x1000 + 1) * 0x1000\r
723\r
724## The class implementing the EDK2 build process\r
725#\r
726# The build process includes:\r
727# 1. Load configuration from target.txt and tools_def.txt in $(WORKSPACE)/Conf\r
728# 2. Parse DSC file of active platform\r
729# 3. Parse FDF file if any\r
730# 4. Establish build database, including parse all other files (module, package)\r
731# 5. Create AutoGen files (C code file, depex file, makefile) if necessary\r
732# 6. Call build command\r
733#\r
734class Build():\r
735 ## Constructor\r
736 #\r
737 # Constructor will load all necessary configurations, parse platform, modules\r
738 # and packages and the establish a database for AutoGen.\r
739 #\r
740 # @param Target The build command target, one of gSupportedTarget\r
741 # @param WorkspaceDir The directory of workspace\r
742 # @param BuildOptions Build options passed from command line\r
743 #\r
744 def __init__(self, Target, WorkspaceDir, BuildOptions):\r
745 self.WorkspaceDir = WorkspaceDir\r
746 self.Target = Target\r
747 self.PlatformFile = BuildOptions.PlatformFile\r
748 self.ModuleFile = BuildOptions.ModuleFile\r
749 self.ArchList = BuildOptions.TargetArch\r
750 self.ToolChainList = BuildOptions.ToolChain\r
751 self.BuildTargetList= BuildOptions.BuildTarget\r
752 self.Fdf = BuildOptions.FdfFile\r
753 self.FdList = BuildOptions.RomImage\r
754 self.FvList = BuildOptions.FvImage\r
755 self.CapList = BuildOptions.CapName\r
756 self.SilentMode = BuildOptions.SilentMode\r
757 self.ThreadNumber = BuildOptions.ThreadNumber\r
758 self.SkipAutoGen = BuildOptions.SkipAutoGen\r
759 self.Reparse = BuildOptions.Reparse\r
760 self.SkuId = BuildOptions.SkuId\r
761 self.ConfDirectory = BuildOptions.ConfDirectory\r
762 self.SpawnMode = True\r
763 self.BuildReport = BuildReport(BuildOptions.ReportFile, BuildOptions.ReportType)\r
764 self.TargetTxt = TargetTxtClassObject()\r
765 self.ToolDef = ToolDefClassObject()\r
766 GlobalData.BuildOptionPcd = BuildOptions.OptionPcd\r
767 #Set global flag for build mode\r
768 GlobalData.gIgnoreSource = BuildOptions.IgnoreSources\r
769\r
770 if self.ConfDirectory:\r
771 # Get alternate Conf location, if it is absolute, then just use the absolute directory name\r
772 ConfDirectoryPath = os.path.normpath(self.ConfDirectory)\r
773\r
774 if not os.path.isabs(ConfDirectoryPath):\r
775 # Since alternate directory name is not absolute, the alternate directory is located within the WORKSPACE\r
776 # This also handles someone specifying the Conf directory in the workspace. Using --conf=Conf\r
777 ConfDirectoryPath = mws.join(self.WorkspaceDir, ConfDirectoryPath)\r
778 else:\r
779 if "CONF_PATH" in os.environ:\r
780 ConfDirectoryPath = os.path.normcase(os.path.normpath(os.environ["CONF_PATH"]))\r
781 else:\r
782 # Get standard WORKSPACE/Conf use the absolute path to the WORKSPACE/Conf\r
783 ConfDirectoryPath = mws.join(self.WorkspaceDir, 'Conf')\r
784 GlobalData.gConfDirectory = ConfDirectoryPath\r
785 GlobalData.gDatabasePath = os.path.normpath(os.path.join(ConfDirectoryPath, GlobalData.gDatabasePath))\r
786\r
787 if BuildOptions.DisableCache:\r
788 self.Db = WorkspaceDatabase(":memory:")\r
789 else:\r
790 self.Db = WorkspaceDatabase(GlobalData.gDatabasePath, self.Reparse)\r
791 self.BuildDatabase = self.Db.BuildObject\r
792 self.Platform = None\r
793 self.ToolChainFamily = None\r
794 self.LoadFixAddress = 0\r
795 self.UniFlag = BuildOptions.Flag\r
796 self.BuildModules = []\r
797 self.Db_Flag = False\r
798 self.LaunchPrebuildFlag = False\r
799 self.PrebuildScript = ''\r
800 self.PostbuildScript = ''\r
801 self.PlatformBuildPath = os.path.join(GlobalData.gConfDirectory,'.cache', '.PlatformBuild')\r
802 if BuildOptions.CommandLength:\r
803 GlobalData.gCommandMaxLength = BuildOptions.CommandLength\r
804\r
805 # print dot character during doing some time-consuming work\r
806 self.Progress = Utils.Progressor()\r
807 # print current build environment and configuration\r
808 EdkLogger.quiet("%-16s = %s" % ("WORKSPACE", os.environ["WORKSPACE"]))\r
809 if "PACKAGES_PATH" in os.environ:\r
810 # WORKSPACE env has been converted before. Print the same path style with WORKSPACE env. \r
811 EdkLogger.quiet("%-16s = %s" % ("PACKAGES_PATH", os.path.normcase(os.path.normpath(os.environ["PACKAGES_PATH"]))))\r
812 EdkLogger.quiet("%-16s = %s" % ("ECP_SOURCE", os.environ["ECP_SOURCE"]))\r
813 EdkLogger.quiet("%-16s = %s" % ("EDK_SOURCE", os.environ["EDK_SOURCE"]))\r
814 EdkLogger.quiet("%-16s = %s" % ("EFI_SOURCE", os.environ["EFI_SOURCE"]))\r
815 EdkLogger.quiet("%-16s = %s" % ("EDK_TOOLS_PATH", os.environ["EDK_TOOLS_PATH"]))\r
816 if "EDK_TOOLS_BIN" in os.environ:\r
817 # Print the same path style with WORKSPACE env. \r
818 EdkLogger.quiet("%-16s = %s" % ("EDK_TOOLS_BIN", os.path.normcase(os.path.normpath(os.environ["EDK_TOOLS_BIN"]))))\r
819 EdkLogger.quiet("%-16s = %s" % ("CONF_PATH", GlobalData.gConfDirectory))\r
820 self.InitPreBuild()\r
821 self.InitPostBuild()\r
822 if self.PrebuildScript:\r
823 EdkLogger.quiet("%-16s = %s" % ("PREBUILD", self.PrebuildScript))\r
824 if self.PostbuildScript:\r
825 EdkLogger.quiet("%-16s = %s" % ("POSTBUILD", self.PostbuildScript))\r
826 if self.PrebuildScript:\r
827 self.LaunchPrebuild()\r
828 self.TargetTxt = TargetTxtClassObject()\r
829 self.ToolDef = ToolDefClassObject()\r
830 if not (self.LaunchPrebuildFlag and os.path.exists(self.PlatformBuildPath)):\r
831 self.InitBuild()\r
832\r
833 EdkLogger.info("")\r
834 os.chdir(self.WorkspaceDir)\r
835\r
836 ## Load configuration\r
837 #\r
838 # This method will parse target.txt and get the build configurations.\r
839 #\r
840 def LoadConfiguration(self):\r
841 #\r
842 # Check target.txt and tools_def.txt and Init them\r
843 #\r
844 BuildConfigurationFile = os.path.normpath(os.path.join(GlobalData.gConfDirectory, gBuildConfiguration))\r
845 if os.path.isfile(BuildConfigurationFile) == True:\r
846 StatusCode = self.TargetTxt.LoadTargetTxtFile(BuildConfigurationFile)\r
847\r
848 ToolDefinitionFile = self.TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_TOOL_CHAIN_CONF]\r
849 if ToolDefinitionFile == '':\r
850 ToolDefinitionFile = gToolsDefinition\r
851 ToolDefinitionFile = os.path.normpath(mws.join(self.WorkspaceDir, 'Conf', ToolDefinitionFile))\r
852 if os.path.isfile(ToolDefinitionFile) == True:\r
853 StatusCode = self.ToolDef.LoadToolDefFile(ToolDefinitionFile)\r
854 else:\r
855 EdkLogger.error("build", FILE_NOT_FOUND, ExtraData=ToolDefinitionFile)\r
856 else:\r
857 EdkLogger.error("build", FILE_NOT_FOUND, ExtraData=BuildConfigurationFile)\r
858\r
859 # if no ARCH given in command line, get it from target.txt\r
860 if not self.ArchList:\r
861 self.ArchList = self.TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_TARGET_ARCH]\r
862 self.ArchList = tuple(self.ArchList)\r
863\r
864 # if no build target given in command line, get it from target.txt\r
865 if not self.BuildTargetList:\r
866 self.BuildTargetList = self.TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_TARGET]\r
867\r
868 # if no tool chain given in command line, get it from target.txt\r
869 if not self.ToolChainList:\r
870 self.ToolChainList = self.TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_TOOL_CHAIN_TAG]\r
871 if self.ToolChainList == None or len(self.ToolChainList) == 0:\r
872 EdkLogger.error("build", RESOURCE_NOT_AVAILABLE, ExtraData="No toolchain given. Don't know how to build.\n")\r
873\r
874 # check if the tool chains are defined or not\r
875 NewToolChainList = []\r
876 for ToolChain in self.ToolChainList:\r
877 if ToolChain not in self.ToolDef.ToolsDefTxtDatabase[TAB_TOD_DEFINES_TOOL_CHAIN_TAG]:\r
878 EdkLogger.warn("build", "Tool chain [%s] is not defined" % ToolChain)\r
879 else:\r
880 NewToolChainList.append(ToolChain)\r
881 # if no tool chain available, break the build\r
882 if len(NewToolChainList) == 0:\r
883 EdkLogger.error("build", RESOURCE_NOT_AVAILABLE,\r
884 ExtraData="[%s] not defined. No toolchain available for build!\n" % ", ".join(self.ToolChainList))\r
885 else:\r
886 self.ToolChainList = NewToolChainList\r
887\r
888 ToolChainFamily = []\r
889 ToolDefinition = self.ToolDef.ToolsDefTxtDatabase\r
890 for Tool in self.ToolChainList:\r
891 if TAB_TOD_DEFINES_FAMILY not in ToolDefinition or Tool not in ToolDefinition[TAB_TOD_DEFINES_FAMILY] \\r
892 or not ToolDefinition[TAB_TOD_DEFINES_FAMILY][Tool]:\r
893 EdkLogger.warn("build", "No tool chain family found in configuration for %s. Default to MSFT." % Tool)\r
894 ToolChainFamily.append("MSFT")\r
895 else:\r
896 ToolChainFamily.append(ToolDefinition[TAB_TOD_DEFINES_FAMILY][Tool])\r
897 self.ToolChainFamily = ToolChainFamily\r
898\r
899 if self.ThreadNumber == None:\r
900 self.ThreadNumber = self.TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_MAX_CONCURRENT_THREAD_NUMBER]\r
901 if self.ThreadNumber == '':\r
902 self.ThreadNumber = 0\r
903 else:\r
904 self.ThreadNumber = int(self.ThreadNumber, 0)\r
905\r
906 if self.ThreadNumber == 0:\r
907 self.ThreadNumber = 1\r
908\r
909 if not self.PlatformFile:\r
910 PlatformFile = self.TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_ACTIVE_PLATFORM]\r
911 if not PlatformFile:\r
912 # Try to find one in current directory\r
913 WorkingDirectory = os.getcwd()\r
914 FileList = glob.glob(os.path.normpath(os.path.join(WorkingDirectory, '*.dsc')))\r
915 FileNum = len(FileList)\r
916 if FileNum >= 2:\r
917 EdkLogger.error("build", OPTION_MISSING,\r
918 ExtraData="There are %d DSC files in %s. Use '-p' to specify one.\n" % (FileNum, WorkingDirectory))\r
919 elif FileNum == 1:\r
920 PlatformFile = FileList[0]\r
921 else:\r
922 EdkLogger.error("build", RESOURCE_NOT_AVAILABLE,\r
923 ExtraData="No active platform specified in target.txt or command line! Nothing can be built.\n")\r
924\r
925 self.PlatformFile = PathClass(NormFile(PlatformFile, self.WorkspaceDir), self.WorkspaceDir)\r
926\r
927 ## Initialize build configuration\r
928 #\r
929 # This method will parse DSC file and merge the configurations from\r
930 # command line and target.txt, then get the final build configurations.\r
931 #\r
932 def InitBuild(self):\r
933 # parse target.txt, tools_def.txt, and platform file\r
934 self.LoadConfiguration()\r
935\r
936 # Allow case-insensitive for those from command line or configuration file\r
937 ErrorCode, ErrorInfo = self.PlatformFile.Validate(".dsc", False)\r
938 if ErrorCode != 0:\r
939 EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)\r
940\r
941 # create metafile database\r
942 if not self.Db_Flag:\r
943 self.Db.InitDatabase()\r
944\r
945 def InitPreBuild(self):\r
946 self.LoadConfiguration()\r
947 ErrorCode, ErrorInfo = self.PlatformFile.Validate(".dsc", False)\r
948 if ErrorCode != 0:\r
949 EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)\r
950 if self.BuildTargetList:\r
951 GlobalData.gGlobalDefines['TARGET'] = self.BuildTargetList[0]\r
952 if self.ArchList:\r
953 GlobalData.gGlobalDefines['ARCH'] = self.ArchList[0]\r
954 if self.ToolChainList:\r
955 GlobalData.gGlobalDefines['TOOLCHAIN'] = self.ToolChainList[0]\r
956 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = self.ToolChainList[0]\r
957 if self.ToolChainFamily:\r
958 GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[0]\r
959 if 'PREBUILD' in GlobalData.gCommandLineDefines.keys():\r
960 self.Prebuild = GlobalData.gCommandLineDefines.get('PREBUILD')\r
961 else:\r
962 self.Db.InitDatabase()\r
963 self.Db_Flag = True\r
964 Platform = self.Db._MapPlatform(str(self.PlatformFile))\r
965 self.Prebuild = str(Platform.Prebuild)\r
966 if self.Prebuild:\r
967 PrebuildList = self.Prebuild.split()\r
968 if not os.path.isabs(PrebuildList[0]):\r
969 PrebuildList[0] = mws.join(self.WorkspaceDir, PrebuildList[0])\r
970 if os.path.isfile(PrebuildList[0]):\r
971 self.PrebuildScript = PrebuildList[0]\r
972 self.Prebuild = ' '.join(PrebuildList)\r
973 self.Prebuild += self.PassCommandOption(self.BuildTargetList, self.ArchList, self.ToolChainList)\r
974 #self.LaunchPrebuild()\r
975 else:\r
976 EdkLogger.error("Prebuild", PREBUILD_ERROR, "the prebuild script %s is not exist.\n If you'd like to disable the Prebuild process, please use the format: -D PREBUILD=\"\" " %(PrebuildList[0]))\r
977\r
978 def InitPostBuild(self):\r
979 if 'POSTBUILD' in GlobalData.gCommandLineDefines.keys():\r
980 self.Postbuild = GlobalData.gCommandLineDefines.get('POSTBUILD')\r
981 else:\r
982 Platform = self.Db._MapPlatform(str(self.PlatformFile))\r
983 self.Postbuild = str(Platform.Postbuild)\r
984 if self.Postbuild:\r
985 PostbuildList = self.Postbuild.split()\r
986 if not os.path.isabs(PostbuildList[0]):\r
987 PostbuildList[0] = mws.join(self.WorkspaceDir, PostbuildList[0])\r
988 if os.path.isfile(PostbuildList[0]):\r
989 self.PostbuildScript = PostbuildList[0]\r
990 self.Postbuild = ' '.join(PostbuildList)\r
991 self.Postbuild += self.PassCommandOption(self.BuildTargetList, self.ArchList, self.ToolChainList)\r
992 else:\r
993 EdkLogger.error("Postbuild", POSTBUILD_ERROR, "the postbuild script %s is not exist.\n If you'd like to disable the Postbuild process, please use the format: -D POSTBUILD=\"\" " %(PostbuildList[0]))\r
994\r
995 def PassCommandOption(self, BuildTarget, TargetArch, ToolChain):\r
996 BuildStr = ''\r
997 if GlobalData.gCommand and isinstance(GlobalData.gCommand, list):\r
998 BuildStr += ' ' + ' '.join(GlobalData.gCommand)\r
999 TargetFlag = False\r
1000 ArchFlag = False\r
1001 ToolChainFlag = False\r
1002\r
1003 if GlobalData.gOptions and not GlobalData.gOptions.BuildTarget:\r
1004 TargetFlag = True\r
1005 if GlobalData.gOptions and not GlobalData.gOptions.TargetArch:\r
1006 ArchFlag = True\r
1007 if GlobalData.gOptions and not GlobalData.gOptions.ToolChain:\r
1008 ToolChainFlag = True\r
1009\r
1010 if TargetFlag and BuildTarget:\r
1011 if isinstance(BuildTarget, list) or isinstance(BuildTarget, tuple):\r
1012 BuildStr += ' -b ' + ' -b '.join(BuildTarget)\r
1013 elif isinstance(BuildTarget, str):\r
1014 BuildStr += ' -b ' + BuildTarget\r
1015 if ArchFlag and TargetArch:\r
1016 if isinstance(TargetArch, list) or isinstance(TargetArch, tuple):\r
1017 BuildStr += ' -a ' + ' -a '.join(TargetArch)\r
1018 elif isinstance(TargetArch, str):\r
1019 BuildStr += ' -a ' + TargetArch\r
1020 if ToolChainFlag and ToolChain:\r
1021 if isinstance(ToolChain, list) or isinstance(ToolChain, tuple):\r
1022 BuildStr += ' -t ' + ' -t '.join(ToolChain)\r
1023 elif isinstance(ToolChain, str):\r
1024 BuildStr += ' -t ' + ToolChain\r
1025\r
1026 return BuildStr\r
1027\r
1028 def LaunchPrebuild(self):\r
1029 if self.Prebuild:\r
1030 EdkLogger.info("\n- Prebuild Start -\n")\r
1031 self.LaunchPrebuildFlag = True\r
1032 #\r
1033 # The purpose of .PrebuildEnv file is capture environment variable settings set by the prebuild script\r
1034 # and preserve them for the rest of the main build step, because the child process environment will\r
1035 # evaporate as soon as it exits, we cannot get it in build step.\r
1036 #\r
1037 PrebuildEnvFile = os.path.join(GlobalData.gConfDirectory,'.cache','.PrebuildEnv')\r
1038 if os.path.isfile(PrebuildEnvFile):\r
1039 os.remove(PrebuildEnvFile)\r
1040 if os.path.isfile(self.PlatformBuildPath):\r
1041 os.remove(self.PlatformBuildPath)\r
1042 if sys.platform == "win32":\r
1043 args = ' && '.join((self.Prebuild, 'set > ' + PrebuildEnvFile))\r
1044 Process = Popen(args, stdout=PIPE, stderr=PIPE, shell=True)\r
1045 else:\r
1046 args = ' && '.join((self.Prebuild, 'env > ' + PrebuildEnvFile))\r
1047 Process = Popen(args, stdout=PIPE, stderr=PIPE, shell=True)\r
1048\r
1049 # launch two threads to read the STDOUT and STDERR\r
1050 EndOfProcedure = Event()\r
1051 EndOfProcedure.clear()\r
1052 if Process.stdout:\r
1053 StdOutThread = Thread(target=ReadMessage, args=(Process.stdout, EdkLogger.info, EndOfProcedure))\r
1054 StdOutThread.setName("STDOUT-Redirector")\r
1055 StdOutThread.setDaemon(False)\r
1056 StdOutThread.start()\r
1057\r
1058 if Process.stderr:\r
1059 StdErrThread = Thread(target=ReadMessage, args=(Process.stderr, EdkLogger.quiet, EndOfProcedure))\r
1060 StdErrThread.setName("STDERR-Redirector")\r
1061 StdErrThread.setDaemon(False)\r
1062 StdErrThread.start()\r
1063 # waiting for program exit\r
1064 Process.wait()\r
1065\r
1066 if Process.stdout:\r
1067 StdOutThread.join()\r
1068 if Process.stderr:\r
1069 StdErrThread.join()\r
1070 if Process.returncode != 0 :\r
1071 EdkLogger.error("Prebuild", PREBUILD_ERROR, 'Prebuild process is not success!')\r
1072\r
1073 if os.path.exists(PrebuildEnvFile):\r
1074 f = open(PrebuildEnvFile)\r
1075 envs = f.readlines()\r
1076 f.close()\r
1077 envs = itertools.imap(lambda l: l.split('=',1), envs)\r
1078 envs = itertools.ifilter(lambda l: len(l) == 2, envs)\r
1079 envs = itertools.imap(lambda l: [i.strip() for i in l], envs)\r
1080 os.environ.update(dict(envs))\r
1081 EdkLogger.info("\n- Prebuild Done -\n")\r
1082\r
1083 def LaunchPostbuild(self):\r
1084 if self.Postbuild:\r
1085 EdkLogger.info("\n- Postbuild Start -\n")\r
1086 if sys.platform == "win32":\r
1087 Process = Popen(self.Postbuild, stdout=PIPE, stderr=PIPE, shell=True)\r
1088 else:\r
1089 Process = Popen(self.Postbuild, stdout=PIPE, stderr=PIPE, shell=True)\r
1090 # launch two threads to read the STDOUT and STDERR\r
1091 EndOfProcedure = Event()\r
1092 EndOfProcedure.clear()\r
1093 if Process.stdout:\r
1094 StdOutThread = Thread(target=ReadMessage, args=(Process.stdout, EdkLogger.info, EndOfProcedure))\r
1095 StdOutThread.setName("STDOUT-Redirector")\r
1096 StdOutThread.setDaemon(False)\r
1097 StdOutThread.start()\r
1098\r
1099 if Process.stderr:\r
1100 StdErrThread = Thread(target=ReadMessage, args=(Process.stderr, EdkLogger.quiet, EndOfProcedure))\r
1101 StdErrThread.setName("STDERR-Redirector")\r
1102 StdErrThread.setDaemon(False)\r
1103 StdErrThread.start()\r
1104 # waiting for program exit\r
1105 Process.wait()\r
1106\r
1107 if Process.stdout:\r
1108 StdOutThread.join()\r
1109 if Process.stderr:\r
1110 StdErrThread.join()\r
1111 if Process.returncode != 0 :\r
1112 EdkLogger.error("Postbuild", POSTBUILD_ERROR, 'Postbuild process is not success!')\r
1113 EdkLogger.info("\n- Postbuild Done -\n")\r
1114 ## Build a module or platform\r
1115 #\r
1116 # Create autogen code and makefile for a module or platform, and the launch\r
1117 # "make" command to build it\r
1118 #\r
1119 # @param Target The target of build command\r
1120 # @param Platform The platform file\r
1121 # @param Module The module file\r
1122 # @param BuildTarget The name of build target, one of "DEBUG", "RELEASE"\r
1123 # @param ToolChain The name of toolchain to build\r
1124 # @param Arch The arch of the module/platform\r
1125 # @param CreateDepModuleCodeFile Flag used to indicate creating code\r
1126 # for dependent modules/Libraries\r
1127 # @param CreateDepModuleMakeFile Flag used to indicate creating makefile\r
1128 # for dependent modules/Libraries\r
1129 #\r
1130 def _BuildPa(self, Target, AutoGenObject, CreateDepsCodeFile=True, CreateDepsMakeFile=True, BuildModule=False):\r
1131 if AutoGenObject == None:\r
1132 return False\r
1133\r
1134 # skip file generation for cleanxxx targets, run and fds target\r
1135 if Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:\r
1136 # for target which must generate AutoGen code and makefile\r
1137 if not self.SkipAutoGen or Target == 'genc':\r
1138 self.Progress.Start("Generating code")\r
1139 AutoGenObject.CreateCodeFile(CreateDepsCodeFile)\r
1140 self.Progress.Stop("done!")\r
1141 if Target == "genc":\r
1142 return True\r
1143\r
1144 if not self.SkipAutoGen or Target == 'genmake':\r
1145 self.Progress.Start("Generating makefile")\r
1146 AutoGenObject.CreateMakeFile(CreateDepsMakeFile)\r
1147 self.Progress.Stop("done!")\r
1148 if Target == "genmake":\r
1149 return True\r
1150 else:\r
1151 # always recreate top/platform makefile when clean, just in case of inconsistency\r
1152 AutoGenObject.CreateCodeFile(False)\r
1153 AutoGenObject.CreateMakeFile(False)\r
1154\r
1155 if EdkLogger.GetLevel() == EdkLogger.QUIET:\r
1156 EdkLogger.quiet("Building ... %s" % repr(AutoGenObject))\r
1157\r
1158 BuildCommand = AutoGenObject.BuildCommand\r
1159 if BuildCommand == None or len(BuildCommand) == 0:\r
1160 EdkLogger.error("build", OPTION_MISSING,\r
1161 "No build command found for this module. "\r
1162 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %\r
1163 (AutoGenObject.BuildTarget, AutoGenObject.ToolChain, AutoGenObject.Arch),\r
1164 ExtraData=str(AutoGenObject))\r
1165\r
1166 makefile = GenMake.BuildFile(AutoGenObject)._FILE_NAME_[GenMake.gMakeType]\r
1167\r
1168 # run\r
1169 if Target == 'run':\r
1170 RunDir = os.path.normpath(os.path.join(AutoGenObject.BuildDir, GlobalData.gGlobalDefines['ARCH']))\r
1171 Command = '.\SecMain'\r
1172 os.chdir(RunDir)\r
1173 LaunchCommand(Command, RunDir)\r
1174 return True\r
1175\r
1176 # build modules\r
1177 if BuildModule:\r
1178 BuildCommand = BuildCommand + [Target]\r
1179 LaunchCommand(BuildCommand, AutoGenObject.MakeFileDir)\r
1180 self.CreateAsBuiltInf()\r
1181 return True\r
1182\r
1183 # build library\r
1184 if Target == 'libraries':\r
1185 for Lib in AutoGenObject.LibraryBuildDirectoryList:\r
1186 NewBuildCommand = BuildCommand + ['-f', os.path.normpath(os.path.join(Lib, makefile)), 'pbuild']\r
1187 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
1188 return True\r
1189\r
1190 # build module\r
1191 if Target == 'modules':\r
1192 for Lib in AutoGenObject.LibraryBuildDirectoryList:\r
1193 NewBuildCommand = BuildCommand + ['-f', os.path.normpath(os.path.join(Lib, makefile)), 'pbuild']\r
1194 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
1195 for Mod in AutoGenObject.ModuleBuildDirectoryList:\r
1196 NewBuildCommand = BuildCommand + ['-f', os.path.normpath(os.path.join(Mod, makefile)), 'pbuild']\r
1197 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
1198 self.CreateAsBuiltInf()\r
1199 return True\r
1200\r
1201 # cleanlib\r
1202 if Target == 'cleanlib':\r
1203 for Lib in AutoGenObject.LibraryBuildDirectoryList:\r
1204 LibMakefile = os.path.normpath(os.path.join(Lib, makefile))\r
1205 if os.path.exists(LibMakefile):\r
1206 NewBuildCommand = BuildCommand + ['-f', LibMakefile, 'cleanall']\r
1207 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
1208 return True\r
1209\r
1210 # clean\r
1211 if Target == 'clean':\r
1212 for Mod in AutoGenObject.ModuleBuildDirectoryList:\r
1213 ModMakefile = os.path.normpath(os.path.join(Mod, makefile))\r
1214 if os.path.exists(ModMakefile):\r
1215 NewBuildCommand = BuildCommand + ['-f', ModMakefile, 'cleanall']\r
1216 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
1217 for Lib in AutoGenObject.LibraryBuildDirectoryList:\r
1218 LibMakefile = os.path.normpath(os.path.join(Lib, makefile))\r
1219 if os.path.exists(LibMakefile):\r
1220 NewBuildCommand = BuildCommand + ['-f', LibMakefile, 'cleanall']\r
1221 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
1222 return True\r
1223\r
1224 # cleanall\r
1225 if Target == 'cleanall':\r
1226 try:\r
1227 #os.rmdir(AutoGenObject.BuildDir)\r
1228 RemoveDirectory(AutoGenObject.BuildDir, True)\r
1229 except WindowsError, X:\r
1230 EdkLogger.error("build", FILE_DELETE_FAILURE, ExtraData=str(X))\r
1231 return True\r
1232\r
1233 ## Build a module or platform\r
1234 #\r
1235 # Create autogen code and makefile for a module or platform, and the launch\r
1236 # "make" command to build it\r
1237 #\r
1238 # @param Target The target of build command\r
1239 # @param Platform The platform file\r
1240 # @param Module The module file\r
1241 # @param BuildTarget The name of build target, one of "DEBUG", "RELEASE"\r
1242 # @param ToolChain The name of toolchain to build\r
1243 # @param Arch The arch of the module/platform\r
1244 # @param CreateDepModuleCodeFile Flag used to indicate creating code\r
1245 # for dependent modules/Libraries\r
1246 # @param CreateDepModuleMakeFile Flag used to indicate creating makefile\r
1247 # for dependent modules/Libraries\r
1248 #\r
1249 def _Build(self, Target, AutoGenObject, CreateDepsCodeFile=True, CreateDepsMakeFile=True, BuildModule=False):\r
1250 if AutoGenObject == None:\r
1251 return False\r
1252\r
1253 # skip file generation for cleanxxx targets, run and fds target\r
1254 if Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:\r
1255 # for target which must generate AutoGen code and makefile\r
1256 if not self.SkipAutoGen or Target == 'genc':\r
1257 self.Progress.Start("Generating code")\r
1258 AutoGenObject.CreateCodeFile(CreateDepsCodeFile)\r
1259 self.Progress.Stop("done!")\r
1260 if Target == "genc":\r
1261 return True\r
1262\r
1263 if not self.SkipAutoGen or Target == 'genmake':\r
1264 self.Progress.Start("Generating makefile")\r
1265 AutoGenObject.CreateMakeFile(CreateDepsMakeFile)\r
1266 #AutoGenObject.CreateAsBuiltInf()\r
1267 self.Progress.Stop("done!")\r
1268 if Target == "genmake":\r
1269 return True\r
1270 else:\r
1271 # always recreate top/platform makefile when clean, just in case of inconsistency\r
1272 AutoGenObject.CreateCodeFile(False)\r
1273 AutoGenObject.CreateMakeFile(False)\r
1274\r
1275 if EdkLogger.GetLevel() == EdkLogger.QUIET:\r
1276 EdkLogger.quiet("Building ... %s" % repr(AutoGenObject))\r
1277\r
1278 BuildCommand = AutoGenObject.BuildCommand\r
1279 if BuildCommand == None or len(BuildCommand) == 0:\r
1280 EdkLogger.error("build", OPTION_MISSING,\r
1281 "No build command found for this module. "\r
1282 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %\r
1283 (AutoGenObject.BuildTarget, AutoGenObject.ToolChain, AutoGenObject.Arch),\r
1284 ExtraData=str(AutoGenObject))\r
1285\r
1286 # build modules\r
1287 if BuildModule:\r
1288 if Target != 'fds':\r
1289 BuildCommand = BuildCommand + [Target]\r
1290 LaunchCommand(BuildCommand, AutoGenObject.MakeFileDir)\r
1291 self.CreateAsBuiltInf()\r
1292 return True\r
1293\r
1294 # genfds\r
1295 if Target == 'fds':\r
1296 LaunchCommand(AutoGenObject.GenFdsCommand, AutoGenObject.MakeFileDir)\r
1297 return True\r
1298\r
1299 # run\r
1300 if Target == 'run':\r
1301 RunDir = os.path.normpath(os.path.join(AutoGenObject.BuildDir, GlobalData.gGlobalDefines['ARCH']))\r
1302 Command = '.\SecMain'\r
1303 os.chdir(RunDir)\r
1304 LaunchCommand(Command, RunDir)\r
1305 return True\r
1306\r
1307 # build library\r
1308 if Target == 'libraries':\r
1309 pass\r
1310\r
1311 # not build modules\r
1312\r
1313\r
1314 # cleanall\r
1315 if Target == 'cleanall':\r
1316 try:\r
1317 #os.rmdir(AutoGenObject.BuildDir)\r
1318 RemoveDirectory(AutoGenObject.BuildDir, True)\r
1319 except WindowsError, X:\r
1320 EdkLogger.error("build", FILE_DELETE_FAILURE, ExtraData=str(X))\r
1321 return True\r
1322\r
1323 ## Rebase module image and Get function address for the input module list.\r
1324 #\r
1325 def _RebaseModule (self, MapBuffer, BaseAddress, ModuleList, AddrIsOffset = True, ModeIsSmm = False):\r
1326 if ModeIsSmm:\r
1327 AddrIsOffset = False\r
1328 InfFileNameList = ModuleList.keys()\r
1329 #InfFileNameList.sort()\r
1330 for InfFile in InfFileNameList:\r
1331 sys.stdout.write (".")\r
1332 sys.stdout.flush()\r
1333 ModuleInfo = ModuleList[InfFile]\r
1334 ModuleName = ModuleInfo.BaseName\r
1335 ModuleOutputImage = ModuleInfo.Image.FileName\r
1336 ModuleDebugImage = os.path.join(ModuleInfo.DebugDir, ModuleInfo.BaseName + '.efi')\r
1337 ## for SMM module in SMRAM, the SMRAM will be allocated from base to top.\r
1338 if not ModeIsSmm:\r
1339 BaseAddress = BaseAddress - ModuleInfo.Image.Size\r
1340 #\r
1341 # Update Image to new BaseAddress by GenFw tool\r
1342 #\r
1343 LaunchCommand(["GenFw", "--rebase", str(BaseAddress), "-r", ModuleOutputImage], ModuleInfo.OutputDir)\r
1344 LaunchCommand(["GenFw", "--rebase", str(BaseAddress), "-r", ModuleDebugImage], ModuleInfo.DebugDir)\r
1345 else:\r
1346 #\r
1347 # Set new address to the section header only for SMM driver.\r
1348 #\r
1349 LaunchCommand(["GenFw", "--address", str(BaseAddress), "-r", ModuleOutputImage], ModuleInfo.OutputDir)\r
1350 LaunchCommand(["GenFw", "--address", str(BaseAddress), "-r", ModuleDebugImage], ModuleInfo.DebugDir)\r
1351 #\r
1352 # Collect funtion address from Map file\r
1353 #\r
1354 ImageMapTable = ModuleOutputImage.replace('.efi', '.map')\r
1355 FunctionList = []\r
1356 if os.path.exists(ImageMapTable):\r
1357 OrigImageBaseAddress = 0\r
1358 ImageMap = open(ImageMapTable, 'r')\r
1359 for LinStr in ImageMap:\r
1360 if len (LinStr.strip()) == 0:\r
1361 continue\r
1362 #\r
1363 # Get the preferred address set on link time.\r
1364 #\r
1365 if LinStr.find ('Preferred load address is') != -1:\r
1366 StrList = LinStr.split()\r
1367 OrigImageBaseAddress = int (StrList[len(StrList) - 1], 16)\r
1368\r
1369 StrList = LinStr.split()\r
1370 if len (StrList) > 4:\r
1371 if StrList[3] == 'f' or StrList[3] == 'F':\r
1372 Name = StrList[1]\r
1373 RelativeAddress = int (StrList[2], 16) - OrigImageBaseAddress\r
1374 FunctionList.append ((Name, RelativeAddress))\r
1375 if ModuleInfo.Arch == 'IPF' and Name.endswith('_ModuleEntryPoint'):\r
1376 #\r
1377 # Get the real entry point address for IPF image.\r
1378 #\r
1379 ModuleInfo.Image.EntryPoint = RelativeAddress\r
1380 ImageMap.close()\r
1381 #\r
1382 # Add general information.\r
1383 #\r
1384 if ModeIsSmm:\r
1385 MapBuffer.write('\n\n%s (Fixed SMRAM Offset, BaseAddress=0x%010X, EntryPoint=0x%010X)\n' % (ModuleName, BaseAddress, BaseAddress + ModuleInfo.Image.EntryPoint))\r
1386 elif AddrIsOffset:\r
1387 MapBuffer.write('\n\n%s (Fixed Memory Offset, BaseAddress=-0x%010X, EntryPoint=-0x%010X)\n' % (ModuleName, 0 - BaseAddress, 0 - (BaseAddress + ModuleInfo.Image.EntryPoint)))\r
1388 else:\r
1389 MapBuffer.write('\n\n%s (Fixed Memory Address, BaseAddress=0x%010X, EntryPoint=0x%010X)\n' % (ModuleName, BaseAddress, BaseAddress + ModuleInfo.Image.EntryPoint))\r
1390 #\r
1391 # Add guid and general seciton section.\r
1392 #\r
1393 TextSectionAddress = 0\r
1394 DataSectionAddress = 0\r
1395 for SectionHeader in ModuleInfo.Image.SectionHeaderList:\r
1396 if SectionHeader[0] == '.text':\r
1397 TextSectionAddress = SectionHeader[1]\r
1398 elif SectionHeader[0] in ['.data', '.sdata']:\r
1399 DataSectionAddress = SectionHeader[1]\r
1400 if AddrIsOffset:\r
1401 MapBuffer.write('(GUID=%s, .textbaseaddress=-0x%010X, .databaseaddress=-0x%010X)\n' % (ModuleInfo.Guid, 0 - (BaseAddress + TextSectionAddress), 0 - (BaseAddress + DataSectionAddress)))\r
1402 else:\r
1403 MapBuffer.write('(GUID=%s, .textbaseaddress=0x%010X, .databaseaddress=0x%010X)\n' % (ModuleInfo.Guid, BaseAddress + TextSectionAddress, BaseAddress + DataSectionAddress))\r
1404 #\r
1405 # Add debug image full path.\r
1406 #\r
1407 MapBuffer.write('(IMAGE=%s)\n\n' % (ModuleDebugImage))\r
1408 #\r
1409 # Add funtion address\r
1410 #\r
1411 for Function in FunctionList:\r
1412 if AddrIsOffset:\r
1413 MapBuffer.write(' -0x%010X %s\n' % (0 - (BaseAddress + Function[1]), Function[0]))\r
1414 else:\r
1415 MapBuffer.write(' 0x%010X %s\n' % (BaseAddress + Function[1], Function[0]))\r
1416 ImageMap.close()\r
1417\r
1418 #\r
1419 # for SMM module in SMRAM, the SMRAM will be allocated from base to top.\r
1420 #\r
1421 if ModeIsSmm:\r
1422 BaseAddress = BaseAddress + ModuleInfo.Image.Size\r
1423\r
1424 ## Collect MAP information of all FVs\r
1425 #\r
1426 def _CollectFvMapBuffer (self, MapBuffer, Wa, ModuleList):\r
1427 if self.Fdf:\r
1428 # First get the XIP base address for FV map file.\r
1429 GuidPattern = re.compile("[-a-fA-F0-9]+")\r
1430 GuidName = re.compile("\(GUID=[-a-fA-F0-9]+")\r
1431 for FvName in Wa.FdfProfile.FvDict.keys():\r
1432 FvMapBuffer = os.path.join(Wa.FvDir, FvName + '.Fv.map')\r
1433 if not os.path.exists(FvMapBuffer):\r
1434 continue\r
1435 FvMap = open(FvMapBuffer, 'r')\r
1436 #skip FV size information\r
1437 FvMap.readline()\r
1438 FvMap.readline()\r
1439 FvMap.readline()\r
1440 FvMap.readline()\r
1441 for Line in FvMap:\r
1442 MatchGuid = GuidPattern.match(Line)\r
1443 if MatchGuid != None:\r
1444 #\r
1445 # Replace GUID with module name\r
1446 #\r
1447 GuidString = MatchGuid.group()\r
1448 if GuidString.upper() in ModuleList:\r
1449 Line = Line.replace(GuidString, ModuleList[GuidString.upper()].Name)\r
1450 MapBuffer.write('%s' % (Line))\r
1451 #\r
1452 # Add the debug image full path.\r
1453 #\r
1454 MatchGuid = GuidName.match(Line)\r
1455 if MatchGuid != None:\r
1456 GuidString = MatchGuid.group().split("=")[1]\r
1457 if GuidString.upper() in ModuleList:\r
1458 MapBuffer.write('(IMAGE=%s)\n' % (os.path.join(ModuleList[GuidString.upper()].DebugDir, ModuleList[GuidString.upper()].Name + '.efi')))\r
1459\r
1460 FvMap.close()\r
1461\r
1462 ## Collect MAP information of all modules\r
1463 #\r
1464 def _CollectModuleMapBuffer (self, MapBuffer, ModuleList):\r
1465 sys.stdout.write ("Generate Load Module At Fix Address Map")\r
1466 sys.stdout.flush()\r
1467 PatchEfiImageList = []\r
1468 PeiModuleList = {}\r
1469 BtModuleList = {}\r
1470 RtModuleList = {}\r
1471 SmmModuleList = {}\r
1472 PeiSize = 0\r
1473 BtSize = 0\r
1474 RtSize = 0\r
1475 # reserve 4K size in SMRAM to make SMM module address not from 0.\r
1476 SmmSize = 0x1000\r
1477 IsIpfPlatform = False\r
1478 if 'IPF' in self.ArchList:\r
1479 IsIpfPlatform = True\r
1480 for ModuleGuid in ModuleList:\r
1481 Module = ModuleList[ModuleGuid]\r
1482 GlobalData.gProcessingFile = "%s [%s, %s, %s]" % (Module.MetaFile, Module.Arch, Module.ToolChain, Module.BuildTarget)\r
1483\r
1484 OutputImageFile = ''\r
1485 for ResultFile in Module.CodaTargetList:\r
1486 if str(ResultFile.Target).endswith('.efi'):\r
1487 #\r
1488 # module list for PEI, DXE, RUNTIME and SMM\r
1489 #\r
1490 OutputImageFile = os.path.join(Module.OutputDir, Module.Name + '.efi')\r
1491 ImageClass = PeImageClass (OutputImageFile)\r
1492 if not ImageClass.IsValid:\r
1493 EdkLogger.error("build", FILE_PARSE_FAILURE, ExtraData=ImageClass.ErrorInfo)\r
1494 ImageInfo = PeImageInfo(Module.Name, Module.Guid, Module.Arch, Module.OutputDir, Module.DebugDir, ImageClass)\r
1495 if Module.ModuleType in ['PEI_CORE', 'PEIM', 'COMBINED_PEIM_DRIVER', 'PIC_PEIM', 'RELOCATABLE_PEIM', 'DXE_CORE']:\r
1496 PeiModuleList[Module.MetaFile] = ImageInfo\r
1497 PeiSize += ImageInfo.Image.Size\r
1498 elif Module.ModuleType in ['BS_DRIVER', 'DXE_DRIVER', 'UEFI_DRIVER']:\r
1499 BtModuleList[Module.MetaFile] = ImageInfo\r
1500 BtSize += ImageInfo.Image.Size\r
1501 elif Module.ModuleType in ['DXE_RUNTIME_DRIVER', 'RT_DRIVER', 'DXE_SAL_DRIVER', 'SAL_RT_DRIVER']:\r
1502 RtModuleList[Module.MetaFile] = ImageInfo\r
1503 #IPF runtime driver needs to be at 2 page alignment.\r
1504 if IsIpfPlatform and ImageInfo.Image.Size % 0x2000 != 0:\r
1505 ImageInfo.Image.Size = (ImageInfo.Image.Size / 0x2000 + 1) * 0x2000\r
1506 RtSize += ImageInfo.Image.Size\r
1507 elif Module.ModuleType in ['SMM_CORE', 'DXE_SMM_DRIVER', 'MM_STANDALONE', 'MM_CORE_STANDALONE']:\r
1508 SmmModuleList[Module.MetaFile] = ImageInfo\r
1509 SmmSize += ImageInfo.Image.Size\r
1510 if Module.ModuleType == 'DXE_SMM_DRIVER':\r
1511 PiSpecVersion = '0x00000000'\r
1512 if 'PI_SPECIFICATION_VERSION' in Module.Module.Specification:\r
1513 PiSpecVersion = Module.Module.Specification['PI_SPECIFICATION_VERSION']\r
1514 # for PI specification < PI1.1, DXE_SMM_DRIVER also runs as BOOT time driver.\r
1515 if int(PiSpecVersion, 16) < 0x0001000A:\r
1516 BtModuleList[Module.MetaFile] = ImageInfo\r
1517 BtSize += ImageInfo.Image.Size\r
1518 break\r
1519 #\r
1520 # EFI image is final target.\r
1521 # Check EFI image contains patchable FixAddress related PCDs.\r
1522 #\r
1523 if OutputImageFile != '':\r
1524 ModuleIsPatch = False\r
1525 for Pcd in Module.ModulePcdList:\r
1526 if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE and Pcd.TokenCName in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_LIST:\r
1527 ModuleIsPatch = True\r
1528 break\r
1529 if not ModuleIsPatch:\r
1530 for Pcd in Module.LibraryPcdList:\r
1531 if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE and Pcd.TokenCName in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_LIST:\r
1532 ModuleIsPatch = True\r
1533 break\r
1534\r
1535 if not ModuleIsPatch:\r
1536 continue\r
1537 #\r
1538 # Module includes the patchable load fix address PCDs.\r
1539 # It will be fixed up later.\r
1540 #\r
1541 PatchEfiImageList.append (OutputImageFile)\r
1542\r
1543 #\r
1544 # Get Top Memory address\r
1545 #\r
1546 ReservedRuntimeMemorySize = 0\r
1547 TopMemoryAddress = 0\r
1548 if self.LoadFixAddress == 0xFFFFFFFFFFFFFFFF:\r
1549 TopMemoryAddress = 0\r
1550 else:\r
1551 TopMemoryAddress = self.LoadFixAddress\r
1552 if TopMemoryAddress < RtSize + BtSize + PeiSize:\r
1553 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS is too low to load driver")\r
1554 # Make IPF runtime driver at 2 page alignment.\r
1555 if IsIpfPlatform:\r
1556 ReservedRuntimeMemorySize = TopMemoryAddress % 0x2000\r
1557 RtSize = RtSize + ReservedRuntimeMemorySize\r
1558\r
1559 #\r
1560 # Patch FixAddress related PCDs into EFI image\r
1561 #\r
1562 for EfiImage in PatchEfiImageList:\r
1563 EfiImageMap = EfiImage.replace('.efi', '.map')\r
1564 if not os.path.exists(EfiImageMap):\r
1565 continue\r
1566 #\r
1567 # Get PCD offset in EFI image by GenPatchPcdTable function\r
1568 #\r
1569 PcdTable = parsePcdInfoFromMapFile(EfiImageMap, EfiImage)\r
1570 #\r
1571 # Patch real PCD value by PatchPcdValue tool\r
1572 #\r
1573 for PcdInfo in PcdTable:\r
1574 ReturnValue = 0\r
1575 if PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE:\r
1576 ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE_DATA_TYPE, str (PeiSize / 0x1000))\r
1577 elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE:\r
1578 ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE_DATA_TYPE, str (BtSize / 0x1000))\r
1579 elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE:\r
1580 ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE_DATA_TYPE, str (RtSize / 0x1000))\r
1581 elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE and len (SmmModuleList) > 0:\r
1582 ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE_DATA_TYPE, str (SmmSize / 0x1000))\r
1583 if ReturnValue != 0:\r
1584 EdkLogger.error("build", PARAMETER_INVALID, "Patch PCD value failed", ExtraData=ErrorInfo)\r
1585\r
1586 MapBuffer.write('PEI_CODE_PAGE_NUMBER = 0x%x\n' % (PeiSize / 0x1000))\r
1587 MapBuffer.write('BOOT_CODE_PAGE_NUMBER = 0x%x\n' % (BtSize / 0x1000))\r
1588 MapBuffer.write('RUNTIME_CODE_PAGE_NUMBER = 0x%x\n' % (RtSize / 0x1000))\r
1589 if len (SmmModuleList) > 0:\r
1590 MapBuffer.write('SMM_CODE_PAGE_NUMBER = 0x%x\n' % (SmmSize / 0x1000))\r
1591\r
1592 PeiBaseAddr = TopMemoryAddress - RtSize - BtSize\r
1593 BtBaseAddr = TopMemoryAddress - RtSize\r
1594 RtBaseAddr = TopMemoryAddress - ReservedRuntimeMemorySize\r
1595\r
1596 self._RebaseModule (MapBuffer, PeiBaseAddr, PeiModuleList, TopMemoryAddress == 0)\r
1597 self._RebaseModule (MapBuffer, BtBaseAddr, BtModuleList, TopMemoryAddress == 0)\r
1598 self._RebaseModule (MapBuffer, RtBaseAddr, RtModuleList, TopMemoryAddress == 0)\r
1599 self._RebaseModule (MapBuffer, 0x1000, SmmModuleList, AddrIsOffset=False, ModeIsSmm=True)\r
1600 MapBuffer.write('\n\n')\r
1601 sys.stdout.write ("\n")\r
1602 sys.stdout.flush()\r
1603\r
1604 ## Save platform Map file\r
1605 #\r
1606 def _SaveMapFile (self, MapBuffer, Wa):\r
1607 #\r
1608 # Map file path is got.\r
1609 #\r
1610 MapFilePath = os.path.join(Wa.BuildDir, Wa.Name + '.map')\r
1611 #\r
1612 # Save address map into MAP file.\r
1613 #\r
1614 SaveFileOnChange(MapFilePath, MapBuffer.getvalue(), False)\r
1615 MapBuffer.close()\r
1616 if self.LoadFixAddress != 0:\r
1617 sys.stdout.write ("\nLoad Module At Fix Address Map file can be found at %s\n" % (MapFilePath))\r
1618 sys.stdout.flush()\r
1619\r
1620 ## Build active platform for different build targets and different tool chains\r
1621 #\r
1622 def _BuildPlatform(self):\r
1623 SaveFileOnChange(self.PlatformBuildPath, '# DO NOT EDIT \n# FILE auto-generated\n', False)\r
1624 for BuildTarget in self.BuildTargetList:\r
1625 GlobalData.gGlobalDefines['TARGET'] = BuildTarget\r
1626 index = 0\r
1627 for ToolChain in self.ToolChainList:\r
1628 GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain\r
1629 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain\r
1630 GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[index]\r
1631 index += 1\r
1632 Wa = WorkspaceAutoGen(\r
1633 self.WorkspaceDir,\r
1634 self.PlatformFile,\r
1635 BuildTarget,\r
1636 ToolChain,\r
1637 self.ArchList,\r
1638 self.BuildDatabase,\r
1639 self.TargetTxt,\r
1640 self.ToolDef,\r
1641 self.Fdf,\r
1642 self.FdList,\r
1643 self.FvList,\r
1644 self.CapList,\r
1645 self.SkuId,\r
1646 self.UniFlag,\r
1647 self.Progress\r
1648 )\r
1649 self.Fdf = Wa.FdfFile\r
1650 self.LoadFixAddress = Wa.Platform.LoadFixAddress\r
1651 self.BuildReport.AddPlatformReport(Wa)\r
1652 self.Progress.Stop("done!")\r
1653 for Arch in Wa.ArchList:\r
1654 GlobalData.gGlobalDefines['ARCH'] = Arch\r
1655 Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)\r
1656 for Module in Pa.Platform.Modules:\r
1657 # Get ModuleAutoGen object to generate C code file and makefile\r
1658 Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)\r
1659 if Ma == None:\r
1660 continue\r
1661 self.BuildModules.append(Ma)\r
1662 self._BuildPa(self.Target, Pa)\r
1663\r
1664 # Create MAP file when Load Fix Address is enabled.\r
1665 if self.Target in ["", "all", "fds"]:\r
1666 for Arch in Wa.ArchList:\r
1667 GlobalData.gGlobalDefines['ARCH'] = Arch\r
1668 #\r
1669 # Check whether the set fix address is above 4G for 32bit image.\r
1670 #\r
1671 if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:\r
1672 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS can't be set to larger than or equal to 4G for the platform with IA32 or ARM arch modules")\r
1673 #\r
1674 # Get Module List\r
1675 #\r
1676 ModuleList = {}\r
1677 for Pa in Wa.AutoGenObjectList:\r
1678 for Ma in Pa.ModuleAutoGenList:\r
1679 if Ma == None:\r
1680 continue\r
1681 if not Ma.IsLibrary:\r
1682 ModuleList[Ma.Guid.upper()] = Ma\r
1683\r
1684 MapBuffer = StringIO('')\r
1685 if self.LoadFixAddress != 0:\r
1686 #\r
1687 # Rebase module to the preferred memory address before GenFds\r
1688 #\r
1689 self._CollectModuleMapBuffer(MapBuffer, ModuleList)\r
1690 if self.Fdf:\r
1691 #\r
1692 # create FDS again for the updated EFI image\r
1693 #\r
1694 self._Build("fds", Wa)\r
1695 #\r
1696 # Create MAP file for all platform FVs after GenFds.\r
1697 #\r
1698 self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)\r
1699 #\r
1700 # Save MAP buffer into MAP file.\r
1701 #\r
1702 self._SaveMapFile (MapBuffer, Wa)\r
1703\r
1704 ## Build active module for different build targets, different tool chains and different archs\r
1705 #\r
1706 def _BuildModule(self):\r
1707 for BuildTarget in self.BuildTargetList:\r
1708 GlobalData.gGlobalDefines['TARGET'] = BuildTarget\r
1709 index = 0\r
1710 for ToolChain in self.ToolChainList:\r
1711 GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain\r
1712 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain\r
1713 GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[index]\r
1714 index += 1\r
1715 #\r
1716 # module build needs platform build information, so get platform\r
1717 # AutoGen first\r
1718 #\r
1719 Wa = WorkspaceAutoGen(\r
1720 self.WorkspaceDir,\r
1721 self.PlatformFile,\r
1722 BuildTarget,\r
1723 ToolChain,\r
1724 self.ArchList,\r
1725 self.BuildDatabase,\r
1726 self.TargetTxt,\r
1727 self.ToolDef,\r
1728 self.Fdf,\r
1729 self.FdList,\r
1730 self.FvList,\r
1731 self.CapList,\r
1732 self.SkuId,\r
1733 self.UniFlag,\r
1734 self.Progress,\r
1735 self.ModuleFile\r
1736 )\r
1737 self.Fdf = Wa.FdfFile\r
1738 self.LoadFixAddress = Wa.Platform.LoadFixAddress\r
1739 Wa.CreateMakeFile(False)\r
1740 self.Progress.Stop("done!")\r
1741 MaList = []\r
1742 for Arch in Wa.ArchList:\r
1743 GlobalData.gGlobalDefines['ARCH'] = Arch\r
1744 Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)\r
1745 for Module in Pa.Platform.Modules:\r
1746 if self.ModuleFile.Dir == Module.Dir and self.ModuleFile.File == Module.File:\r
1747 Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)\r
1748 if Ma == None: continue\r
1749 MaList.append(Ma)\r
1750 self.BuildModules.append(Ma)\r
1751 if not Ma.IsBinaryModule:\r
1752 self._Build(self.Target, Ma, BuildModule=True)\r
1753\r
1754 self.BuildReport.AddPlatformReport(Wa, MaList)\r
1755 if MaList == []:\r
1756 EdkLogger.error(\r
1757 'build',\r
1758 BUILD_ERROR,\r
1759 "Module for [%s] is not a component of active platform."\\r
1760 " Please make sure that the ARCH and inf file path are"\\r
1761 " given in the same as in [%s]" % \\r
1762 (', '.join(Wa.ArchList), self.PlatformFile),\r
1763 ExtraData=self.ModuleFile\r
1764 )\r
1765 # Create MAP file when Load Fix Address is enabled.\r
1766 if self.Target == "fds" and self.Fdf:\r
1767 for Arch in Wa.ArchList:\r
1768 #\r
1769 # Check whether the set fix address is above 4G for 32bit image.\r
1770 #\r
1771 if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:\r
1772 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS can't be set to larger than or equal to 4G for the platorm with IA32 or ARM arch modules")\r
1773 #\r
1774 # Get Module List\r
1775 #\r
1776 ModuleList = {}\r
1777 for Pa in Wa.AutoGenObjectList:\r
1778 for Ma in Pa.ModuleAutoGenList:\r
1779 if Ma == None:\r
1780 continue\r
1781 if not Ma.IsLibrary:\r
1782 ModuleList[Ma.Guid.upper()] = Ma\r
1783\r
1784 MapBuffer = StringIO('')\r
1785 if self.LoadFixAddress != 0:\r
1786 #\r
1787 # Rebase module to the preferred memory address before GenFds\r
1788 #\r
1789 self._CollectModuleMapBuffer(MapBuffer, ModuleList)\r
1790 #\r
1791 # create FDS again for the updated EFI image\r
1792 #\r
1793 self._Build("fds", Wa)\r
1794 #\r
1795 # Create MAP file for all platform FVs after GenFds.\r
1796 #\r
1797 self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)\r
1798 #\r
1799 # Save MAP buffer into MAP file.\r
1800 #\r
1801 self._SaveMapFile (MapBuffer, Wa)\r
1802\r
1803 ## Build a platform in multi-thread mode\r
1804 #\r
1805 def _MultiThreadBuildPlatform(self):\r
1806 SaveFileOnChange(self.PlatformBuildPath, '# DO NOT EDIT \n# FILE auto-generated\n', False)\r
1807 for BuildTarget in self.BuildTargetList:\r
1808 GlobalData.gGlobalDefines['TARGET'] = BuildTarget\r
1809 index = 0\r
1810 for ToolChain in self.ToolChainList:\r
1811 GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain\r
1812 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain\r
1813 GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[index]\r
1814 index += 1\r
1815 Wa = WorkspaceAutoGen(\r
1816 self.WorkspaceDir,\r
1817 self.PlatformFile,\r
1818 BuildTarget,\r
1819 ToolChain,\r
1820 self.ArchList,\r
1821 self.BuildDatabase,\r
1822 self.TargetTxt,\r
1823 self.ToolDef,\r
1824 self.Fdf,\r
1825 self.FdList,\r
1826 self.FvList,\r
1827 self.CapList,\r
1828 self.SkuId,\r
1829 self.UniFlag,\r
1830 self.Progress\r
1831 )\r
1832 self.Fdf = Wa.FdfFile\r
1833 self.LoadFixAddress = Wa.Platform.LoadFixAddress\r
1834 self.BuildReport.AddPlatformReport(Wa)\r
1835 Wa.CreateMakeFile(False)\r
1836\r
1837 # multi-thread exit flag\r
1838 ExitFlag = threading.Event()\r
1839 ExitFlag.clear()\r
1840 for Arch in Wa.ArchList:\r
1841 GlobalData.gGlobalDefines['ARCH'] = Arch\r
1842 Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)\r
1843 if Pa == None:\r
1844 continue\r
1845 ModuleList = []\r
1846 for Inf in Pa.Platform.Modules:\r
1847 ModuleList.append(Inf)\r
1848 # Add the INF only list in FDF\r
1849 if GlobalData.gFdfParser != None:\r
1850 for InfName in GlobalData.gFdfParser.Profile.InfList:\r
1851 Inf = PathClass(NormPath(InfName), self.WorkspaceDir, Arch)\r
1852 if Inf in Pa.Platform.Modules:\r
1853 continue\r
1854 ModuleList.append(Inf)\r
1855 for Module in ModuleList:\r
1856 # Get ModuleAutoGen object to generate C code file and makefile\r
1857 Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)\r
1858 \r
1859 if Ma == None:\r
1860 continue\r
1861 # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'\r
1862 if self.Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:\r
1863 # for target which must generate AutoGen code and makefile\r
1864 if not self.SkipAutoGen or self.Target == 'genc':\r
1865 Ma.CreateCodeFile(True)\r
1866 if self.Target == "genc":\r
1867 continue\r
1868\r
1869 if not self.SkipAutoGen or self.Target == 'genmake':\r
1870 Ma.CreateMakeFile(True)\r
1871 if self.Target == "genmake":\r
1872 continue\r
1873 self.BuildModules.append(Ma)\r
1874 self.Progress.Stop("done!")\r
1875\r
1876 for Ma in self.BuildModules:\r
1877 # Generate build task for the module\r
1878 if not Ma.IsBinaryModule:\r
1879 Bt = BuildTask.New(ModuleMakeUnit(Ma, self.Target))\r
1880 # Break build if any build thread has error\r
1881 if BuildTask.HasError():\r
1882 # we need a full version of makefile for platform\r
1883 ExitFlag.set()\r
1884 BuildTask.WaitForComplete()\r
1885 Pa.CreateMakeFile(False)\r
1886 EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)\r
1887 # Start task scheduler\r
1888 if not BuildTask.IsOnGoing():\r
1889 BuildTask.StartScheduler(self.ThreadNumber, ExitFlag)\r
1890\r
1891 # in case there's an interruption. we need a full version of makefile for platform\r
1892 Pa.CreateMakeFile(False)\r
1893 if BuildTask.HasError():\r
1894 EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)\r
1895\r
1896 #\r
1897 # Save temp tables to a TmpTableDict.\r
1898 #\r
1899 for Key in Wa.BuildDatabase._CACHE_:\r
1900 if Wa.BuildDatabase._CACHE_[Key]._RawData and Wa.BuildDatabase._CACHE_[Key]._RawData._Table and Wa.BuildDatabase._CACHE_[Key]._RawData._Table.Table:\r
1901 if TemporaryTablePattern.match(Wa.BuildDatabase._CACHE_[Key]._RawData._Table.Table):\r
1902 TmpTableDict[Wa.BuildDatabase._CACHE_[Key]._RawData._Table.Table] = Wa.BuildDatabase._CACHE_[Key]._RawData._Table.Cur\r
1903 #\r
1904 #\r
1905 # All modules have been put in build tasks queue. Tell task scheduler\r
1906 # to exit if all tasks are completed\r
1907 #\r
1908 ExitFlag.set()\r
1909 BuildTask.WaitForComplete()\r
1910 self.CreateAsBuiltInf()\r
1911\r
1912 #\r
1913 # Check for build error, and raise exception if one\r
1914 # has been signaled.\r
1915 #\r
1916 if BuildTask.HasError():\r
1917 EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)\r
1918\r
1919 # Create MAP file when Load Fix Address is enabled.\r
1920 if self.Target in ["", "all", "fds"]:\r
1921 for Arch in Wa.ArchList:\r
1922 #\r
1923 # Check whether the set fix address is above 4G for 32bit image.\r
1924 #\r
1925 if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:\r
1926 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS can't be set to larger than or equal to 4G for the platorm with IA32 or ARM arch modules")\r
1927 #\r
1928 # Get Module List\r
1929 #\r
1930 ModuleList = {}\r
1931 for Pa in Wa.AutoGenObjectList:\r
1932 for Ma in Pa.ModuleAutoGenList:\r
1933 if Ma == None:\r
1934 continue\r
1935 if not Ma.IsLibrary:\r
1936 ModuleList[Ma.Guid.upper()] = Ma\r
1937 #\r
1938 # Rebase module to the preferred memory address before GenFds\r
1939 #\r
1940 MapBuffer = StringIO('')\r
1941 if self.LoadFixAddress != 0:\r
1942 self._CollectModuleMapBuffer(MapBuffer, ModuleList)\r
1943\r
1944 if self.Fdf:\r
1945 #\r
1946 # Generate FD image if there's a FDF file found\r
1947 #\r
1948 LaunchCommand(Wa.GenFdsCommand, os.getcwd())\r
1949\r
1950 #\r
1951 # Create MAP file for all platform FVs after GenFds.\r
1952 #\r
1953 self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)\r
1954 #\r
1955 # Save MAP buffer into MAP file.\r
1956 #\r
1957 self._SaveMapFile(MapBuffer, Wa)\r
1958\r
1959 ## Generate GuidedSectionTools.txt in the FV directories.\r
1960 #\r
1961 def CreateGuidedSectionToolsFile(self):\r
1962 for BuildTarget in self.BuildTargetList:\r
1963 for ToolChain in self.ToolChainList:\r
1964 Wa = WorkspaceAutoGen(\r
1965 self.WorkspaceDir,\r
1966 self.PlatformFile,\r
1967 BuildTarget,\r
1968 ToolChain,\r
1969 self.ArchList,\r
1970 self.BuildDatabase,\r
1971 self.TargetTxt,\r
1972 self.ToolDef,\r
1973 self.Fdf,\r
1974 self.FdList,\r
1975 self.FvList,\r
1976 self.CapList,\r
1977 self.SkuId,\r
1978 self.UniFlag\r
1979 )\r
1980 FvDir = Wa.FvDir\r
1981 if not os.path.exists(FvDir):\r
1982 continue\r
1983\r
1984 for Arch in self.ArchList:\r
1985 # Build up the list of supported architectures for this build\r
1986 prefix = '%s_%s_%s_' % (BuildTarget, ToolChain, Arch)\r
1987\r
1988 # Look through the tool definitions for GUIDed tools\r
1989 guidAttribs = []\r
1990 for (attrib, value) in self.ToolDef.ToolsDefTxtDictionary.iteritems():\r
1991 if attrib.upper().endswith('_GUID'):\r
1992 split = attrib.split('_')\r
1993 thisPrefix = '_'.join(split[0:3]) + '_'\r
1994 if thisPrefix == prefix:\r
1995 guid = self.ToolDef.ToolsDefTxtDictionary[attrib]\r
1996 guid = guid.lower()\r
1997 toolName = split[3]\r
1998 path = '_'.join(split[0:4]) + '_PATH'\r
1999 path = self.ToolDef.ToolsDefTxtDictionary[path]\r
2000 path = self.GetFullPathOfTool(path)\r
2001 guidAttribs.append((guid, toolName, path))\r
2002\r
2003 # Write out GuidedSecTools.txt\r
2004 toolsFile = os.path.join(FvDir, 'GuidedSectionTools.txt')\r
2005 toolsFile = open(toolsFile, 'wt')\r
2006 for guidedSectionTool in guidAttribs:\r
2007 print >> toolsFile, ' '.join(guidedSectionTool)\r
2008 toolsFile.close()\r
2009\r
2010 ## Returns the full path of the tool.\r
2011 #\r
2012 def GetFullPathOfTool (self, tool):\r
2013 if os.path.exists(tool):\r
2014 return os.path.realpath(tool)\r
2015 else:\r
2016 # We need to search for the tool using the\r
2017 # PATH environment variable.\r
2018 for dirInPath in os.environ['PATH'].split(os.pathsep):\r
2019 foundPath = os.path.join(dirInPath, tool)\r
2020 if os.path.exists(foundPath):\r
2021 return os.path.realpath(foundPath)\r
2022\r
2023 # If the tool was not found in the path then we just return\r
2024 # the input tool.\r
2025 return tool\r
2026\r
2027 ## Launch the module or platform build\r
2028 #\r
2029 def Launch(self):\r
2030 if not self.ModuleFile:\r
2031 if not self.SpawnMode or self.Target not in ["", "all"]:\r
2032 self.SpawnMode = False\r
2033 self._BuildPlatform()\r
2034 else:\r
2035 self._MultiThreadBuildPlatform()\r
2036 self.CreateGuidedSectionToolsFile()\r
2037 else:\r
2038 self.SpawnMode = False\r
2039 self._BuildModule()\r
2040\r
2041 if self.Target == 'cleanall':\r
2042 self.Db.Close()\r
2043 RemoveDirectory(os.path.dirname(GlobalData.gDatabasePath), True)\r
2044\r
2045 def CreateAsBuiltInf(self):\r
2046 for Module in self.BuildModules:\r
2047 Module.CreateAsBuiltInf()\r
2048 self.BuildModules = []\r
2049 ## Do some clean-up works when error occurred\r
2050 def Relinquish(self):\r
2051 OldLogLevel = EdkLogger.GetLevel()\r
2052 EdkLogger.SetLevel(EdkLogger.ERROR)\r
2053 #self.DumpBuildData()\r
2054 Utils.Progressor.Abort()\r
2055 if self.SpawnMode == True:\r
2056 BuildTask.Abort()\r
2057 EdkLogger.SetLevel(OldLogLevel)\r
2058\r
2059 def DumpBuildData(self):\r
2060 CacheDirectory = os.path.dirname(GlobalData.gDatabasePath)\r
2061 Utils.CreateDirectory(CacheDirectory)\r
2062 Utils.DataDump(Utils.gFileTimeStampCache, os.path.join(CacheDirectory, "gFileTimeStampCache"))\r
2063 Utils.DataDump(Utils.gDependencyDatabase, os.path.join(CacheDirectory, "gDependencyDatabase"))\r
2064\r
2065 def RestoreBuildData(self):\r
2066 FilePath = os.path.join(os.path.dirname(GlobalData.gDatabasePath), "gFileTimeStampCache")\r
2067 if Utils.gFileTimeStampCache == {} and os.path.isfile(FilePath):\r
2068 Utils.gFileTimeStampCache = Utils.DataRestore(FilePath)\r
2069 if Utils.gFileTimeStampCache == None:\r
2070 Utils.gFileTimeStampCache = {}\r
2071\r
2072 FilePath = os.path.join(os.path.dirname(GlobalData.gDatabasePath), "gDependencyDatabase")\r
2073 if Utils.gDependencyDatabase == {} and os.path.isfile(FilePath):\r
2074 Utils.gDependencyDatabase = Utils.DataRestore(FilePath)\r
2075 if Utils.gDependencyDatabase == None:\r
2076 Utils.gDependencyDatabase = {}\r
2077\r
2078def ParseDefines(DefineList=[]):\r
2079 DefineDict = {}\r
2080 if DefineList != None:\r
2081 for Define in DefineList:\r
2082 DefineTokenList = Define.split("=", 1)\r
2083 if not GlobalData.gMacroNamePattern.match(DefineTokenList[0]):\r
2084 EdkLogger.error('build', FORMAT_INVALID,\r
2085 "The macro name must be in the pattern [A-Z][A-Z0-9_]*",\r
2086 ExtraData=DefineTokenList[0])\r
2087\r
2088 if len(DefineTokenList) == 1:\r
2089 DefineDict[DefineTokenList[0]] = "TRUE"\r
2090 else:\r
2091 DefineDict[DefineTokenList[0]] = DefineTokenList[1].strip()\r
2092 return DefineDict\r
2093\r
2094gParamCheck = []\r
2095def SingleCheckCallback(option, opt_str, value, parser):\r
2096 if option not in gParamCheck:\r
2097 setattr(parser.values, option.dest, value)\r
2098 gParamCheck.append(option)\r
2099 else:\r
2100 parser.error("Option %s only allows one instance in command line!" % option)\r
2101\r
2102## Parse command line options\r
2103#\r
2104# Using standard Python module optparse to parse command line option of this tool.\r
2105#\r
2106# @retval Opt A optparse.Values object containing the parsed options\r
2107# @retval Args Target of build command\r
2108#\r
2109def MyOptionParser():\r
2110 Parser = OptionParser(description=__copyright__, version=__version__, prog="build.exe", usage="%prog [options] [all|fds|genc|genmake|clean|cleanall|cleanlib|modules|libraries|run]")\r
2111 Parser.add_option("-a", "--arch", action="append", type="choice", choices=['IA32', 'X64', 'IPF', 'EBC', 'ARM', 'AARCH64'], dest="TargetArch",\r
2112 help="ARCHS is one of list: IA32, X64, IPF, ARM, AARCH64 or EBC, which overrides target.txt's TARGET_ARCH definition. To specify more archs, please repeat this option.")\r
2113 Parser.add_option("-p", "--platform", action="callback", type="string", dest="PlatformFile", callback=SingleCheckCallback,\r
2114 help="Build the platform specified by the DSC file name argument, overriding target.txt's ACTIVE_PLATFORM definition.")\r
2115 Parser.add_option("-m", "--module", action="callback", type="string", dest="ModuleFile", callback=SingleCheckCallback,\r
2116 help="Build the module specified by the INF file name argument.")\r
2117 Parser.add_option("-b", "--buildtarget", type="string", dest="BuildTarget", help="Using the TARGET to build the platform, overriding target.txt's TARGET definition.",\r
2118 action="append")\r
2119 Parser.add_option("-t", "--tagname", action="append", type="string", dest="ToolChain",\r
2120 help="Using the Tool Chain Tagname to build the platform, overriding target.txt's TOOL_CHAIN_TAG definition.")\r
2121 Parser.add_option("-x", "--sku-id", action="callback", type="string", dest="SkuId", callback=SingleCheckCallback,\r
2122 help="Using this name of SKU ID to build the platform, overriding SKUID_IDENTIFIER in DSC file.")\r
2123\r
2124 Parser.add_option("-n", action="callback", type="int", dest="ThreadNumber", callback=SingleCheckCallback,\r
2125 help="Build the platform using multi-threaded compiler. The value overrides target.txt's MAX_CONCURRENT_THREAD_NUMBER. Less than 2 will disable multi-thread builds.")\r
2126\r
2127 Parser.add_option("-f", "--fdf", action="callback", type="string", dest="FdfFile", callback=SingleCheckCallback,\r
2128 help="The name of the FDF file to use, which overrides the setting in the DSC file.")\r
2129 Parser.add_option("-r", "--rom-image", action="append", type="string", dest="RomImage", default=[],\r
2130 help="The name of FD to be generated. The name must be from [FD] section in FDF file.")\r
2131 Parser.add_option("-i", "--fv-image", action="append", type="string", dest="FvImage", default=[],\r
2132 help="The name of FV to be generated. The name must be from [FV] section in FDF file.")\r
2133 Parser.add_option("-C", "--capsule-image", action="append", type="string", dest="CapName", default=[],\r
2134 help="The name of Capsule to be generated. The name must be from [Capsule] section in FDF file.")\r
2135 Parser.add_option("-u", "--skip-autogen", action="store_true", dest="SkipAutoGen", help="Skip AutoGen step.")\r
2136 Parser.add_option("-e", "--re-parse", action="store_true", dest="Reparse", help="Re-parse all meta-data files.")\r
2137\r
2138 Parser.add_option("-c", "--case-insensitive", action="store_true", dest="CaseInsensitive", default=False, help="Don't check case of file name.")\r
2139\r
2140 Parser.add_option("-w", "--warning-as-error", action="store_true", dest="WarningAsError", help="Treat warning in tools as error.")\r
2141 Parser.add_option("-j", "--log", action="store", dest="LogFile", help="Put log in specified file as well as on console.")\r
2142\r
2143 Parser.add_option("-s", "--silent", action="store_true", type=None, dest="SilentMode",\r
2144 help="Make use of silent mode of (n)make.")\r
2145 Parser.add_option("-q", "--quiet", action="store_true", type=None, help="Disable all messages except FATAL ERRORS.")\r
2146 Parser.add_option("-v", "--verbose", action="store_true", type=None, help="Turn on verbose output with informational messages printed, "\\r
2147 "including library instances selected, final dependency expression, "\\r
2148 "and warning messages, etc.")\r
2149 Parser.add_option("-d", "--debug", action="store", type="int", help="Enable debug messages at specified level.")\r
2150 Parser.add_option("-D", "--define", action="append", type="string", dest="Macros", help="Macro: \"Name [= Value]\".")\r
2151\r
2152 Parser.add_option("-y", "--report-file", action="store", dest="ReportFile", help="Create/overwrite the report to the specified filename.")\r
2153 Parser.add_option("-Y", "--report-type", action="append", type="choice", choices=['PCD','LIBRARY','FLASH','DEPEX','BUILD_FLAGS','FIXED_ADDRESS','HASH','EXECUTION_ORDER'], dest="ReportType", default=[],\r
2154 help="Flags that control the type of build report to generate. Must be one of: [PCD, LIBRARY, FLASH, DEPEX, BUILD_FLAGS, FIXED_ADDRESS, HASH, EXECUTION_ORDER]. "\\r
2155 "To specify more than one flag, repeat this option on the command line and the default flag set is [PCD, LIBRARY, FLASH, DEPEX, BUILD_FLAGS, FIXED_ADDRESS]")\r
2156 Parser.add_option("-F", "--flag", action="store", type="string", dest="Flag",\r
2157 help="Specify the specific option to parse EDK UNI file. Must be one of: [-c, -s]. -c is for EDK framework UNI file, and -s is for EDK UEFI UNI file. "\\r
2158 "This option can also be specified by setting *_*_*_BUILD_FLAGS in [BuildOptions] section of platform DSC. If they are both specified, this value "\\r
2159 "will override the setting in [BuildOptions] section of platform DSC.")\r
2160 Parser.add_option("-N", "--no-cache", action="store_true", dest="DisableCache", default=False, help="Disable build cache mechanism")\r
2161 Parser.add_option("--conf", action="store", type="string", dest="ConfDirectory", help="Specify the customized Conf directory.")\r
2162 Parser.add_option("--check-usage", action="store_true", dest="CheckUsage", default=False, help="Check usage content of entries listed in INF file.")\r
2163 Parser.add_option("--ignore-sources", action="store_true", dest="IgnoreSources", default=False, help="Focus to a binary build and ignore all source files")\r
2164 Parser.add_option("--pcd", action="append", dest="OptionPcd", help="Set PCD value by command line. Format: \"PcdName=Value\" ")\r
2165 Parser.add_option("-l", "--cmd-len", action="store", type="int", dest="CommandLength", help="Specify the maximum line length of build command. Default is 4096.")\r
2166\r
2167 (Opt, Args) = Parser.parse_args()\r
2168 return (Opt, Args)\r
2169\r
2170## Tool entrance method\r
2171#\r
2172# This method mainly dispatch specific methods per the command line options.\r
2173# If no error found, return zero value so the caller of this tool can know\r
2174# if it's executed successfully or not.\r
2175#\r
2176# @retval 0 Tool was successful\r
2177# @retval 1 Tool failed\r
2178#\r
2179def Main():\r
2180 StartTime = time.time()\r
2181\r
2182 # Initialize log system\r
2183 EdkLogger.Initialize()\r
2184 GlobalData.gCommand = sys.argv[1:]\r
2185 #\r
2186 # Parse the options and args\r
2187 #\r
2188 (Option, Target) = MyOptionParser()\r
2189 GlobalData.gOptions = Option\r
2190 GlobalData.gCaseInsensitive = Option.CaseInsensitive\r
2191\r
2192 # Set log level\r
2193 if Option.verbose != None:\r
2194 EdkLogger.SetLevel(EdkLogger.VERBOSE)\r
2195 elif Option.quiet != None:\r
2196 EdkLogger.SetLevel(EdkLogger.QUIET)\r
2197 elif Option.debug != None:\r
2198 EdkLogger.SetLevel(Option.debug + 1)\r
2199 else:\r
2200 EdkLogger.SetLevel(EdkLogger.INFO)\r
2201\r
2202 if Option.LogFile != None:\r
2203 EdkLogger.SetLogFile(Option.LogFile)\r
2204\r
2205 if Option.WarningAsError == True:\r
2206 EdkLogger.SetWarningAsError()\r
2207\r
2208 if platform.platform().find("Windows") >= 0:\r
2209 GlobalData.gIsWindows = True\r
2210 else:\r
2211 GlobalData.gIsWindows = False\r
2212\r
2213 EdkLogger.quiet("Build environment: %s" % platform.platform())\r
2214 EdkLogger.quiet(time.strftime("Build start time: %H:%M:%S, %b.%d %Y\n", time.localtime()));\r
2215 ReturnCode = 0\r
2216 MyBuild = None\r
2217 BuildError = True\r
2218 try:\r
2219 if len(Target) == 0:\r
2220 Target = "all"\r
2221 elif len(Target) >= 2:\r
2222 EdkLogger.error("build", OPTION_NOT_SUPPORTED, "More than one targets are not supported.",\r
2223 ExtraData="Please select one of: %s" % (' '.join(gSupportedTarget)))\r
2224 else:\r
2225 Target = Target[0].lower()\r
2226\r
2227 if Target not in gSupportedTarget:\r
2228 EdkLogger.error("build", OPTION_NOT_SUPPORTED, "Not supported target [%s]." % Target,\r
2229 ExtraData="Please select one of: %s" % (' '.join(gSupportedTarget)))\r
2230\r
2231 #\r
2232 # Check environment variable: EDK_TOOLS_PATH, WORKSPACE, PATH\r
2233 #\r
2234 CheckEnvVariable()\r
2235 GlobalData.gCommandLineDefines.update(ParseDefines(Option.Macros))\r
2236\r
2237 Workspace = os.getenv("WORKSPACE")\r
2238 #\r
2239 # Get files real name in workspace dir\r
2240 #\r
2241 GlobalData.gAllFiles = Utils.DirCache(Workspace)\r
2242\r
2243 WorkingDirectory = os.getcwd()\r
2244 if not Option.ModuleFile:\r
2245 FileList = glob.glob(os.path.normpath(os.path.join(WorkingDirectory, '*.inf')))\r
2246 FileNum = len(FileList)\r
2247 if FileNum >= 2:\r
2248 EdkLogger.error("build", OPTION_NOT_SUPPORTED, "There are %d INF files in %s." % (FileNum, WorkingDirectory),\r
2249 ExtraData="Please use '-m <INF_FILE_PATH>' switch to choose one.")\r
2250 elif FileNum == 1:\r
2251 Option.ModuleFile = NormFile(FileList[0], Workspace)\r
2252\r
2253 if Option.ModuleFile:\r
2254 if os.path.isabs (Option.ModuleFile):\r
2255 if os.path.normcase (os.path.normpath(Option.ModuleFile)).find (Workspace) == 0:\r
2256 Option.ModuleFile = NormFile(os.path.normpath(Option.ModuleFile), Workspace)\r
2257 Option.ModuleFile = PathClass(Option.ModuleFile, Workspace)\r
2258 ErrorCode, ErrorInfo = Option.ModuleFile.Validate(".inf", False)\r
2259 if ErrorCode != 0:\r
2260 EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)\r
2261\r
2262 if Option.PlatformFile != None:\r
2263 if os.path.isabs (Option.PlatformFile):\r
2264 if os.path.normcase (os.path.normpath(Option.PlatformFile)).find (Workspace) == 0:\r
2265 Option.PlatformFile = NormFile(os.path.normpath(Option.PlatformFile), Workspace)\r
2266 Option.PlatformFile = PathClass(Option.PlatformFile, Workspace)\r
2267\r
2268 if Option.FdfFile != None:\r
2269 if os.path.isabs (Option.FdfFile):\r
2270 if os.path.normcase (os.path.normpath(Option.FdfFile)).find (Workspace) == 0:\r
2271 Option.FdfFile = NormFile(os.path.normpath(Option.FdfFile), Workspace)\r
2272 Option.FdfFile = PathClass(Option.FdfFile, Workspace)\r
2273 ErrorCode, ErrorInfo = Option.FdfFile.Validate(".fdf", False)\r
2274 if ErrorCode != 0:\r
2275 EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)\r
2276\r
2277 if Option.Flag != None and Option.Flag not in ['-c', '-s']:\r
2278 EdkLogger.error("build", OPTION_VALUE_INVALID, "UNI flag must be one of -c or -s")\r
2279\r
2280 MyBuild = Build(Target, Workspace, Option)\r
2281 GlobalData.gCommandLineDefines['ARCH'] = ' '.join(MyBuild.ArchList)\r
2282 if not (MyBuild.LaunchPrebuildFlag and os.path.exists(MyBuild.PlatformBuildPath)):\r
2283 MyBuild.Launch()\r
2284 # Drop temp tables to avoid database locked.\r
2285 for TmpTableName in TmpTableDict:\r
2286 SqlCommand = """drop table IF EXISTS %s""" % TmpTableName\r
2287 TmpTableDict[TmpTableName].execute(SqlCommand)\r
2288 #MyBuild.DumpBuildData()\r
2289 #\r
2290 # All job done, no error found and no exception raised\r
2291 #\r
2292 BuildError = False\r
2293 except FatalError, X:\r
2294 if MyBuild != None:\r
2295 # for multi-thread build exits safely\r
2296 MyBuild.Relinquish()\r
2297 if Option != None and Option.debug != None:\r
2298 EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())\r
2299 ReturnCode = X.args[0]\r
2300 except Warning, X:\r
2301 # error from Fdf parser\r
2302 if MyBuild != None:\r
2303 # for multi-thread build exits safely\r
2304 MyBuild.Relinquish()\r
2305 if Option != None and Option.debug != None:\r
2306 EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())\r
2307 else:\r
2308 EdkLogger.error(X.ToolName, FORMAT_INVALID, File=X.FileName, Line=X.LineNumber, ExtraData=X.Message, RaiseError=False)\r
2309 ReturnCode = FORMAT_INVALID\r
2310 except KeyboardInterrupt:\r
2311 ReturnCode = ABORT_ERROR\r
2312 if Option != None and Option.debug != None:\r
2313 EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())\r
2314 except:\r
2315 if MyBuild != None:\r
2316 # for multi-thread build exits safely\r
2317 MyBuild.Relinquish()\r
2318\r
2319 # try to get the meta-file from the object causing exception\r
2320 Tb = sys.exc_info()[-1]\r
2321 MetaFile = GlobalData.gProcessingFile\r
2322 while Tb != None:\r
2323 if 'self' in Tb.tb_frame.f_locals and hasattr(Tb.tb_frame.f_locals['self'], 'MetaFile'):\r
2324 MetaFile = Tb.tb_frame.f_locals['self'].MetaFile\r
2325 Tb = Tb.tb_next\r
2326 EdkLogger.error(\r
2327 "\nbuild",\r
2328 CODE_ERROR,\r
2329 "Unknown fatal error when processing [%s]" % MetaFile,\r
2330 ExtraData="\n(Please send email to edk2-devel@lists.01.org for help, attaching following call stack trace!)\n",\r
2331 RaiseError=False\r
2332 )\r
2333 EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())\r
2334 ReturnCode = CODE_ERROR\r
2335 finally:\r
2336 Utils.Progressor.Abort()\r
2337 Utils.ClearDuplicatedInf()\r
2338\r
2339 if ReturnCode == 0:\r
2340 try:\r
2341 MyBuild.LaunchPostbuild()\r
2342 Conclusion = "Done"\r
2343 except:\r
2344 Conclusion = "Failed"\r
2345 elif ReturnCode == ABORT_ERROR:\r
2346 Conclusion = "Aborted"\r
2347 else:\r
2348 Conclusion = "Failed"\r
2349 FinishTime = time.time()\r
2350 BuildDuration = time.gmtime(int(round(FinishTime - StartTime)))\r
2351 BuildDurationStr = ""\r
2352 if BuildDuration.tm_yday > 1:\r
2353 BuildDurationStr = time.strftime("%H:%M:%S", BuildDuration) + ", %d day(s)" % (BuildDuration.tm_yday - 1)\r
2354 else:\r
2355 BuildDurationStr = time.strftime("%H:%M:%S", BuildDuration)\r
2356 if MyBuild != None:\r
2357 if not BuildError:\r
2358 MyBuild.BuildReport.GenerateReport(BuildDurationStr)\r
2359 MyBuild.Db.Close()\r
2360 EdkLogger.SetLevel(EdkLogger.QUIET)\r
2361 EdkLogger.quiet("\n- %s -" % Conclusion)\r
2362 EdkLogger.quiet(time.strftime("Build end time: %H:%M:%S, %b.%d %Y", time.localtime()))\r
2363 EdkLogger.quiet("Build total time: %s\n" % BuildDurationStr)\r
2364 return ReturnCode\r
2365\r
2366if __name__ == '__main__':\r
2367 r = Main()\r
2368 ## 0-127 is a safe return range, and 1 is a standard default error\r
2369 if r < 0 or r > 127: r = 1\r
2370 sys.exit(r)\r
2371\r
EFI Development Kit II mirror for PVE