]> 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
MdeModulePkg: Update DEC/DSC version from 0.96 to 0.97
[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 - 2016, 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 - 2016, 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("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 PrebuildEnvFile = os.path.join(GlobalData.gConfDirectory,'.cache','.PrebuildEnv')\r
1033 if os.path.isfile(PrebuildEnvFile):\r
1034 os.remove(PrebuildEnvFile)\r
1035 if os.path.isfile(self.PlatformBuildPath):\r
1036 os.remove(self.PlatformBuildPath)\r
1037 if sys.platform == "win32":\r
1038 args = ' && '.join((self.Prebuild, 'set > ' + PrebuildEnvFile))\r
1039 Process = Popen(args, stdout=PIPE, stderr=PIPE)\r
1040 else:\r
1041 args = ' && '.join((self.Prebuild, 'env > ' + PrebuildEnvFile))\r
1042 Process = Popen(args, stdout=PIPE, stderr=PIPE, shell=True, executable="/bin/bash")\r
1043\r
1044 # launch two threads to read the STDOUT and STDERR\r
1045 EndOfProcedure = Event()\r
1046 EndOfProcedure.clear()\r
1047 if Process.stdout:\r
1048 StdOutThread = Thread(target=ReadMessage, args=(Process.stdout, EdkLogger.info, EndOfProcedure))\r
1049 StdOutThread.setName("STDOUT-Redirector")\r
1050 StdOutThread.setDaemon(False)\r
1051 StdOutThread.start()\r
1052\r
1053 if Process.stderr:\r
1054 StdErrThread = Thread(target=ReadMessage, args=(Process.stderr, EdkLogger.quiet, EndOfProcedure))\r
1055 StdErrThread.setName("STDERR-Redirector")\r
1056 StdErrThread.setDaemon(False)\r
1057 StdErrThread.start()\r
1058 # waiting for program exit\r
1059 Process.wait()\r
1060\r
1061 if Process.stdout:\r
1062 StdOutThread.join()\r
1063 if Process.stderr:\r
1064 StdErrThread.join()\r
1065 if Process.returncode != 0 :\r
1066 EdkLogger.error("Prebuild", PREBUILD_ERROR, 'Prebuild process is not success!')\r
1067\r
1068 if os.path.exists(PrebuildEnvFile):\r
1069 f = open(PrebuildEnvFile)\r
1070 envs = f.readlines()\r
1071 f.close()\r
1072 envs = itertools.imap(lambda l: l.split('=',1), envs)\r
1073 envs = itertools.ifilter(lambda l: len(l) == 2, envs)\r
1074 envs = itertools.imap(lambda l: [i.strip() for i in l], envs)\r
1075 os.environ.update(dict(envs))\r
1076 EdkLogger.info("\n- Prebuild Done -\n")\r
1077\r
1078 def LaunchPostbuild(self):\r
1079 if self.Postbuild:\r
1080 EdkLogger.info("\n- Postbuild Start -\n")\r
1081 if sys.platform == "win32":\r
1082 Process = Popen(self.Postbuild, stdout=PIPE, stderr=PIPE)\r
1083 else:\r
1084 Process = Popen(self.Postbuild, stdout=PIPE, stderr=PIPE, shell=True, executable="/bin/bash")\r
1085 # launch two threads to read the STDOUT and STDERR\r
1086 EndOfProcedure = Event()\r
1087 EndOfProcedure.clear()\r
1088 if Process.stdout:\r
1089 StdOutThread = Thread(target=ReadMessage, args=(Process.stdout, EdkLogger.info, EndOfProcedure))\r
1090 StdOutThread.setName("STDOUT-Redirector")\r
1091 StdOutThread.setDaemon(False)\r
1092 StdOutThread.start()\r
1093\r
1094 if Process.stderr:\r
1095 StdErrThread = Thread(target=ReadMessage, args=(Process.stderr, EdkLogger.quiet, EndOfProcedure))\r
1096 StdErrThread.setName("STDERR-Redirector")\r
1097 StdErrThread.setDaemon(False)\r
1098 StdErrThread.start()\r
1099 # waiting for program exit\r
1100 Process.wait()\r
1101\r
1102 if Process.stdout:\r
1103 StdOutThread.join()\r
1104 if Process.stderr:\r
1105 StdErrThread.join()\r
1106 if Process.returncode != 0 :\r
1107 EdkLogger.error("Postbuild", POSTBUILD_ERROR, 'Postbuild process is not success!')\r
1108 EdkLogger.info("\n- Postbuild Done -\n")\r
1109 ## Build a module or platform\r
1110 #\r
1111 # Create autogen code and makefile for a module or platform, and the launch\r
1112 # "make" command to build it\r
1113 #\r
1114 # @param Target The target of build command\r
1115 # @param Platform The platform file\r
1116 # @param Module The module file\r
1117 # @param BuildTarget The name of build target, one of "DEBUG", "RELEASE"\r
1118 # @param ToolChain The name of toolchain to build\r
1119 # @param Arch The arch of the module/platform\r
1120 # @param CreateDepModuleCodeFile Flag used to indicate creating code\r
1121 # for dependent modules/Libraries\r
1122 # @param CreateDepModuleMakeFile Flag used to indicate creating makefile\r
1123 # for dependent modules/Libraries\r
1124 #\r
1125 def _BuildPa(self, Target, AutoGenObject, CreateDepsCodeFile=True, CreateDepsMakeFile=True, BuildModule=False):\r
1126 if AutoGenObject == None:\r
1127 return False\r
1128\r
1129 # skip file generation for cleanxxx targets, run and fds target\r
1130 if Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:\r
1131 # for target which must generate AutoGen code and makefile\r
1132 if not self.SkipAutoGen or Target == 'genc':\r
1133 self.Progress.Start("Generating code")\r
1134 AutoGenObject.CreateCodeFile(CreateDepsCodeFile)\r
1135 self.Progress.Stop("done!")\r
1136 if Target == "genc":\r
1137 return True\r
1138\r
1139 if not self.SkipAutoGen or Target == 'genmake':\r
1140 self.Progress.Start("Generating makefile")\r
1141 AutoGenObject.CreateMakeFile(CreateDepsMakeFile)\r
1142 self.Progress.Stop("done!")\r
1143 if Target == "genmake":\r
1144 return True\r
1145 else:\r
1146 # always recreate top/platform makefile when clean, just in case of inconsistency\r
1147 AutoGenObject.CreateCodeFile(False)\r
1148 AutoGenObject.CreateMakeFile(False)\r
1149\r
1150 if EdkLogger.GetLevel() == EdkLogger.QUIET:\r
1151 EdkLogger.quiet("Building ... %s" % repr(AutoGenObject))\r
1152\r
1153 BuildCommand = AutoGenObject.BuildCommand\r
1154 if BuildCommand == None or len(BuildCommand) == 0:\r
1155 EdkLogger.error("build", OPTION_MISSING,\r
1156 "No build command found for this module. "\r
1157 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %\r
1158 (AutoGenObject.BuildTarget, AutoGenObject.ToolChain, AutoGenObject.Arch),\r
1159 ExtraData=str(AutoGenObject))\r
1160\r
1161 makefile = GenMake.BuildFile(AutoGenObject)._FILE_NAME_[GenMake.gMakeType]\r
1162\r
1163 # run\r
1164 if Target == 'run':\r
1165 RunDir = os.path.normpath(os.path.join(AutoGenObject.BuildDir, GlobalData.gGlobalDefines['ARCH']))\r
1166 Command = '.\SecMain'\r
1167 os.chdir(RunDir)\r
1168 LaunchCommand(Command, RunDir)\r
1169 return True\r
1170\r
1171 # build modules\r
1172 if BuildModule:\r
1173 BuildCommand = BuildCommand + [Target]\r
1174 LaunchCommand(BuildCommand, AutoGenObject.MakeFileDir)\r
1175 self.CreateAsBuiltInf()\r
1176 return True\r
1177\r
1178 # build library\r
1179 if Target == 'libraries':\r
1180 for Lib in AutoGenObject.LibraryBuildDirectoryList:\r
1181 NewBuildCommand = BuildCommand + ['-f', os.path.normpath(os.path.join(Lib, makefile)), 'pbuild']\r
1182 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
1183 return True\r
1184\r
1185 # build module\r
1186 if Target == 'modules':\r
1187 for Lib in AutoGenObject.LibraryBuildDirectoryList:\r
1188 NewBuildCommand = BuildCommand + ['-f', os.path.normpath(os.path.join(Lib, makefile)), 'pbuild']\r
1189 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
1190 for Mod in AutoGenObject.ModuleBuildDirectoryList:\r
1191 NewBuildCommand = BuildCommand + ['-f', os.path.normpath(os.path.join(Mod, makefile)), 'pbuild']\r
1192 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
1193 self.CreateAsBuiltInf()\r
1194 return True\r
1195\r
1196 # cleanlib\r
1197 if Target == 'cleanlib':\r
1198 for Lib in AutoGenObject.LibraryBuildDirectoryList:\r
1199 LibMakefile = os.path.normpath(os.path.join(Lib, makefile))\r
1200 if os.path.exists(LibMakefile):\r
1201 NewBuildCommand = BuildCommand + ['-f', LibMakefile, 'cleanall']\r
1202 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
1203 return True\r
1204\r
1205 # clean\r
1206 if Target == 'clean':\r
1207 for Mod in AutoGenObject.ModuleBuildDirectoryList:\r
1208 ModMakefile = os.path.normpath(os.path.join(Mod, makefile))\r
1209 if os.path.exists(ModMakefile):\r
1210 NewBuildCommand = BuildCommand + ['-f', ModMakefile, 'cleanall']\r
1211 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
1212 for Lib in AutoGenObject.LibraryBuildDirectoryList:\r
1213 LibMakefile = os.path.normpath(os.path.join(Lib, makefile))\r
1214 if os.path.exists(LibMakefile):\r
1215 NewBuildCommand = BuildCommand + ['-f', LibMakefile, 'cleanall']\r
1216 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
1217 return True\r
1218\r
1219 # cleanall\r
1220 if Target == 'cleanall':\r
1221 try:\r
1222 #os.rmdir(AutoGenObject.BuildDir)\r
1223 RemoveDirectory(AutoGenObject.BuildDir, True)\r
1224 except WindowsError, X:\r
1225 EdkLogger.error("build", FILE_DELETE_FAILURE, ExtraData=str(X))\r
1226 return True\r
1227\r
1228 ## Build a module or platform\r
1229 #\r
1230 # Create autogen code and makefile for a module or platform, and the launch\r
1231 # "make" command to build it\r
1232 #\r
1233 # @param Target The target of build command\r
1234 # @param Platform The platform file\r
1235 # @param Module The module file\r
1236 # @param BuildTarget The name of build target, one of "DEBUG", "RELEASE"\r
1237 # @param ToolChain The name of toolchain to build\r
1238 # @param Arch The arch of the module/platform\r
1239 # @param CreateDepModuleCodeFile Flag used to indicate creating code\r
1240 # for dependent modules/Libraries\r
1241 # @param CreateDepModuleMakeFile Flag used to indicate creating makefile\r
1242 # for dependent modules/Libraries\r
1243 #\r
1244 def _Build(self, Target, AutoGenObject, CreateDepsCodeFile=True, CreateDepsMakeFile=True, BuildModule=False):\r
1245 if AutoGenObject == None:\r
1246 return False\r
1247\r
1248 # skip file generation for cleanxxx targets, run and fds target\r
1249 if Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:\r
1250 # for target which must generate AutoGen code and makefile\r
1251 if not self.SkipAutoGen or Target == 'genc':\r
1252 self.Progress.Start("Generating code")\r
1253 AutoGenObject.CreateCodeFile(CreateDepsCodeFile)\r
1254 self.Progress.Stop("done!")\r
1255 if Target == "genc":\r
1256 return True\r
1257\r
1258 if not self.SkipAutoGen or Target == 'genmake':\r
1259 self.Progress.Start("Generating makefile")\r
1260 AutoGenObject.CreateMakeFile(CreateDepsMakeFile)\r
1261 #AutoGenObject.CreateAsBuiltInf()\r
1262 self.Progress.Stop("done!")\r
1263 if Target == "genmake":\r
1264 return True\r
1265 else:\r
1266 # always recreate top/platform makefile when clean, just in case of inconsistency\r
1267 AutoGenObject.CreateCodeFile(False)\r
1268 AutoGenObject.CreateMakeFile(False)\r
1269\r
1270 if EdkLogger.GetLevel() == EdkLogger.QUIET:\r
1271 EdkLogger.quiet("Building ... %s" % repr(AutoGenObject))\r
1272\r
1273 BuildCommand = AutoGenObject.BuildCommand\r
1274 if BuildCommand == None or len(BuildCommand) == 0:\r
1275 EdkLogger.error("build", OPTION_MISSING,\r
1276 "No build command found for this module. "\r
1277 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %\r
1278 (AutoGenObject.BuildTarget, AutoGenObject.ToolChain, AutoGenObject.Arch),\r
1279 ExtraData=str(AutoGenObject))\r
1280\r
1281 # build modules\r
1282 if BuildModule:\r
1283 if Target != 'fds':\r
1284 BuildCommand = BuildCommand + [Target]\r
1285 LaunchCommand(BuildCommand, AutoGenObject.MakeFileDir)\r
1286 self.CreateAsBuiltInf()\r
1287 return True\r
1288\r
1289 # genfds\r
1290 if Target == 'fds':\r
1291 LaunchCommand(AutoGenObject.GenFdsCommand, AutoGenObject.MakeFileDir)\r
1292 return True\r
1293\r
1294 # run\r
1295 if Target == 'run':\r
1296 RunDir = os.path.normpath(os.path.join(AutoGenObject.BuildDir, GlobalData.gGlobalDefines['ARCH']))\r
1297 Command = '.\SecMain'\r
1298 os.chdir(RunDir)\r
1299 LaunchCommand(Command, RunDir)\r
1300 return True\r
1301\r
1302 # build library\r
1303 if Target == 'libraries':\r
1304 pass\r
1305\r
1306 # not build modules\r
1307\r
1308\r
1309 # cleanall\r
1310 if Target == 'cleanall':\r
1311 try:\r
1312 #os.rmdir(AutoGenObject.BuildDir)\r
1313 RemoveDirectory(AutoGenObject.BuildDir, True)\r
1314 except WindowsError, X:\r
1315 EdkLogger.error("build", FILE_DELETE_FAILURE, ExtraData=str(X))\r
1316 return True\r
1317\r
1318 ## Rebase module image and Get function address for the input module list.\r
1319 #\r
1320 def _RebaseModule (self, MapBuffer, BaseAddress, ModuleList, AddrIsOffset = True, ModeIsSmm = False):\r
1321 if ModeIsSmm:\r
1322 AddrIsOffset = False\r
1323 InfFileNameList = ModuleList.keys()\r
1324 #InfFileNameList.sort()\r
1325 for InfFile in InfFileNameList:\r
1326 sys.stdout.write (".")\r
1327 sys.stdout.flush()\r
1328 ModuleInfo = ModuleList[InfFile]\r
1329 ModuleName = ModuleInfo.BaseName\r
1330 ModuleOutputImage = ModuleInfo.Image.FileName\r
1331 ModuleDebugImage = os.path.join(ModuleInfo.DebugDir, ModuleInfo.BaseName + '.efi')\r
1332 ## for SMM module in SMRAM, the SMRAM will be allocated from base to top.\r
1333 if not ModeIsSmm:\r
1334 BaseAddress = BaseAddress - ModuleInfo.Image.Size\r
1335 #\r
1336 # Update Image to new BaseAddress by GenFw tool\r
1337 #\r
1338 LaunchCommand(["GenFw", "--rebase", str(BaseAddress), "-r", ModuleOutputImage], ModuleInfo.OutputDir)\r
1339 LaunchCommand(["GenFw", "--rebase", str(BaseAddress), "-r", ModuleDebugImage], ModuleInfo.DebugDir)\r
1340 else:\r
1341 #\r
1342 # Set new address to the section header only for SMM driver.\r
1343 #\r
1344 LaunchCommand(["GenFw", "--address", str(BaseAddress), "-r", ModuleOutputImage], ModuleInfo.OutputDir)\r
1345 LaunchCommand(["GenFw", "--address", str(BaseAddress), "-r", ModuleDebugImage], ModuleInfo.DebugDir)\r
1346 #\r
1347 # Collect funtion address from Map file\r
1348 #\r
1349 ImageMapTable = ModuleOutputImage.replace('.efi', '.map')\r
1350 FunctionList = []\r
1351 if os.path.exists(ImageMapTable):\r
1352 OrigImageBaseAddress = 0\r
1353 ImageMap = open(ImageMapTable, 'r')\r
1354 for LinStr in ImageMap:\r
1355 if len (LinStr.strip()) == 0:\r
1356 continue\r
1357 #\r
1358 # Get the preferred address set on link time.\r
1359 #\r
1360 if LinStr.find ('Preferred load address is') != -1:\r
1361 StrList = LinStr.split()\r
1362 OrigImageBaseAddress = int (StrList[len(StrList) - 1], 16)\r
1363\r
1364 StrList = LinStr.split()\r
1365 if len (StrList) > 4:\r
1366 if StrList[3] == 'f' or StrList[3] == 'F':\r
1367 Name = StrList[1]\r
1368 RelativeAddress = int (StrList[2], 16) - OrigImageBaseAddress\r
1369 FunctionList.append ((Name, RelativeAddress))\r
1370 if ModuleInfo.Arch == 'IPF' and Name.endswith('_ModuleEntryPoint'):\r
1371 #\r
1372 # Get the real entry point address for IPF image.\r
1373 #\r
1374 ModuleInfo.Image.EntryPoint = RelativeAddress\r
1375 ImageMap.close()\r
1376 #\r
1377 # Add general information.\r
1378 #\r
1379 if ModeIsSmm:\r
1380 MapBuffer.write('\n\n%s (Fixed SMRAM Offset, BaseAddress=0x%010X, EntryPoint=0x%010X)\n' % (ModuleName, BaseAddress, BaseAddress + ModuleInfo.Image.EntryPoint))\r
1381 elif AddrIsOffset:\r
1382 MapBuffer.write('\n\n%s (Fixed Memory Offset, BaseAddress=-0x%010X, EntryPoint=-0x%010X)\n' % (ModuleName, 0 - BaseAddress, 0 - (BaseAddress + ModuleInfo.Image.EntryPoint)))\r
1383 else:\r
1384 MapBuffer.write('\n\n%s (Fixed Memory Address, BaseAddress=0x%010X, EntryPoint=0x%010X)\n' % (ModuleName, BaseAddress, BaseAddress + ModuleInfo.Image.EntryPoint))\r
1385 #\r
1386 # Add guid and general seciton section.\r
1387 #\r
1388 TextSectionAddress = 0\r
1389 DataSectionAddress = 0\r
1390 for SectionHeader in ModuleInfo.Image.SectionHeaderList:\r
1391 if SectionHeader[0] == '.text':\r
1392 TextSectionAddress = SectionHeader[1]\r
1393 elif SectionHeader[0] in ['.data', '.sdata']:\r
1394 DataSectionAddress = SectionHeader[1]\r
1395 if AddrIsOffset:\r
1396 MapBuffer.write('(GUID=%s, .textbaseaddress=-0x%010X, .databaseaddress=-0x%010X)\n' % (ModuleInfo.Guid, 0 - (BaseAddress + TextSectionAddress), 0 - (BaseAddress + DataSectionAddress)))\r
1397 else:\r
1398 MapBuffer.write('(GUID=%s, .textbaseaddress=0x%010X, .databaseaddress=0x%010X)\n' % (ModuleInfo.Guid, BaseAddress + TextSectionAddress, BaseAddress + DataSectionAddress))\r
1399 #\r
1400 # Add debug image full path.\r
1401 #\r
1402 MapBuffer.write('(IMAGE=%s)\n\n' % (ModuleDebugImage))\r
1403 #\r
1404 # Add funtion address\r
1405 #\r
1406 for Function in FunctionList:\r
1407 if AddrIsOffset:\r
1408 MapBuffer.write(' -0x%010X %s\n' % (0 - (BaseAddress + Function[1]), Function[0]))\r
1409 else:\r
1410 MapBuffer.write(' 0x%010X %s\n' % (BaseAddress + Function[1], Function[0]))\r
1411 ImageMap.close()\r
1412\r
1413 #\r
1414 # for SMM module in SMRAM, the SMRAM will be allocated from base to top.\r
1415 #\r
1416 if ModeIsSmm:\r
1417 BaseAddress = BaseAddress + ModuleInfo.Image.Size\r
1418\r
1419 ## Collect MAP information of all FVs\r
1420 #\r
1421 def _CollectFvMapBuffer (self, MapBuffer, Wa, ModuleList):\r
1422 if self.Fdf:\r
1423 # First get the XIP base address for FV map file.\r
1424 GuidPattern = re.compile("[-a-fA-F0-9]+")\r
1425 GuidName = re.compile("\(GUID=[-a-fA-F0-9]+")\r
1426 for FvName in Wa.FdfProfile.FvDict.keys():\r
1427 FvMapBuffer = os.path.join(Wa.FvDir, FvName + '.Fv.map')\r
1428 if not os.path.exists(FvMapBuffer):\r
1429 continue\r
1430 FvMap = open(FvMapBuffer, 'r')\r
1431 #skip FV size information\r
1432 FvMap.readline()\r
1433 FvMap.readline()\r
1434 FvMap.readline()\r
1435 FvMap.readline()\r
1436 for Line in FvMap:\r
1437 MatchGuid = GuidPattern.match(Line)\r
1438 if MatchGuid != None:\r
1439 #\r
1440 # Replace GUID with module name\r
1441 #\r
1442 GuidString = MatchGuid.group()\r
1443 if GuidString.upper() in ModuleList:\r
1444 Line = Line.replace(GuidString, ModuleList[GuidString.upper()].Name)\r
1445 MapBuffer.write('%s' % (Line))\r
1446 #\r
1447 # Add the debug image full path.\r
1448 #\r
1449 MatchGuid = GuidName.match(Line)\r
1450 if MatchGuid != None:\r
1451 GuidString = MatchGuid.group().split("=")[1]\r
1452 if GuidString.upper() in ModuleList:\r
1453 MapBuffer.write('(IMAGE=%s)\n' % (os.path.join(ModuleList[GuidString.upper()].DebugDir, ModuleList[GuidString.upper()].Name + '.efi')))\r
1454\r
1455 FvMap.close()\r
1456\r
1457 ## Collect MAP information of all modules\r
1458 #\r
1459 def _CollectModuleMapBuffer (self, MapBuffer, ModuleList):\r
1460 sys.stdout.write ("Generate Load Module At Fix Address Map")\r
1461 sys.stdout.flush()\r
1462 PatchEfiImageList = []\r
1463 PeiModuleList = {}\r
1464 BtModuleList = {}\r
1465 RtModuleList = {}\r
1466 SmmModuleList = {}\r
1467 PeiSize = 0\r
1468 BtSize = 0\r
1469 RtSize = 0\r
1470 # reserve 4K size in SMRAM to make SMM module address not from 0.\r
1471 SmmSize = 0x1000\r
1472 IsIpfPlatform = False\r
1473 if 'IPF' in self.ArchList:\r
1474 IsIpfPlatform = True\r
1475 for ModuleGuid in ModuleList:\r
1476 Module = ModuleList[ModuleGuid]\r
1477 GlobalData.gProcessingFile = "%s [%s, %s, %s]" % (Module.MetaFile, Module.Arch, Module.ToolChain, Module.BuildTarget)\r
1478\r
1479 OutputImageFile = ''\r
1480 for ResultFile in Module.CodaTargetList:\r
1481 if str(ResultFile.Target).endswith('.efi'):\r
1482 #\r
1483 # module list for PEI, DXE, RUNTIME and SMM\r
1484 #\r
1485 OutputImageFile = os.path.join(Module.OutputDir, Module.Name + '.efi')\r
1486 ImageClass = PeImageClass (OutputImageFile)\r
1487 if not ImageClass.IsValid:\r
1488 EdkLogger.error("build", FILE_PARSE_FAILURE, ExtraData=ImageClass.ErrorInfo)\r
1489 ImageInfo = PeImageInfo(Module.Name, Module.Guid, Module.Arch, Module.OutputDir, Module.DebugDir, ImageClass)\r
1490 if Module.ModuleType in ['PEI_CORE', 'PEIM', 'COMBINED_PEIM_DRIVER', 'PIC_PEIM', 'RELOCATABLE_PEIM', 'DXE_CORE']:\r
1491 PeiModuleList[Module.MetaFile] = ImageInfo\r
1492 PeiSize += ImageInfo.Image.Size\r
1493 elif Module.ModuleType in ['BS_DRIVER', 'DXE_DRIVER', 'UEFI_DRIVER']:\r
1494 BtModuleList[Module.MetaFile] = ImageInfo\r
1495 BtSize += ImageInfo.Image.Size\r
1496 elif Module.ModuleType in ['DXE_RUNTIME_DRIVER', 'RT_DRIVER', 'DXE_SAL_DRIVER', 'SAL_RT_DRIVER']:\r
1497 RtModuleList[Module.MetaFile] = ImageInfo\r
1498 #IPF runtime driver needs to be at 2 page alignment.\r
1499 if IsIpfPlatform and ImageInfo.Image.Size % 0x2000 != 0:\r
1500 ImageInfo.Image.Size = (ImageInfo.Image.Size / 0x2000 + 1) * 0x2000\r
1501 RtSize += ImageInfo.Image.Size\r
1502 elif Module.ModuleType in ['SMM_CORE', 'DXE_SMM_DRIVER']:\r
1503 SmmModuleList[Module.MetaFile] = ImageInfo\r
1504 SmmSize += ImageInfo.Image.Size\r
1505 if Module.ModuleType == 'DXE_SMM_DRIVER':\r
1506 PiSpecVersion = '0x00000000'\r
1507 if 'PI_SPECIFICATION_VERSION' in Module.Module.Specification:\r
1508 PiSpecVersion = Module.Module.Specification['PI_SPECIFICATION_VERSION']\r
1509 # for PI specification < PI1.1, DXE_SMM_DRIVER also runs as BOOT time driver.\r
1510 if int(PiSpecVersion, 16) < 0x0001000A:\r
1511 BtModuleList[Module.MetaFile] = ImageInfo\r
1512 BtSize += ImageInfo.Image.Size\r
1513 break\r
1514 #\r
1515 # EFI image is final target.\r
1516 # Check EFI image contains patchable FixAddress related PCDs.\r
1517 #\r
1518 if OutputImageFile != '':\r
1519 ModuleIsPatch = False\r
1520 for Pcd in Module.ModulePcdList:\r
1521 if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE and Pcd.TokenCName in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_LIST:\r
1522 ModuleIsPatch = True\r
1523 break\r
1524 if not ModuleIsPatch:\r
1525 for Pcd in Module.LibraryPcdList:\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\r
1530 if not ModuleIsPatch:\r
1531 continue\r
1532 #\r
1533 # Module includes the patchable load fix address PCDs.\r
1534 # It will be fixed up later.\r
1535 #\r
1536 PatchEfiImageList.append (OutputImageFile)\r
1537\r
1538 #\r
1539 # Get Top Memory address\r
1540 #\r
1541 ReservedRuntimeMemorySize = 0\r
1542 TopMemoryAddress = 0\r
1543 if self.LoadFixAddress == 0xFFFFFFFFFFFFFFFF:\r
1544 TopMemoryAddress = 0\r
1545 else:\r
1546 TopMemoryAddress = self.LoadFixAddress\r
1547 if TopMemoryAddress < RtSize + BtSize + PeiSize:\r
1548 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS is too low to load driver")\r
1549 # Make IPF runtime driver at 2 page alignment.\r
1550 if IsIpfPlatform:\r
1551 ReservedRuntimeMemorySize = TopMemoryAddress % 0x2000\r
1552 RtSize = RtSize + ReservedRuntimeMemorySize\r
1553\r
1554 #\r
1555 # Patch FixAddress related PCDs into EFI image\r
1556 #\r
1557 for EfiImage in PatchEfiImageList:\r
1558 EfiImageMap = EfiImage.replace('.efi', '.map')\r
1559 if not os.path.exists(EfiImageMap):\r
1560 continue\r
1561 #\r
1562 # Get PCD offset in EFI image by GenPatchPcdTable function\r
1563 #\r
1564 PcdTable = parsePcdInfoFromMapFile(EfiImageMap, EfiImage)\r
1565 #\r
1566 # Patch real PCD value by PatchPcdValue tool\r
1567 #\r
1568 for PcdInfo in PcdTable:\r
1569 ReturnValue = 0\r
1570 if PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE:\r
1571 ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE_DATA_TYPE, str (PeiSize / 0x1000))\r
1572 elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE:\r
1573 ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE_DATA_TYPE, str (BtSize / 0x1000))\r
1574 elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE:\r
1575 ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE_DATA_TYPE, str (RtSize / 0x1000))\r
1576 elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE and len (SmmModuleList) > 0:\r
1577 ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE_DATA_TYPE, str (SmmSize / 0x1000))\r
1578 if ReturnValue != 0:\r
1579 EdkLogger.error("build", PARAMETER_INVALID, "Patch PCD value failed", ExtraData=ErrorInfo)\r
1580\r
1581 MapBuffer.write('PEI_CODE_PAGE_NUMBER = 0x%x\n' % (PeiSize / 0x1000))\r
1582 MapBuffer.write('BOOT_CODE_PAGE_NUMBER = 0x%x\n' % (BtSize / 0x1000))\r
1583 MapBuffer.write('RUNTIME_CODE_PAGE_NUMBER = 0x%x\n' % (RtSize / 0x1000))\r
1584 if len (SmmModuleList) > 0:\r
1585 MapBuffer.write('SMM_CODE_PAGE_NUMBER = 0x%x\n' % (SmmSize / 0x1000))\r
1586\r
1587 PeiBaseAddr = TopMemoryAddress - RtSize - BtSize\r
1588 BtBaseAddr = TopMemoryAddress - RtSize\r
1589 RtBaseAddr = TopMemoryAddress - ReservedRuntimeMemorySize\r
1590\r
1591 self._RebaseModule (MapBuffer, PeiBaseAddr, PeiModuleList, TopMemoryAddress == 0)\r
1592 self._RebaseModule (MapBuffer, BtBaseAddr, BtModuleList, TopMemoryAddress == 0)\r
1593 self._RebaseModule (MapBuffer, RtBaseAddr, RtModuleList, TopMemoryAddress == 0)\r
1594 self._RebaseModule (MapBuffer, 0x1000, SmmModuleList, AddrIsOffset=False, ModeIsSmm=True)\r
1595 MapBuffer.write('\n\n')\r
1596 sys.stdout.write ("\n")\r
1597 sys.stdout.flush()\r
1598\r
1599 ## Save platform Map file\r
1600 #\r
1601 def _SaveMapFile (self, MapBuffer, Wa):\r
1602 #\r
1603 # Map file path is got.\r
1604 #\r
1605 MapFilePath = os.path.join(Wa.BuildDir, Wa.Name + '.map')\r
1606 #\r
1607 # Save address map into MAP file.\r
1608 #\r
1609 SaveFileOnChange(MapFilePath, MapBuffer.getvalue(), False)\r
1610 MapBuffer.close()\r
1611 if self.LoadFixAddress != 0:\r
1612 sys.stdout.write ("\nLoad Module At Fix Address Map file can be found at %s\n" % (MapFilePath))\r
1613 sys.stdout.flush()\r
1614\r
1615 ## Build active platform for different build targets and different tool chains\r
1616 #\r
1617 def _BuildPlatform(self):\r
1618 SaveFileOnChange(self.PlatformBuildPath, '# DO NOT EDIT \n# FILE auto-generated\n', False)\r
1619 for BuildTarget in self.BuildTargetList:\r
1620 GlobalData.gGlobalDefines['TARGET'] = BuildTarget\r
1621 index = 0\r
1622 for ToolChain in self.ToolChainList:\r
1623 GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain\r
1624 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain\r
1625 GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[index]\r
1626 index += 1\r
1627 Wa = WorkspaceAutoGen(\r
1628 self.WorkspaceDir,\r
1629 self.PlatformFile,\r
1630 BuildTarget,\r
1631 ToolChain,\r
1632 self.ArchList,\r
1633 self.BuildDatabase,\r
1634 self.TargetTxt,\r
1635 self.ToolDef,\r
1636 self.Fdf,\r
1637 self.FdList,\r
1638 self.FvList,\r
1639 self.CapList,\r
1640 self.SkuId,\r
1641 self.UniFlag,\r
1642 self.Progress\r
1643 )\r
1644 self.Fdf = Wa.FdfFile\r
1645 self.LoadFixAddress = Wa.Platform.LoadFixAddress\r
1646 self.BuildReport.AddPlatformReport(Wa)\r
1647 self.Progress.Stop("done!")\r
1648 for Arch in Wa.ArchList:\r
1649 GlobalData.gGlobalDefines['ARCH'] = Arch\r
1650 Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)\r
1651 for Module in Pa.Platform.Modules:\r
1652 # Get ModuleAutoGen object to generate C code file and makefile\r
1653 Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)\r
1654 if Ma == None:\r
1655 continue\r
1656 self.BuildModules.append(Ma)\r
1657 self._BuildPa(self.Target, Pa)\r
1658\r
1659 # Create MAP file when Load Fix Address is enabled.\r
1660 if self.Target in ["", "all", "fds"]:\r
1661 for Arch in Wa.ArchList:\r
1662 GlobalData.gGlobalDefines['ARCH'] = Arch\r
1663 #\r
1664 # Check whether the set fix address is above 4G for 32bit image.\r
1665 #\r
1666 if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:\r
1667 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
1668 #\r
1669 # Get Module List\r
1670 #\r
1671 ModuleList = {}\r
1672 for Pa in Wa.AutoGenObjectList:\r
1673 for Ma in Pa.ModuleAutoGenList:\r
1674 if Ma == None:\r
1675 continue\r
1676 if not Ma.IsLibrary:\r
1677 ModuleList[Ma.Guid.upper()] = Ma\r
1678\r
1679 MapBuffer = StringIO('')\r
1680 if self.LoadFixAddress != 0:\r
1681 #\r
1682 # Rebase module to the preferred memory address before GenFds\r
1683 #\r
1684 self._CollectModuleMapBuffer(MapBuffer, ModuleList)\r
1685 if self.Fdf:\r
1686 #\r
1687 # create FDS again for the updated EFI image\r
1688 #\r
1689 self._Build("fds", Wa)\r
1690 #\r
1691 # Create MAP file for all platform FVs after GenFds.\r
1692 #\r
1693 self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)\r
1694 #\r
1695 # Save MAP buffer into MAP file.\r
1696 #\r
1697 self._SaveMapFile (MapBuffer, Wa)\r
1698\r
1699 ## Build active module for different build targets, different tool chains and different archs\r
1700 #\r
1701 def _BuildModule(self):\r
1702 for BuildTarget in self.BuildTargetList:\r
1703 GlobalData.gGlobalDefines['TARGET'] = BuildTarget\r
1704 index = 0\r
1705 for ToolChain in self.ToolChainList:\r
1706 GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain\r
1707 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain\r
1708 GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[index]\r
1709 index += 1\r
1710 #\r
1711 # module build needs platform build information, so get platform\r
1712 # AutoGen first\r
1713 #\r
1714 Wa = WorkspaceAutoGen(\r
1715 self.WorkspaceDir,\r
1716 self.PlatformFile,\r
1717 BuildTarget,\r
1718 ToolChain,\r
1719 self.ArchList,\r
1720 self.BuildDatabase,\r
1721 self.TargetTxt,\r
1722 self.ToolDef,\r
1723 self.Fdf,\r
1724 self.FdList,\r
1725 self.FvList,\r
1726 self.CapList,\r
1727 self.SkuId,\r
1728 self.UniFlag,\r
1729 self.Progress,\r
1730 self.ModuleFile\r
1731 )\r
1732 self.Fdf = Wa.FdfFile\r
1733 self.LoadFixAddress = Wa.Platform.LoadFixAddress\r
1734 Wa.CreateMakeFile(False)\r
1735 self.Progress.Stop("done!")\r
1736 MaList = []\r
1737 for Arch in Wa.ArchList:\r
1738 GlobalData.gGlobalDefines['ARCH'] = Arch\r
1739 Ma = ModuleAutoGen(Wa, self.ModuleFile, BuildTarget, ToolChain, Arch, self.PlatformFile)\r
1740 if Ma == None: continue\r
1741 MaList.append(Ma)\r
1742 self.BuildModules.append(Ma)\r
1743 if not Ma.IsBinaryModule:\r
1744 self._Build(self.Target, Ma, BuildModule=True)\r
1745\r
1746 self.BuildReport.AddPlatformReport(Wa, MaList)\r
1747 if MaList == []:\r
1748 EdkLogger.error(\r
1749 'build',\r
1750 BUILD_ERROR,\r
1751 "Module for [%s] is not a component of active platform."\\r
1752 " Please make sure that the ARCH and inf file path are"\\r
1753 " given in the same as in [%s]" % \\r
1754 (', '.join(Wa.ArchList), self.PlatformFile),\r
1755 ExtraData=self.ModuleFile\r
1756 )\r
1757 # Create MAP file when Load Fix Address is enabled.\r
1758 if self.Target == "fds" and self.Fdf:\r
1759 for Arch in Wa.ArchList:\r
1760 #\r
1761 # Check whether the set fix address is above 4G for 32bit image.\r
1762 #\r
1763 if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:\r
1764 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
1765 #\r
1766 # Get Module List\r
1767 #\r
1768 ModuleList = {}\r
1769 for Pa in Wa.AutoGenObjectList:\r
1770 for Ma in Pa.ModuleAutoGenList:\r
1771 if Ma == None:\r
1772 continue\r
1773 if not Ma.IsLibrary:\r
1774 ModuleList[Ma.Guid.upper()] = Ma\r
1775\r
1776 MapBuffer = StringIO('')\r
1777 if self.LoadFixAddress != 0:\r
1778 #\r
1779 # Rebase module to the preferred memory address before GenFds\r
1780 #\r
1781 self._CollectModuleMapBuffer(MapBuffer, ModuleList)\r
1782 #\r
1783 # create FDS again for the updated EFI image\r
1784 #\r
1785 self._Build("fds", Wa)\r
1786 #\r
1787 # Create MAP file for all platform FVs after GenFds.\r
1788 #\r
1789 self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)\r
1790 #\r
1791 # Save MAP buffer into MAP file.\r
1792 #\r
1793 self._SaveMapFile (MapBuffer, Wa)\r
1794\r
1795 ## Build a platform in multi-thread mode\r
1796 #\r
1797 def _MultiThreadBuildPlatform(self):\r
1798 SaveFileOnChange(self.PlatformBuildPath, '# DO NOT EDIT \n# FILE auto-generated\n', False)\r
1799 for BuildTarget in self.BuildTargetList:\r
1800 GlobalData.gGlobalDefines['TARGET'] = BuildTarget\r
1801 index = 0\r
1802 for ToolChain in self.ToolChainList:\r
1803 GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain\r
1804 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain\r
1805 GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[index]\r
1806 index += 1\r
1807 Wa = WorkspaceAutoGen(\r
1808 self.WorkspaceDir,\r
1809 self.PlatformFile,\r
1810 BuildTarget,\r
1811 ToolChain,\r
1812 self.ArchList,\r
1813 self.BuildDatabase,\r
1814 self.TargetTxt,\r
1815 self.ToolDef,\r
1816 self.Fdf,\r
1817 self.FdList,\r
1818 self.FvList,\r
1819 self.CapList,\r
1820 self.SkuId,\r
1821 self.UniFlag,\r
1822 self.Progress\r
1823 )\r
1824 self.Fdf = Wa.FdfFile\r
1825 self.LoadFixAddress = Wa.Platform.LoadFixAddress\r
1826 self.BuildReport.AddPlatformReport(Wa)\r
1827 Wa.CreateMakeFile(False)\r
1828\r
1829 # multi-thread exit flag\r
1830 ExitFlag = threading.Event()\r
1831 ExitFlag.clear()\r
1832 for Arch in Wa.ArchList:\r
1833 GlobalData.gGlobalDefines['ARCH'] = Arch\r
1834 Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)\r
1835 if Pa == None:\r
1836 continue\r
1837 ModuleList = []\r
1838 for Inf in Pa.Platform.Modules:\r
1839 ModuleList.append(Inf)\r
1840 # Add the INF only list in FDF\r
1841 if GlobalData.gFdfParser != None:\r
1842 for InfName in GlobalData.gFdfParser.Profile.InfList:\r
1843 Inf = PathClass(NormPath(InfName), self.WorkspaceDir, Arch)\r
1844 if Inf in Pa.Platform.Modules:\r
1845 continue\r
1846 ModuleList.append(Inf)\r
1847 for Module in ModuleList:\r
1848 # Get ModuleAutoGen object to generate C code file and makefile\r
1849 Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)\r
1850 \r
1851 if Ma == None:\r
1852 continue\r
1853 # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'\r
1854 if self.Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:\r
1855 # for target which must generate AutoGen code and makefile\r
1856 if not self.SkipAutoGen or self.Target == 'genc':\r
1857 Ma.CreateCodeFile(True)\r
1858 if self.Target == "genc":\r
1859 continue\r
1860\r
1861 if not self.SkipAutoGen or self.Target == 'genmake':\r
1862 Ma.CreateMakeFile(True)\r
1863 if self.Target == "genmake":\r
1864 continue\r
1865 self.BuildModules.append(Ma)\r
1866 self.Progress.Stop("done!")\r
1867\r
1868 for Ma in self.BuildModules:\r
1869 # Generate build task for the module\r
1870 if not Ma.IsBinaryModule:\r
1871 Bt = BuildTask.New(ModuleMakeUnit(Ma, self.Target))\r
1872 # Break build if any build thread has error\r
1873 if BuildTask.HasError():\r
1874 # we need a full version of makefile for platform\r
1875 ExitFlag.set()\r
1876 BuildTask.WaitForComplete()\r
1877 Pa.CreateMakeFile(False)\r
1878 EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)\r
1879 # Start task scheduler\r
1880 if not BuildTask.IsOnGoing():\r
1881 BuildTask.StartScheduler(self.ThreadNumber, ExitFlag)\r
1882\r
1883 # in case there's an interruption. we need a full version of makefile for platform\r
1884 Pa.CreateMakeFile(False)\r
1885 if BuildTask.HasError():\r
1886 EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)\r
1887\r
1888 #\r
1889 # Save temp tables to a TmpTableDict.\r
1890 #\r
1891 for Key in Wa.BuildDatabase._CACHE_:\r
1892 if Wa.BuildDatabase._CACHE_[Key]._RawData and Wa.BuildDatabase._CACHE_[Key]._RawData._Table and Wa.BuildDatabase._CACHE_[Key]._RawData._Table.Table:\r
1893 if TemporaryTablePattern.match(Wa.BuildDatabase._CACHE_[Key]._RawData._Table.Table):\r
1894 TmpTableDict[Wa.BuildDatabase._CACHE_[Key]._RawData._Table.Table] = Wa.BuildDatabase._CACHE_[Key]._RawData._Table.Cur\r
1895 #\r
1896 #\r
1897 # All modules have been put in build tasks queue. Tell task scheduler\r
1898 # to exit if all tasks are completed\r
1899 #\r
1900 ExitFlag.set()\r
1901 BuildTask.WaitForComplete()\r
1902 self.CreateAsBuiltInf()\r
1903\r
1904 #\r
1905 # Check for build error, and raise exception if one\r
1906 # has been signaled.\r
1907 #\r
1908 if BuildTask.HasError():\r
1909 EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)\r
1910\r
1911 # Create MAP file when Load Fix Address is enabled.\r
1912 if self.Target in ["", "all", "fds"]:\r
1913 for Arch in Wa.ArchList:\r
1914 #\r
1915 # Check whether the set fix address is above 4G for 32bit image.\r
1916 #\r
1917 if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:\r
1918 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
1919 #\r
1920 # Get Module List\r
1921 #\r
1922 ModuleList = {}\r
1923 for Pa in Wa.AutoGenObjectList:\r
1924 for Ma in Pa.ModuleAutoGenList:\r
1925 if Ma == None:\r
1926 continue\r
1927 if not Ma.IsLibrary:\r
1928 ModuleList[Ma.Guid.upper()] = Ma\r
1929 #\r
1930 # Rebase module to the preferred memory address before GenFds\r
1931 #\r
1932 MapBuffer = StringIO('')\r
1933 if self.LoadFixAddress != 0:\r
1934 self._CollectModuleMapBuffer(MapBuffer, ModuleList)\r
1935\r
1936 if self.Fdf:\r
1937 #\r
1938 # Generate FD image if there's a FDF file found\r
1939 #\r
1940 LaunchCommand(Wa.GenFdsCommand, os.getcwd())\r
1941\r
1942 #\r
1943 # Create MAP file for all platform FVs after GenFds.\r
1944 #\r
1945 self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)\r
1946 #\r
1947 # Save MAP buffer into MAP file.\r
1948 #\r
1949 self._SaveMapFile(MapBuffer, Wa)\r
1950\r
1951 ## Generate GuidedSectionTools.txt in the FV directories.\r
1952 #\r
1953 def CreateGuidedSectionToolsFile(self):\r
1954 for BuildTarget in self.BuildTargetList:\r
1955 for ToolChain in self.ToolChainList:\r
1956 Wa = WorkspaceAutoGen(\r
1957 self.WorkspaceDir,\r
1958 self.PlatformFile,\r
1959 BuildTarget,\r
1960 ToolChain,\r
1961 self.ArchList,\r
1962 self.BuildDatabase,\r
1963 self.TargetTxt,\r
1964 self.ToolDef,\r
1965 self.Fdf,\r
1966 self.FdList,\r
1967 self.FvList,\r
1968 self.CapList,\r
1969 self.SkuId,\r
1970 self.UniFlag\r
1971 )\r
1972 FvDir = Wa.FvDir\r
1973 if not os.path.exists(FvDir):\r
1974 continue\r
1975\r
1976 for Arch in self.ArchList:\r
1977 # Build up the list of supported architectures for this build\r
1978 prefix = '%s_%s_%s_' % (BuildTarget, ToolChain, Arch)\r
1979\r
1980 # Look through the tool definitions for GUIDed tools\r
1981 guidAttribs = []\r
1982 for (attrib, value) in self.ToolDef.ToolsDefTxtDictionary.iteritems():\r
1983 if attrib.upper().endswith('_GUID'):\r
1984 split = attrib.split('_')\r
1985 thisPrefix = '_'.join(split[0:3]) + '_'\r
1986 if thisPrefix == prefix:\r
1987 guid = self.ToolDef.ToolsDefTxtDictionary[attrib]\r
1988 guid = guid.lower()\r
1989 toolName = split[3]\r
1990 path = '_'.join(split[0:4]) + '_PATH'\r
1991 path = self.ToolDef.ToolsDefTxtDictionary[path]\r
1992 path = self.GetFullPathOfTool(path)\r
1993 guidAttribs.append((guid, toolName, path))\r
1994\r
1995 # Write out GuidedSecTools.txt\r
1996 toolsFile = os.path.join(FvDir, 'GuidedSectionTools.txt')\r
1997 toolsFile = open(toolsFile, 'wt')\r
1998 for guidedSectionTool in guidAttribs:\r
1999 print >> toolsFile, ' '.join(guidedSectionTool)\r
2000 toolsFile.close()\r
2001\r
2002 ## Returns the full path of the tool.\r
2003 #\r
2004 def GetFullPathOfTool (self, tool):\r
2005 if os.path.exists(tool):\r
2006 return os.path.realpath(tool)\r
2007 else:\r
2008 # We need to search for the tool using the\r
2009 # PATH environment variable.\r
2010 for dirInPath in os.environ['PATH'].split(os.pathsep):\r
2011 foundPath = os.path.join(dirInPath, tool)\r
2012 if os.path.exists(foundPath):\r
2013 return os.path.realpath(foundPath)\r
2014\r
2015 # If the tool was not found in the path then we just return\r
2016 # the input tool.\r
2017 return tool\r
2018\r
2019 ## Launch the module or platform build\r
2020 #\r
2021 def Launch(self):\r
2022 if not self.ModuleFile:\r
2023 if not self.SpawnMode or self.Target not in ["", "all"]:\r
2024 self.SpawnMode = False\r
2025 self._BuildPlatform()\r
2026 else:\r
2027 self._MultiThreadBuildPlatform()\r
2028 self.CreateGuidedSectionToolsFile()\r
2029 else:\r
2030 self.SpawnMode = False\r
2031 self._BuildModule()\r
2032\r
2033 if self.Target == 'cleanall':\r
2034 self.Db.Close()\r
2035 RemoveDirectory(os.path.dirname(GlobalData.gDatabasePath), True)\r
2036\r
2037 def CreateAsBuiltInf(self):\r
2038 for Module in self.BuildModules:\r
2039 Module.CreateAsBuiltInf()\r
2040 self.BuildModules = []\r
2041 ## Do some clean-up works when error occurred\r
2042 def Relinquish(self):\r
2043 OldLogLevel = EdkLogger.GetLevel()\r
2044 EdkLogger.SetLevel(EdkLogger.ERROR)\r
2045 #self.DumpBuildData()\r
2046 Utils.Progressor.Abort()\r
2047 if self.SpawnMode == True:\r
2048 BuildTask.Abort()\r
2049 EdkLogger.SetLevel(OldLogLevel)\r
2050\r
2051 def DumpBuildData(self):\r
2052 CacheDirectory = os.path.dirname(GlobalData.gDatabasePath)\r
2053 Utils.CreateDirectory(CacheDirectory)\r
2054 Utils.DataDump(Utils.gFileTimeStampCache, os.path.join(CacheDirectory, "gFileTimeStampCache"))\r
2055 Utils.DataDump(Utils.gDependencyDatabase, os.path.join(CacheDirectory, "gDependencyDatabase"))\r
2056\r
2057 def RestoreBuildData(self):\r
2058 FilePath = os.path.join(os.path.dirname(GlobalData.gDatabasePath), "gFileTimeStampCache")\r
2059 if Utils.gFileTimeStampCache == {} and os.path.isfile(FilePath):\r
2060 Utils.gFileTimeStampCache = Utils.DataRestore(FilePath)\r
2061 if Utils.gFileTimeStampCache == None:\r
2062 Utils.gFileTimeStampCache = {}\r
2063\r
2064 FilePath = os.path.join(os.path.dirname(GlobalData.gDatabasePath), "gDependencyDatabase")\r
2065 if Utils.gDependencyDatabase == {} and os.path.isfile(FilePath):\r
2066 Utils.gDependencyDatabase = Utils.DataRestore(FilePath)\r
2067 if Utils.gDependencyDatabase == None:\r
2068 Utils.gDependencyDatabase = {}\r
2069\r
2070def ParseDefines(DefineList=[]):\r
2071 DefineDict = {}\r
2072 if DefineList != None:\r
2073 for Define in DefineList:\r
2074 DefineTokenList = Define.split("=", 1)\r
2075 if not GlobalData.gMacroNamePattern.match(DefineTokenList[0]):\r
2076 EdkLogger.error('build', FORMAT_INVALID,\r
2077 "The macro name must be in the pattern [A-Z][A-Z0-9_]*",\r
2078 ExtraData=DefineTokenList[0])\r
2079\r
2080 if len(DefineTokenList) == 1:\r
2081 DefineDict[DefineTokenList[0]] = "TRUE"\r
2082 else:\r
2083 DefineDict[DefineTokenList[0]] = DefineTokenList[1].strip()\r
2084 return DefineDict\r
2085\r
2086gParamCheck = []\r
2087def SingleCheckCallback(option, opt_str, value, parser):\r
2088 if option not in gParamCheck:\r
2089 setattr(parser.values, option.dest, value)\r
2090 gParamCheck.append(option)\r
2091 else:\r
2092 parser.error("Option %s only allows one instance in command line!" % option)\r
2093\r
2094## Parse command line options\r
2095#\r
2096# Using standard Python module optparse to parse command line option of this tool.\r
2097#\r
2098# @retval Opt A optparse.Values object containing the parsed options\r
2099# @retval Args Target of build command\r
2100#\r
2101def MyOptionParser():\r
2102 Parser = OptionParser(description=__copyright__, version=__version__, prog="build.exe", usage="%prog [options] [all|fds|genc|genmake|clean|cleanall|cleanlib|modules|libraries|run]")\r
2103 Parser.add_option("-a", "--arch", action="append", type="choice", choices=['IA32', 'X64', 'IPF', 'EBC', 'ARM', 'AARCH64'], dest="TargetArch",\r
2104 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
2105 Parser.add_option("-p", "--platform", action="callback", type="string", dest="PlatformFile", callback=SingleCheckCallback,\r
2106 help="Build the platform specified by the DSC file name argument, overriding target.txt's ACTIVE_PLATFORM definition.")\r
2107 Parser.add_option("-m", "--module", action="callback", type="string", dest="ModuleFile", callback=SingleCheckCallback,\r
2108 help="Build the module specified by the INF file name argument.")\r
2109 Parser.add_option("-b", "--buildtarget", type="string", dest="BuildTarget", help="Using the TARGET to build the platform, overriding target.txt's TARGET definition.",\r
2110 action="append")\r
2111 Parser.add_option("-t", "--tagname", action="append", type="string", dest="ToolChain",\r
2112 help="Using the Tool Chain Tagname to build the platform, overriding target.txt's TOOL_CHAIN_TAG definition.")\r
2113 Parser.add_option("-x", "--sku-id", action="callback", type="string", dest="SkuId", callback=SingleCheckCallback,\r
2114 help="Using this name of SKU ID to build the platform, overriding SKUID_IDENTIFIER in DSC file.")\r
2115\r
2116 Parser.add_option("-n", action="callback", type="int", dest="ThreadNumber", callback=SingleCheckCallback,\r
2117 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
2118\r
2119 Parser.add_option("-f", "--fdf", action="callback", type="string", dest="FdfFile", callback=SingleCheckCallback,\r
2120 help="The name of the FDF file to use, which overrides the setting in the DSC file.")\r
2121 Parser.add_option("-r", "--rom-image", action="append", type="string", dest="RomImage", default=[],\r
2122 help="The name of FD to be generated. The name must be from [FD] section in FDF file.")\r
2123 Parser.add_option("-i", "--fv-image", action="append", type="string", dest="FvImage", default=[],\r
2124 help="The name of FV to be generated. The name must be from [FV] section in FDF file.")\r
2125 Parser.add_option("-C", "--capsule-image", action="append", type="string", dest="CapName", default=[],\r
2126 help="The name of Capsule to be generated. The name must be from [Capsule] section in FDF file.")\r
2127 Parser.add_option("-u", "--skip-autogen", action="store_true", dest="SkipAutoGen", help="Skip AutoGen step.")\r
2128 Parser.add_option("-e", "--re-parse", action="store_true", dest="Reparse", help="Re-parse all meta-data files.")\r
2129\r
2130 Parser.add_option("-c", "--case-insensitive", action="store_true", dest="CaseInsensitive", default=False, help="Don't check case of file name.")\r
2131\r
2132 Parser.add_option("-w", "--warning-as-error", action="store_true", dest="WarningAsError", help="Treat warning in tools as error.")\r
2133 Parser.add_option("-j", "--log", action="store", dest="LogFile", help="Put log in specified file as well as on console.")\r
2134\r
2135 Parser.add_option("-s", "--silent", action="store_true", type=None, dest="SilentMode",\r
2136 help="Make use of silent mode of (n)make.")\r
2137 Parser.add_option("-q", "--quiet", action="store_true", type=None, help="Disable all messages except FATAL ERRORS.")\r
2138 Parser.add_option("-v", "--verbose", action="store_true", type=None, help="Turn on verbose output with informational messages printed, "\\r
2139 "including library instances selected, final dependency expression, "\\r
2140 "and warning messages, etc.")\r
2141 Parser.add_option("-d", "--debug", action="store", type="int", help="Enable debug messages at specified level.")\r
2142 Parser.add_option("-D", "--define", action="append", type="string", dest="Macros", help="Macro: \"Name [= Value]\".")\r
2143\r
2144 Parser.add_option("-y", "--report-file", action="store", dest="ReportFile", help="Create/overwrite the report to the specified filename.")\r
2145 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
2146 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
2147 "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
2148 Parser.add_option("-F", "--flag", action="store", type="string", dest="Flag",\r
2149 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
2150 "This option can also be specified by setting *_*_*_BUILD_FLAGS in [BuildOptions] section of platform DSC. If they are both specified, this value "\\r
2151 "will override the setting in [BuildOptions] section of platform DSC.")\r
2152 Parser.add_option("-N", "--no-cache", action="store_true", dest="DisableCache", default=False, help="Disable build cache mechanism")\r
2153 Parser.add_option("--conf", action="store", type="string", dest="ConfDirectory", help="Specify the customized Conf directory.")\r
2154 Parser.add_option("--check-usage", action="store_true", dest="CheckUsage", default=False, help="Check usage content of entries listed in INF file.")\r
2155 Parser.add_option("--ignore-sources", action="store_true", dest="IgnoreSources", default=False, help="Focus to a binary build and ignore all source files")\r
2156 Parser.add_option("--pcd", action="append", dest="OptionPcd", help="Set PCD value by command line. Format: \"PcdName=Value\" ")\r
2157 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
2158\r
2159 (Opt, Args) = Parser.parse_args()\r
2160 return (Opt, Args)\r
2161\r
2162## Tool entrance method\r
2163#\r
2164# This method mainly dispatch specific methods per the command line options.\r
2165# If no error found, return zero value so the caller of this tool can know\r
2166# if it's executed successfully or not.\r
2167#\r
2168# @retval 0 Tool was successful\r
2169# @retval 1 Tool failed\r
2170#\r
2171def Main():\r
2172 StartTime = time.time()\r
2173\r
2174 # Initialize log system\r
2175 EdkLogger.Initialize()\r
2176 GlobalData.gCommand = sys.argv[1:]\r
2177 #\r
2178 # Parse the options and args\r
2179 #\r
2180 (Option, Target) = MyOptionParser()\r
2181 GlobalData.gOptions = Option\r
2182 GlobalData.gCaseInsensitive = Option.CaseInsensitive\r
2183\r
2184 # Set log level\r
2185 if Option.verbose != None:\r
2186 EdkLogger.SetLevel(EdkLogger.VERBOSE)\r
2187 elif Option.quiet != None:\r
2188 EdkLogger.SetLevel(EdkLogger.QUIET)\r
2189 elif Option.debug != None:\r
2190 EdkLogger.SetLevel(Option.debug + 1)\r
2191 else:\r
2192 EdkLogger.SetLevel(EdkLogger.INFO)\r
2193\r
2194 if Option.LogFile != None:\r
2195 EdkLogger.SetLogFile(Option.LogFile)\r
2196\r
2197 if Option.WarningAsError == True:\r
2198 EdkLogger.SetWarningAsError()\r
2199\r
2200 if platform.platform().find("Windows") >= 0:\r
2201 GlobalData.gIsWindows = True\r
2202 else:\r
2203 GlobalData.gIsWindows = False\r
2204\r
2205 EdkLogger.quiet("Build environment: %s" % platform.platform())\r
2206 EdkLogger.quiet(time.strftime("Build start time: %H:%M:%S, %b.%d %Y\n", time.localtime()));\r
2207 ReturnCode = 0\r
2208 MyBuild = None\r
2209 BuildError = True\r
2210 try:\r
2211 if len(Target) == 0:\r
2212 Target = "all"\r
2213 elif len(Target) >= 2:\r
2214 EdkLogger.error("build", OPTION_NOT_SUPPORTED, "More than one targets are not supported.",\r
2215 ExtraData="Please select one of: %s" % (' '.join(gSupportedTarget)))\r
2216 else:\r
2217 Target = Target[0].lower()\r
2218\r
2219 if Target not in gSupportedTarget:\r
2220 EdkLogger.error("build", OPTION_NOT_SUPPORTED, "Not supported target [%s]." % Target,\r
2221 ExtraData="Please select one of: %s" % (' '.join(gSupportedTarget)))\r
2222\r
2223 #\r
2224 # Check environment variable: EDK_TOOLS_PATH, WORKSPACE, PATH\r
2225 #\r
2226 CheckEnvVariable()\r
2227 GlobalData.gCommandLineDefines.update(ParseDefines(Option.Macros))\r
2228\r
2229 Workspace = os.getenv("WORKSPACE")\r
2230 #\r
2231 # Get files real name in workspace dir\r
2232 #\r
2233 GlobalData.gAllFiles = Utils.DirCache(Workspace)\r
2234\r
2235 WorkingDirectory = os.getcwd()\r
2236 if not Option.ModuleFile:\r
2237 FileList = glob.glob(os.path.normpath(os.path.join(WorkingDirectory, '*.inf')))\r
2238 FileNum = len(FileList)\r
2239 if FileNum >= 2:\r
2240 EdkLogger.error("build", OPTION_NOT_SUPPORTED, "There are %d INF files in %s." % (FileNum, WorkingDirectory),\r
2241 ExtraData="Please use '-m <INF_FILE_PATH>' switch to choose one.")\r
2242 elif FileNum == 1:\r
2243 Option.ModuleFile = NormFile(FileList[0], Workspace)\r
2244\r
2245 if Option.ModuleFile:\r
2246 if os.path.isabs (Option.ModuleFile):\r
2247 if os.path.normcase (os.path.normpath(Option.ModuleFile)).find (Workspace) == 0:\r
2248 Option.ModuleFile = NormFile(os.path.normpath(Option.ModuleFile), Workspace)\r
2249 Option.ModuleFile = PathClass(Option.ModuleFile, Workspace)\r
2250 ErrorCode, ErrorInfo = Option.ModuleFile.Validate(".inf", False)\r
2251 if ErrorCode != 0:\r
2252 EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)\r
2253\r
2254 if Option.PlatformFile != None:\r
2255 if os.path.isabs (Option.PlatformFile):\r
2256 if os.path.normcase (os.path.normpath(Option.PlatformFile)).find (Workspace) == 0:\r
2257 Option.PlatformFile = NormFile(os.path.normpath(Option.PlatformFile), Workspace)\r
2258 Option.PlatformFile = PathClass(Option.PlatformFile, Workspace)\r
2259\r
2260 if Option.FdfFile != None:\r
2261 if os.path.isabs (Option.FdfFile):\r
2262 if os.path.normcase (os.path.normpath(Option.FdfFile)).find (Workspace) == 0:\r
2263 Option.FdfFile = NormFile(os.path.normpath(Option.FdfFile), Workspace)\r
2264 Option.FdfFile = PathClass(Option.FdfFile, Workspace)\r
2265 ErrorCode, ErrorInfo = Option.FdfFile.Validate(".fdf", False)\r
2266 if ErrorCode != 0:\r
2267 EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)\r
2268\r
2269 if Option.Flag != None and Option.Flag not in ['-c', '-s']:\r
2270 EdkLogger.error("build", OPTION_VALUE_INVALID, "UNI flag must be one of -c or -s")\r
2271\r
2272 MyBuild = Build(Target, Workspace, Option)\r
2273 GlobalData.gCommandLineDefines['ARCH'] = ' '.join(MyBuild.ArchList)\r
2274 if not (MyBuild.LaunchPrebuildFlag and os.path.exists(MyBuild.PlatformBuildPath)):\r
2275 MyBuild.Launch()\r
2276 # Drop temp tables to avoid database locked.\r
2277 for TmpTableName in TmpTableDict:\r
2278 SqlCommand = """drop table IF EXISTS %s""" % TmpTableName\r
2279 TmpTableDict[TmpTableName].execute(SqlCommand)\r
2280 #MyBuild.DumpBuildData()\r
2281 #\r
2282 # All job done, no error found and no exception raised\r
2283 #\r
2284 BuildError = False\r
2285 except FatalError, X:\r
2286 if MyBuild != None:\r
2287 # for multi-thread build exits safely\r
2288 MyBuild.Relinquish()\r
2289 if Option != None and Option.debug != None:\r
2290 EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())\r
2291 ReturnCode = X.args[0]\r
2292 except Warning, X:\r
2293 # error from Fdf parser\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 else:\r
2300 EdkLogger.error(X.ToolName, FORMAT_INVALID, File=X.FileName, Line=X.LineNumber, ExtraData=X.Message, RaiseError=False)\r
2301 ReturnCode = FORMAT_INVALID\r
2302 except KeyboardInterrupt:\r
2303 ReturnCode = ABORT_ERROR\r
2304 if Option != None and Option.debug != None:\r
2305 EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())\r
2306 except:\r
2307 if MyBuild != None:\r
2308 # for multi-thread build exits safely\r
2309 MyBuild.Relinquish()\r
2310\r
2311 # try to get the meta-file from the object causing exception\r
2312 Tb = sys.exc_info()[-1]\r
2313 MetaFile = GlobalData.gProcessingFile\r
2314 while Tb != None:\r
2315 if 'self' in Tb.tb_frame.f_locals and hasattr(Tb.tb_frame.f_locals['self'], 'MetaFile'):\r
2316 MetaFile = Tb.tb_frame.f_locals['self'].MetaFile\r
2317 Tb = Tb.tb_next\r
2318 EdkLogger.error(\r
2319 "\nbuild",\r
2320 CODE_ERROR,\r
2321 "Unknown fatal error when processing [%s]" % MetaFile,\r
2322 ExtraData="\n(Please send email to edk2-devel@lists.01.org for help, attaching following call stack trace!)\n",\r
2323 RaiseError=False\r
2324 )\r
2325 EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())\r
2326 ReturnCode = CODE_ERROR\r
2327 finally:\r
2328 Utils.Progressor.Abort()\r
2329 Utils.ClearDuplicatedInf()\r
2330\r
2331 if ReturnCode == 0:\r
2332 try:\r
2333 MyBuild.LaunchPostbuild()\r
2334 Conclusion = "Done"\r
2335 except:\r
2336 Conclusion = "Failed"\r
2337 elif ReturnCode == ABORT_ERROR:\r
2338 Conclusion = "Aborted"\r
2339 else:\r
2340 Conclusion = "Failed"\r
2341 FinishTime = time.time()\r
2342 BuildDuration = time.gmtime(int(round(FinishTime - StartTime)))\r
2343 BuildDurationStr = ""\r
2344 if BuildDuration.tm_yday > 1:\r
2345 BuildDurationStr = time.strftime("%H:%M:%S", BuildDuration) + ", %d day(s)" % (BuildDuration.tm_yday - 1)\r
2346 else:\r
2347 BuildDurationStr = time.strftime("%H:%M:%S", BuildDuration)\r
2348 if MyBuild != None:\r
2349 if not BuildError:\r
2350 MyBuild.BuildReport.GenerateReport(BuildDurationStr)\r
2351 MyBuild.Db.Close()\r
2352 EdkLogger.SetLevel(EdkLogger.QUIET)\r
2353 EdkLogger.quiet("\n- %s -" % Conclusion)\r
2354 EdkLogger.quiet(time.strftime("Build end time: %H:%M:%S, %b.%d %Y", time.localtime()))\r
2355 EdkLogger.quiet("Build total time: %s\n" % BuildDurationStr)\r
2356 return ReturnCode\r
2357\r
2358if __name__ == '__main__':\r
2359 r = Main()\r
2360 ## 0-127 is a safe return range, and 1 is a standard default error\r
2361 if r < 0 or r > 127: r = 1\r
2362 sys.exit(r)\r
2363\r
EFI Development Kit II mirror for PVE