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