]> git.proxmox.com Git - mirror_edk2.git/blob - BaseTools/Source/Python/build/build.py
projects / mirror_edk2.git / blob
? search:


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