2 # build a platform or a module
4 # Copyright (c) 2014, Hewlett-Packard Development Company, L.P.<BR>
5 # Copyright (c) 2007 - 2019, Intel Corporation. All rights reserved.<BR>
6 # Copyright (c) 2018, Hewlett Packard Enterprise Development, L.P.<BR>
8 # SPDX-License-Identifier: BSD-2-Clause-Patent
14 from __future__
import print_function
15 import Common
.LongFilePathOs
as os
22 import encodings
.ascii
23 import multiprocessing
26 from threading
import *
28 from optparse
import OptionParser
29 from subprocess
import *
30 from Common
import Misc
as Utils
32 from Common
.LongFilePathSupport
import OpenLongFilePath
as open
33 from Common
.TargetTxtClassObject
import TargetTxtClassObject
34 from Common
.ToolDefClassObject
import ToolDefClassObject
35 from Common
.DataType
import *
36 from Common
.BuildVersion
import gBUILD_VERSION
37 from AutoGen
.AutoGen
import *
38 from Common
.BuildToolError
import *
39 from Workspace
.WorkspaceDatabase
import WorkspaceDatabase
40 from Common
.MultipleWorkspace
import MultipleWorkspace
as mws
42 from BuildReport
import BuildReport
43 from GenPatchPcdTable
.GenPatchPcdTable
import *
44 from PatchPcdValue
.PatchPcdValue
import *
46 import Common
.EdkLogger
47 import Common
.GlobalData
as GlobalData
48 from GenFds
.GenFds
import GenFds
, GenFdsApi
50 from collections
import OrderedDict
, defaultdict
52 # Version and Copyright
53 VersionNumber
= "0.60" + ' ' + gBUILD_VERSION
54 __version__
= "%prog Version " + VersionNumber
55 __copyright__
= "Copyright (c) 2007 - 2018, Intel Corporation All rights reserved."
57 ## standard targets of build command
58 gSupportedTarget
= ['all', 'genc', 'genmake', 'modules', 'libraries', 'fds', 'clean', 'cleanall', 'cleanlib', 'run']
60 ## build configuration file
61 gBuildConfiguration
= "target.txt"
62 gToolsDefinition
= "tools_def.txt"
64 TemporaryTablePattern
= re
.compile(r
'^_\d+_\d+_[a-fA-F0-9]+$')
67 ## Check environment PATH variable to make sure the specified tool is found
69 # If the tool is found in the PATH, then True is returned
70 # Otherwise, False is returned
72 def IsToolInPath(tool
):
73 if 'PATHEXT' in os
.environ
:
74 extns
= os
.environ
['PATHEXT'].split(os
.path
.pathsep
)
77 for pathDir
in os
.environ
['PATH'].split(os
.path
.pathsep
):
79 if os
.path
.exists(os
.path
.join(pathDir
, tool
+ ext
)):
83 ## Check environment variables
85 # Check environment variables that must be set for build. Currently they are
87 # WORKSPACE The directory all packages/platforms start from
88 # EDK_TOOLS_PATH The directory contains all tools needed by the build
89 # PATH $(EDK_TOOLS_PATH)/Bin/<sys> must be set in PATH
91 # If any of above environment variable is not set or has error, the build
94 def CheckEnvVariable():
96 if "WORKSPACE" not in os
.environ
:
97 EdkLogger
.error("build", ATTRIBUTE_NOT_AVAILABLE
, "Environment variable not found",
98 ExtraData
="WORKSPACE")
100 WorkspaceDir
= os
.path
.normcase(os
.path
.normpath(os
.environ
["WORKSPACE"]))
101 if not os
.path
.exists(WorkspaceDir
):
102 EdkLogger
.error("build", FILE_NOT_FOUND
, "WORKSPACE doesn't exist", ExtraData
=WorkspaceDir
)
103 elif ' ' in WorkspaceDir
:
104 EdkLogger
.error("build", FORMAT_NOT_SUPPORTED
, "No space is allowed in WORKSPACE path",
105 ExtraData
=WorkspaceDir
)
106 os
.environ
["WORKSPACE"] = WorkspaceDir
108 # set multiple workspace
109 PackagesPath
= os
.getenv("PACKAGES_PATH")
110 mws
.setWs(WorkspaceDir
, PackagesPath
)
111 if mws
.PACKAGES_PATH
:
112 for Path
in mws
.PACKAGES_PATH
:
113 if not os
.path
.exists(Path
):
114 EdkLogger
.error("build", FILE_NOT_FOUND
, "One Path in PACKAGES_PATH doesn't exist", ExtraData
=Path
)
116 EdkLogger
.error("build", FORMAT_NOT_SUPPORTED
, "No space is allowed in PACKAGES_PATH", ExtraData
=Path
)
119 os
.environ
["EDK_TOOLS_PATH"] = os
.path
.normcase(os
.environ
["EDK_TOOLS_PATH"])
121 # check EDK_TOOLS_PATH
122 if "EDK_TOOLS_PATH" not in os
.environ
:
123 EdkLogger
.error("build", ATTRIBUTE_NOT_AVAILABLE
, "Environment variable not found",
124 ExtraData
="EDK_TOOLS_PATH")
127 if "PATH" not in os
.environ
:
128 EdkLogger
.error("build", ATTRIBUTE_NOT_AVAILABLE
, "Environment variable not found",
131 GlobalData
.gWorkspace
= WorkspaceDir
133 GlobalData
.gGlobalDefines
["WORKSPACE"] = WorkspaceDir
134 GlobalData
.gGlobalDefines
["EDK_TOOLS_PATH"] = os
.environ
["EDK_TOOLS_PATH"]
136 ## Get normalized file path
138 # Convert the path to be local format, and remove the WORKSPACE path at the
139 # beginning if the file path is given in full path.
141 # @param FilePath File path to be normalized
142 # @param Workspace Workspace path which the FilePath will be checked against
144 # @retval string The normalized file path
146 def NormFile(FilePath
, Workspace
):
147 # check if the path is absolute or relative
148 if os
.path
.isabs(FilePath
):
149 FileFullPath
= os
.path
.normpath(FilePath
)
151 FileFullPath
= os
.path
.normpath(mws
.join(Workspace
, FilePath
))
152 Workspace
= mws
.getWs(Workspace
, FilePath
)
154 # check if the file path exists or not
155 if not os
.path
.isfile(FileFullPath
):
156 EdkLogger
.error("build", FILE_NOT_FOUND
, ExtraData
="\t%s (Please give file in absolute path or relative to WORKSPACE)" % FileFullPath
)
158 # remove workspace directory from the beginning part of the file path
159 if Workspace
[-1] in ["\\", "/"]:
160 return FileFullPath
[len(Workspace
):]
162 return FileFullPath
[(len(Workspace
) + 1):]
164 ## Get the output of an external program
166 # This is the entrance method of thread reading output of an external program and
167 # putting them in STDOUT/STDERR of current program.
169 # @param From The stream message read from
170 # @param To The stream message put on
171 # @param ExitFlag The flag used to indicate stopping reading
173 def ReadMessage(From
, To
, ExitFlag
):
175 # read one line a time
176 Line
= From
.readline()
177 # empty string means "end"
178 if Line
is not None and Line
!= b
"":
179 To(Line
.rstrip().decode(encoding
='utf-8', errors
='ignore'))
185 ## Launch an external program
187 # This method will call subprocess.Popen to execute an external program with
188 # given options in specified directory. Because of the dead-lock issue during
189 # redirecting output of the external program, threads are used to to do the
192 # @param Command A list or string containing the call of the program
193 # @param WorkingDir The directory in which the program will be running
195 def LaunchCommand(Command
, WorkingDir
):
196 BeginTime
= time
.time()
197 # if working directory doesn't exist, Popen() will raise an exception
198 if not os
.path
.isdir(WorkingDir
):
199 EdkLogger
.error("build", FILE_NOT_FOUND
, ExtraData
=WorkingDir
)
201 # Command is used as the first Argument in following Popen().
202 # It could be a string or sequence. We find that if command is a string in following Popen(),
203 # ubuntu may fail with an error message that the command is not found.
204 # So here we may need convert command from string to list instance.
205 if platform
.system() != 'Windows':
206 if not isinstance(Command
, list):
207 Command
= Command
.split()
208 Command
= ' '.join(Command
)
211 EndOfProcedure
= None
214 Proc
= Popen(Command
, stdout
=PIPE
, stderr
=PIPE
, env
=os
.environ
, cwd
=WorkingDir
, bufsize
=-1, shell
=True)
216 # launch two threads to read the STDOUT and STDERR
217 EndOfProcedure
= Event()
218 EndOfProcedure
.clear()
220 StdOutThread
= Thread(target
=ReadMessage
, args
=(Proc
.stdout
, EdkLogger
.info
, EndOfProcedure
))
221 StdOutThread
.setName("STDOUT-Redirector")
222 StdOutThread
.setDaemon(False)
226 StdErrThread
= Thread(target
=ReadMessage
, args
=(Proc
.stderr
, EdkLogger
.quiet
, EndOfProcedure
))
227 StdErrThread
.setName("STDERR-Redirector")
228 StdErrThread
.setDaemon(False)
231 # waiting for program exit
233 except: # in case of aborting
234 # terminate the threads redirecting the program output
235 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
236 if EndOfProcedure
is not None:
239 if not isinstance(Command
, type("")):
240 Command
= " ".join(Command
)
241 EdkLogger
.error("build", COMMAND_FAILURE
, "Failed to start command", ExtraData
="%s [%s]" % (Command
, WorkingDir
))
248 # check the return code of the program
249 if Proc
.returncode
!= 0:
250 if not isinstance(Command
, type("")):
251 Command
= " ".join(Command
)
252 # print out the Response file and its content when make failure
253 RespFile
= os
.path
.join(WorkingDir
, 'OUTPUT', 'respfilelist.txt')
254 if os
.path
.isfile(RespFile
):
256 RespContent
= f
.read()
258 EdkLogger
.info(RespContent
)
260 EdkLogger
.error("build", COMMAND_FAILURE
, ExtraData
="%s [%s]" % (Command
, WorkingDir
))
261 return "%dms" % (int(round((time
.time() - BeginTime
) * 1000)))
263 ## The smallest unit that can be built in multi-thread build mode
265 # This is the base class of build unit. The "Obj" parameter must provide
266 # __str__(), __eq__() and __hash__() methods. Otherwise there could be build units
269 # Currently the "Obj" should be only ModuleAutoGen or PlatformAutoGen objects.
274 # @param self The object pointer
275 # @param Obj The object the build is working on
276 # @param Target The build target name, one of gSupportedTarget
277 # @param Dependency The BuildUnit(s) which must be completed in advance
278 # @param WorkingDir The directory build command starts in
280 def __init__(self
, Obj
, BuildCommand
, Target
, Dependency
, WorkingDir
="."):
281 self
.BuildObject
= Obj
282 self
.Dependency
= Dependency
283 self
.WorkingDir
= WorkingDir
285 self
.BuildCommand
= BuildCommand
287 EdkLogger
.error("build", OPTION_MISSING
,
288 "No build command found for this module. "
289 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %
290 (Obj
.BuildTarget
, Obj
.ToolChain
, Obj
.Arch
),
296 # It just returns the string representation of self.BuildObject
298 # @param self The object pointer
301 return str(self
.BuildObject
)
303 ## "==" operator method
305 # It just compares self.BuildObject with "Other". So self.BuildObject must
306 # provide its own __eq__() method.
308 # @param self The object pointer
309 # @param Other The other BuildUnit object compared to
311 def __eq__(self
, Other
):
312 return Other
and self
.BuildObject
== Other
.BuildObject \
313 and Other
.BuildObject \
314 and self
.BuildObject
.Arch
== Other
.BuildObject
.Arch
318 # It just returns the hash value of self.BuildObject which must be hashable.
320 # @param self The object pointer
323 return hash(self
.BuildObject
) + hash(self
.BuildObject
.Arch
)
326 return repr(self
.BuildObject
)
328 ## The smallest module unit that can be built by nmake/make command in multi-thread build mode
330 # This class is for module build by nmake/make build system. The "Obj" parameter
331 # must provide __str__(), __eq__() and __hash__() methods. Otherwise there could
332 # be make units missing build.
334 # Currently the "Obj" should be only ModuleAutoGen object.
336 class ModuleMakeUnit(BuildUnit
):
339 # @param self The object pointer
340 # @param Obj The ModuleAutoGen object the build is working on
341 # @param Target The build target name, one of gSupportedTarget
343 def __init__(self
, Obj
, Target
):
344 Dependency
= [ModuleMakeUnit(La
, Target
) for La
in Obj
.LibraryAutoGenList
]
345 BuildUnit
.__init
__(self
, Obj
, Obj
.BuildCommand
, Target
, Dependency
, Obj
.MakeFileDir
)
346 if Target
in [None, "", "all"]:
347 self
.Target
= "tbuild"
349 ## The smallest platform unit that can be built by nmake/make command in multi-thread build mode
351 # This class is for platform build by nmake/make build system. The "Obj" parameter
352 # must provide __str__(), __eq__() and __hash__() methods. Otherwise there could
353 # be make units missing build.
355 # Currently the "Obj" should be only PlatformAutoGen object.
357 class PlatformMakeUnit(BuildUnit
):
360 # @param self The object pointer
361 # @param Obj The PlatformAutoGen object the build is working on
362 # @param Target The build target name, one of gSupportedTarget
364 def __init__(self
, Obj
, Target
):
365 Dependency
= [ModuleMakeUnit(Lib
, Target
) for Lib
in self
.BuildObject
.LibraryAutoGenList
]
366 Dependency
.extend([ModuleMakeUnit(Mod
, Target
) for Mod
in self
.BuildObject
.ModuleAutoGenList
])
367 BuildUnit
.__init
__(self
, Obj
, Obj
.BuildCommand
, Target
, Dependency
, Obj
.MakeFileDir
)
369 ## The class representing the task of a module build or platform build
371 # This class manages the build tasks in multi-thread build mode. Its jobs include
372 # scheduling thread running, catching thread error, monitor the thread status, etc.
375 # queue for tasks waiting for schedule
376 _PendingQueue
= OrderedDict()
377 _PendingQueueLock
= threading
.Lock()
379 # queue for tasks ready for running
380 _ReadyQueue
= OrderedDict()
381 _ReadyQueueLock
= threading
.Lock()
383 # queue for run tasks
384 _RunningQueue
= OrderedDict()
385 _RunningQueueLock
= threading
.Lock()
387 # queue containing all build tasks, in case duplicate build
388 _TaskQueue
= OrderedDict()
390 # flag indicating error occurs in a running thread
391 _ErrorFlag
= threading
.Event()
395 # BoundedSemaphore object used to control the number of running threads
398 # flag indicating if the scheduler is started or not
399 _SchedulerStopped
= threading
.Event()
400 _SchedulerStopped
.set()
402 ## Start the task scheduler thread
404 # @param MaxThreadNumber The maximum thread number
405 # @param ExitFlag Flag used to end the scheduler
408 def StartScheduler(MaxThreadNumber
, ExitFlag
):
409 SchedulerThread
= Thread(target
=BuildTask
.Scheduler
, args
=(MaxThreadNumber
, ExitFlag
))
410 SchedulerThread
.setName("Build-Task-Scheduler")
411 SchedulerThread
.setDaemon(False)
412 SchedulerThread
.start()
413 # wait for the scheduler to be started, especially useful in Linux
414 while not BuildTask
.IsOnGoing():
419 # @param MaxThreadNumber The maximum thread number
420 # @param ExitFlag Flag used to end the scheduler
423 def Scheduler(MaxThreadNumber
, ExitFlag
):
424 BuildTask
._SchedulerStopped
.clear()
426 # use BoundedSemaphore to control the maximum running threads
427 BuildTask
._Thread
= BoundedSemaphore(MaxThreadNumber
)
429 # scheduling loop, which will exits when no pending/ready task and
430 # indicated to do so, or there's error in running thread
432 while (len(BuildTask
._PendingQueue
) > 0 or len(BuildTask
._ReadyQueue
) > 0 \
433 or not ExitFlag
.isSet()) and not BuildTask
._ErrorFlag
.isSet():
434 EdkLogger
.debug(EdkLogger
.DEBUG_8
, "Pending Queue (%d), Ready Queue (%d)"
435 % (len(BuildTask
._PendingQueue
), len(BuildTask
._ReadyQueue
)))
437 # get all pending tasks
438 BuildTask
._PendingQueueLock
.acquire()
439 BuildObjectList
= list(BuildTask
._PendingQueue
.keys())
441 # check if their dependency is resolved, and if true, move them
444 for BuildObject
in BuildObjectList
:
445 Bt
= BuildTask
._PendingQueue
[BuildObject
]
447 BuildTask
._ReadyQueue
[BuildObject
] = BuildTask
._PendingQueue
.pop(BuildObject
)
448 BuildTask
._PendingQueueLock
.release()
450 # launch build thread until the maximum number of threads is reached
451 while not BuildTask
._ErrorFlag
.isSet():
452 # empty ready queue, do nothing further
453 if len(BuildTask
._ReadyQueue
) == 0:
456 # wait for active thread(s) exit
457 BuildTask
._Thread
.acquire(True)
459 # start a new build thread
460 Bo
, Bt
= BuildTask
._ReadyQueue
.popitem()
462 # move into running queue
463 BuildTask
._RunningQueueLock
.acquire()
464 BuildTask
._RunningQueue
[Bo
] = Bt
465 BuildTask
._RunningQueueLock
.release()
474 # wait for all running threads exit
475 if BuildTask
._ErrorFlag
.isSet():
476 EdkLogger
.quiet("\nWaiting for all build threads exit...")
477 # while not BuildTask._ErrorFlag.isSet() and \
478 while len(BuildTask
._RunningQueue
) > 0:
479 EdkLogger
.verbose("Waiting for thread ending...(%d)" % len(BuildTask
._RunningQueue
))
480 EdkLogger
.debug(EdkLogger
.DEBUG_8
, "Threads [%s]" % ", ".join(Th
.getName() for Th
in threading
.enumerate()))
483 except BaseException
as X
:
485 # TRICK: hide the output of threads left running, so that the user can
486 # catch the error message easily
488 EdkLogger
.SetLevel(EdkLogger
.ERROR
)
489 BuildTask
._ErrorFlag
.set()
490 BuildTask
._ErrorMessage
= "build thread scheduler error\n\t%s" % str(X
)
492 BuildTask
._PendingQueue
.clear()
493 BuildTask
._ReadyQueue
.clear()
494 BuildTask
._RunningQueue
.clear()
495 BuildTask
._TaskQueue
.clear()
496 BuildTask
._SchedulerStopped
.set()
498 ## Wait for all running method exit
501 def WaitForComplete():
502 BuildTask
._SchedulerStopped
.wait()
504 ## Check if the scheduler is running or not
508 return not BuildTask
._SchedulerStopped
.isSet()
513 if BuildTask
.IsOnGoing():
514 BuildTask
._ErrorFlag
.set()
515 BuildTask
.WaitForComplete()
517 ## Check if there's error in running thread
519 # Since the main thread cannot catch exceptions in other thread, we have to
520 # use threading.Event to communicate this formation to main thread.
524 return BuildTask
._ErrorFlag
.isSet()
526 ## Get error message in running thread
528 # Since the main thread cannot catch exceptions in other thread, we have to
529 # use a static variable to communicate this message to main thread.
532 def GetErrorMessage():
533 return BuildTask
._ErrorMessage
535 ## Factory method to create a BuildTask object
537 # This method will check if a module is building or has been built. And if
538 # true, just return the associated BuildTask object in the _TaskQueue. If
539 # not, create and return a new BuildTask object. The new BuildTask object
540 # will be appended to the _PendingQueue for scheduling later.
542 # @param BuildItem A BuildUnit object representing a build object
543 # @param Dependency The dependent build object of BuildItem
546 def New(BuildItem
, Dependency
=None):
547 if BuildItem
in BuildTask
._TaskQueue
:
548 Bt
= BuildTask
._TaskQueue
[BuildItem
]
552 Bt
._Init
(BuildItem
, Dependency
)
553 BuildTask
._TaskQueue
[BuildItem
] = Bt
555 BuildTask
._PendingQueueLock
.acquire()
556 BuildTask
._PendingQueue
[BuildItem
] = Bt
557 BuildTask
._PendingQueueLock
.release()
561 ## The real constructor of BuildTask
563 # @param BuildItem A BuildUnit object representing a build object
564 # @param Dependency The dependent build object of BuildItem
566 def _Init(self
, BuildItem
, Dependency
=None):
567 self
.BuildItem
= BuildItem
569 self
.DependencyList
= []
570 if Dependency
is None:
571 Dependency
= BuildItem
.Dependency
573 Dependency
.extend(BuildItem
.Dependency
)
574 self
.AddDependency(Dependency
)
575 # flag indicating build completes, used to avoid unnecessary re-build
576 self
.CompleteFlag
= False
578 ## Check if all dependent build tasks are completed or not
582 for Dep
in self
.DependencyList
:
583 if Dep
.CompleteFlag
== True:
590 ## Add dependent build task
592 # @param Dependency The list of dependent build objects
594 def AddDependency(self
, Dependency
):
595 for Dep
in Dependency
:
596 if not Dep
.BuildObject
.IsBinaryModule
:
597 self
.DependencyList
.append(BuildTask
.New(Dep
)) # BuildTask list
599 ## The thread wrapper of LaunchCommand function
601 # @param Command A list or string contains the call of the command
602 # @param WorkingDir The directory in which the program will be running
604 def _CommandThread(self
, Command
, WorkingDir
):
606 self
.BuildItem
.BuildObject
.BuildTime
= LaunchCommand(Command
, WorkingDir
)
607 self
.CompleteFlag
= True
610 # TRICK: hide the output of threads left running, so that the user can
611 # catch the error message easily
613 if not BuildTask
._ErrorFlag
.isSet():
614 GlobalData
.gBuildingModule
= "%s [%s, %s, %s]" % (str(self
.BuildItem
.BuildObject
),
615 self
.BuildItem
.BuildObject
.Arch
,
616 self
.BuildItem
.BuildObject
.ToolChain
,
617 self
.BuildItem
.BuildObject
.BuildTarget
619 EdkLogger
.SetLevel(EdkLogger
.ERROR
)
620 BuildTask
._ErrorFlag
.set()
621 BuildTask
._ErrorMessage
= "%s broken\n %s [%s]" % \
622 (threading
.currentThread().getName(), Command
, WorkingDir
)
623 if self
.BuildItem
.BuildObject
in GlobalData
.gModuleBuildTracking
and not BuildTask
._ErrorFlag
.isSet():
624 GlobalData
.gModuleBuildTracking
[self
.BuildItem
.BuildObject
] = True
625 # indicate there's a thread is available for another build task
626 BuildTask
._RunningQueueLock
.acquire()
627 BuildTask
._RunningQueue
.pop(self
.BuildItem
)
628 BuildTask
._RunningQueueLock
.release()
629 BuildTask
._Thread
.release()
631 ## Start build task thread
634 EdkLogger
.quiet("Building ... %s" % repr(self
.BuildItem
))
635 Command
= self
.BuildItem
.BuildCommand
+ [self
.BuildItem
.Target
]
636 self
.BuildTread
= Thread(target
=self
._CommandThread
, args
=(Command
, self
.BuildItem
.WorkingDir
))
637 self
.BuildTread
.setName("build thread")
638 self
.BuildTread
.setDaemon(False)
639 self
.BuildTread
.start()
641 ## The class contains the information related to EFI image
646 # Constructor will load all required image information.
648 # @param BaseName The full file path of image.
649 # @param Guid The GUID for image.
650 # @param Arch Arch of this image.
651 # @param OutputDir The output directory for image.
652 # @param DebugDir The debug directory for image.
653 # @param ImageClass PeImage Information
655 def __init__(self
, BaseName
, Guid
, Arch
, OutputDir
, DebugDir
, ImageClass
):
656 self
.BaseName
= BaseName
659 self
.OutputDir
= OutputDir
660 self
.DebugDir
= DebugDir
661 self
.Image
= ImageClass
662 self
.Image
.Size
= (self
.Image
.Size
// 0x1000 + 1) * 0x1000
664 ## The class implementing the EDK2 build process
666 # The build process includes:
667 # 1. Load configuration from target.txt and tools_def.txt in $(WORKSPACE)/Conf
668 # 2. Parse DSC file of active platform
669 # 3. Parse FDF file if any
670 # 4. Establish build database, including parse all other files (module, package)
671 # 5. Create AutoGen files (C code file, depex file, makefile) if necessary
672 # 6. Call build command
677 # Constructor will load all necessary configurations, parse platform, modules
678 # and packages and the establish a database for AutoGen.
680 # @param Target The build command target, one of gSupportedTarget
681 # @param WorkspaceDir The directory of workspace
682 # @param BuildOptions Build options passed from command line
684 def __init__(self
, Target
, WorkspaceDir
, BuildOptions
):
685 self
.WorkspaceDir
= WorkspaceDir
687 self
.PlatformFile
= BuildOptions
.PlatformFile
688 self
.ModuleFile
= BuildOptions
.ModuleFile
689 self
.ArchList
= BuildOptions
.TargetArch
690 self
.ToolChainList
= BuildOptions
.ToolChain
691 self
.BuildTargetList
= BuildOptions
.BuildTarget
692 self
.Fdf
= BuildOptions
.FdfFile
693 self
.FdList
= BuildOptions
.RomImage
694 self
.FvList
= BuildOptions
.FvImage
695 self
.CapList
= BuildOptions
.CapName
696 self
.SilentMode
= BuildOptions
.SilentMode
697 self
.ThreadNumber
= BuildOptions
.ThreadNumber
698 self
.SkipAutoGen
= BuildOptions
.SkipAutoGen
699 self
.Reparse
= BuildOptions
.Reparse
700 self
.SkuId
= BuildOptions
.SkuId
702 GlobalData
.gSKUID_CMD
= self
.SkuId
703 self
.ConfDirectory
= BuildOptions
.ConfDirectory
704 self
.SpawnMode
= True
705 self
.BuildReport
= BuildReport(BuildOptions
.ReportFile
, BuildOptions
.ReportType
)
706 self
.TargetTxt
= TargetTxtClassObject()
707 self
.ToolDef
= ToolDefClassObject()
711 GlobalData
.BuildOptionPcd
= BuildOptions
.OptionPcd
if BuildOptions
.OptionPcd
else []
712 #Set global flag for build mode
713 GlobalData
.gIgnoreSource
= BuildOptions
.IgnoreSources
714 GlobalData
.gUseHashCache
= BuildOptions
.UseHashCache
715 GlobalData
.gBinCacheDest
= BuildOptions
.BinCacheDest
716 GlobalData
.gBinCacheSource
= BuildOptions
.BinCacheSource
717 GlobalData
.gEnableGenfdsMultiThread
= BuildOptions
.GenfdsMultiThread
718 GlobalData
.gDisableIncludePathCheck
= BuildOptions
.DisableIncludePathCheck
720 if GlobalData
.gBinCacheDest
and not GlobalData
.gUseHashCache
:
721 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, ExtraData
="--binary-destination must be used together with --hash.")
723 if GlobalData
.gBinCacheSource
and not GlobalData
.gUseHashCache
:
724 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, ExtraData
="--binary-source must be used together with --hash.")
726 if GlobalData
.gBinCacheDest
and GlobalData
.gBinCacheSource
:
727 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, ExtraData
="--binary-destination can not be used together with --binary-source.")
729 if GlobalData
.gBinCacheSource
:
730 BinCacheSource
= os
.path
.normpath(GlobalData
.gBinCacheSource
)
731 if not os
.path
.isabs(BinCacheSource
):
732 BinCacheSource
= mws
.join(self
.WorkspaceDir
, BinCacheSource
)
733 GlobalData
.gBinCacheSource
= BinCacheSource
735 if GlobalData
.gBinCacheSource
is not None:
736 EdkLogger
.error("build", OPTION_VALUE_INVALID
, ExtraData
="Invalid value of option --binary-source.")
738 if GlobalData
.gBinCacheDest
:
739 BinCacheDest
= os
.path
.normpath(GlobalData
.gBinCacheDest
)
740 if not os
.path
.isabs(BinCacheDest
):
741 BinCacheDest
= mws
.join(self
.WorkspaceDir
, BinCacheDest
)
742 GlobalData
.gBinCacheDest
= BinCacheDest
744 if GlobalData
.gBinCacheDest
is not None:
745 EdkLogger
.error("build", OPTION_VALUE_INVALID
, ExtraData
="Invalid value of option --binary-destination.")
747 if self
.ConfDirectory
:
748 # Get alternate Conf location, if it is absolute, then just use the absolute directory name
749 ConfDirectoryPath
= os
.path
.normpath(self
.ConfDirectory
)
751 if not os
.path
.isabs(ConfDirectoryPath
):
752 # Since alternate directory name is not absolute, the alternate directory is located within the WORKSPACE
753 # This also handles someone specifying the Conf directory in the workspace. Using --conf=Conf
754 ConfDirectoryPath
= mws
.join(self
.WorkspaceDir
, ConfDirectoryPath
)
756 if "CONF_PATH" in os
.environ
:
757 ConfDirectoryPath
= os
.path
.normcase(os
.path
.normpath(os
.environ
["CONF_PATH"]))
759 # Get standard WORKSPACE/Conf use the absolute path to the WORKSPACE/Conf
760 ConfDirectoryPath
= mws
.join(self
.WorkspaceDir
, 'Conf')
761 GlobalData
.gConfDirectory
= ConfDirectoryPath
762 GlobalData
.gDatabasePath
= os
.path
.normpath(os
.path
.join(ConfDirectoryPath
, GlobalData
.gDatabasePath
))
764 self
.Db
= WorkspaceDatabase()
765 self
.BuildDatabase
= self
.Db
.BuildObject
767 self
.ToolChainFamily
= None
768 self
.LoadFixAddress
= 0
769 self
.UniFlag
= BuildOptions
.Flag
770 self
.BuildModules
= []
771 self
.HashSkipModules
= []
773 self
.LaunchPrebuildFlag
= False
774 self
.PlatformBuildPath
= os
.path
.join(GlobalData
.gConfDirectory
, '.cache', '.PlatformBuild')
775 if BuildOptions
.CommandLength
:
776 GlobalData
.gCommandMaxLength
= BuildOptions
.CommandLength
778 # print dot character during doing some time-consuming work
779 self
.Progress
= Utils
.Progressor()
780 # print current build environment and configuration
781 EdkLogger
.quiet("%-16s = %s" % ("WORKSPACE", os
.environ
["WORKSPACE"]))
782 if "PACKAGES_PATH" in os
.environ
:
783 # WORKSPACE env has been converted before. Print the same path style with WORKSPACE env.
784 EdkLogger
.quiet("%-16s = %s" % ("PACKAGES_PATH", os
.path
.normcase(os
.path
.normpath(os
.environ
["PACKAGES_PATH"]))))
785 EdkLogger
.quiet("%-16s = %s" % ("EDK_TOOLS_PATH", os
.environ
["EDK_TOOLS_PATH"]))
786 if "EDK_TOOLS_BIN" in os
.environ
:
787 # Print the same path style with WORKSPACE env.
788 EdkLogger
.quiet("%-16s = %s" % ("EDK_TOOLS_BIN", os
.path
.normcase(os
.path
.normpath(os
.environ
["EDK_TOOLS_BIN"]))))
789 EdkLogger
.quiet("%-16s = %s" % ("CONF_PATH", GlobalData
.gConfDirectory
))
790 if "PYTHON3_ENABLE" in os
.environ
:
791 PYTHON3_ENABLE
= os
.environ
["PYTHON3_ENABLE"]
792 if PYTHON3_ENABLE
!= "TRUE":
793 PYTHON3_ENABLE
= "FALSE"
794 EdkLogger
.quiet("%-16s = %s" % ("PYTHON3_ENABLE", PYTHON3_ENABLE
))
795 if "PYTHON_COMMAND" in os
.environ
:
796 EdkLogger
.quiet("%-16s = %s" % ("PYTHON_COMMAND", os
.environ
["PYTHON_COMMAND"]))
800 EdkLogger
.quiet("%-16s = %s" % ("PREBUILD", self
.Prebuild
))
802 EdkLogger
.quiet("%-16s = %s" % ("POSTBUILD", self
.Postbuild
))
804 self
.LaunchPrebuild()
805 self
.TargetTxt
= TargetTxtClassObject()
806 self
.ToolDef
= ToolDefClassObject()
807 if not (self
.LaunchPrebuildFlag
and os
.path
.exists(self
.PlatformBuildPath
)):
811 os
.chdir(self
.WorkspaceDir
)
813 ## Load configuration
815 # This method will parse target.txt and get the build configurations.
817 def LoadConfiguration(self
):
819 # Check target.txt and tools_def.txt and Init them
821 BuildConfigurationFile
= os
.path
.normpath(os
.path
.join(GlobalData
.gConfDirectory
, gBuildConfiguration
))
822 if os
.path
.isfile(BuildConfigurationFile
) == True:
823 StatusCode
= self
.TargetTxt
.LoadTargetTxtFile(BuildConfigurationFile
)
825 ToolDefinitionFile
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_TOOL_CHAIN_CONF
]
826 if ToolDefinitionFile
== '':
827 ToolDefinitionFile
= gToolsDefinition
828 ToolDefinitionFile
= os
.path
.normpath(mws
.join(self
.WorkspaceDir
, 'Conf', ToolDefinitionFile
))
829 if os
.path
.isfile(ToolDefinitionFile
) == True:
830 StatusCode
= self
.ToolDef
.LoadToolDefFile(ToolDefinitionFile
)
832 EdkLogger
.error("build", FILE_NOT_FOUND
, ExtraData
=ToolDefinitionFile
)
834 EdkLogger
.error("build", FILE_NOT_FOUND
, ExtraData
=BuildConfigurationFile
)
836 # if no ARCH given in command line, get it from target.txt
837 if not self
.ArchList
:
838 self
.ArchList
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_TARGET_ARCH
]
839 self
.ArchList
= tuple(self
.ArchList
)
841 # if no build target given in command line, get it from target.txt
842 if not self
.BuildTargetList
:
843 self
.BuildTargetList
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_TARGET
]
845 # if no tool chain given in command line, get it from target.txt
846 if not self
.ToolChainList
:
847 self
.ToolChainList
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_TOOL_CHAIN_TAG
]
848 if self
.ToolChainList
is None or len(self
.ToolChainList
) == 0:
849 EdkLogger
.error("build", RESOURCE_NOT_AVAILABLE
, ExtraData
="No toolchain given. Don't know how to build.\n")
851 # check if the tool chains are defined or not
852 NewToolChainList
= []
853 for ToolChain
in self
.ToolChainList
:
854 if ToolChain
not in self
.ToolDef
.ToolsDefTxtDatabase
[TAB_TOD_DEFINES_TOOL_CHAIN_TAG
]:
855 EdkLogger
.warn("build", "Tool chain [%s] is not defined" % ToolChain
)
857 NewToolChainList
.append(ToolChain
)
858 # if no tool chain available, break the build
859 if len(NewToolChainList
) == 0:
860 EdkLogger
.error("build", RESOURCE_NOT_AVAILABLE
,
861 ExtraData
="[%s] not defined. No toolchain available for build!\n" % ", ".join(self
.ToolChainList
))
863 self
.ToolChainList
= NewToolChainList
866 ToolDefinition
= self
.ToolDef
.ToolsDefTxtDatabase
867 for Tool
in self
.ToolChainList
:
868 if TAB_TOD_DEFINES_FAMILY
not in ToolDefinition
or Tool
not in ToolDefinition
[TAB_TOD_DEFINES_FAMILY
] \
869 or not ToolDefinition
[TAB_TOD_DEFINES_FAMILY
][Tool
]:
870 EdkLogger
.warn("build", "No tool chain family found in configuration for %s. Default to MSFT." % Tool
)
871 ToolChainFamily
.append(TAB_COMPILER_MSFT
)
873 ToolChainFamily
.append(ToolDefinition
[TAB_TOD_DEFINES_FAMILY
][Tool
])
874 self
.ToolChainFamily
= ToolChainFamily
876 if self
.ThreadNumber
is None:
877 self
.ThreadNumber
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_MAX_CONCURRENT_THREAD_NUMBER
]
878 if self
.ThreadNumber
== '':
879 self
.ThreadNumber
= 0
881 self
.ThreadNumber
= int(self
.ThreadNumber
, 0)
883 if self
.ThreadNumber
== 0:
885 self
.ThreadNumber
= multiprocessing
.cpu_count()
886 except (ImportError, NotImplementedError):
887 self
.ThreadNumber
= 1
889 if not self
.PlatformFile
:
890 PlatformFile
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_ACTIVE_PLATFORM
]
892 # Try to find one in current directory
893 WorkingDirectory
= os
.getcwd()
894 FileList
= glob
.glob(os
.path
.normpath(os
.path
.join(WorkingDirectory
, '*.dsc')))
895 FileNum
= len(FileList
)
897 EdkLogger
.error("build", OPTION_MISSING
,
898 ExtraData
="There are %d DSC files in %s. Use '-p' to specify one.\n" % (FileNum
, WorkingDirectory
))
900 PlatformFile
= FileList
[0]
902 EdkLogger
.error("build", RESOURCE_NOT_AVAILABLE
,
903 ExtraData
="No active platform specified in target.txt or command line! Nothing can be built.\n")
905 self
.PlatformFile
= PathClass(NormFile(PlatformFile
, self
.WorkspaceDir
), self
.WorkspaceDir
)
907 ## Initialize build configuration
909 # This method will parse DSC file and merge the configurations from
910 # command line and target.txt, then get the final build configurations.
913 # parse target.txt, tools_def.txt, and platform file
914 self
.LoadConfiguration()
916 # Allow case-insensitive for those from command line or configuration file
917 ErrorCode
, ErrorInfo
= self
.PlatformFile
.Validate(".dsc", False)
919 EdkLogger
.error("build", ErrorCode
, ExtraData
=ErrorInfo
)
922 def InitPreBuild(self
):
923 self
.LoadConfiguration()
924 ErrorCode
, ErrorInfo
= self
.PlatformFile
.Validate(".dsc", False)
926 EdkLogger
.error("build", ErrorCode
, ExtraData
=ErrorInfo
)
927 if self
.BuildTargetList
:
928 GlobalData
.gGlobalDefines
['TARGET'] = self
.BuildTargetList
[0]
930 GlobalData
.gGlobalDefines
['ARCH'] = self
.ArchList
[0]
931 if self
.ToolChainList
:
932 GlobalData
.gGlobalDefines
['TOOLCHAIN'] = self
.ToolChainList
[0]
933 GlobalData
.gGlobalDefines
['TOOL_CHAIN_TAG'] = self
.ToolChainList
[0]
934 if self
.ToolChainFamily
:
935 GlobalData
.gGlobalDefines
['FAMILY'] = self
.ToolChainFamily
[0]
936 if 'PREBUILD' in GlobalData
.gCommandLineDefines
:
937 self
.Prebuild
= GlobalData
.gCommandLineDefines
.get('PREBUILD')
940 Platform
= self
.Db
.MapPlatform(str(self
.PlatformFile
))
941 self
.Prebuild
= str(Platform
.Prebuild
)
945 # Evaluate all arguments and convert arguments that are WORKSPACE
946 # relative paths to absolute paths. Filter arguments that look like
947 # flags or do not follow the file/dir naming rules to avoid false
948 # positives on this conversion.
950 for Arg
in self
.Prebuild
.split():
952 # Do not modify Arg if it looks like a flag or an absolute file path
954 if Arg
.startswith('-') or os
.path
.isabs(Arg
):
955 PrebuildList
.append(Arg
)
958 # Do not modify Arg if it does not look like a Workspace relative
959 # path that starts with a valid package directory name
961 if not Arg
[0].isalpha() or os
.path
.dirname(Arg
) == '':
962 PrebuildList
.append(Arg
)
965 # If Arg looks like a WORKSPACE relative path, then convert to an
966 # absolute path and check to see if the file exists.
968 Temp
= mws
.join(self
.WorkspaceDir
, Arg
)
969 if os
.path
.isfile(Temp
):
971 PrebuildList
.append(Arg
)
972 self
.Prebuild
= ' '.join(PrebuildList
)
973 self
.Prebuild
+= self
.PassCommandOption(self
.BuildTargetList
, self
.ArchList
, self
.ToolChainList
, self
.PlatformFile
, self
.Target
)
975 def InitPostBuild(self
):
976 if 'POSTBUILD' in GlobalData
.gCommandLineDefines
:
977 self
.Postbuild
= GlobalData
.gCommandLineDefines
.get('POSTBUILD')
979 Platform
= self
.Db
.MapPlatform(str(self
.PlatformFile
))
980 self
.Postbuild
= str(Platform
.Postbuild
)
984 # Evaluate all arguments and convert arguments that are WORKSPACE
985 # relative paths to absolute paths. Filter arguments that look like
986 # flags or do not follow the file/dir naming rules to avoid false
987 # positives on this conversion.
989 for Arg
in self
.Postbuild
.split():
991 # Do not modify Arg if it looks like a flag or an absolute file path
993 if Arg
.startswith('-') or os
.path
.isabs(Arg
):
994 PostbuildList
.append(Arg
)
997 # Do not modify Arg if it does not look like a Workspace relative
998 # path that starts with a valid package directory name
1000 if not Arg
[0].isalpha() or os
.path
.dirname(Arg
) == '':
1001 PostbuildList
.append(Arg
)
1004 # If Arg looks like a WORKSPACE relative path, then convert to an
1005 # absolute path and check to see if the file exists.
1007 Temp
= mws
.join(self
.WorkspaceDir
, Arg
)
1008 if os
.path
.isfile(Temp
):
1010 PostbuildList
.append(Arg
)
1011 self
.Postbuild
= ' '.join(PostbuildList
)
1012 self
.Postbuild
+= self
.PassCommandOption(self
.BuildTargetList
, self
.ArchList
, self
.ToolChainList
, self
.PlatformFile
, self
.Target
)
1014 def PassCommandOption(self
, BuildTarget
, TargetArch
, ToolChain
, PlatformFile
, Target
):
1016 if GlobalData
.gCommand
and isinstance(GlobalData
.gCommand
, list):
1017 BuildStr
+= ' ' + ' '.join(GlobalData
.gCommand
)
1020 ToolChainFlag
= False
1021 PlatformFileFlag
= False
1023 if GlobalData
.gOptions
and not GlobalData
.gOptions
.BuildTarget
:
1025 if GlobalData
.gOptions
and not GlobalData
.gOptions
.TargetArch
:
1027 if GlobalData
.gOptions
and not GlobalData
.gOptions
.ToolChain
:
1028 ToolChainFlag
= True
1029 if GlobalData
.gOptions
and not GlobalData
.gOptions
.PlatformFile
:
1030 PlatformFileFlag
= True
1032 if TargetFlag
and BuildTarget
:
1033 if isinstance(BuildTarget
, list) or isinstance(BuildTarget
, tuple):
1034 BuildStr
+= ' -b ' + ' -b '.join(BuildTarget
)
1035 elif isinstance(BuildTarget
, str):
1036 BuildStr
+= ' -b ' + BuildTarget
1037 if ArchFlag
and TargetArch
:
1038 if isinstance(TargetArch
, list) or isinstance(TargetArch
, tuple):
1039 BuildStr
+= ' -a ' + ' -a '.join(TargetArch
)
1040 elif isinstance(TargetArch
, str):
1041 BuildStr
+= ' -a ' + TargetArch
1042 if ToolChainFlag
and ToolChain
:
1043 if isinstance(ToolChain
, list) or isinstance(ToolChain
, tuple):
1044 BuildStr
+= ' -t ' + ' -t '.join(ToolChain
)
1045 elif isinstance(ToolChain
, str):
1046 BuildStr
+= ' -t ' + ToolChain
1047 if PlatformFileFlag
and PlatformFile
:
1048 if isinstance(PlatformFile
, list) or isinstance(PlatformFile
, tuple):
1049 BuildStr
+= ' -p ' + ' -p '.join(PlatformFile
)
1050 elif isinstance(PlatformFile
, str):
1051 BuildStr
+= ' -p' + PlatformFile
1052 BuildStr
+= ' --conf=' + GlobalData
.gConfDirectory
1054 BuildStr
+= ' ' + Target
1058 def LaunchPrebuild(self
):
1060 EdkLogger
.info("\n- Prebuild Start -\n")
1061 self
.LaunchPrebuildFlag
= True
1063 # The purpose of .PrebuildEnv file is capture environment variable settings set by the prebuild script
1064 # and preserve them for the rest of the main build step, because the child process environment will
1065 # evaporate as soon as it exits, we cannot get it in build step.
1067 PrebuildEnvFile
= os
.path
.join(GlobalData
.gConfDirectory
, '.cache', '.PrebuildEnv')
1068 if os
.path
.isfile(PrebuildEnvFile
):
1069 os
.remove(PrebuildEnvFile
)
1070 if os
.path
.isfile(self
.PlatformBuildPath
):
1071 os
.remove(self
.PlatformBuildPath
)
1072 if sys
.platform
== "win32":
1073 args
= ' && '.join((self
.Prebuild
, 'set > ' + PrebuildEnvFile
))
1074 Process
= Popen(args
, stdout
=PIPE
, stderr
=PIPE
, shell
=True)
1076 args
= ' && '.join((self
.Prebuild
, 'env > ' + PrebuildEnvFile
))
1077 Process
= Popen(args
, stdout
=PIPE
, stderr
=PIPE
, shell
=True)
1079 # launch two threads to read the STDOUT and STDERR
1080 EndOfProcedure
= Event()
1081 EndOfProcedure
.clear()
1083 StdOutThread
= Thread(target
=ReadMessage
, args
=(Process
.stdout
, EdkLogger
.info
, EndOfProcedure
))
1084 StdOutThread
.setName("STDOUT-Redirector")
1085 StdOutThread
.setDaemon(False)
1086 StdOutThread
.start()
1089 StdErrThread
= Thread(target
=ReadMessage
, args
=(Process
.stderr
, EdkLogger
.quiet
, EndOfProcedure
))
1090 StdErrThread
.setName("STDERR-Redirector")
1091 StdErrThread
.setDaemon(False)
1092 StdErrThread
.start()
1093 # waiting for program exit
1100 if Process
.returncode
!= 0 :
1101 EdkLogger
.error("Prebuild", PREBUILD_ERROR
, 'Prebuild process is not success!')
1103 if os
.path
.exists(PrebuildEnvFile
):
1104 f
= open(PrebuildEnvFile
)
1105 envs
= f
.readlines()
1107 envs
= [l
.split("=", 1) for l
in envs
]
1108 envs
= [[I
.strip() for I
in item
] for item
in envs
if len(item
) == 2]
1109 os
.environ
.update(dict(envs
))
1110 EdkLogger
.info("\n- Prebuild Done -\n")
1112 def LaunchPostbuild(self
):
1114 EdkLogger
.info("\n- Postbuild Start -\n")
1115 if sys
.platform
== "win32":
1116 Process
= Popen(self
.Postbuild
, stdout
=PIPE
, stderr
=PIPE
, shell
=True)
1118 Process
= Popen(self
.Postbuild
, stdout
=PIPE
, stderr
=PIPE
, shell
=True)
1119 # launch two threads to read the STDOUT and STDERR
1120 EndOfProcedure
= Event()
1121 EndOfProcedure
.clear()
1123 StdOutThread
= Thread(target
=ReadMessage
, args
=(Process
.stdout
, EdkLogger
.info
, EndOfProcedure
))
1124 StdOutThread
.setName("STDOUT-Redirector")
1125 StdOutThread
.setDaemon(False)
1126 StdOutThread
.start()
1129 StdErrThread
= Thread(target
=ReadMessage
, args
=(Process
.stderr
, EdkLogger
.quiet
, EndOfProcedure
))
1130 StdErrThread
.setName("STDERR-Redirector")
1131 StdErrThread
.setDaemon(False)
1132 StdErrThread
.start()
1133 # waiting for program exit
1140 if Process
.returncode
!= 0 :
1141 EdkLogger
.error("Postbuild", POSTBUILD_ERROR
, 'Postbuild process is not success!')
1142 EdkLogger
.info("\n- Postbuild Done -\n")
1144 ## Error handling for hash feature
1146 # On BuildTask error, iterate through the Module Build tracking
1147 # dictionary to determine wheather a module failed to build. Invalidate
1148 # the hash associated with that module by removing it from storage.
1151 def invalidateHash(self
):
1152 # GlobalData.gModuleBuildTracking contains only modules that cannot be skipped by hash
1153 for moduleAutoGenObj
in GlobalData
.gModuleBuildTracking
.keys():
1154 # False == FAIL : True == Success
1155 # Skip invalidating for Successful module builds
1156 if GlobalData
.gModuleBuildTracking
[moduleAutoGenObj
] == True:
1159 # The module failed to build or failed to start building, from this point on
1161 # Remove .hash from build
1162 if GlobalData
.gUseHashCache
:
1163 ModuleHashFile
= path
.join(moduleAutoGenObj
.BuildDir
, moduleAutoGenObj
.Name
+ ".hash")
1164 if os
.path
.exists(ModuleHashFile
):
1165 os
.remove(ModuleHashFile
)
1167 # Remove .hash file from cache
1168 if GlobalData
.gBinCacheDest
:
1169 FileDir
= path
.join(GlobalData
.gBinCacheDest
, moduleAutoGenObj
.Arch
, moduleAutoGenObj
.SourceDir
, moduleAutoGenObj
.MetaFile
.BaseName
)
1170 HashFile
= path
.join(FileDir
, moduleAutoGenObj
.Name
+ '.hash')
1171 if os
.path
.exists(HashFile
):
1174 ## Build a module or platform
1176 # Create autogen code and makefile for a module or platform, and the launch
1177 # "make" command to build it
1179 # @param Target The target of build command
1180 # @param Platform The platform file
1181 # @param Module The module file
1182 # @param BuildTarget The name of build target, one of "DEBUG", "RELEASE"
1183 # @param ToolChain The name of toolchain to build
1184 # @param Arch The arch of the module/platform
1185 # @param CreateDepModuleCodeFile Flag used to indicate creating code
1186 # for dependent modules/Libraries
1187 # @param CreateDepModuleMakeFile Flag used to indicate creating makefile
1188 # for dependent modules/Libraries
1190 def _BuildPa(self
, Target
, AutoGenObject
, CreateDepsCodeFile
=True, CreateDepsMakeFile
=True, BuildModule
=False, FfsCommand
={}):
1191 if AutoGenObject
is None:
1194 # skip file generation for cleanxxx targets, run and fds target
1195 if Target
not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1196 # for target which must generate AutoGen code and makefile
1197 if not self
.SkipAutoGen
or Target
== 'genc':
1198 self
.Progress
.Start("Generating code")
1199 AutoGenObject
.CreateCodeFile(CreateDepsCodeFile
)
1200 self
.Progress
.Stop("done!")
1201 if Target
== "genc":
1204 if not self
.SkipAutoGen
or Target
== 'genmake':
1205 self
.Progress
.Start("Generating makefile")
1206 AutoGenObject
.CreateMakeFile(CreateDepsMakeFile
, FfsCommand
)
1207 self
.Progress
.Stop("done!")
1208 if Target
== "genmake":
1211 # always recreate top/platform makefile when clean, just in case of inconsistency
1212 AutoGenObject
.CreateCodeFile(False)
1213 AutoGenObject
.CreateMakeFile(False)
1215 if EdkLogger
.GetLevel() == EdkLogger
.QUIET
:
1216 EdkLogger
.quiet("Building ... %s" % repr(AutoGenObject
))
1218 BuildCommand
= AutoGenObject
.BuildCommand
1219 if BuildCommand
is None or len(BuildCommand
) == 0:
1220 EdkLogger
.error("build", OPTION_MISSING
,
1221 "No build command found for this module. "
1222 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %
1223 (AutoGenObject
.BuildTarget
, AutoGenObject
.ToolChain
, AutoGenObject
.Arch
),
1224 ExtraData
=str(AutoGenObject
))
1226 makefile
= GenMake
.BuildFile(AutoGenObject
)._FILE
_NAME
_[GenMake
.gMakeType
]
1230 RunDir
= os
.path
.normpath(os
.path
.join(AutoGenObject
.BuildDir
, GlobalData
.gGlobalDefines
['ARCH']))
1231 Command
= '.\SecMain'
1233 LaunchCommand(Command
, RunDir
)
1238 BuildCommand
= BuildCommand
+ [Target
]
1239 LaunchCommand(BuildCommand
, AutoGenObject
.MakeFileDir
)
1240 self
.CreateAsBuiltInf()
1244 if Target
== 'libraries':
1245 for Lib
in AutoGenObject
.LibraryBuildDirectoryList
:
1246 NewBuildCommand
= BuildCommand
+ ['-f', os
.path
.normpath(os
.path
.join(Lib
, makefile
)), 'pbuild']
1247 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1251 if Target
== 'modules':
1252 for Lib
in AutoGenObject
.LibraryBuildDirectoryList
:
1253 NewBuildCommand
= BuildCommand
+ ['-f', os
.path
.normpath(os
.path
.join(Lib
, makefile
)), 'pbuild']
1254 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1255 for Mod
in AutoGenObject
.ModuleBuildDirectoryList
:
1256 NewBuildCommand
= BuildCommand
+ ['-f', os
.path
.normpath(os
.path
.join(Mod
, makefile
)), 'pbuild']
1257 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1258 self
.CreateAsBuiltInf()
1262 if Target
== 'cleanlib':
1263 for Lib
in AutoGenObject
.LibraryBuildDirectoryList
:
1264 LibMakefile
= os
.path
.normpath(os
.path
.join(Lib
, makefile
))
1265 if os
.path
.exists(LibMakefile
):
1266 NewBuildCommand
= BuildCommand
+ ['-f', LibMakefile
, 'cleanall']
1267 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1271 if Target
== 'clean':
1272 for Mod
in AutoGenObject
.ModuleBuildDirectoryList
:
1273 ModMakefile
= os
.path
.normpath(os
.path
.join(Mod
, makefile
))
1274 if os
.path
.exists(ModMakefile
):
1275 NewBuildCommand
= BuildCommand
+ ['-f', ModMakefile
, 'cleanall']
1276 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1277 for Lib
in AutoGenObject
.LibraryBuildDirectoryList
:
1278 LibMakefile
= os
.path
.normpath(os
.path
.join(Lib
, makefile
))
1279 if os
.path
.exists(LibMakefile
):
1280 NewBuildCommand
= BuildCommand
+ ['-f', LibMakefile
, 'cleanall']
1281 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1285 if Target
== 'cleanall':
1287 #os.rmdir(AutoGenObject.BuildDir)
1288 RemoveDirectory(AutoGenObject
.BuildDir
, True)
1289 except WindowsError as X
:
1290 EdkLogger
.error("build", FILE_DELETE_FAILURE
, ExtraData
=str(X
))
1293 ## Build a module or platform
1295 # Create autogen code and makefile for a module or platform, and the launch
1296 # "make" command to build it
1298 # @param Target The target of build command
1299 # @param Platform The platform file
1300 # @param Module The module file
1301 # @param BuildTarget The name of build target, one of "DEBUG", "RELEASE"
1302 # @param ToolChain The name of toolchain to build
1303 # @param Arch The arch of the module/platform
1304 # @param CreateDepModuleCodeFile Flag used to indicate creating code
1305 # for dependent modules/Libraries
1306 # @param CreateDepModuleMakeFile Flag used to indicate creating makefile
1307 # for dependent modules/Libraries
1309 def _Build(self
, Target
, AutoGenObject
, CreateDepsCodeFile
=True, CreateDepsMakeFile
=True, BuildModule
=False):
1310 if AutoGenObject
is None:
1313 # skip file generation for cleanxxx targets, run and fds target
1314 if Target
not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1315 # for target which must generate AutoGen code and makefile
1316 if not self
.SkipAutoGen
or Target
== 'genc':
1317 self
.Progress
.Start("Generating code")
1318 AutoGenObject
.CreateCodeFile(CreateDepsCodeFile
)
1319 self
.Progress
.Stop("done!")
1320 if Target
== "genc":
1323 if not self
.SkipAutoGen
or Target
== 'genmake':
1324 self
.Progress
.Start("Generating makefile")
1325 AutoGenObject
.CreateMakeFile(CreateDepsMakeFile
)
1326 #AutoGenObject.CreateAsBuiltInf()
1327 self
.Progress
.Stop("done!")
1328 if Target
== "genmake":
1331 # always recreate top/platform makefile when clean, just in case of inconsistency
1332 AutoGenObject
.CreateCodeFile(False)
1333 AutoGenObject
.CreateMakeFile(False)
1335 if EdkLogger
.GetLevel() == EdkLogger
.QUIET
:
1336 EdkLogger
.quiet("Building ... %s" % repr(AutoGenObject
))
1338 BuildCommand
= AutoGenObject
.BuildCommand
1339 if BuildCommand
is None or len(BuildCommand
) == 0:
1340 EdkLogger
.error("build", OPTION_MISSING
,
1341 "No build command found for this module. "
1342 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %
1343 (AutoGenObject
.BuildTarget
, AutoGenObject
.ToolChain
, AutoGenObject
.Arch
),
1344 ExtraData
=str(AutoGenObject
))
1349 BuildCommand
= BuildCommand
+ [Target
]
1350 AutoGenObject
.BuildTime
= LaunchCommand(BuildCommand
, AutoGenObject
.MakeFileDir
)
1351 self
.CreateAsBuiltInf()
1356 if GenFdsApi(AutoGenObject
.GenFdsCommandDict
, self
.Db
):
1357 EdkLogger
.error("build", COMMAND_FAILURE
)
1362 RunDir
= os
.path
.normpath(os
.path
.join(AutoGenObject
.BuildDir
, GlobalData
.gGlobalDefines
['ARCH']))
1363 Command
= '.\SecMain'
1365 LaunchCommand(Command
, RunDir
)
1369 if Target
== 'libraries':
1376 if Target
== 'cleanall':
1378 #os.rmdir(AutoGenObject.BuildDir)
1379 RemoveDirectory(AutoGenObject
.BuildDir
, True)
1380 except WindowsError as X
:
1381 EdkLogger
.error("build", FILE_DELETE_FAILURE
, ExtraData
=str(X
))
1384 ## Rebase module image and Get function address for the input module list.
1386 def _RebaseModule (self
, MapBuffer
, BaseAddress
, ModuleList
, AddrIsOffset
= True, ModeIsSmm
= False):
1388 AddrIsOffset
= False
1389 for InfFile
in ModuleList
:
1390 sys
.stdout
.write (".")
1392 ModuleInfo
= ModuleList
[InfFile
]
1393 ModuleName
= ModuleInfo
.BaseName
1394 ModuleOutputImage
= ModuleInfo
.Image
.FileName
1395 ModuleDebugImage
= os
.path
.join(ModuleInfo
.DebugDir
, ModuleInfo
.BaseName
+ '.efi')
1396 ## for SMM module in SMRAM, the SMRAM will be allocated from base to top.
1398 BaseAddress
= BaseAddress
- ModuleInfo
.Image
.Size
1400 # Update Image to new BaseAddress by GenFw tool
1402 LaunchCommand(["GenFw", "--rebase", str(BaseAddress
), "-r", ModuleOutputImage
], ModuleInfo
.OutputDir
)
1403 LaunchCommand(["GenFw", "--rebase", str(BaseAddress
), "-r", ModuleDebugImage
], ModuleInfo
.DebugDir
)
1406 # Set new address to the section header only for SMM driver.
1408 LaunchCommand(["GenFw", "--address", str(BaseAddress
), "-r", ModuleOutputImage
], ModuleInfo
.OutputDir
)
1409 LaunchCommand(["GenFw", "--address", str(BaseAddress
), "-r", ModuleDebugImage
], ModuleInfo
.DebugDir
)
1411 # Collect function address from Map file
1413 ImageMapTable
= ModuleOutputImage
.replace('.efi', '.map')
1415 if os
.path
.exists(ImageMapTable
):
1416 OrigImageBaseAddress
= 0
1417 ImageMap
= open(ImageMapTable
, 'r')
1418 for LinStr
in ImageMap
:
1419 if len (LinStr
.strip()) == 0:
1422 # Get the preferred address set on link time.
1424 if LinStr
.find ('Preferred load address is') != -1:
1425 StrList
= LinStr
.split()
1426 OrigImageBaseAddress
= int (StrList
[len(StrList
) - 1], 16)
1428 StrList
= LinStr
.split()
1429 if len (StrList
) > 4:
1430 if StrList
[3] == 'f' or StrList
[3] == 'F':
1432 RelativeAddress
= int (StrList
[2], 16) - OrigImageBaseAddress
1433 FunctionList
.append ((Name
, RelativeAddress
))
1437 # Add general information.
1440 MapBuffer
.append('\n\n%s (Fixed SMRAM Offset, BaseAddress=0x%010X, EntryPoint=0x%010X)\n' % (ModuleName
, BaseAddress
, BaseAddress
+ ModuleInfo
.Image
.EntryPoint
))
1442 MapBuffer
.append('\n\n%s (Fixed Memory Offset, BaseAddress=-0x%010X, EntryPoint=-0x%010X)\n' % (ModuleName
, 0 - BaseAddress
, 0 - (BaseAddress
+ ModuleInfo
.Image
.EntryPoint
)))
1444 MapBuffer
.append('\n\n%s (Fixed Memory Address, BaseAddress=0x%010X, EntryPoint=0x%010X)\n' % (ModuleName
, BaseAddress
, BaseAddress
+ ModuleInfo
.Image
.EntryPoint
))
1446 # Add guid and general seciton section.
1448 TextSectionAddress
= 0
1449 DataSectionAddress
= 0
1450 for SectionHeader
in ModuleInfo
.Image
.SectionHeaderList
:
1451 if SectionHeader
[0] == '.text':
1452 TextSectionAddress
= SectionHeader
[1]
1453 elif SectionHeader
[0] in ['.data', '.sdata']:
1454 DataSectionAddress
= SectionHeader
[1]
1456 MapBuffer
.append('(GUID=%s, .textbaseaddress=-0x%010X, .databaseaddress=-0x%010X)\n' % (ModuleInfo
.Guid
, 0 - (BaseAddress
+ TextSectionAddress
), 0 - (BaseAddress
+ DataSectionAddress
)))
1458 MapBuffer
.append('(GUID=%s, .textbaseaddress=0x%010X, .databaseaddress=0x%010X)\n' % (ModuleInfo
.Guid
, BaseAddress
+ TextSectionAddress
, BaseAddress
+ DataSectionAddress
))
1460 # Add debug image full path.
1462 MapBuffer
.append('(IMAGE=%s)\n\n' % (ModuleDebugImage
))
1464 # Add function address
1466 for Function
in FunctionList
:
1468 MapBuffer
.append(' -0x%010X %s\n' % (0 - (BaseAddress
+ Function
[1]), Function
[0]))
1470 MapBuffer
.append(' 0x%010X %s\n' % (BaseAddress
+ Function
[1], Function
[0]))
1474 # for SMM module in SMRAM, the SMRAM will be allocated from base to top.
1477 BaseAddress
= BaseAddress
+ ModuleInfo
.Image
.Size
1479 ## Collect MAP information of all FVs
1481 def _CollectFvMapBuffer (self
, MapBuffer
, Wa
, ModuleList
):
1483 # First get the XIP base address for FV map file.
1484 GuidPattern
= re
.compile("[-a-fA-F0-9]+")
1485 GuidName
= re
.compile("\(GUID=[-a-fA-F0-9]+")
1486 for FvName
in Wa
.FdfProfile
.FvDict
:
1487 FvMapBuffer
= os
.path
.join(Wa
.FvDir
, FvName
+ '.Fv.map')
1488 if not os
.path
.exists(FvMapBuffer
):
1490 FvMap
= open(FvMapBuffer
, 'r')
1491 #skip FV size information
1497 MatchGuid
= GuidPattern
.match(Line
)
1498 if MatchGuid
is not None:
1500 # Replace GUID with module name
1502 GuidString
= MatchGuid
.group()
1503 if GuidString
.upper() in ModuleList
:
1504 Line
= Line
.replace(GuidString
, ModuleList
[GuidString
.upper()].Name
)
1505 MapBuffer
.append(Line
)
1507 # Add the debug image full path.
1509 MatchGuid
= GuidName
.match(Line
)
1510 if MatchGuid
is not None:
1511 GuidString
= MatchGuid
.group().split("=")[1]
1512 if GuidString
.upper() in ModuleList
:
1513 MapBuffer
.append('(IMAGE=%s)\n' % (os
.path
.join(ModuleList
[GuidString
.upper()].DebugDir
, ModuleList
[GuidString
.upper()].Name
+ '.efi')))
1517 ## Collect MAP information of all modules
1519 def _CollectModuleMapBuffer (self
, MapBuffer
, ModuleList
):
1520 sys
.stdout
.write ("Generate Load Module At Fix Address Map")
1522 PatchEfiImageList
= []
1530 # reserve 4K size in SMRAM to make SMM module address not from 0.
1532 for ModuleGuid
in ModuleList
:
1533 Module
= ModuleList
[ModuleGuid
]
1534 GlobalData
.gProcessingFile
= "%s [%s, %s, %s]" % (Module
.MetaFile
, Module
.Arch
, Module
.ToolChain
, Module
.BuildTarget
)
1536 OutputImageFile
= ''
1537 for ResultFile
in Module
.CodaTargetList
:
1538 if str(ResultFile
.Target
).endswith('.efi'):
1540 # module list for PEI, DXE, RUNTIME and SMM
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 [SUP_MODULE_PEI_CORE
, SUP_MODULE_PEIM
, EDK_COMPONENT_TYPE_COMBINED_PEIM_DRIVER
, EDK_COMPONENT_TYPE_PIC_PEIM
, EDK_COMPONENT_TYPE_RELOCATABLE_PEIM
, SUP_MODULE_DXE_CORE
]:
1548 PeiModuleList
[Module
.MetaFile
] = ImageInfo
1549 PeiSize
+= ImageInfo
.Image
.Size
1550 elif Module
.ModuleType
in [EDK_COMPONENT_TYPE_BS_DRIVER
, SUP_MODULE_DXE_DRIVER
, SUP_MODULE_UEFI_DRIVER
]:
1551 BtModuleList
[Module
.MetaFile
] = ImageInfo
1552 BtSize
+= ImageInfo
.Image
.Size
1553 elif Module
.ModuleType
in [SUP_MODULE_DXE_RUNTIME_DRIVER
, EDK_COMPONENT_TYPE_RT_DRIVER
, SUP_MODULE_DXE_SAL_DRIVER
, EDK_COMPONENT_TYPE_SAL_RT_DRIVER
]:
1554 RtModuleList
[Module
.MetaFile
] = ImageInfo
1555 RtSize
+= ImageInfo
.Image
.Size
1556 elif Module
.ModuleType
in [SUP_MODULE_SMM_CORE
, SUP_MODULE_DXE_SMM_DRIVER
, SUP_MODULE_MM_STANDALONE
, SUP_MODULE_MM_CORE_STANDALONE
]:
1557 SmmModuleList
[Module
.MetaFile
] = ImageInfo
1558 SmmSize
+= ImageInfo
.Image
.Size
1559 if Module
.ModuleType
== SUP_MODULE_DXE_SMM_DRIVER
:
1560 PiSpecVersion
= Module
.Module
.Specification
.get('PI_SPECIFICATION_VERSION', '0x00000000')
1561 # for PI specification < PI1.1, DXE_SMM_DRIVER also runs as BOOT time driver.
1562 if int(PiSpecVersion
, 16) < 0x0001000A:
1563 BtModuleList
[Module
.MetaFile
] = ImageInfo
1564 BtSize
+= ImageInfo
.Image
.Size
1567 # EFI image is final target.
1568 # Check EFI image contains patchable FixAddress related PCDs.
1570 if OutputImageFile
!= '':
1571 ModuleIsPatch
= False
1572 for Pcd
in Module
.ModulePcdList
:
1573 if Pcd
.Type
== TAB_PCDS_PATCHABLE_IN_MODULE
and Pcd
.TokenCName
in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SET
:
1574 ModuleIsPatch
= True
1576 if not ModuleIsPatch
:
1577 for Pcd
in Module
.LibraryPcdList
:
1578 if Pcd
.Type
== TAB_PCDS_PATCHABLE_IN_MODULE
and Pcd
.TokenCName
in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SET
:
1579 ModuleIsPatch
= True
1582 if not ModuleIsPatch
:
1585 # Module includes the patchable load fix address PCDs.
1586 # It will be fixed up later.
1588 PatchEfiImageList
.append (OutputImageFile
)
1591 # Get Top Memory address
1593 ReservedRuntimeMemorySize
= 0
1594 TopMemoryAddress
= 0
1595 if self
.LoadFixAddress
== 0xFFFFFFFFFFFFFFFF:
1596 TopMemoryAddress
= 0
1598 TopMemoryAddress
= self
.LoadFixAddress
1599 if TopMemoryAddress
< RtSize
+ BtSize
+ PeiSize
:
1600 EdkLogger
.error("build", PARAMETER_INVALID
, "FIX_LOAD_TOP_MEMORY_ADDRESS is too low to load driver")
1603 # Patch FixAddress related PCDs into EFI image
1605 for EfiImage
in PatchEfiImageList
:
1606 EfiImageMap
= EfiImage
.replace('.efi', '.map')
1607 if not os
.path
.exists(EfiImageMap
):
1610 # Get PCD offset in EFI image by GenPatchPcdTable function
1612 PcdTable
= parsePcdInfoFromMapFile(EfiImageMap
, EfiImage
)
1614 # Patch real PCD value by PatchPcdValue tool
1616 for PcdInfo
in PcdTable
:
1618 if PcdInfo
[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE
:
1619 ReturnValue
, ErrorInfo
= PatchBinaryFile (EfiImage
, PcdInfo
[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE_DATA_TYPE
, str (PeiSize
// 0x1000))
1620 elif PcdInfo
[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE
:
1621 ReturnValue
, ErrorInfo
= PatchBinaryFile (EfiImage
, PcdInfo
[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE_DATA_TYPE
, str (BtSize
// 0x1000))
1622 elif PcdInfo
[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE
:
1623 ReturnValue
, ErrorInfo
= PatchBinaryFile (EfiImage
, PcdInfo
[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE_DATA_TYPE
, str (RtSize
// 0x1000))
1624 elif PcdInfo
[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE
and len (SmmModuleList
) > 0:
1625 ReturnValue
, ErrorInfo
= PatchBinaryFile (EfiImage
, PcdInfo
[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE_DATA_TYPE
, str (SmmSize
// 0x1000))
1626 if ReturnValue
!= 0:
1627 EdkLogger
.error("build", PARAMETER_INVALID
, "Patch PCD value failed", ExtraData
=ErrorInfo
)
1629 MapBuffer
.append('PEI_CODE_PAGE_NUMBER = 0x%x\n' % (PeiSize
// 0x1000))
1630 MapBuffer
.append('BOOT_CODE_PAGE_NUMBER = 0x%x\n' % (BtSize
// 0x1000))
1631 MapBuffer
.append('RUNTIME_CODE_PAGE_NUMBER = 0x%x\n' % (RtSize
// 0x1000))
1632 if len (SmmModuleList
) > 0:
1633 MapBuffer
.append('SMM_CODE_PAGE_NUMBER = 0x%x\n' % (SmmSize
// 0x1000))
1635 PeiBaseAddr
= TopMemoryAddress
- RtSize
- BtSize
1636 BtBaseAddr
= TopMemoryAddress
- RtSize
1637 RtBaseAddr
= TopMemoryAddress
- ReservedRuntimeMemorySize
1639 self
._RebaseModule
(MapBuffer
, PeiBaseAddr
, PeiModuleList
, TopMemoryAddress
== 0)
1640 self
._RebaseModule
(MapBuffer
, BtBaseAddr
, BtModuleList
, TopMemoryAddress
== 0)
1641 self
._RebaseModule
(MapBuffer
, RtBaseAddr
, RtModuleList
, TopMemoryAddress
== 0)
1642 self
._RebaseModule
(MapBuffer
, 0x1000, SmmModuleList
, AddrIsOffset
=False, ModeIsSmm
=True)
1643 MapBuffer
.append('\n\n')
1644 sys
.stdout
.write ("\n")
1647 ## Save platform Map file
1649 def _SaveMapFile (self
, MapBuffer
, Wa
):
1651 # Map file path is got.
1653 MapFilePath
= os
.path
.join(Wa
.BuildDir
, Wa
.Name
+ '.map')
1655 # Save address map into MAP file.
1657 SaveFileOnChange(MapFilePath
, ''.join(MapBuffer
), False)
1658 if self
.LoadFixAddress
!= 0:
1659 sys
.stdout
.write ("\nLoad Module At Fix Address Map file can be found at %s\n" % (MapFilePath
))
1662 ## Build active platform for different build targets and different tool chains
1664 def _BuildPlatform(self
):
1665 SaveFileOnChange(self
.PlatformBuildPath
, '# DO NOT EDIT \n# FILE auto-generated\n', False)
1666 for BuildTarget
in self
.BuildTargetList
:
1667 GlobalData
.gGlobalDefines
['TARGET'] = BuildTarget
1669 for ToolChain
in self
.ToolChainList
:
1670 GlobalData
.gGlobalDefines
['TOOLCHAIN'] = ToolChain
1671 GlobalData
.gGlobalDefines
['TOOL_CHAIN_TAG'] = ToolChain
1672 GlobalData
.gGlobalDefines
['FAMILY'] = self
.ToolChainFamily
[index
]
1674 Wa
= WorkspaceAutoGen(
1691 self
.Fdf
= Wa
.FdfFile
1692 self
.LoadFixAddress
= Wa
.Platform
.LoadFixAddress
1693 self
.BuildReport
.AddPlatformReport(Wa
)
1694 self
.Progress
.Stop("done!")
1696 # Add ffs build to makefile
1698 if GlobalData
.gEnableGenfdsMultiThread
and self
.Fdf
:
1699 CmdListDict
= self
._GenFfsCmd
(Wa
.ArchList
)
1701 for Arch
in Wa
.ArchList
:
1702 GlobalData
.gGlobalDefines
['ARCH'] = Arch
1703 Pa
= PlatformAutoGen(Wa
, self
.PlatformFile
, BuildTarget
, ToolChain
, Arch
)
1704 for Module
in Pa
.Platform
.Modules
:
1705 # Get ModuleAutoGen object to generate C code file and makefile
1706 Ma
= ModuleAutoGen(Wa
, Module
, BuildTarget
, ToolChain
, Arch
, self
.PlatformFile
)
1709 self
.BuildModules
.append(Ma
)
1710 self
._BuildPa
(self
.Target
, Pa
, FfsCommand
=CmdListDict
)
1712 # Create MAP file when Load Fix Address is enabled.
1713 if self
.Target
in ["", "all", "fds"]:
1714 for Arch
in Wa
.ArchList
:
1715 GlobalData
.gGlobalDefines
['ARCH'] = Arch
1717 # Check whether the set fix address is above 4G for 32bit image.
1719 if (Arch
== 'IA32' or Arch
== 'ARM') and self
.LoadFixAddress
!= 0xFFFFFFFFFFFFFFFF and self
.LoadFixAddress
>= 0x100000000:
1720 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 for Pa
in Wa
.AutoGenObjectList
:
1726 for Ma
in Pa
.ModuleAutoGenList
:
1729 if not Ma
.IsLibrary
:
1730 ModuleList
[Ma
.Guid
.upper()] = Ma
1733 if self
.LoadFixAddress
!= 0:
1735 # Rebase module to the preferred memory address before GenFds
1737 self
._CollectModuleMapBuffer
(MapBuffer
, ModuleList
)
1740 # create FDS again for the updated EFI image
1742 self
._Build
("fds", Wa
)
1744 # Create MAP file for all platform FVs after GenFds.
1746 self
._CollectFvMapBuffer
(MapBuffer
, Wa
, ModuleList
)
1748 # Save MAP buffer into MAP file.
1750 self
._SaveMapFile
(MapBuffer
, Wa
)
1752 ## Build active module for different build targets, different tool chains and different archs
1754 def _BuildModule(self
):
1755 for BuildTarget
in self
.BuildTargetList
:
1756 GlobalData
.gGlobalDefines
['TARGET'] = BuildTarget
1758 for ToolChain
in self
.ToolChainList
:
1759 WorkspaceAutoGenTime
= time
.time()
1760 GlobalData
.gGlobalDefines
['TOOLCHAIN'] = ToolChain
1761 GlobalData
.gGlobalDefines
['TOOL_CHAIN_TAG'] = ToolChain
1762 GlobalData
.gGlobalDefines
['FAMILY'] = self
.ToolChainFamily
[index
]
1765 # module build needs platform build information, so get platform
1768 Wa
= WorkspaceAutoGen(
1786 self
.Fdf
= Wa
.FdfFile
1787 self
.LoadFixAddress
= Wa
.Platform
.LoadFixAddress
1788 Wa
.CreateMakeFile(False)
1789 # Add ffs build to makefile
1791 if GlobalData
.gEnableGenfdsMultiThread
and self
.Fdf
:
1792 CmdListDict
= self
._GenFfsCmd
(Wa
.ArchList
)
1793 self
.Progress
.Stop("done!")
1795 ExitFlag
= threading
.Event()
1797 self
.AutoGenTime
+= int(round((time
.time() - WorkspaceAutoGenTime
)))
1798 for Arch
in Wa
.ArchList
:
1799 AutoGenStart
= time
.time()
1800 GlobalData
.gGlobalDefines
['ARCH'] = Arch
1801 Pa
= PlatformAutoGen(Wa
, self
.PlatformFile
, BuildTarget
, ToolChain
, Arch
)
1802 for Module
in Pa
.Platform
.Modules
:
1803 if self
.ModuleFile
.Dir
== Module
.Dir
and self
.ModuleFile
.Name
== Module
.Name
:
1804 Ma
= ModuleAutoGen(Wa
, Module
, BuildTarget
, ToolChain
, Arch
, self
.PlatformFile
)
1808 if Ma
.CanSkipbyHash():
1809 self
.HashSkipModules
.append(Ma
)
1811 # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'
1812 if self
.Target
not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1813 # for target which must generate AutoGen code and makefile
1814 if not self
.SkipAutoGen
or self
.Target
== 'genc':
1815 self
.Progress
.Start("Generating code")
1816 Ma
.CreateCodeFile(True)
1817 self
.Progress
.Stop("done!")
1818 if self
.Target
== "genc":
1820 if not self
.SkipAutoGen
or self
.Target
== 'genmake':
1821 self
.Progress
.Start("Generating makefile")
1822 if CmdListDict
and self
.Fdf
and (Module
.File
, Arch
) in CmdListDict
:
1823 Ma
.CreateMakeFile(True, CmdListDict
[Module
.File
, Arch
])
1824 del CmdListDict
[Module
.File
, Arch
]
1826 Ma
.CreateMakeFile(True)
1827 self
.Progress
.Stop("done!")
1828 if self
.Target
== "genmake":
1830 self
.BuildModules
.append(Ma
)
1831 # Initialize all modules in tracking to False (FAIL)
1832 if Ma
not in GlobalData
.gModuleBuildTracking
:
1833 GlobalData
.gModuleBuildTracking
[Ma
] = False
1834 self
.AutoGenTime
+= int(round((time
.time() - AutoGenStart
)))
1835 MakeStart
= time
.time()
1836 for Ma
in self
.BuildModules
:
1837 if not Ma
.IsBinaryModule
:
1838 Bt
= BuildTask
.New(ModuleMakeUnit(Ma
, self
.Target
))
1839 # Break build if any build thread has error
1840 if BuildTask
.HasError():
1841 # we need a full version of makefile for platform
1843 BuildTask
.WaitForComplete()
1844 self
.invalidateHash()
1845 Pa
.CreateMakeFile(False)
1846 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
1847 # Start task scheduler
1848 if not BuildTask
.IsOnGoing():
1849 BuildTask
.StartScheduler(self
.ThreadNumber
, ExitFlag
)
1851 # in case there's an interruption. we need a full version of makefile for platform
1852 Pa
.CreateMakeFile(False)
1853 if BuildTask
.HasError():
1854 self
.invalidateHash()
1855 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
1856 self
.MakeTime
+= int(round((time
.time() - MakeStart
)))
1858 MakeContiue
= time
.time()
1860 BuildTask
.WaitForComplete()
1861 self
.CreateAsBuiltInf()
1862 self
.MakeTime
+= int(round((time
.time() - MakeContiue
)))
1863 if BuildTask
.HasError():
1864 self
.invalidateHash()
1865 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
1867 self
.BuildReport
.AddPlatformReport(Wa
, MaList
)
1872 "Module for [%s] is not a component of active platform."\
1873 " Please make sure that the ARCH and inf file path are"\
1874 " given in the same as in [%s]" % \
1875 (', '.join(Wa
.ArchList
), self
.PlatformFile
),
1876 ExtraData
=self
.ModuleFile
1878 # Create MAP file when Load Fix Address is enabled.
1879 if self
.Target
== "fds" and self
.Fdf
:
1880 for Arch
in Wa
.ArchList
:
1882 # Check whether the set fix address is above 4G for 32bit image.
1884 if (Arch
== 'IA32' or Arch
== 'ARM') and self
.LoadFixAddress
!= 0xFFFFFFFFFFFFFFFF and self
.LoadFixAddress
>= 0x100000000:
1885 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")
1890 for Pa
in Wa
.AutoGenObjectList
:
1891 for Ma
in Pa
.ModuleAutoGenList
:
1894 if not Ma
.IsLibrary
:
1895 ModuleList
[Ma
.Guid
.upper()] = Ma
1898 if self
.LoadFixAddress
!= 0:
1900 # Rebase module to the preferred memory address before GenFds
1902 self
._CollectModuleMapBuffer
(MapBuffer
, ModuleList
)
1904 # create FDS again for the updated EFI image
1906 GenFdsStart
= time
.time()
1907 self
._Build
("fds", Wa
)
1908 self
.GenFdsTime
+= int(round((time
.time() - GenFdsStart
)))
1910 # Create MAP file for all platform FVs after GenFds.
1912 self
._CollectFvMapBuffer
(MapBuffer
, Wa
, ModuleList
)
1914 # Save MAP buffer into MAP file.
1916 self
._SaveMapFile
(MapBuffer
, Wa
)
1918 def _GenFfsCmd(self
,ArchList
):
1919 # convert dictionary of Cmd:(Inf,Arch)
1920 # to a new dictionary of (Inf,Arch):Cmd,Cmd,Cmd...
1921 CmdSetDict
= defaultdict(set)
1922 GenFfsDict
= GenFds
.GenFfsMakefile('', GlobalData
.gFdfParser
, self
, ArchList
, GlobalData
)
1923 for Cmd
in GenFfsDict
:
1924 tmpInf
, tmpArch
= GenFfsDict
[Cmd
]
1925 CmdSetDict
[tmpInf
, tmpArch
].add(Cmd
)
1928 ## Build a platform in multi-thread mode
1930 def _MultiThreadBuildPlatform(self
):
1931 SaveFileOnChange(self
.PlatformBuildPath
, '# DO NOT EDIT \n# FILE auto-generated\n', False)
1932 for BuildTarget
in self
.BuildTargetList
:
1933 GlobalData
.gGlobalDefines
['TARGET'] = BuildTarget
1935 for ToolChain
in self
.ToolChainList
:
1936 WorkspaceAutoGenTime
= time
.time()
1937 GlobalData
.gGlobalDefines
['TOOLCHAIN'] = ToolChain
1938 GlobalData
.gGlobalDefines
['TOOL_CHAIN_TAG'] = ToolChain
1939 GlobalData
.gGlobalDefines
['FAMILY'] = self
.ToolChainFamily
[index
]
1941 Wa
= WorkspaceAutoGen(
1958 self
.Fdf
= Wa
.FdfFile
1959 self
.LoadFixAddress
= Wa
.Platform
.LoadFixAddress
1960 self
.BuildReport
.AddPlatformReport(Wa
)
1961 Wa
.CreateMakeFile(False)
1963 # Add ffs build to makefile
1965 if GlobalData
.gEnableGenfdsMultiThread
and self
.Fdf
:
1966 CmdListDict
= self
._GenFfsCmd
(Wa
.ArchList
)
1968 # multi-thread exit flag
1969 ExitFlag
= threading
.Event()
1971 self
.AutoGenTime
+= int(round((time
.time() - WorkspaceAutoGenTime
)))
1972 for Arch
in Wa
.ArchList
:
1973 AutoGenStart
= time
.time()
1974 GlobalData
.gGlobalDefines
['ARCH'] = Arch
1975 Pa
= PlatformAutoGen(Wa
, self
.PlatformFile
, BuildTarget
, ToolChain
, Arch
)
1979 for Inf
in Pa
.Platform
.Modules
:
1980 ModuleList
.append(Inf
)
1981 # Add the INF only list in FDF
1982 if GlobalData
.gFdfParser
is not None:
1983 for InfName
in GlobalData
.gFdfParser
.Profile
.InfList
:
1984 Inf
= PathClass(NormPath(InfName
), self
.WorkspaceDir
, Arch
)
1985 if Inf
in Pa
.Platform
.Modules
:
1987 ModuleList
.append(Inf
)
1988 for Module
in ModuleList
:
1989 # Get ModuleAutoGen object to generate C code file and makefile
1990 Ma
= ModuleAutoGen(Wa
, Module
, BuildTarget
, ToolChain
, Arch
, self
.PlatformFile
)
1994 if Ma
.CanSkipbyHash():
1995 self
.HashSkipModules
.append(Ma
)
1998 # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'
1999 if self
.Target
not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
2000 # for target which must generate AutoGen code and makefile
2001 if not self
.SkipAutoGen
or self
.Target
== 'genc':
2002 Ma
.CreateCodeFile(True)
2003 if self
.Target
== "genc":
2006 if not self
.SkipAutoGen
or self
.Target
== 'genmake':
2007 if CmdListDict
and self
.Fdf
and (Module
.File
, Arch
) in CmdListDict
:
2008 Ma
.CreateMakeFile(True, CmdListDict
[Module
.File
, Arch
])
2009 del CmdListDict
[Module
.File
, Arch
]
2011 Ma
.CreateMakeFile(True)
2012 if self
.Target
== "genmake":
2014 self
.BuildModules
.append(Ma
)
2015 # Initialize all modules in tracking to False (FAIL)
2016 if Ma
not in GlobalData
.gModuleBuildTracking
:
2017 GlobalData
.gModuleBuildTracking
[Ma
] = False
2018 self
.Progress
.Stop("done!")
2019 self
.AutoGenTime
+= int(round((time
.time() - AutoGenStart
)))
2020 MakeStart
= time
.time()
2021 for Ma
in self
.BuildModules
:
2022 # Generate build task for the module
2023 if not Ma
.IsBinaryModule
:
2024 Bt
= BuildTask
.New(ModuleMakeUnit(Ma
, self
.Target
))
2025 # Break build if any build thread has error
2026 if BuildTask
.HasError():
2027 # we need a full version of makefile for platform
2029 BuildTask
.WaitForComplete()
2030 self
.invalidateHash()
2031 Pa
.CreateMakeFile(False)
2032 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
2033 # Start task scheduler
2034 if not BuildTask
.IsOnGoing():
2035 BuildTask
.StartScheduler(self
.ThreadNumber
, ExitFlag
)
2037 # in case there's an interruption. we need a full version of makefile for platform
2038 Pa
.CreateMakeFile(False)
2039 if BuildTask
.HasError():
2040 self
.invalidateHash()
2041 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
2042 self
.MakeTime
+= int(round((time
.time() - MakeStart
)))
2044 MakeContiue
= time
.time()
2048 # All modules have been put in build tasks queue. Tell task scheduler
2049 # to exit if all tasks are completed
2052 BuildTask
.WaitForComplete()
2053 self
.CreateAsBuiltInf()
2054 self
.MakeTime
+= int(round((time
.time() - MakeContiue
)))
2056 # Check for build error, and raise exception if one
2057 # has been signaled.
2059 if BuildTask
.HasError():
2060 self
.invalidateHash()
2061 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
2063 # Create MAP file when Load Fix Address is enabled.
2064 if self
.Target
in ["", "all", "fds"]:
2065 for Arch
in Wa
.ArchList
:
2067 # Check whether the set fix address is above 4G for 32bit image.
2069 if (Arch
== 'IA32' or Arch
== 'ARM') and self
.LoadFixAddress
!= 0xFFFFFFFFFFFFFFFF and self
.LoadFixAddress
>= 0x100000000:
2070 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")
2075 for Pa
in Wa
.AutoGenObjectList
:
2076 for Ma
in Pa
.ModuleAutoGenList
:
2079 if not Ma
.IsLibrary
:
2080 ModuleList
[Ma
.Guid
.upper()] = Ma
2082 # Rebase module to the preferred memory address before GenFds
2085 if self
.LoadFixAddress
!= 0:
2086 self
._CollectModuleMapBuffer
(MapBuffer
, ModuleList
)
2090 # Generate FD image if there's a FDF file found
2092 GenFdsStart
= time
.time()
2093 if GenFdsApi(Wa
.GenFdsCommandDict
, self
.Db
):
2094 EdkLogger
.error("build", COMMAND_FAILURE
)
2097 # Create MAP file for all platform FVs after GenFds.
2099 self
._CollectFvMapBuffer
(MapBuffer
, Wa
, ModuleList
)
2100 self
.GenFdsTime
+= int(round((time
.time() - GenFdsStart
)))
2102 # Save MAP buffer into MAP file.
2104 self
._SaveMapFile
(MapBuffer
, Wa
)
2106 ## Generate GuidedSectionTools.txt in the FV directories.
2108 def CreateGuidedSectionToolsFile(self
):
2109 for BuildTarget
in self
.BuildTargetList
:
2110 for ToolChain
in self
.ToolChainList
:
2111 Wa
= WorkspaceAutoGen(
2128 if not os
.path
.exists(FvDir
):
2131 for Arch
in self
.ArchList
:
2132 # Build up the list of supported architectures for this build
2133 prefix
= '%s_%s_%s_' % (BuildTarget
, ToolChain
, Arch
)
2135 # Look through the tool definitions for GUIDed tools
2137 for (attrib
, value
) in self
.ToolDef
.ToolsDefTxtDictionary
.items():
2138 if attrib
.upper().endswith('_GUID'):
2139 split
= attrib
.split('_')
2140 thisPrefix
= '_'.join(split
[0:3]) + '_'
2141 if thisPrefix
== prefix
:
2142 guid
= self
.ToolDef
.ToolsDefTxtDictionary
[attrib
]
2145 path
= '_'.join(split
[0:4]) + '_PATH'
2146 path
= self
.ToolDef
.ToolsDefTxtDictionary
[path
]
2147 path
= self
.GetFullPathOfTool(path
)
2148 guidAttribs
.append((guid
, toolName
, path
))
2150 # Write out GuidedSecTools.txt
2151 toolsFile
= os
.path
.join(FvDir
, 'GuidedSectionTools.txt')
2152 toolsFile
= open(toolsFile
, 'wt')
2153 for guidedSectionTool
in guidAttribs
:
2154 print(' '.join(guidedSectionTool
), file=toolsFile
)
2157 ## Returns the full path of the tool.
2159 def GetFullPathOfTool (self
, tool
):
2160 if os
.path
.exists(tool
):
2161 return os
.path
.realpath(tool
)
2163 # We need to search for the tool using the
2164 # PATH environment variable.
2165 for dirInPath
in os
.environ
['PATH'].split(os
.pathsep
):
2166 foundPath
= os
.path
.join(dirInPath
, tool
)
2167 if os
.path
.exists(foundPath
):
2168 return os
.path
.realpath(foundPath
)
2170 # If the tool was not found in the path then we just return
2174 ## Launch the module or platform build
2177 if not self
.ModuleFile
:
2178 if not self
.SpawnMode
or self
.Target
not in ["", "all"]:
2179 self
.SpawnMode
= False
2180 self
._BuildPlatform
()
2182 self
._MultiThreadBuildPlatform
()
2183 self
.CreateGuidedSectionToolsFile()
2185 self
.SpawnMode
= False
2188 if self
.Target
== 'cleanall':
2189 RemoveDirectory(os
.path
.dirname(GlobalData
.gDatabasePath
), True)
2191 def CreateAsBuiltInf(self
):
2194 for Module
in self
.BuildModules
:
2195 Module
.CreateAsBuiltInf()
2196 all_mod_set
.add(Module
)
2197 for Module
in self
.HashSkipModules
:
2198 Module
.CreateAsBuiltInf(True)
2199 all_mod_set
.add(Module
)
2200 for Module
in all_mod_set
:
2201 for lib
in Module
.LibraryAutoGenList
:
2202 all_lib_set
.add(lib
)
2203 for lib
in all_lib_set
:
2204 lib
.CreateAsBuiltInf(True)
2207 self
.BuildModules
= []
2208 self
.HashSkipModules
= []
2209 ## Do some clean-up works when error occurred
2210 def Relinquish(self
):
2211 OldLogLevel
= EdkLogger
.GetLevel()
2212 EdkLogger
.SetLevel(EdkLogger
.ERROR
)
2213 Utils
.Progressor
.Abort()
2214 if self
.SpawnMode
== True:
2216 EdkLogger
.SetLevel(OldLogLevel
)
2218 def ParseDefines(DefineList
=[]):
2220 if DefineList
is not None:
2221 for Define
in DefineList
:
2222 DefineTokenList
= Define
.split("=", 1)
2223 if not GlobalData
.gMacroNamePattern
.match(DefineTokenList
[0]):
2224 EdkLogger
.error('build', FORMAT_INVALID
,
2225 "The macro name must be in the pattern [A-Z][A-Z0-9_]*",
2226 ExtraData
=DefineTokenList
[0])
2228 if len(DefineTokenList
) == 1:
2229 DefineDict
[DefineTokenList
[0]] = "TRUE"
2231 DefineDict
[DefineTokenList
[0]] = DefineTokenList
[1].strip()
2235 def SingleCheckCallback(option
, opt_str
, value
, parser
):
2236 if option
not in gParamCheck
:
2237 setattr(parser
.values
, option
.dest
, value
)
2238 gParamCheck
.append(option
)
2240 parser
.error("Option %s only allows one instance in command line!" % option
)
2242 def LogBuildTime(Time
):
2245 TimeDur
= time
.gmtime(Time
)
2246 if TimeDur
.tm_yday
> 1:
2247 TimeDurStr
= time
.strftime("%H:%M:%S", TimeDur
) + ", %d day(s)" % (TimeDur
.tm_yday
- 1)
2249 TimeDurStr
= time
.strftime("%H:%M:%S", TimeDur
)
2254 ## Parse command line options
2256 # Using standard Python module optparse to parse command line option of this tool.
2258 # @retval Opt A optparse.Values object containing the parsed options
2259 # @retval Args Target of build command
2261 def MyOptionParser():
2262 Parser
= OptionParser(description
=__copyright__
, version
=__version__
, prog
="build.exe", usage
="%prog [options] [all|fds|genc|genmake|clean|cleanall|cleanlib|modules|libraries|run]")
2263 Parser
.add_option("-a", "--arch", action
="append", type="choice", choices
=['IA32', 'X64', 'EBC', 'ARM', 'AARCH64'], dest
="TargetArch",
2264 help="ARCHS is one of list: IA32, X64, ARM, AARCH64 or EBC, which overrides target.txt's TARGET_ARCH definition. To specify more archs, please repeat this option.")
2265 Parser
.add_option("-p", "--platform", action
="callback", type="string", dest
="PlatformFile", callback
=SingleCheckCallback
,
2266 help="Build the platform specified by the DSC file name argument, overriding target.txt's ACTIVE_PLATFORM definition.")
2267 Parser
.add_option("-m", "--module", action
="callback", type="string", dest
="ModuleFile", callback
=SingleCheckCallback
,
2268 help="Build the module specified by the INF file name argument.")
2269 Parser
.add_option("-b", "--buildtarget", type="string", dest
="BuildTarget", help="Using the TARGET to build the platform, overriding target.txt's TARGET definition.",
2271 Parser
.add_option("-t", "--tagname", action
="append", type="string", dest
="ToolChain",
2272 help="Using the Tool Chain Tagname to build the platform, overriding target.txt's TOOL_CHAIN_TAG definition.")
2273 Parser
.add_option("-x", "--sku-id", action
="callback", type="string", dest
="SkuId", callback
=SingleCheckCallback
,
2274 help="Using this name of SKU ID to build the platform, overriding SKUID_IDENTIFIER in DSC file.")
2276 Parser
.add_option("-n", action
="callback", type="int", dest
="ThreadNumber", callback
=SingleCheckCallback
,
2277 help="Build the platform using multi-threaded compiler. The value overrides target.txt's MAX_CONCURRENT_THREAD_NUMBER. When value is set to 0, tool automatically detect number of "\
2278 "processor threads, set value to 1 means disable multi-thread build, and set value to more than 1 means user specify the threads number to build.")
2280 Parser
.add_option("-f", "--fdf", action
="callback", type="string", dest
="FdfFile", callback
=SingleCheckCallback
,
2281 help="The name of the FDF file to use, which overrides the setting in the DSC file.")
2282 Parser
.add_option("-r", "--rom-image", action
="append", type="string", dest
="RomImage", default
=[],
2283 help="The name of FD to be generated. The name must be from [FD] section in FDF file.")
2284 Parser
.add_option("-i", "--fv-image", action
="append", type="string", dest
="FvImage", default
=[],
2285 help="The name of FV to be generated. The name must be from [FV] section in FDF file.")
2286 Parser
.add_option("-C", "--capsule-image", action
="append", type="string", dest
="CapName", default
=[],
2287 help="The name of Capsule to be generated. The name must be from [Capsule] section in FDF file.")
2288 Parser
.add_option("-u", "--skip-autogen", action
="store_true", dest
="SkipAutoGen", help="Skip AutoGen step.")
2289 Parser
.add_option("-e", "--re-parse", action
="store_true", dest
="Reparse", help="Re-parse all meta-data files.")
2291 Parser
.add_option("-c", "--case-insensitive", action
="store_true", dest
="CaseInsensitive", default
=False, help="Don't check case of file name.")
2293 Parser
.add_option("-w", "--warning-as-error", action
="store_true", dest
="WarningAsError", help="Treat warning in tools as error.")
2294 Parser
.add_option("-j", "--log", action
="store", dest
="LogFile", help="Put log in specified file as well as on console.")
2296 Parser
.add_option("-s", "--silent", action
="store_true", type=None, dest
="SilentMode",
2297 help="Make use of silent mode of (n)make.")
2298 Parser
.add_option("-q", "--quiet", action
="store_true", type=None, help="Disable all messages except FATAL ERRORS.")
2299 Parser
.add_option("-v", "--verbose", action
="store_true", type=None, help="Turn on verbose output with informational messages printed, "\
2300 "including library instances selected, final dependency expression, "\
2301 "and warning messages, etc.")
2302 Parser
.add_option("-d", "--debug", action
="store", type="int", help="Enable debug messages at specified level.")
2303 Parser
.add_option("-D", "--define", action
="append", type="string", dest
="Macros", help="Macro: \"Name [= Value]\".")
2305 Parser
.add_option("-y", "--report-file", action
="store", dest
="ReportFile", help="Create/overwrite the report to the specified filename.")
2306 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
=[],
2307 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]. "\
2308 "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]")
2309 Parser
.add_option("-F", "--flag", action
="store", type="string", dest
="Flag",
2310 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. "\
2311 "This option can also be specified by setting *_*_*_BUILD_FLAGS in [BuildOptions] section of platform DSC. If they are both specified, this value "\
2312 "will override the setting in [BuildOptions] section of platform DSC.")
2313 Parser
.add_option("-N", "--no-cache", action
="store_true", dest
="DisableCache", default
=False, help="Disable build cache mechanism")
2314 Parser
.add_option("--conf", action
="store", type="string", dest
="ConfDirectory", help="Specify the customized Conf directory.")
2315 Parser
.add_option("--check-usage", action
="store_true", dest
="CheckUsage", default
=False, help="Check usage content of entries listed in INF file.")
2316 Parser
.add_option("--ignore-sources", action
="store_true", dest
="IgnoreSources", default
=False, help="Focus to a binary build and ignore all source files")
2317 Parser
.add_option("--pcd", action
="append", dest
="OptionPcd", help="Set PCD value by command line. Format: \"PcdName=Value\" ")
2318 Parser
.add_option("-l", "--cmd-len", action
="store", type="int", dest
="CommandLength", help="Specify the maximum line length of build command. Default is 4096.")
2319 Parser
.add_option("--hash", action
="store_true", dest
="UseHashCache", default
=False, help="Enable hash-based caching during build process.")
2320 Parser
.add_option("--binary-destination", action
="store", type="string", dest
="BinCacheDest", help="Generate a cache of binary files in the specified directory.")
2321 Parser
.add_option("--binary-source", action
="store", type="string", dest
="BinCacheSource", help="Consume a cache of binary files from the specified directory.")
2322 Parser
.add_option("--genfds-multi-thread", action
="store_true", dest
="GenfdsMultiThread", default
=False, help="Enable GenFds multi thread to generate ffs file.")
2323 Parser
.add_option("--disable-include-path-check", action
="store_true", dest
="DisableIncludePathCheck", default
=False, help="Disable the include path check for outside of package.")
2324 (Opt
, Args
) = Parser
.parse_args()
2327 ## Tool entrance method
2329 # This method mainly dispatch specific methods per the command line options.
2330 # If no error found, return zero value so the caller of this tool can know
2331 # if it's executed successfully or not.
2333 # @retval 0 Tool was successful
2334 # @retval 1 Tool failed
2337 StartTime
= time
.time()
2339 # Initialize log system
2340 EdkLogger
.Initialize()
2341 GlobalData
.gCommand
= sys
.argv
[1:]
2343 # Parse the options and args
2345 (Option
, Target
) = MyOptionParser()
2346 GlobalData
.gOptions
= Option
2347 GlobalData
.gCaseInsensitive
= Option
.CaseInsensitive
2350 if Option
.verbose
is not None:
2351 EdkLogger
.SetLevel(EdkLogger
.VERBOSE
)
2352 elif Option
.quiet
is not None:
2353 EdkLogger
.SetLevel(EdkLogger
.QUIET
)
2354 elif Option
.debug
is not None:
2355 EdkLogger
.SetLevel(Option
.debug
+ 1)
2357 EdkLogger
.SetLevel(EdkLogger
.INFO
)
2359 if Option
.LogFile
is not None:
2360 EdkLogger
.SetLogFile(Option
.LogFile
)
2362 if Option
.WarningAsError
== True:
2363 EdkLogger
.SetWarningAsError()
2365 if platform
.platform().find("Windows") >= 0:
2366 GlobalData
.gIsWindows
= True
2368 GlobalData
.gIsWindows
= False
2370 EdkLogger
.quiet("Build environment: %s" % platform
.platform())
2371 EdkLogger
.quiet(time
.strftime("Build start time: %H:%M:%S, %b.%d %Y\n", time
.localtime()));
2376 if len(Target
) == 0:
2378 elif len(Target
) >= 2:
2379 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, "More than one targets are not supported.",
2380 ExtraData
="Please select one of: %s" % (' '.join(gSupportedTarget
)))
2382 Target
= Target
[0].lower()
2384 if Target
not in gSupportedTarget
:
2385 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, "Not supported target [%s]." % Target
,
2386 ExtraData
="Please select one of: %s" % (' '.join(gSupportedTarget
)))
2389 # Check environment variable: EDK_TOOLS_PATH, WORKSPACE, PATH
2392 GlobalData
.gCommandLineDefines
.update(ParseDefines(Option
.Macros
))
2394 Workspace
= os
.getenv("WORKSPACE")
2396 # Get files real name in workspace dir
2398 GlobalData
.gAllFiles
= Utils
.DirCache(Workspace
)
2400 WorkingDirectory
= os
.getcwd()
2401 if not Option
.ModuleFile
:
2402 FileList
= glob
.glob(os
.path
.normpath(os
.path
.join(WorkingDirectory
, '*.inf')))
2403 FileNum
= len(FileList
)
2405 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, "There are %d INF files in %s." % (FileNum
, WorkingDirectory
),
2406 ExtraData
="Please use '-m <INF_FILE_PATH>' switch to choose one.")
2408 Option
.ModuleFile
= NormFile(FileList
[0], Workspace
)
2410 if Option
.ModuleFile
:
2411 if os
.path
.isabs (Option
.ModuleFile
):
2412 if os
.path
.normcase (os
.path
.normpath(Option
.ModuleFile
)).find (Workspace
) == 0:
2413 Option
.ModuleFile
= NormFile(os
.path
.normpath(Option
.ModuleFile
), Workspace
)
2414 Option
.ModuleFile
= PathClass(Option
.ModuleFile
, Workspace
)
2415 ErrorCode
, ErrorInfo
= Option
.ModuleFile
.Validate(".inf", False)
2417 EdkLogger
.error("build", ErrorCode
, ExtraData
=ErrorInfo
)
2419 if Option
.PlatformFile
is not None:
2420 if os
.path
.isabs (Option
.PlatformFile
):
2421 if os
.path
.normcase (os
.path
.normpath(Option
.PlatformFile
)).find (Workspace
) == 0:
2422 Option
.PlatformFile
= NormFile(os
.path
.normpath(Option
.PlatformFile
), Workspace
)
2423 Option
.PlatformFile
= PathClass(Option
.PlatformFile
, Workspace
)
2425 if Option
.FdfFile
is not None:
2426 if os
.path
.isabs (Option
.FdfFile
):
2427 if os
.path
.normcase (os
.path
.normpath(Option
.FdfFile
)).find (Workspace
) == 0:
2428 Option
.FdfFile
= NormFile(os
.path
.normpath(Option
.FdfFile
), Workspace
)
2429 Option
.FdfFile
= PathClass(Option
.FdfFile
, Workspace
)
2430 ErrorCode
, ErrorInfo
= Option
.FdfFile
.Validate(".fdf", False)
2432 EdkLogger
.error("build", ErrorCode
, ExtraData
=ErrorInfo
)
2434 if Option
.Flag
is not None and Option
.Flag
not in ['-c', '-s']:
2435 EdkLogger
.error("build", OPTION_VALUE_INVALID
, "UNI flag must be one of -c or -s")
2437 MyBuild
= Build(Target
, Workspace
, Option
)
2438 GlobalData
.gCommandLineDefines
['ARCH'] = ' '.join(MyBuild
.ArchList
)
2439 if not (MyBuild
.LaunchPrebuildFlag
and os
.path
.exists(MyBuild
.PlatformBuildPath
)):
2443 # All job done, no error found and no exception raised
2446 except FatalError
as X
:
2447 if MyBuild
is not None:
2448 # for multi-thread build exits safely
2449 MyBuild
.Relinquish()
2450 if Option
is not None and Option
.debug
is not None:
2451 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
2452 ReturnCode
= X
.args
[0]
2453 except Warning as X
:
2454 # error from Fdf parser
2455 if MyBuild
is not None:
2456 # for multi-thread build exits safely
2457 MyBuild
.Relinquish()
2458 if Option
is not None and Option
.debug
is not None:
2459 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
2461 EdkLogger
.error(X
.ToolName
, FORMAT_INVALID
, File
=X
.FileName
, Line
=X
.LineNumber
, ExtraData
=X
.Message
, RaiseError
=False)
2462 ReturnCode
= FORMAT_INVALID
2463 except KeyboardInterrupt:
2464 ReturnCode
= ABORT_ERROR
2465 if Option
is not None and Option
.debug
is not None:
2466 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
2468 if MyBuild
is not None:
2469 # for multi-thread build exits safely
2470 MyBuild
.Relinquish()
2472 # try to get the meta-file from the object causing exception
2473 Tb
= sys
.exc_info()[-1]
2474 MetaFile
= GlobalData
.gProcessingFile
2475 while Tb
is not None:
2476 if 'self' in Tb
.tb_frame
.f_locals
and hasattr(Tb
.tb_frame
.f_locals
['self'], 'MetaFile'):
2477 MetaFile
= Tb
.tb_frame
.f_locals
['self'].MetaFile
2482 "Unknown fatal error when processing [%s]" % MetaFile
,
2483 ExtraData
="\n(Please send email to edk2-devel@lists.01.org for help, attaching following call stack trace!)\n",
2486 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
2487 ReturnCode
= CODE_ERROR
2489 Utils
.Progressor
.Abort()
2490 Utils
.ClearDuplicatedInf()
2494 MyBuild
.LaunchPostbuild()
2497 Conclusion
= "Failed"
2498 elif ReturnCode
== ABORT_ERROR
:
2499 Conclusion
= "Aborted"
2501 Conclusion
= "Failed"
2502 FinishTime
= time
.time()
2503 BuildDuration
= time
.gmtime(int(round(FinishTime
- StartTime
)))
2504 BuildDurationStr
= ""
2505 if BuildDuration
.tm_yday
> 1:
2506 BuildDurationStr
= time
.strftime("%H:%M:%S", BuildDuration
) + ", %d day(s)" % (BuildDuration
.tm_yday
- 1)
2508 BuildDurationStr
= time
.strftime("%H:%M:%S", BuildDuration
)
2509 if MyBuild
is not None:
2511 MyBuild
.BuildReport
.GenerateReport(BuildDurationStr
, LogBuildTime(MyBuild
.AutoGenTime
), LogBuildTime(MyBuild
.MakeTime
), LogBuildTime(MyBuild
.GenFdsTime
))
2513 EdkLogger
.SetLevel(EdkLogger
.QUIET
)
2514 EdkLogger
.quiet("\n- %s -" % Conclusion
)
2515 EdkLogger
.quiet(time
.strftime("Build end time: %H:%M:%S, %b.%d %Y", time
.localtime()))
2516 EdkLogger
.quiet("Build total time: %s\n" % BuildDurationStr
)
2519 if __name__
== '__main__':
2521 ## 0-127 is a safe return range, and 1 is a standard default error
2522 if r
< 0 or r
> 127: r
= 1