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