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 # indicate there's a thread is available for another build task
624 BuildTask
._RunningQueueLock
.acquire()
625 BuildTask
._RunningQueue
.pop(self
.BuildItem
)
626 BuildTask
._RunningQueueLock
.release()
627 BuildTask
._Thread
.release()
629 ## Start build task thread
632 EdkLogger
.quiet("Building ... %s" % repr(self
.BuildItem
))
633 Command
= self
.BuildItem
.BuildCommand
+ [self
.BuildItem
.Target
]
634 self
.BuildTread
= Thread(target
=self
._CommandThread
, args
=(Command
, self
.BuildItem
.WorkingDir
))
635 self
.BuildTread
.setName("build thread")
636 self
.BuildTread
.setDaemon(False)
637 self
.BuildTread
.start()
639 ## The class contains the information related to EFI image
644 # Constructor will load all required image information.
646 # @param BaseName The full file path of image.
647 # @param Guid The GUID for image.
648 # @param Arch Arch of this image.
649 # @param OutputDir The output directory for image.
650 # @param DebugDir The debug directory for image.
651 # @param ImageClass PeImage Information
653 def __init__(self
, BaseName
, Guid
, Arch
, OutputDir
, DebugDir
, ImageClass
):
654 self
.BaseName
= BaseName
657 self
.OutputDir
= OutputDir
658 self
.DebugDir
= DebugDir
659 self
.Image
= ImageClass
660 self
.Image
.Size
= (self
.Image
.Size
// 0x1000 + 1) * 0x1000
662 ## The class implementing the EDK2 build process
664 # The build process includes:
665 # 1. Load configuration from target.txt and tools_def.txt in $(WORKSPACE)/Conf
666 # 2. Parse DSC file of active platform
667 # 3. Parse FDF file if any
668 # 4. Establish build database, including parse all other files (module, package)
669 # 5. Create AutoGen files (C code file, depex file, makefile) if necessary
670 # 6. Call build command
675 # Constructor will load all necessary configurations, parse platform, modules
676 # and packages and the establish a database for AutoGen.
678 # @param Target The build command target, one of gSupportedTarget
679 # @param WorkspaceDir The directory of workspace
680 # @param BuildOptions Build options passed from command line
682 def __init__(self
, Target
, WorkspaceDir
, BuildOptions
):
683 self
.WorkspaceDir
= WorkspaceDir
685 self
.PlatformFile
= BuildOptions
.PlatformFile
686 self
.ModuleFile
= BuildOptions
.ModuleFile
687 self
.ArchList
= BuildOptions
.TargetArch
688 self
.ToolChainList
= BuildOptions
.ToolChain
689 self
.BuildTargetList
= BuildOptions
.BuildTarget
690 self
.Fdf
= BuildOptions
.FdfFile
691 self
.FdList
= BuildOptions
.RomImage
692 self
.FvList
= BuildOptions
.FvImage
693 self
.CapList
= BuildOptions
.CapName
694 self
.SilentMode
= BuildOptions
.SilentMode
695 self
.ThreadNumber
= BuildOptions
.ThreadNumber
696 self
.SkipAutoGen
= BuildOptions
.SkipAutoGen
697 self
.Reparse
= BuildOptions
.Reparse
698 self
.SkuId
= BuildOptions
.SkuId
700 GlobalData
.gSKUID_CMD
= self
.SkuId
701 self
.ConfDirectory
= BuildOptions
.ConfDirectory
702 self
.SpawnMode
= True
703 self
.BuildReport
= BuildReport(BuildOptions
.ReportFile
, BuildOptions
.ReportType
)
704 self
.TargetTxt
= TargetTxtClassObject()
705 self
.ToolDef
= ToolDefClassObject()
709 GlobalData
.BuildOptionPcd
= BuildOptions
.OptionPcd
if BuildOptions
.OptionPcd
else []
710 #Set global flag for build mode
711 GlobalData
.gIgnoreSource
= BuildOptions
.IgnoreSources
712 GlobalData
.gUseHashCache
= BuildOptions
.UseHashCache
713 GlobalData
.gBinCacheDest
= BuildOptions
.BinCacheDest
714 GlobalData
.gBinCacheSource
= BuildOptions
.BinCacheSource
715 GlobalData
.gEnableGenfdsMultiThread
= BuildOptions
.GenfdsMultiThread
716 GlobalData
.gDisableIncludePathCheck
= BuildOptions
.DisableIncludePathCheck
718 if GlobalData
.gBinCacheDest
and not GlobalData
.gUseHashCache
:
719 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, ExtraData
="--binary-destination must be used together with --hash.")
721 if GlobalData
.gBinCacheSource
and not GlobalData
.gUseHashCache
:
722 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, ExtraData
="--binary-source must be used together with --hash.")
724 if GlobalData
.gBinCacheDest
and GlobalData
.gBinCacheSource
:
725 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, ExtraData
="--binary-destination can not be used together with --binary-source.")
727 if GlobalData
.gBinCacheSource
:
728 BinCacheSource
= os
.path
.normpath(GlobalData
.gBinCacheSource
)
729 if not os
.path
.isabs(BinCacheSource
):
730 BinCacheSource
= mws
.join(self
.WorkspaceDir
, BinCacheSource
)
731 GlobalData
.gBinCacheSource
= BinCacheSource
733 if GlobalData
.gBinCacheSource
is not None:
734 EdkLogger
.error("build", OPTION_VALUE_INVALID
, ExtraData
="Invalid value of option --binary-source.")
736 if GlobalData
.gBinCacheDest
:
737 BinCacheDest
= os
.path
.normpath(GlobalData
.gBinCacheDest
)
738 if not os
.path
.isabs(BinCacheDest
):
739 BinCacheDest
= mws
.join(self
.WorkspaceDir
, BinCacheDest
)
740 GlobalData
.gBinCacheDest
= BinCacheDest
742 if GlobalData
.gBinCacheDest
is not None:
743 EdkLogger
.error("build", OPTION_VALUE_INVALID
, ExtraData
="Invalid value of option --binary-destination.")
745 if self
.ConfDirectory
:
746 # Get alternate Conf location, if it is absolute, then just use the absolute directory name
747 ConfDirectoryPath
= os
.path
.normpath(self
.ConfDirectory
)
749 if not os
.path
.isabs(ConfDirectoryPath
):
750 # Since alternate directory name is not absolute, the alternate directory is located within the WORKSPACE
751 # This also handles someone specifying the Conf directory in the workspace. Using --conf=Conf
752 ConfDirectoryPath
= mws
.join(self
.WorkspaceDir
, ConfDirectoryPath
)
754 if "CONF_PATH" in os
.environ
:
755 ConfDirectoryPath
= os
.path
.normcase(os
.path
.normpath(os
.environ
["CONF_PATH"]))
757 # Get standard WORKSPACE/Conf use the absolute path to the WORKSPACE/Conf
758 ConfDirectoryPath
= mws
.join(self
.WorkspaceDir
, 'Conf')
759 GlobalData
.gConfDirectory
= ConfDirectoryPath
760 GlobalData
.gDatabasePath
= os
.path
.normpath(os
.path
.join(ConfDirectoryPath
, GlobalData
.gDatabasePath
))
762 self
.Db
= WorkspaceDatabase()
763 self
.BuildDatabase
= self
.Db
.BuildObject
765 self
.ToolChainFamily
= None
766 self
.LoadFixAddress
= 0
767 self
.UniFlag
= BuildOptions
.Flag
768 self
.BuildModules
= []
769 self
.HashSkipModules
= []
771 self
.LaunchPrebuildFlag
= False
772 self
.PlatformBuildPath
= os
.path
.join(GlobalData
.gConfDirectory
, '.cache', '.PlatformBuild')
773 if BuildOptions
.CommandLength
:
774 GlobalData
.gCommandMaxLength
= BuildOptions
.CommandLength
776 # print dot character during doing some time-consuming work
777 self
.Progress
= Utils
.Progressor()
778 # print current build environment and configuration
779 EdkLogger
.quiet("%-16s = %s" % ("WORKSPACE", os
.environ
["WORKSPACE"]))
780 if "PACKAGES_PATH" in os
.environ
:
781 # WORKSPACE env has been converted before. Print the same path style with WORKSPACE env.
782 EdkLogger
.quiet("%-16s = %s" % ("PACKAGES_PATH", os
.path
.normcase(os
.path
.normpath(os
.environ
["PACKAGES_PATH"]))))
783 EdkLogger
.quiet("%-16s = %s" % ("EDK_TOOLS_PATH", os
.environ
["EDK_TOOLS_PATH"]))
784 if "EDK_TOOLS_BIN" in os
.environ
:
785 # Print the same path style with WORKSPACE env.
786 EdkLogger
.quiet("%-16s = %s" % ("EDK_TOOLS_BIN", os
.path
.normcase(os
.path
.normpath(os
.environ
["EDK_TOOLS_BIN"]))))
787 EdkLogger
.quiet("%-16s = %s" % ("CONF_PATH", GlobalData
.gConfDirectory
))
788 if "PYTHON3_ENABLE" in os
.environ
:
789 PYTHON3_ENABLE
= os
.environ
["PYTHON3_ENABLE"]
790 if PYTHON3_ENABLE
!= "TRUE":
791 PYTHON3_ENABLE
= "FALSE"
792 EdkLogger
.quiet("%-16s = %s" % ("PYTHON3_ENABLE", PYTHON3_ENABLE
))
793 if "PYTHON_COMMAND" in os
.environ
:
794 EdkLogger
.quiet("%-16s = %s" % ("PYTHON_COMMAND", os
.environ
["PYTHON_COMMAND"]))
798 EdkLogger
.quiet("%-16s = %s" % ("PREBUILD", self
.Prebuild
))
800 EdkLogger
.quiet("%-16s = %s" % ("POSTBUILD", self
.Postbuild
))
802 self
.LaunchPrebuild()
803 self
.TargetTxt
= TargetTxtClassObject()
804 self
.ToolDef
= ToolDefClassObject()
805 if not (self
.LaunchPrebuildFlag
and os
.path
.exists(self
.PlatformBuildPath
)):
809 os
.chdir(self
.WorkspaceDir
)
811 ## Load configuration
813 # This method will parse target.txt and get the build configurations.
815 def LoadConfiguration(self
):
817 # Check target.txt and tools_def.txt and Init them
819 BuildConfigurationFile
= os
.path
.normpath(os
.path
.join(GlobalData
.gConfDirectory
, gBuildConfiguration
))
820 if os
.path
.isfile(BuildConfigurationFile
) == True:
821 StatusCode
= self
.TargetTxt
.LoadTargetTxtFile(BuildConfigurationFile
)
823 ToolDefinitionFile
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_TOOL_CHAIN_CONF
]
824 if ToolDefinitionFile
== '':
825 ToolDefinitionFile
= gToolsDefinition
826 ToolDefinitionFile
= os
.path
.normpath(mws
.join(self
.WorkspaceDir
, 'Conf', ToolDefinitionFile
))
827 if os
.path
.isfile(ToolDefinitionFile
) == True:
828 StatusCode
= self
.ToolDef
.LoadToolDefFile(ToolDefinitionFile
)
830 EdkLogger
.error("build", FILE_NOT_FOUND
, ExtraData
=ToolDefinitionFile
)
832 EdkLogger
.error("build", FILE_NOT_FOUND
, ExtraData
=BuildConfigurationFile
)
834 # if no ARCH given in command line, get it from target.txt
835 if not self
.ArchList
:
836 self
.ArchList
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_TARGET_ARCH
]
837 self
.ArchList
= tuple(self
.ArchList
)
839 # if no build target given in command line, get it from target.txt
840 if not self
.BuildTargetList
:
841 self
.BuildTargetList
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_TARGET
]
843 # if no tool chain given in command line, get it from target.txt
844 if not self
.ToolChainList
:
845 self
.ToolChainList
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_TOOL_CHAIN_TAG
]
846 if self
.ToolChainList
is None or len(self
.ToolChainList
) == 0:
847 EdkLogger
.error("build", RESOURCE_NOT_AVAILABLE
, ExtraData
="No toolchain given. Don't know how to build.\n")
849 # check if the tool chains are defined or not
850 NewToolChainList
= []
851 for ToolChain
in self
.ToolChainList
:
852 if ToolChain
not in self
.ToolDef
.ToolsDefTxtDatabase
[TAB_TOD_DEFINES_TOOL_CHAIN_TAG
]:
853 EdkLogger
.warn("build", "Tool chain [%s] is not defined" % ToolChain
)
855 NewToolChainList
.append(ToolChain
)
856 # if no tool chain available, break the build
857 if len(NewToolChainList
) == 0:
858 EdkLogger
.error("build", RESOURCE_NOT_AVAILABLE
,
859 ExtraData
="[%s] not defined. No toolchain available for build!\n" % ", ".join(self
.ToolChainList
))
861 self
.ToolChainList
= NewToolChainList
864 ToolDefinition
= self
.ToolDef
.ToolsDefTxtDatabase
865 for Tool
in self
.ToolChainList
:
866 if TAB_TOD_DEFINES_FAMILY
not in ToolDefinition
or Tool
not in ToolDefinition
[TAB_TOD_DEFINES_FAMILY
] \
867 or not ToolDefinition
[TAB_TOD_DEFINES_FAMILY
][Tool
]:
868 EdkLogger
.warn("build", "No tool chain family found in configuration for %s. Default to MSFT." % Tool
)
869 ToolChainFamily
.append(TAB_COMPILER_MSFT
)
871 ToolChainFamily
.append(ToolDefinition
[TAB_TOD_DEFINES_FAMILY
][Tool
])
872 self
.ToolChainFamily
= ToolChainFamily
874 if self
.ThreadNumber
is None:
875 self
.ThreadNumber
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_MAX_CONCURRENT_THREAD_NUMBER
]
876 if self
.ThreadNumber
== '':
877 self
.ThreadNumber
= 0
879 self
.ThreadNumber
= int(self
.ThreadNumber
, 0)
881 if self
.ThreadNumber
== 0:
883 self
.ThreadNumber
= multiprocessing
.cpu_count()
884 except (ImportError, NotImplementedError):
885 self
.ThreadNumber
= 1
887 if not self
.PlatformFile
:
888 PlatformFile
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_ACTIVE_PLATFORM
]
890 # Try to find one in current directory
891 WorkingDirectory
= os
.getcwd()
892 FileList
= glob
.glob(os
.path
.normpath(os
.path
.join(WorkingDirectory
, '*.dsc')))
893 FileNum
= len(FileList
)
895 EdkLogger
.error("build", OPTION_MISSING
,
896 ExtraData
="There are %d DSC files in %s. Use '-p' to specify one.\n" % (FileNum
, WorkingDirectory
))
898 PlatformFile
= FileList
[0]
900 EdkLogger
.error("build", RESOURCE_NOT_AVAILABLE
,
901 ExtraData
="No active platform specified in target.txt or command line! Nothing can be built.\n")
903 self
.PlatformFile
= PathClass(NormFile(PlatformFile
, self
.WorkspaceDir
), self
.WorkspaceDir
)
905 ## Initialize build configuration
907 # This method will parse DSC file and merge the configurations from
908 # command line and target.txt, then get the final build configurations.
911 # parse target.txt, tools_def.txt, and platform file
912 self
.LoadConfiguration()
914 # Allow case-insensitive for those from command line or configuration file
915 ErrorCode
, ErrorInfo
= self
.PlatformFile
.Validate(".dsc", False)
917 EdkLogger
.error("build", ErrorCode
, ExtraData
=ErrorInfo
)
920 def InitPreBuild(self
):
921 self
.LoadConfiguration()
922 ErrorCode
, ErrorInfo
= self
.PlatformFile
.Validate(".dsc", False)
924 EdkLogger
.error("build", ErrorCode
, ExtraData
=ErrorInfo
)
925 if self
.BuildTargetList
:
926 GlobalData
.gGlobalDefines
['TARGET'] = self
.BuildTargetList
[0]
928 GlobalData
.gGlobalDefines
['ARCH'] = self
.ArchList
[0]
929 if self
.ToolChainList
:
930 GlobalData
.gGlobalDefines
['TOOLCHAIN'] = self
.ToolChainList
[0]
931 GlobalData
.gGlobalDefines
['TOOL_CHAIN_TAG'] = self
.ToolChainList
[0]
932 if self
.ToolChainFamily
:
933 GlobalData
.gGlobalDefines
['FAMILY'] = self
.ToolChainFamily
[0]
934 if 'PREBUILD' in GlobalData
.gCommandLineDefines
:
935 self
.Prebuild
= GlobalData
.gCommandLineDefines
.get('PREBUILD')
938 Platform
= self
.Db
.MapPlatform(str(self
.PlatformFile
))
939 self
.Prebuild
= str(Platform
.Prebuild
)
943 # Evaluate all arguments and convert arguments that are WORKSPACE
944 # relative paths to absolute paths. Filter arguments that look like
945 # flags or do not follow the file/dir naming rules to avoid false
946 # positives on this conversion.
948 for Arg
in self
.Prebuild
.split():
950 # Do not modify Arg if it looks like a flag or an absolute file path
952 if Arg
.startswith('-') or os
.path
.isabs(Arg
):
953 PrebuildList
.append(Arg
)
956 # Do not modify Arg if it does not look like a Workspace relative
957 # path that starts with a valid package directory name
959 if not Arg
[0].isalpha() or os
.path
.dirname(Arg
) == '':
960 PrebuildList
.append(Arg
)
963 # If Arg looks like a WORKSPACE relative path, then convert to an
964 # absolute path and check to see if the file exists.
966 Temp
= mws
.join(self
.WorkspaceDir
, Arg
)
967 if os
.path
.isfile(Temp
):
969 PrebuildList
.append(Arg
)
970 self
.Prebuild
= ' '.join(PrebuildList
)
971 self
.Prebuild
+= self
.PassCommandOption(self
.BuildTargetList
, self
.ArchList
, self
.ToolChainList
, self
.PlatformFile
, self
.Target
)
973 def InitPostBuild(self
):
974 if 'POSTBUILD' in GlobalData
.gCommandLineDefines
:
975 self
.Postbuild
= GlobalData
.gCommandLineDefines
.get('POSTBUILD')
977 Platform
= self
.Db
.MapPlatform(str(self
.PlatformFile
))
978 self
.Postbuild
= str(Platform
.Postbuild
)
982 # Evaluate all arguments and convert arguments that are WORKSPACE
983 # relative paths to absolute paths. Filter arguments that look like
984 # flags or do not follow the file/dir naming rules to avoid false
985 # positives on this conversion.
987 for Arg
in self
.Postbuild
.split():
989 # Do not modify Arg if it looks like a flag or an absolute file path
991 if Arg
.startswith('-') or os
.path
.isabs(Arg
):
992 PostbuildList
.append(Arg
)
995 # Do not modify Arg if it does not look like a Workspace relative
996 # path that starts with a valid package directory name
998 if not Arg
[0].isalpha() or os
.path
.dirname(Arg
) == '':
999 PostbuildList
.append(Arg
)
1002 # If Arg looks like a WORKSPACE relative path, then convert to an
1003 # absolute path and check to see if the file exists.
1005 Temp
= mws
.join(self
.WorkspaceDir
, Arg
)
1006 if os
.path
.isfile(Temp
):
1008 PostbuildList
.append(Arg
)
1009 self
.Postbuild
= ' '.join(PostbuildList
)
1010 self
.Postbuild
+= self
.PassCommandOption(self
.BuildTargetList
, self
.ArchList
, self
.ToolChainList
, self
.PlatformFile
, self
.Target
)
1012 def PassCommandOption(self
, BuildTarget
, TargetArch
, ToolChain
, PlatformFile
, Target
):
1014 if GlobalData
.gCommand
and isinstance(GlobalData
.gCommand
, list):
1015 BuildStr
+= ' ' + ' '.join(GlobalData
.gCommand
)
1018 ToolChainFlag
= False
1019 PlatformFileFlag
= False
1021 if GlobalData
.gOptions
and not GlobalData
.gOptions
.BuildTarget
:
1023 if GlobalData
.gOptions
and not GlobalData
.gOptions
.TargetArch
:
1025 if GlobalData
.gOptions
and not GlobalData
.gOptions
.ToolChain
:
1026 ToolChainFlag
= True
1027 if GlobalData
.gOptions
and not GlobalData
.gOptions
.PlatformFile
:
1028 PlatformFileFlag
= True
1030 if TargetFlag
and BuildTarget
:
1031 if isinstance(BuildTarget
, list) or isinstance(BuildTarget
, tuple):
1032 BuildStr
+= ' -b ' + ' -b '.join(BuildTarget
)
1033 elif isinstance(BuildTarget
, str):
1034 BuildStr
+= ' -b ' + BuildTarget
1035 if ArchFlag
and TargetArch
:
1036 if isinstance(TargetArch
, list) or isinstance(TargetArch
, tuple):
1037 BuildStr
+= ' -a ' + ' -a '.join(TargetArch
)
1038 elif isinstance(TargetArch
, str):
1039 BuildStr
+= ' -a ' + TargetArch
1040 if ToolChainFlag
and ToolChain
:
1041 if isinstance(ToolChain
, list) or isinstance(ToolChain
, tuple):
1042 BuildStr
+= ' -t ' + ' -t '.join(ToolChain
)
1043 elif isinstance(ToolChain
, str):
1044 BuildStr
+= ' -t ' + ToolChain
1045 if PlatformFileFlag
and PlatformFile
:
1046 if isinstance(PlatformFile
, list) or isinstance(PlatformFile
, tuple):
1047 BuildStr
+= ' -p ' + ' -p '.join(PlatformFile
)
1048 elif isinstance(PlatformFile
, str):
1049 BuildStr
+= ' -p' + PlatformFile
1050 BuildStr
+= ' --conf=' + GlobalData
.gConfDirectory
1052 BuildStr
+= ' ' + Target
1056 def LaunchPrebuild(self
):
1058 EdkLogger
.info("\n- Prebuild Start -\n")
1059 self
.LaunchPrebuildFlag
= True
1061 # The purpose of .PrebuildEnv file is capture environment variable settings set by the prebuild script
1062 # and preserve them for the rest of the main build step, because the child process environment will
1063 # evaporate as soon as it exits, we cannot get it in build step.
1065 PrebuildEnvFile
= os
.path
.join(GlobalData
.gConfDirectory
, '.cache', '.PrebuildEnv')
1066 if os
.path
.isfile(PrebuildEnvFile
):
1067 os
.remove(PrebuildEnvFile
)
1068 if os
.path
.isfile(self
.PlatformBuildPath
):
1069 os
.remove(self
.PlatformBuildPath
)
1070 if sys
.platform
== "win32":
1071 args
= ' && '.join((self
.Prebuild
, 'set > ' + PrebuildEnvFile
))
1072 Process
= Popen(args
, stdout
=PIPE
, stderr
=PIPE
, shell
=True)
1074 args
= ' && '.join((self
.Prebuild
, 'env > ' + PrebuildEnvFile
))
1075 Process
= Popen(args
, stdout
=PIPE
, stderr
=PIPE
, shell
=True)
1077 # launch two threads to read the STDOUT and STDERR
1078 EndOfProcedure
= Event()
1079 EndOfProcedure
.clear()
1081 StdOutThread
= Thread(target
=ReadMessage
, args
=(Process
.stdout
, EdkLogger
.info
, EndOfProcedure
))
1082 StdOutThread
.setName("STDOUT-Redirector")
1083 StdOutThread
.setDaemon(False)
1084 StdOutThread
.start()
1087 StdErrThread
= Thread(target
=ReadMessage
, args
=(Process
.stderr
, EdkLogger
.quiet
, EndOfProcedure
))
1088 StdErrThread
.setName("STDERR-Redirector")
1089 StdErrThread
.setDaemon(False)
1090 StdErrThread
.start()
1091 # waiting for program exit
1098 if Process
.returncode
!= 0 :
1099 EdkLogger
.error("Prebuild", PREBUILD_ERROR
, 'Prebuild process is not success!')
1101 if os
.path
.exists(PrebuildEnvFile
):
1102 f
= open(PrebuildEnvFile
)
1103 envs
= f
.readlines()
1105 envs
= [l
.split("=", 1) for l
in envs
]
1106 envs
= [[I
.strip() for I
in item
] for item
in envs
if len(item
) == 2]
1107 os
.environ
.update(dict(envs
))
1108 EdkLogger
.info("\n- Prebuild Done -\n")
1110 def LaunchPostbuild(self
):
1112 EdkLogger
.info("\n- Postbuild Start -\n")
1113 if sys
.platform
== "win32":
1114 Process
= Popen(self
.Postbuild
, stdout
=PIPE
, stderr
=PIPE
, shell
=True)
1116 Process
= Popen(self
.Postbuild
, stdout
=PIPE
, stderr
=PIPE
, shell
=True)
1117 # launch two threads to read the STDOUT and STDERR
1118 EndOfProcedure
= Event()
1119 EndOfProcedure
.clear()
1121 StdOutThread
= Thread(target
=ReadMessage
, args
=(Process
.stdout
, EdkLogger
.info
, EndOfProcedure
))
1122 StdOutThread
.setName("STDOUT-Redirector")
1123 StdOutThread
.setDaemon(False)
1124 StdOutThread
.start()
1127 StdErrThread
= Thread(target
=ReadMessage
, args
=(Process
.stderr
, EdkLogger
.quiet
, EndOfProcedure
))
1128 StdErrThread
.setName("STDERR-Redirector")
1129 StdErrThread
.setDaemon(False)
1130 StdErrThread
.start()
1131 # waiting for program exit
1138 if Process
.returncode
!= 0 :
1139 EdkLogger
.error("Postbuild", POSTBUILD_ERROR
, 'Postbuild process is not success!')
1140 EdkLogger
.info("\n- Postbuild Done -\n")
1141 ## Build a module or platform
1143 # Create autogen code and makefile for a module or platform, and the launch
1144 # "make" command to build it
1146 # @param Target The target of build command
1147 # @param Platform The platform file
1148 # @param Module The module file
1149 # @param BuildTarget The name of build target, one of "DEBUG", "RELEASE"
1150 # @param ToolChain The name of toolchain to build
1151 # @param Arch The arch of the module/platform
1152 # @param CreateDepModuleCodeFile Flag used to indicate creating code
1153 # for dependent modules/Libraries
1154 # @param CreateDepModuleMakeFile Flag used to indicate creating makefile
1155 # for dependent modules/Libraries
1157 def _BuildPa(self
, Target
, AutoGenObject
, CreateDepsCodeFile
=True, CreateDepsMakeFile
=True, BuildModule
=False, FfsCommand
={}):
1158 if AutoGenObject
is None:
1161 # skip file generation for cleanxxx targets, run and fds target
1162 if Target
not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1163 # for target which must generate AutoGen code and makefile
1164 if not self
.SkipAutoGen
or Target
== 'genc':
1165 self
.Progress
.Start("Generating code")
1166 AutoGenObject
.CreateCodeFile(CreateDepsCodeFile
)
1167 self
.Progress
.Stop("done!")
1168 if Target
== "genc":
1171 if not self
.SkipAutoGen
or Target
== 'genmake':
1172 self
.Progress
.Start("Generating makefile")
1173 AutoGenObject
.CreateMakeFile(CreateDepsMakeFile
, FfsCommand
)
1174 self
.Progress
.Stop("done!")
1175 if Target
== "genmake":
1178 # always recreate top/platform makefile when clean, just in case of inconsistency
1179 AutoGenObject
.CreateCodeFile(False)
1180 AutoGenObject
.CreateMakeFile(False)
1182 if EdkLogger
.GetLevel() == EdkLogger
.QUIET
:
1183 EdkLogger
.quiet("Building ... %s" % repr(AutoGenObject
))
1185 BuildCommand
= AutoGenObject
.BuildCommand
1186 if BuildCommand
is None or len(BuildCommand
) == 0:
1187 EdkLogger
.error("build", OPTION_MISSING
,
1188 "No build command found for this module. "
1189 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %
1190 (AutoGenObject
.BuildTarget
, AutoGenObject
.ToolChain
, AutoGenObject
.Arch
),
1191 ExtraData
=str(AutoGenObject
))
1193 makefile
= GenMake
.BuildFile(AutoGenObject
)._FILE
_NAME
_[GenMake
.gMakeType
]
1197 RunDir
= os
.path
.normpath(os
.path
.join(AutoGenObject
.BuildDir
, GlobalData
.gGlobalDefines
['ARCH']))
1198 Command
= '.\SecMain'
1200 LaunchCommand(Command
, RunDir
)
1205 BuildCommand
= BuildCommand
+ [Target
]
1206 LaunchCommand(BuildCommand
, AutoGenObject
.MakeFileDir
)
1207 self
.CreateAsBuiltInf()
1211 if Target
== 'libraries':
1212 for Lib
in AutoGenObject
.LibraryBuildDirectoryList
:
1213 NewBuildCommand
= BuildCommand
+ ['-f', os
.path
.normpath(os
.path
.join(Lib
, makefile
)), 'pbuild']
1214 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1218 if Target
== 'modules':
1219 for Lib
in AutoGenObject
.LibraryBuildDirectoryList
:
1220 NewBuildCommand
= BuildCommand
+ ['-f', os
.path
.normpath(os
.path
.join(Lib
, makefile
)), 'pbuild']
1221 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1222 for Mod
in AutoGenObject
.ModuleBuildDirectoryList
:
1223 NewBuildCommand
= BuildCommand
+ ['-f', os
.path
.normpath(os
.path
.join(Mod
, makefile
)), 'pbuild']
1224 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1225 self
.CreateAsBuiltInf()
1229 if Target
== 'cleanlib':
1230 for Lib
in AutoGenObject
.LibraryBuildDirectoryList
:
1231 LibMakefile
= os
.path
.normpath(os
.path
.join(Lib
, makefile
))
1232 if os
.path
.exists(LibMakefile
):
1233 NewBuildCommand
= BuildCommand
+ ['-f', LibMakefile
, 'cleanall']
1234 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1238 if Target
== 'clean':
1239 for Mod
in AutoGenObject
.ModuleBuildDirectoryList
:
1240 ModMakefile
= os
.path
.normpath(os
.path
.join(Mod
, makefile
))
1241 if os
.path
.exists(ModMakefile
):
1242 NewBuildCommand
= BuildCommand
+ ['-f', ModMakefile
, 'cleanall']
1243 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1244 for Lib
in AutoGenObject
.LibraryBuildDirectoryList
:
1245 LibMakefile
= os
.path
.normpath(os
.path
.join(Lib
, makefile
))
1246 if os
.path
.exists(LibMakefile
):
1247 NewBuildCommand
= BuildCommand
+ ['-f', LibMakefile
, 'cleanall']
1248 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1252 if Target
== 'cleanall':
1254 #os.rmdir(AutoGenObject.BuildDir)
1255 RemoveDirectory(AutoGenObject
.BuildDir
, True)
1256 except WindowsError as X
:
1257 EdkLogger
.error("build", FILE_DELETE_FAILURE
, ExtraData
=str(X
))
1260 ## Build a module or platform
1262 # Create autogen code and makefile for a module or platform, and the launch
1263 # "make" command to build it
1265 # @param Target The target of build command
1266 # @param Platform The platform file
1267 # @param Module The module file
1268 # @param BuildTarget The name of build target, one of "DEBUG", "RELEASE"
1269 # @param ToolChain The name of toolchain to build
1270 # @param Arch The arch of the module/platform
1271 # @param CreateDepModuleCodeFile Flag used to indicate creating code
1272 # for dependent modules/Libraries
1273 # @param CreateDepModuleMakeFile Flag used to indicate creating makefile
1274 # for dependent modules/Libraries
1276 def _Build(self
, Target
, AutoGenObject
, CreateDepsCodeFile
=True, CreateDepsMakeFile
=True, BuildModule
=False):
1277 if AutoGenObject
is None:
1280 # skip file generation for cleanxxx targets, run and fds target
1281 if Target
not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1282 # for target which must generate AutoGen code and makefile
1283 if not self
.SkipAutoGen
or Target
== 'genc':
1284 self
.Progress
.Start("Generating code")
1285 AutoGenObject
.CreateCodeFile(CreateDepsCodeFile
)
1286 self
.Progress
.Stop("done!")
1287 if Target
== "genc":
1290 if not self
.SkipAutoGen
or Target
== 'genmake':
1291 self
.Progress
.Start("Generating makefile")
1292 AutoGenObject
.CreateMakeFile(CreateDepsMakeFile
)
1293 #AutoGenObject.CreateAsBuiltInf()
1294 self
.Progress
.Stop("done!")
1295 if Target
== "genmake":
1298 # always recreate top/platform makefile when clean, just in case of inconsistency
1299 AutoGenObject
.CreateCodeFile(False)
1300 AutoGenObject
.CreateMakeFile(False)
1302 if EdkLogger
.GetLevel() == EdkLogger
.QUIET
:
1303 EdkLogger
.quiet("Building ... %s" % repr(AutoGenObject
))
1305 BuildCommand
= AutoGenObject
.BuildCommand
1306 if BuildCommand
is None or len(BuildCommand
) == 0:
1307 EdkLogger
.error("build", OPTION_MISSING
,
1308 "No build command found for this module. "
1309 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %
1310 (AutoGenObject
.BuildTarget
, AutoGenObject
.ToolChain
, AutoGenObject
.Arch
),
1311 ExtraData
=str(AutoGenObject
))
1316 BuildCommand
= BuildCommand
+ [Target
]
1317 AutoGenObject
.BuildTime
= LaunchCommand(BuildCommand
, AutoGenObject
.MakeFileDir
)
1318 self
.CreateAsBuiltInf()
1323 if GenFdsApi(AutoGenObject
.GenFdsCommandDict
, self
.Db
):
1324 EdkLogger
.error("build", COMMAND_FAILURE
)
1329 RunDir
= os
.path
.normpath(os
.path
.join(AutoGenObject
.BuildDir
, GlobalData
.gGlobalDefines
['ARCH']))
1330 Command
= '.\SecMain'
1332 LaunchCommand(Command
, RunDir
)
1336 if Target
== 'libraries':
1343 if Target
== 'cleanall':
1345 #os.rmdir(AutoGenObject.BuildDir)
1346 RemoveDirectory(AutoGenObject
.BuildDir
, True)
1347 except WindowsError as X
:
1348 EdkLogger
.error("build", FILE_DELETE_FAILURE
, ExtraData
=str(X
))
1351 ## Rebase module image and Get function address for the input module list.
1353 def _RebaseModule (self
, MapBuffer
, BaseAddress
, ModuleList
, AddrIsOffset
= True, ModeIsSmm
= False):
1355 AddrIsOffset
= False
1356 for InfFile
in ModuleList
:
1357 sys
.stdout
.write (".")
1359 ModuleInfo
= ModuleList
[InfFile
]
1360 ModuleName
= ModuleInfo
.BaseName
1361 ModuleOutputImage
= ModuleInfo
.Image
.FileName
1362 ModuleDebugImage
= os
.path
.join(ModuleInfo
.DebugDir
, ModuleInfo
.BaseName
+ '.efi')
1363 ## for SMM module in SMRAM, the SMRAM will be allocated from base to top.
1365 BaseAddress
= BaseAddress
- ModuleInfo
.Image
.Size
1367 # Update Image to new BaseAddress by GenFw tool
1369 LaunchCommand(["GenFw", "--rebase", str(BaseAddress
), "-r", ModuleOutputImage
], ModuleInfo
.OutputDir
)
1370 LaunchCommand(["GenFw", "--rebase", str(BaseAddress
), "-r", ModuleDebugImage
], ModuleInfo
.DebugDir
)
1373 # Set new address to the section header only for SMM driver.
1375 LaunchCommand(["GenFw", "--address", str(BaseAddress
), "-r", ModuleOutputImage
], ModuleInfo
.OutputDir
)
1376 LaunchCommand(["GenFw", "--address", str(BaseAddress
), "-r", ModuleDebugImage
], ModuleInfo
.DebugDir
)
1378 # Collect function address from Map file
1380 ImageMapTable
= ModuleOutputImage
.replace('.efi', '.map')
1382 if os
.path
.exists(ImageMapTable
):
1383 OrigImageBaseAddress
= 0
1384 ImageMap
= open(ImageMapTable
, 'r')
1385 for LinStr
in ImageMap
:
1386 if len (LinStr
.strip()) == 0:
1389 # Get the preferred address set on link time.
1391 if LinStr
.find ('Preferred load address is') != -1:
1392 StrList
= LinStr
.split()
1393 OrigImageBaseAddress
= int (StrList
[len(StrList
) - 1], 16)
1395 StrList
= LinStr
.split()
1396 if len (StrList
) > 4:
1397 if StrList
[3] == 'f' or StrList
[3] == 'F':
1399 RelativeAddress
= int (StrList
[2], 16) - OrigImageBaseAddress
1400 FunctionList
.append ((Name
, RelativeAddress
))
1404 # Add general information.
1407 MapBuffer
.append('\n\n%s (Fixed SMRAM Offset, BaseAddress=0x%010X, EntryPoint=0x%010X)\n' % (ModuleName
, BaseAddress
, BaseAddress
+ ModuleInfo
.Image
.EntryPoint
))
1409 MapBuffer
.append('\n\n%s (Fixed Memory Offset, BaseAddress=-0x%010X, EntryPoint=-0x%010X)\n' % (ModuleName
, 0 - BaseAddress
, 0 - (BaseAddress
+ ModuleInfo
.Image
.EntryPoint
)))
1411 MapBuffer
.append('\n\n%s (Fixed Memory Address, BaseAddress=0x%010X, EntryPoint=0x%010X)\n' % (ModuleName
, BaseAddress
, BaseAddress
+ ModuleInfo
.Image
.EntryPoint
))
1413 # Add guid and general seciton section.
1415 TextSectionAddress
= 0
1416 DataSectionAddress
= 0
1417 for SectionHeader
in ModuleInfo
.Image
.SectionHeaderList
:
1418 if SectionHeader
[0] == '.text':
1419 TextSectionAddress
= SectionHeader
[1]
1420 elif SectionHeader
[0] in ['.data', '.sdata']:
1421 DataSectionAddress
= SectionHeader
[1]
1423 MapBuffer
.append('(GUID=%s, .textbaseaddress=-0x%010X, .databaseaddress=-0x%010X)\n' % (ModuleInfo
.Guid
, 0 - (BaseAddress
+ TextSectionAddress
), 0 - (BaseAddress
+ DataSectionAddress
)))
1425 MapBuffer
.append('(GUID=%s, .textbaseaddress=0x%010X, .databaseaddress=0x%010X)\n' % (ModuleInfo
.Guid
, BaseAddress
+ TextSectionAddress
, BaseAddress
+ DataSectionAddress
))
1427 # Add debug image full path.
1429 MapBuffer
.append('(IMAGE=%s)\n\n' % (ModuleDebugImage
))
1431 # Add function address
1433 for Function
in FunctionList
:
1435 MapBuffer
.append(' -0x%010X %s\n' % (0 - (BaseAddress
+ Function
[1]), Function
[0]))
1437 MapBuffer
.append(' 0x%010X %s\n' % (BaseAddress
+ Function
[1], Function
[0]))
1441 # for SMM module in SMRAM, the SMRAM will be allocated from base to top.
1444 BaseAddress
= BaseAddress
+ ModuleInfo
.Image
.Size
1446 ## Collect MAP information of all FVs
1448 def _CollectFvMapBuffer (self
, MapBuffer
, Wa
, ModuleList
):
1450 # First get the XIP base address for FV map file.
1451 GuidPattern
= re
.compile("[-a-fA-F0-9]+")
1452 GuidName
= re
.compile("\(GUID=[-a-fA-F0-9]+")
1453 for FvName
in Wa
.FdfProfile
.FvDict
:
1454 FvMapBuffer
= os
.path
.join(Wa
.FvDir
, FvName
+ '.Fv.map')
1455 if not os
.path
.exists(FvMapBuffer
):
1457 FvMap
= open(FvMapBuffer
, 'r')
1458 #skip FV size information
1464 MatchGuid
= GuidPattern
.match(Line
)
1465 if MatchGuid
is not None:
1467 # Replace GUID with module name
1469 GuidString
= MatchGuid
.group()
1470 if GuidString
.upper() in ModuleList
:
1471 Line
= Line
.replace(GuidString
, ModuleList
[GuidString
.upper()].Name
)
1472 MapBuffer
.append(Line
)
1474 # Add the debug image full path.
1476 MatchGuid
= GuidName
.match(Line
)
1477 if MatchGuid
is not None:
1478 GuidString
= MatchGuid
.group().split("=")[1]
1479 if GuidString
.upper() in ModuleList
:
1480 MapBuffer
.append('(IMAGE=%s)\n' % (os
.path
.join(ModuleList
[GuidString
.upper()].DebugDir
, ModuleList
[GuidString
.upper()].Name
+ '.efi')))
1484 ## Collect MAP information of all modules
1486 def _CollectModuleMapBuffer (self
, MapBuffer
, ModuleList
):
1487 sys
.stdout
.write ("Generate Load Module At Fix Address Map")
1489 PatchEfiImageList
= []
1497 # reserve 4K size in SMRAM to make SMM module address not from 0.
1499 for ModuleGuid
in ModuleList
:
1500 Module
= ModuleList
[ModuleGuid
]
1501 GlobalData
.gProcessingFile
= "%s [%s, %s, %s]" % (Module
.MetaFile
, Module
.Arch
, Module
.ToolChain
, Module
.BuildTarget
)
1503 OutputImageFile
= ''
1504 for ResultFile
in Module
.CodaTargetList
:
1505 if str(ResultFile
.Target
).endswith('.efi'):
1507 # module list for PEI, DXE, RUNTIME and SMM
1509 OutputImageFile
= os
.path
.join(Module
.OutputDir
, Module
.Name
+ '.efi')
1510 ImageClass
= PeImageClass (OutputImageFile
)
1511 if not ImageClass
.IsValid
:
1512 EdkLogger
.error("build", FILE_PARSE_FAILURE
, ExtraData
=ImageClass
.ErrorInfo
)
1513 ImageInfo
= PeImageInfo(Module
.Name
, Module
.Guid
, Module
.Arch
, Module
.OutputDir
, Module
.DebugDir
, ImageClass
)
1514 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
]:
1515 PeiModuleList
[Module
.MetaFile
] = ImageInfo
1516 PeiSize
+= ImageInfo
.Image
.Size
1517 elif Module
.ModuleType
in [EDK_COMPONENT_TYPE_BS_DRIVER
, SUP_MODULE_DXE_DRIVER
, SUP_MODULE_UEFI_DRIVER
]:
1518 BtModuleList
[Module
.MetaFile
] = ImageInfo
1519 BtSize
+= ImageInfo
.Image
.Size
1520 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
]:
1521 RtModuleList
[Module
.MetaFile
] = ImageInfo
1522 RtSize
+= ImageInfo
.Image
.Size
1523 elif Module
.ModuleType
in [SUP_MODULE_SMM_CORE
, SUP_MODULE_DXE_SMM_DRIVER
, SUP_MODULE_MM_STANDALONE
, SUP_MODULE_MM_CORE_STANDALONE
]:
1524 SmmModuleList
[Module
.MetaFile
] = ImageInfo
1525 SmmSize
+= ImageInfo
.Image
.Size
1526 if Module
.ModuleType
== SUP_MODULE_DXE_SMM_DRIVER
:
1527 PiSpecVersion
= Module
.Module
.Specification
.get('PI_SPECIFICATION_VERSION', '0x00000000')
1528 # for PI specification < PI1.1, DXE_SMM_DRIVER also runs as BOOT time driver.
1529 if int(PiSpecVersion
, 16) < 0x0001000A:
1530 BtModuleList
[Module
.MetaFile
] = ImageInfo
1531 BtSize
+= ImageInfo
.Image
.Size
1534 # EFI image is final target.
1535 # Check EFI image contains patchable FixAddress related PCDs.
1537 if OutputImageFile
!= '':
1538 ModuleIsPatch
= False
1539 for Pcd
in Module
.ModulePcdList
:
1540 if Pcd
.Type
== TAB_PCDS_PATCHABLE_IN_MODULE
and Pcd
.TokenCName
in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SET
:
1541 ModuleIsPatch
= True
1543 if not ModuleIsPatch
:
1544 for Pcd
in Module
.LibraryPcdList
:
1545 if Pcd
.Type
== TAB_PCDS_PATCHABLE_IN_MODULE
and Pcd
.TokenCName
in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SET
:
1546 ModuleIsPatch
= True
1549 if not ModuleIsPatch
:
1552 # Module includes the patchable load fix address PCDs.
1553 # It will be fixed up later.
1555 PatchEfiImageList
.append (OutputImageFile
)
1558 # Get Top Memory address
1560 ReservedRuntimeMemorySize
= 0
1561 TopMemoryAddress
= 0
1562 if self
.LoadFixAddress
== 0xFFFFFFFFFFFFFFFF:
1563 TopMemoryAddress
= 0
1565 TopMemoryAddress
= self
.LoadFixAddress
1566 if TopMemoryAddress
< RtSize
+ BtSize
+ PeiSize
:
1567 EdkLogger
.error("build", PARAMETER_INVALID
, "FIX_LOAD_TOP_MEMORY_ADDRESS is too low to load driver")
1570 # Patch FixAddress related PCDs into EFI image
1572 for EfiImage
in PatchEfiImageList
:
1573 EfiImageMap
= EfiImage
.replace('.efi', '.map')
1574 if not os
.path
.exists(EfiImageMap
):
1577 # Get PCD offset in EFI image by GenPatchPcdTable function
1579 PcdTable
= parsePcdInfoFromMapFile(EfiImageMap
, EfiImage
)
1581 # Patch real PCD value by PatchPcdValue tool
1583 for PcdInfo
in PcdTable
:
1585 if PcdInfo
[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE
:
1586 ReturnValue
, ErrorInfo
= PatchBinaryFile (EfiImage
, PcdInfo
[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE_DATA_TYPE
, str (PeiSize
// 0x1000))
1587 elif PcdInfo
[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE
:
1588 ReturnValue
, ErrorInfo
= PatchBinaryFile (EfiImage
, PcdInfo
[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE_DATA_TYPE
, str (BtSize
// 0x1000))
1589 elif PcdInfo
[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE
:
1590 ReturnValue
, ErrorInfo
= PatchBinaryFile (EfiImage
, PcdInfo
[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE_DATA_TYPE
, str (RtSize
// 0x1000))
1591 elif PcdInfo
[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE
and len (SmmModuleList
) > 0:
1592 ReturnValue
, ErrorInfo
= PatchBinaryFile (EfiImage
, PcdInfo
[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE_DATA_TYPE
, str (SmmSize
// 0x1000))
1593 if ReturnValue
!= 0:
1594 EdkLogger
.error("build", PARAMETER_INVALID
, "Patch PCD value failed", ExtraData
=ErrorInfo
)
1596 MapBuffer
.append('PEI_CODE_PAGE_NUMBER = 0x%x\n' % (PeiSize
// 0x1000))
1597 MapBuffer
.append('BOOT_CODE_PAGE_NUMBER = 0x%x\n' % (BtSize
// 0x1000))
1598 MapBuffer
.append('RUNTIME_CODE_PAGE_NUMBER = 0x%x\n' % (RtSize
// 0x1000))
1599 if len (SmmModuleList
) > 0:
1600 MapBuffer
.append('SMM_CODE_PAGE_NUMBER = 0x%x\n' % (SmmSize
// 0x1000))
1602 PeiBaseAddr
= TopMemoryAddress
- RtSize
- BtSize
1603 BtBaseAddr
= TopMemoryAddress
- RtSize
1604 RtBaseAddr
= TopMemoryAddress
- ReservedRuntimeMemorySize
1606 self
._RebaseModule
(MapBuffer
, PeiBaseAddr
, PeiModuleList
, TopMemoryAddress
== 0)
1607 self
._RebaseModule
(MapBuffer
, BtBaseAddr
, BtModuleList
, TopMemoryAddress
== 0)
1608 self
._RebaseModule
(MapBuffer
, RtBaseAddr
, RtModuleList
, TopMemoryAddress
== 0)
1609 self
._RebaseModule
(MapBuffer
, 0x1000, SmmModuleList
, AddrIsOffset
=False, ModeIsSmm
=True)
1610 MapBuffer
.append('\n\n')
1611 sys
.stdout
.write ("\n")
1614 ## Save platform Map file
1616 def _SaveMapFile (self
, MapBuffer
, Wa
):
1618 # Map file path is got.
1620 MapFilePath
= os
.path
.join(Wa
.BuildDir
, Wa
.Name
+ '.map')
1622 # Save address map into MAP file.
1624 SaveFileOnChange(MapFilePath
, ''.join(MapBuffer
), False)
1625 if self
.LoadFixAddress
!= 0:
1626 sys
.stdout
.write ("\nLoad Module At Fix Address Map file can be found at %s\n" % (MapFilePath
))
1629 ## Build active platform for different build targets and different tool chains
1631 def _BuildPlatform(self
):
1632 SaveFileOnChange(self
.PlatformBuildPath
, '# DO NOT EDIT \n# FILE auto-generated\n', False)
1633 for BuildTarget
in self
.BuildTargetList
:
1634 GlobalData
.gGlobalDefines
['TARGET'] = BuildTarget
1636 for ToolChain
in self
.ToolChainList
:
1637 GlobalData
.gGlobalDefines
['TOOLCHAIN'] = ToolChain
1638 GlobalData
.gGlobalDefines
['TOOL_CHAIN_TAG'] = ToolChain
1639 GlobalData
.gGlobalDefines
['FAMILY'] = self
.ToolChainFamily
[index
]
1641 Wa
= WorkspaceAutoGen(
1658 self
.Fdf
= Wa
.FdfFile
1659 self
.LoadFixAddress
= Wa
.Platform
.LoadFixAddress
1660 self
.BuildReport
.AddPlatformReport(Wa
)
1661 self
.Progress
.Stop("done!")
1663 # Add ffs build to makefile
1665 if GlobalData
.gEnableGenfdsMultiThread
and self
.Fdf
:
1666 CmdListDict
= self
._GenFfsCmd
(Wa
.ArchList
)
1668 for Arch
in Wa
.ArchList
:
1669 GlobalData
.gGlobalDefines
['ARCH'] = Arch
1670 Pa
= PlatformAutoGen(Wa
, self
.PlatformFile
, BuildTarget
, ToolChain
, Arch
)
1671 for Module
in Pa
.Platform
.Modules
:
1672 # Get ModuleAutoGen object to generate C code file and makefile
1673 Ma
= ModuleAutoGen(Wa
, Module
, BuildTarget
, ToolChain
, Arch
, self
.PlatformFile
)
1676 self
.BuildModules
.append(Ma
)
1677 self
._BuildPa
(self
.Target
, Pa
, FfsCommand
=CmdListDict
)
1679 # Create MAP file when Load Fix Address is enabled.
1680 if self
.Target
in ["", "all", "fds"]:
1681 for Arch
in Wa
.ArchList
:
1682 GlobalData
.gGlobalDefines
['ARCH'] = Arch
1684 # Check whether the set fix address is above 4G for 32bit image.
1686 if (Arch
== 'IA32' or Arch
== 'ARM') and self
.LoadFixAddress
!= 0xFFFFFFFFFFFFFFFF and self
.LoadFixAddress
>= 0x100000000:
1687 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")
1692 for Pa
in Wa
.AutoGenObjectList
:
1693 for Ma
in Pa
.ModuleAutoGenList
:
1696 if not Ma
.IsLibrary
:
1697 ModuleList
[Ma
.Guid
.upper()] = Ma
1700 if self
.LoadFixAddress
!= 0:
1702 # Rebase module to the preferred memory address before GenFds
1704 self
._CollectModuleMapBuffer
(MapBuffer
, ModuleList
)
1707 # create FDS again for the updated EFI image
1709 self
._Build
("fds", Wa
)
1711 # Create MAP file for all platform FVs after GenFds.
1713 self
._CollectFvMapBuffer
(MapBuffer
, Wa
, ModuleList
)
1715 # Save MAP buffer into MAP file.
1717 self
._SaveMapFile
(MapBuffer
, Wa
)
1719 ## Build active module for different build targets, different tool chains and different archs
1721 def _BuildModule(self
):
1722 for BuildTarget
in self
.BuildTargetList
:
1723 GlobalData
.gGlobalDefines
['TARGET'] = BuildTarget
1725 for ToolChain
in self
.ToolChainList
:
1726 WorkspaceAutoGenTime
= time
.time()
1727 GlobalData
.gGlobalDefines
['TOOLCHAIN'] = ToolChain
1728 GlobalData
.gGlobalDefines
['TOOL_CHAIN_TAG'] = ToolChain
1729 GlobalData
.gGlobalDefines
['FAMILY'] = self
.ToolChainFamily
[index
]
1732 # module build needs platform build information, so get platform
1735 Wa
= WorkspaceAutoGen(
1753 self
.Fdf
= Wa
.FdfFile
1754 self
.LoadFixAddress
= Wa
.Platform
.LoadFixAddress
1755 Wa
.CreateMakeFile(False)
1756 # Add ffs build to makefile
1758 if GlobalData
.gEnableGenfdsMultiThread
and self
.Fdf
:
1759 CmdListDict
= self
._GenFfsCmd
(Wa
.ArchList
)
1760 self
.Progress
.Stop("done!")
1762 ExitFlag
= threading
.Event()
1764 self
.AutoGenTime
+= int(round((time
.time() - WorkspaceAutoGenTime
)))
1765 for Arch
in Wa
.ArchList
:
1766 AutoGenStart
= time
.time()
1767 GlobalData
.gGlobalDefines
['ARCH'] = Arch
1768 Pa
= PlatformAutoGen(Wa
, self
.PlatformFile
, BuildTarget
, ToolChain
, Arch
)
1769 for Module
in Pa
.Platform
.Modules
:
1770 if self
.ModuleFile
.Dir
== Module
.Dir
and self
.ModuleFile
.Name
== Module
.Name
:
1771 Ma
= ModuleAutoGen(Wa
, Module
, BuildTarget
, ToolChain
, Arch
, self
.PlatformFile
)
1772 if Ma
is None: continue
1774 if Ma
.CanSkipbyHash():
1775 self
.HashSkipModules
.append(Ma
)
1777 # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'
1778 if self
.Target
not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1779 # for target which must generate AutoGen code and makefile
1780 if not self
.SkipAutoGen
or self
.Target
== 'genc':
1781 self
.Progress
.Start("Generating code")
1782 Ma
.CreateCodeFile(True)
1783 self
.Progress
.Stop("done!")
1784 if self
.Target
== "genc":
1786 if not self
.SkipAutoGen
or self
.Target
== 'genmake':
1787 self
.Progress
.Start("Generating makefile")
1788 if CmdListDict
and self
.Fdf
and (Module
.File
, Arch
) in CmdListDict
:
1789 Ma
.CreateMakeFile(True, CmdListDict
[Module
.File
, Arch
])
1790 del CmdListDict
[Module
.File
, Arch
]
1792 Ma
.CreateMakeFile(True)
1793 self
.Progress
.Stop("done!")
1794 if self
.Target
== "genmake":
1796 self
.BuildModules
.append(Ma
)
1797 self
.AutoGenTime
+= int(round((time
.time() - AutoGenStart
)))
1798 MakeStart
= time
.time()
1799 for Ma
in self
.BuildModules
:
1800 if not Ma
.IsBinaryModule
:
1801 Bt
= BuildTask
.New(ModuleMakeUnit(Ma
, self
.Target
))
1802 # Break build if any build thread has error
1803 if BuildTask
.HasError():
1804 # we need a full version of makefile for platform
1806 BuildTask
.WaitForComplete()
1807 Pa
.CreateMakeFile(False)
1808 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
1809 # Start task scheduler
1810 if not BuildTask
.IsOnGoing():
1811 BuildTask
.StartScheduler(self
.ThreadNumber
, ExitFlag
)
1813 # in case there's an interruption. we need a full version of makefile for platform
1814 Pa
.CreateMakeFile(False)
1815 if BuildTask
.HasError():
1816 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
1817 self
.MakeTime
+= int(round((time
.time() - MakeStart
)))
1819 MakeContiue
= time
.time()
1821 BuildTask
.WaitForComplete()
1822 self
.CreateAsBuiltInf()
1823 self
.MakeTime
+= int(round((time
.time() - MakeContiue
)))
1824 if BuildTask
.HasError():
1825 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
1827 self
.BuildReport
.AddPlatformReport(Wa
, MaList
)
1832 "Module for [%s] is not a component of active platform."\
1833 " Please make sure that the ARCH and inf file path are"\
1834 " given in the same as in [%s]" % \
1835 (', '.join(Wa
.ArchList
), self
.PlatformFile
),
1836 ExtraData
=self
.ModuleFile
1838 # Create MAP file when Load Fix Address is enabled.
1839 if self
.Target
== "fds" and self
.Fdf
:
1840 for Arch
in Wa
.ArchList
:
1842 # Check whether the set fix address is above 4G for 32bit image.
1844 if (Arch
== 'IA32' or Arch
== 'ARM') and self
.LoadFixAddress
!= 0xFFFFFFFFFFFFFFFF and self
.LoadFixAddress
>= 0x100000000:
1845 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")
1850 for Pa
in Wa
.AutoGenObjectList
:
1851 for Ma
in Pa
.ModuleAutoGenList
:
1854 if not Ma
.IsLibrary
:
1855 ModuleList
[Ma
.Guid
.upper()] = Ma
1858 if self
.LoadFixAddress
!= 0:
1860 # Rebase module to the preferred memory address before GenFds
1862 self
._CollectModuleMapBuffer
(MapBuffer
, ModuleList
)
1864 # create FDS again for the updated EFI image
1866 GenFdsStart
= time
.time()
1867 self
._Build
("fds", Wa
)
1868 self
.GenFdsTime
+= int(round((time
.time() - GenFdsStart
)))
1870 # Create MAP file for all platform FVs after GenFds.
1872 self
._CollectFvMapBuffer
(MapBuffer
, Wa
, ModuleList
)
1874 # Save MAP buffer into MAP file.
1876 self
._SaveMapFile
(MapBuffer
, Wa
)
1878 def _GenFfsCmd(self
,ArchList
):
1879 # convert dictionary of Cmd:(Inf,Arch)
1880 # to a new dictionary of (Inf,Arch):Cmd,Cmd,Cmd...
1881 CmdSetDict
= defaultdict(set)
1882 GenFfsDict
= GenFds
.GenFfsMakefile('', GlobalData
.gFdfParser
, self
, ArchList
, GlobalData
)
1883 for Cmd
in GenFfsDict
:
1884 tmpInf
, tmpArch
= GenFfsDict
[Cmd
]
1885 CmdSetDict
[tmpInf
, tmpArch
].add(Cmd
)
1888 ## Build a platform in multi-thread mode
1890 def _MultiThreadBuildPlatform(self
):
1891 SaveFileOnChange(self
.PlatformBuildPath
, '# DO NOT EDIT \n# FILE auto-generated\n', False)
1892 for BuildTarget
in self
.BuildTargetList
:
1893 GlobalData
.gGlobalDefines
['TARGET'] = BuildTarget
1895 for ToolChain
in self
.ToolChainList
:
1896 WorkspaceAutoGenTime
= time
.time()
1897 GlobalData
.gGlobalDefines
['TOOLCHAIN'] = ToolChain
1898 GlobalData
.gGlobalDefines
['TOOL_CHAIN_TAG'] = ToolChain
1899 GlobalData
.gGlobalDefines
['FAMILY'] = self
.ToolChainFamily
[index
]
1901 Wa
= WorkspaceAutoGen(
1918 self
.Fdf
= Wa
.FdfFile
1919 self
.LoadFixAddress
= Wa
.Platform
.LoadFixAddress
1920 self
.BuildReport
.AddPlatformReport(Wa
)
1921 Wa
.CreateMakeFile(False)
1923 # Add ffs build to makefile
1925 if GlobalData
.gEnableGenfdsMultiThread
and self
.Fdf
:
1926 CmdListDict
= self
._GenFfsCmd
(Wa
.ArchList
)
1928 # multi-thread exit flag
1929 ExitFlag
= threading
.Event()
1931 self
.AutoGenTime
+= int(round((time
.time() - WorkspaceAutoGenTime
)))
1932 for Arch
in Wa
.ArchList
:
1933 AutoGenStart
= time
.time()
1934 GlobalData
.gGlobalDefines
['ARCH'] = Arch
1935 Pa
= PlatformAutoGen(Wa
, self
.PlatformFile
, BuildTarget
, ToolChain
, Arch
)
1939 for Inf
in Pa
.Platform
.Modules
:
1940 ModuleList
.append(Inf
)
1941 # Add the INF only list in FDF
1942 if GlobalData
.gFdfParser
is not None:
1943 for InfName
in GlobalData
.gFdfParser
.Profile
.InfList
:
1944 Inf
= PathClass(NormPath(InfName
), self
.WorkspaceDir
, Arch
)
1945 if Inf
in Pa
.Platform
.Modules
:
1947 ModuleList
.append(Inf
)
1948 for Module
in ModuleList
:
1949 # Get ModuleAutoGen object to generate C code file and makefile
1950 Ma
= ModuleAutoGen(Wa
, Module
, BuildTarget
, ToolChain
, Arch
, self
.PlatformFile
)
1954 if Ma
.CanSkipbyHash():
1955 self
.HashSkipModules
.append(Ma
)
1958 # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'
1959 if self
.Target
not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1960 # for target which must generate AutoGen code and makefile
1961 if not self
.SkipAutoGen
or self
.Target
== 'genc':
1962 Ma
.CreateCodeFile(True)
1963 if self
.Target
== "genc":
1966 if not self
.SkipAutoGen
or self
.Target
== 'genmake':
1967 if CmdListDict
and self
.Fdf
and (Module
.File
, Arch
) in CmdListDict
:
1968 Ma
.CreateMakeFile(True, CmdListDict
[Module
.File
, Arch
])
1969 del CmdListDict
[Module
.File
, Arch
]
1971 Ma
.CreateMakeFile(True)
1972 if self
.Target
== "genmake":
1974 self
.BuildModules
.append(Ma
)
1975 self
.Progress
.Stop("done!")
1976 self
.AutoGenTime
+= int(round((time
.time() - AutoGenStart
)))
1977 MakeStart
= time
.time()
1978 for Ma
in self
.BuildModules
:
1979 # Generate build task for the module
1980 if not Ma
.IsBinaryModule
:
1981 Bt
= BuildTask
.New(ModuleMakeUnit(Ma
, self
.Target
))
1982 # Break build if any build thread has error
1983 if BuildTask
.HasError():
1984 # we need a full version of makefile for platform
1986 BuildTask
.WaitForComplete()
1987 Pa
.CreateMakeFile(False)
1988 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
1989 # Start task scheduler
1990 if not BuildTask
.IsOnGoing():
1991 BuildTask
.StartScheduler(self
.ThreadNumber
, ExitFlag
)
1993 # in case there's an interruption. we need a full version of makefile for platform
1994 Pa
.CreateMakeFile(False)
1995 if BuildTask
.HasError():
1996 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
1997 self
.MakeTime
+= int(round((time
.time() - MakeStart
)))
1999 MakeContiue
= time
.time()
2003 # All modules have been put in build tasks queue. Tell task scheduler
2004 # to exit if all tasks are completed
2007 BuildTask
.WaitForComplete()
2008 self
.CreateAsBuiltInf()
2009 self
.MakeTime
+= int(round((time
.time() - MakeContiue
)))
2011 # Check for build error, and raise exception if one
2012 # has been signaled.
2014 if BuildTask
.HasError():
2015 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
2017 # Create MAP file when Load Fix Address is enabled.
2018 if self
.Target
in ["", "all", "fds"]:
2019 for Arch
in Wa
.ArchList
:
2021 # Check whether the set fix address is above 4G for 32bit image.
2023 if (Arch
== 'IA32' or Arch
== 'ARM') and self
.LoadFixAddress
!= 0xFFFFFFFFFFFFFFFF and self
.LoadFixAddress
>= 0x100000000:
2024 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")
2029 for Pa
in Wa
.AutoGenObjectList
:
2030 for Ma
in Pa
.ModuleAutoGenList
:
2033 if not Ma
.IsLibrary
:
2034 ModuleList
[Ma
.Guid
.upper()] = Ma
2036 # Rebase module to the preferred memory address before GenFds
2039 if self
.LoadFixAddress
!= 0:
2040 self
._CollectModuleMapBuffer
(MapBuffer
, ModuleList
)
2044 # Generate FD image if there's a FDF file found
2046 GenFdsStart
= time
.time()
2047 if GenFdsApi(Wa
.GenFdsCommandDict
, self
.Db
):
2048 EdkLogger
.error("build", COMMAND_FAILURE
)
2051 # Create MAP file for all platform FVs after GenFds.
2053 self
._CollectFvMapBuffer
(MapBuffer
, Wa
, ModuleList
)
2054 self
.GenFdsTime
+= int(round((time
.time() - GenFdsStart
)))
2056 # Save MAP buffer into MAP file.
2058 self
._SaveMapFile
(MapBuffer
, Wa
)
2060 ## Generate GuidedSectionTools.txt in the FV directories.
2062 def CreateGuidedSectionToolsFile(self
):
2063 for BuildTarget
in self
.BuildTargetList
:
2064 for ToolChain
in self
.ToolChainList
:
2065 Wa
= WorkspaceAutoGen(
2082 if not os
.path
.exists(FvDir
):
2085 for Arch
in self
.ArchList
:
2086 # Build up the list of supported architectures for this build
2087 prefix
= '%s_%s_%s_' % (BuildTarget
, ToolChain
, Arch
)
2089 # Look through the tool definitions for GUIDed tools
2091 for (attrib
, value
) in self
.ToolDef
.ToolsDefTxtDictionary
.items():
2092 if attrib
.upper().endswith('_GUID'):
2093 split
= attrib
.split('_')
2094 thisPrefix
= '_'.join(split
[0:3]) + '_'
2095 if thisPrefix
== prefix
:
2096 guid
= self
.ToolDef
.ToolsDefTxtDictionary
[attrib
]
2099 path
= '_'.join(split
[0:4]) + '_PATH'
2100 path
= self
.ToolDef
.ToolsDefTxtDictionary
[path
]
2101 path
= self
.GetFullPathOfTool(path
)
2102 guidAttribs
.append((guid
, toolName
, path
))
2104 # Write out GuidedSecTools.txt
2105 toolsFile
= os
.path
.join(FvDir
, 'GuidedSectionTools.txt')
2106 toolsFile
= open(toolsFile
, 'wt')
2107 for guidedSectionTool
in guidAttribs
:
2108 print(' '.join(guidedSectionTool
), file=toolsFile
)
2111 ## Returns the full path of the tool.
2113 def GetFullPathOfTool (self
, tool
):
2114 if os
.path
.exists(tool
):
2115 return os
.path
.realpath(tool
)
2117 # We need to search for the tool using the
2118 # PATH environment variable.
2119 for dirInPath
in os
.environ
['PATH'].split(os
.pathsep
):
2120 foundPath
= os
.path
.join(dirInPath
, tool
)
2121 if os
.path
.exists(foundPath
):
2122 return os
.path
.realpath(foundPath
)
2124 # If the tool was not found in the path then we just return
2128 ## Launch the module or platform build
2131 if not self
.ModuleFile
:
2132 if not self
.SpawnMode
or self
.Target
not in ["", "all"]:
2133 self
.SpawnMode
= False
2134 self
._BuildPlatform
()
2136 self
._MultiThreadBuildPlatform
()
2137 self
.CreateGuidedSectionToolsFile()
2139 self
.SpawnMode
= False
2142 if self
.Target
== 'cleanall':
2143 RemoveDirectory(os
.path
.dirname(GlobalData
.gDatabasePath
), True)
2145 def CreateAsBuiltInf(self
):
2146 for Module
in self
.BuildModules
:
2147 Module
.CreateAsBuiltInf()
2148 for Module
in self
.HashSkipModules
:
2149 Module
.CreateAsBuiltInf(True)
2150 self
.BuildModules
= []
2151 self
.HashSkipModules
= []
2152 ## Do some clean-up works when error occurred
2153 def Relinquish(self
):
2154 OldLogLevel
= EdkLogger
.GetLevel()
2155 EdkLogger
.SetLevel(EdkLogger
.ERROR
)
2156 Utils
.Progressor
.Abort()
2157 if self
.SpawnMode
== True:
2159 EdkLogger
.SetLevel(OldLogLevel
)
2161 def ParseDefines(DefineList
=[]):
2163 if DefineList
is not None:
2164 for Define
in DefineList
:
2165 DefineTokenList
= Define
.split("=", 1)
2166 if not GlobalData
.gMacroNamePattern
.match(DefineTokenList
[0]):
2167 EdkLogger
.error('build', FORMAT_INVALID
,
2168 "The macro name must be in the pattern [A-Z][A-Z0-9_]*",
2169 ExtraData
=DefineTokenList
[0])
2171 if len(DefineTokenList
) == 1:
2172 DefineDict
[DefineTokenList
[0]] = "TRUE"
2174 DefineDict
[DefineTokenList
[0]] = DefineTokenList
[1].strip()
2178 def SingleCheckCallback(option
, opt_str
, value
, parser
):
2179 if option
not in gParamCheck
:
2180 setattr(parser
.values
, option
.dest
, value
)
2181 gParamCheck
.append(option
)
2183 parser
.error("Option %s only allows one instance in command line!" % option
)
2185 def LogBuildTime(Time
):
2188 TimeDur
= time
.gmtime(Time
)
2189 if TimeDur
.tm_yday
> 1:
2190 TimeDurStr
= time
.strftime("%H:%M:%S", TimeDur
) + ", %d day(s)" % (TimeDur
.tm_yday
- 1)
2192 TimeDurStr
= time
.strftime("%H:%M:%S", TimeDur
)
2197 ## Parse command line options
2199 # Using standard Python module optparse to parse command line option of this tool.
2201 # @retval Opt A optparse.Values object containing the parsed options
2202 # @retval Args Target of build command
2204 def MyOptionParser():
2205 Parser
= OptionParser(description
=__copyright__
, version
=__version__
, prog
="build.exe", usage
="%prog [options] [all|fds|genc|genmake|clean|cleanall|cleanlib|modules|libraries|run]")
2206 Parser
.add_option("-a", "--arch", action
="append", type="choice", choices
=['IA32', 'X64', 'EBC', 'ARM', 'AARCH64'], dest
="TargetArch",
2207 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.")
2208 Parser
.add_option("-p", "--platform", action
="callback", type="string", dest
="PlatformFile", callback
=SingleCheckCallback
,
2209 help="Build the platform specified by the DSC file name argument, overriding target.txt's ACTIVE_PLATFORM definition.")
2210 Parser
.add_option("-m", "--module", action
="callback", type="string", dest
="ModuleFile", callback
=SingleCheckCallback
,
2211 help="Build the module specified by the INF file name argument.")
2212 Parser
.add_option("-b", "--buildtarget", type="string", dest
="BuildTarget", help="Using the TARGET to build the platform, overriding target.txt's TARGET definition.",
2214 Parser
.add_option("-t", "--tagname", action
="append", type="string", dest
="ToolChain",
2215 help="Using the Tool Chain Tagname to build the platform, overriding target.txt's TOOL_CHAIN_TAG definition.")
2216 Parser
.add_option("-x", "--sku-id", action
="callback", type="string", dest
="SkuId", callback
=SingleCheckCallback
,
2217 help="Using this name of SKU ID to build the platform, overriding SKUID_IDENTIFIER in DSC file.")
2219 Parser
.add_option("-n", action
="callback", type="int", dest
="ThreadNumber", callback
=SingleCheckCallback
,
2220 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 "\
2221 "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.")
2223 Parser
.add_option("-f", "--fdf", action
="callback", type="string", dest
="FdfFile", callback
=SingleCheckCallback
,
2224 help="The name of the FDF file to use, which overrides the setting in the DSC file.")
2225 Parser
.add_option("-r", "--rom-image", action
="append", type="string", dest
="RomImage", default
=[],
2226 help="The name of FD to be generated. The name must be from [FD] section in FDF file.")
2227 Parser
.add_option("-i", "--fv-image", action
="append", type="string", dest
="FvImage", default
=[],
2228 help="The name of FV to be generated. The name must be from [FV] section in FDF file.")
2229 Parser
.add_option("-C", "--capsule-image", action
="append", type="string", dest
="CapName", default
=[],
2230 help="The name of Capsule to be generated. The name must be from [Capsule] section in FDF file.")
2231 Parser
.add_option("-u", "--skip-autogen", action
="store_true", dest
="SkipAutoGen", help="Skip AutoGen step.")
2232 Parser
.add_option("-e", "--re-parse", action
="store_true", dest
="Reparse", help="Re-parse all meta-data files.")
2234 Parser
.add_option("-c", "--case-insensitive", action
="store_true", dest
="CaseInsensitive", default
=False, help="Don't check case of file name.")
2236 Parser
.add_option("-w", "--warning-as-error", action
="store_true", dest
="WarningAsError", help="Treat warning in tools as error.")
2237 Parser
.add_option("-j", "--log", action
="store", dest
="LogFile", help="Put log in specified file as well as on console.")
2239 Parser
.add_option("-s", "--silent", action
="store_true", type=None, dest
="SilentMode",
2240 help="Make use of silent mode of (n)make.")
2241 Parser
.add_option("-q", "--quiet", action
="store_true", type=None, help="Disable all messages except FATAL ERRORS.")
2242 Parser
.add_option("-v", "--verbose", action
="store_true", type=None, help="Turn on verbose output with informational messages printed, "\
2243 "including library instances selected, final dependency expression, "\
2244 "and warning messages, etc.")
2245 Parser
.add_option("-d", "--debug", action
="store", type="int", help="Enable debug messages at specified level.")
2246 Parser
.add_option("-D", "--define", action
="append", type="string", dest
="Macros", help="Macro: \"Name [= Value]\".")
2248 Parser
.add_option("-y", "--report-file", action
="store", dest
="ReportFile", help="Create/overwrite the report to the specified filename.")
2249 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
=[],
2250 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]. "\
2251 "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]")
2252 Parser
.add_option("-F", "--flag", action
="store", type="string", dest
="Flag",
2253 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. "\
2254 "This option can also be specified by setting *_*_*_BUILD_FLAGS in [BuildOptions] section of platform DSC. If they are both specified, this value "\
2255 "will override the setting in [BuildOptions] section of platform DSC.")
2256 Parser
.add_option("-N", "--no-cache", action
="store_true", dest
="DisableCache", default
=False, help="Disable build cache mechanism")
2257 Parser
.add_option("--conf", action
="store", type="string", dest
="ConfDirectory", help="Specify the customized Conf directory.")
2258 Parser
.add_option("--check-usage", action
="store_true", dest
="CheckUsage", default
=False, help="Check usage content of entries listed in INF file.")
2259 Parser
.add_option("--ignore-sources", action
="store_true", dest
="IgnoreSources", default
=False, help="Focus to a binary build and ignore all source files")
2260 Parser
.add_option("--pcd", action
="append", dest
="OptionPcd", help="Set PCD value by command line. Format: \"PcdName=Value\" ")
2261 Parser
.add_option("-l", "--cmd-len", action
="store", type="int", dest
="CommandLength", help="Specify the maximum line length of build command. Default is 4096.")
2262 Parser
.add_option("--hash", action
="store_true", dest
="UseHashCache", default
=False, help="Enable hash-based caching during build process.")
2263 Parser
.add_option("--binary-destination", action
="store", type="string", dest
="BinCacheDest", help="Generate a cache of binary files in the specified directory.")
2264 Parser
.add_option("--binary-source", action
="store", type="string", dest
="BinCacheSource", help="Consume a cache of binary files from the specified directory.")
2265 Parser
.add_option("--genfds-multi-thread", action
="store_true", dest
="GenfdsMultiThread", default
=False, help="Enable GenFds multi thread to generate ffs file.")
2266 Parser
.add_option("--disable-include-path-check", action
="store_true", dest
="DisableIncludePathCheck", default
=False, help="Disable the include path check for outside of package.")
2267 (Opt
, Args
) = Parser
.parse_args()
2270 ## Tool entrance method
2272 # This method mainly dispatch specific methods per the command line options.
2273 # If no error found, return zero value so the caller of this tool can know
2274 # if it's executed successfully or not.
2276 # @retval 0 Tool was successful
2277 # @retval 1 Tool failed
2280 StartTime
= time
.time()
2282 # Initialize log system
2283 EdkLogger
.Initialize()
2284 GlobalData
.gCommand
= sys
.argv
[1:]
2286 # Parse the options and args
2288 (Option
, Target
) = MyOptionParser()
2289 GlobalData
.gOptions
= Option
2290 GlobalData
.gCaseInsensitive
= Option
.CaseInsensitive
2293 if Option
.verbose
is not None:
2294 EdkLogger
.SetLevel(EdkLogger
.VERBOSE
)
2295 elif Option
.quiet
is not None:
2296 EdkLogger
.SetLevel(EdkLogger
.QUIET
)
2297 elif Option
.debug
is not None:
2298 EdkLogger
.SetLevel(Option
.debug
+ 1)
2300 EdkLogger
.SetLevel(EdkLogger
.INFO
)
2302 if Option
.LogFile
is not None:
2303 EdkLogger
.SetLogFile(Option
.LogFile
)
2305 if Option
.WarningAsError
== True:
2306 EdkLogger
.SetWarningAsError()
2308 if platform
.platform().find("Windows") >= 0:
2309 GlobalData
.gIsWindows
= True
2311 GlobalData
.gIsWindows
= False
2313 EdkLogger
.quiet("Build environment: %s" % platform
.platform())
2314 EdkLogger
.quiet(time
.strftime("Build start time: %H:%M:%S, %b.%d %Y\n", time
.localtime()));
2319 if len(Target
) == 0:
2321 elif len(Target
) >= 2:
2322 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, "More than one targets are not supported.",
2323 ExtraData
="Please select one of: %s" % (' '.join(gSupportedTarget
)))
2325 Target
= Target
[0].lower()
2327 if Target
not in gSupportedTarget
:
2328 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, "Not supported target [%s]." % Target
,
2329 ExtraData
="Please select one of: %s" % (' '.join(gSupportedTarget
)))
2332 # Check environment variable: EDK_TOOLS_PATH, WORKSPACE, PATH
2335 GlobalData
.gCommandLineDefines
.update(ParseDefines(Option
.Macros
))
2337 Workspace
= os
.getenv("WORKSPACE")
2339 # Get files real name in workspace dir
2341 GlobalData
.gAllFiles
= Utils
.DirCache(Workspace
)
2343 WorkingDirectory
= os
.getcwd()
2344 if not Option
.ModuleFile
:
2345 FileList
= glob
.glob(os
.path
.normpath(os
.path
.join(WorkingDirectory
, '*.inf')))
2346 FileNum
= len(FileList
)
2348 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, "There are %d INF files in %s." % (FileNum
, WorkingDirectory
),
2349 ExtraData
="Please use '-m <INF_FILE_PATH>' switch to choose one.")
2351 Option
.ModuleFile
= NormFile(FileList
[0], Workspace
)
2353 if Option
.ModuleFile
:
2354 if os
.path
.isabs (Option
.ModuleFile
):
2355 if os
.path
.normcase (os
.path
.normpath(Option
.ModuleFile
)).find (Workspace
) == 0:
2356 Option
.ModuleFile
= NormFile(os
.path
.normpath(Option
.ModuleFile
), Workspace
)
2357 Option
.ModuleFile
= PathClass(Option
.ModuleFile
, Workspace
)
2358 ErrorCode
, ErrorInfo
= Option
.ModuleFile
.Validate(".inf", False)
2360 EdkLogger
.error("build", ErrorCode
, ExtraData
=ErrorInfo
)
2362 if Option
.PlatformFile
is not None:
2363 if os
.path
.isabs (Option
.PlatformFile
):
2364 if os
.path
.normcase (os
.path
.normpath(Option
.PlatformFile
)).find (Workspace
) == 0:
2365 Option
.PlatformFile
= NormFile(os
.path
.normpath(Option
.PlatformFile
), Workspace
)
2366 Option
.PlatformFile
= PathClass(Option
.PlatformFile
, Workspace
)
2368 if Option
.FdfFile
is not None:
2369 if os
.path
.isabs (Option
.FdfFile
):
2370 if os
.path
.normcase (os
.path
.normpath(Option
.FdfFile
)).find (Workspace
) == 0:
2371 Option
.FdfFile
= NormFile(os
.path
.normpath(Option
.FdfFile
), Workspace
)
2372 Option
.FdfFile
= PathClass(Option
.FdfFile
, Workspace
)
2373 ErrorCode
, ErrorInfo
= Option
.FdfFile
.Validate(".fdf", False)
2375 EdkLogger
.error("build", ErrorCode
, ExtraData
=ErrorInfo
)
2377 if Option
.Flag
is not None and Option
.Flag
not in ['-c', '-s']:
2378 EdkLogger
.error("build", OPTION_VALUE_INVALID
, "UNI flag must be one of -c or -s")
2380 MyBuild
= Build(Target
, Workspace
, Option
)
2381 GlobalData
.gCommandLineDefines
['ARCH'] = ' '.join(MyBuild
.ArchList
)
2382 if not (MyBuild
.LaunchPrebuildFlag
and os
.path
.exists(MyBuild
.PlatformBuildPath
)):
2386 # All job done, no error found and no exception raised
2389 except FatalError
as X
:
2390 if MyBuild
is not None:
2391 # for multi-thread build exits safely
2392 MyBuild
.Relinquish()
2393 if Option
is not None and Option
.debug
is not None:
2394 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
2395 ReturnCode
= X
.args
[0]
2396 except Warning as X
:
2397 # error from Fdf parser
2398 if MyBuild
is not None:
2399 # for multi-thread build exits safely
2400 MyBuild
.Relinquish()
2401 if Option
is not None and Option
.debug
is not None:
2402 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
2404 EdkLogger
.error(X
.ToolName
, FORMAT_INVALID
, File
=X
.FileName
, Line
=X
.LineNumber
, ExtraData
=X
.Message
, RaiseError
=False)
2405 ReturnCode
= FORMAT_INVALID
2406 except KeyboardInterrupt:
2407 ReturnCode
= ABORT_ERROR
2408 if Option
is not None and Option
.debug
is not None:
2409 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
2411 if MyBuild
is not None:
2412 # for multi-thread build exits safely
2413 MyBuild
.Relinquish()
2415 # try to get the meta-file from the object causing exception
2416 Tb
= sys
.exc_info()[-1]
2417 MetaFile
= GlobalData
.gProcessingFile
2418 while Tb
is not None:
2419 if 'self' in Tb
.tb_frame
.f_locals
and hasattr(Tb
.tb_frame
.f_locals
['self'], 'MetaFile'):
2420 MetaFile
= Tb
.tb_frame
.f_locals
['self'].MetaFile
2425 "Unknown fatal error when processing [%s]" % MetaFile
,
2426 ExtraData
="\n(Please send email to edk2-devel@lists.01.org for help, attaching following call stack trace!)\n",
2429 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
2430 ReturnCode
= CODE_ERROR
2432 Utils
.Progressor
.Abort()
2433 Utils
.ClearDuplicatedInf()
2437 MyBuild
.LaunchPostbuild()
2440 Conclusion
= "Failed"
2441 elif ReturnCode
== ABORT_ERROR
:
2442 Conclusion
= "Aborted"
2444 Conclusion
= "Failed"
2445 FinishTime
= time
.time()
2446 BuildDuration
= time
.gmtime(int(round(FinishTime
- StartTime
)))
2447 BuildDurationStr
= ""
2448 if BuildDuration
.tm_yday
> 1:
2449 BuildDurationStr
= time
.strftime("%H:%M:%S", BuildDuration
) + ", %d day(s)" % (BuildDuration
.tm_yday
- 1)
2451 BuildDurationStr
= time
.strftime("%H:%M:%S", BuildDuration
)
2452 if MyBuild
is not None:
2454 MyBuild
.BuildReport
.GenerateReport(BuildDurationStr
, LogBuildTime(MyBuild
.AutoGenTime
), LogBuildTime(MyBuild
.MakeTime
), LogBuildTime(MyBuild
.GenFdsTime
))
2456 EdkLogger
.SetLevel(EdkLogger
.QUIET
)
2457 EdkLogger
.quiet("\n- %s -" % Conclusion
)
2458 EdkLogger
.quiet(time
.strftime("Build end time: %H:%M:%S, %b.%d %Y", time
.localtime()))
2459 EdkLogger
.quiet("Build total time: %s\n" % BuildDurationStr
)
2462 if __name__
== '__main__':
2464 ## 0-127 is a safe return range, and 1 is a standard default error
2465 if r
< 0 or r
> 127: r
= 1