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