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