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
and not Dep
.BuildObject
.CanSkipbyHash():
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
609 # Run hash operation post dependency, to account for libs
610 if GlobalData
.gUseHashCache
and self
.BuildItem
.BuildObject
.IsLibrary
:
611 HashFile
= path
.join(self
.BuildItem
.BuildObject
.BuildDir
, self
.BuildItem
.BuildObject
.Name
+ ".hash")
612 SaveFileOnChange(HashFile
, self
.BuildItem
.BuildObject
.GenModuleHash(), True)
615 # TRICK: hide the output of threads left running, so that the user can
616 # catch the error message easily
618 if not BuildTask
._ErrorFlag
.isSet():
619 GlobalData
.gBuildingModule
= "%s [%s, %s, %s]" % (str(self
.BuildItem
.BuildObject
),
620 self
.BuildItem
.BuildObject
.Arch
,
621 self
.BuildItem
.BuildObject
.ToolChain
,
622 self
.BuildItem
.BuildObject
.BuildTarget
624 EdkLogger
.SetLevel(EdkLogger
.ERROR
)
625 BuildTask
._ErrorFlag
.set()
626 BuildTask
._ErrorMessage
= "%s broken\n %s [%s]" % \
627 (threading
.currentThread().getName(), Command
, WorkingDir
)
628 if self
.BuildItem
.BuildObject
in GlobalData
.gModuleBuildTracking
and not BuildTask
._ErrorFlag
.isSet():
629 GlobalData
.gModuleBuildTracking
[self
.BuildItem
.BuildObject
] = True
630 # indicate there's a thread is available for another build task
631 BuildTask
._RunningQueueLock
.acquire()
632 BuildTask
._RunningQueue
.pop(self
.BuildItem
)
633 BuildTask
._RunningQueueLock
.release()
634 BuildTask
._Thread
.release()
636 ## Start build task thread
639 EdkLogger
.quiet("Building ... %s" % repr(self
.BuildItem
))
640 Command
= self
.BuildItem
.BuildCommand
+ [self
.BuildItem
.Target
]
641 self
.BuildTread
= Thread(target
=self
._CommandThread
, args
=(Command
, self
.BuildItem
.WorkingDir
))
642 self
.BuildTread
.setName("build thread")
643 self
.BuildTread
.setDaemon(False)
644 self
.BuildTread
.start()
646 ## The class contains the information related to EFI image
651 # Constructor will load all required image information.
653 # @param BaseName The full file path of image.
654 # @param Guid The GUID for image.
655 # @param Arch Arch of this image.
656 # @param OutputDir The output directory for image.
657 # @param DebugDir The debug directory for image.
658 # @param ImageClass PeImage Information
660 def __init__(self
, BaseName
, Guid
, Arch
, OutputDir
, DebugDir
, ImageClass
):
661 self
.BaseName
= BaseName
664 self
.OutputDir
= OutputDir
665 self
.DebugDir
= DebugDir
666 self
.Image
= ImageClass
667 self
.Image
.Size
= (self
.Image
.Size
// 0x1000 + 1) * 0x1000
669 ## The class implementing the EDK2 build process
671 # The build process includes:
672 # 1. Load configuration from target.txt and tools_def.txt in $(WORKSPACE)/Conf
673 # 2. Parse DSC file of active platform
674 # 3. Parse FDF file if any
675 # 4. Establish build database, including parse all other files (module, package)
676 # 5. Create AutoGen files (C code file, depex file, makefile) if necessary
677 # 6. Call build command
682 # Constructor will load all necessary configurations, parse platform, modules
683 # and packages and the establish a database for AutoGen.
685 # @param Target The build command target, one of gSupportedTarget
686 # @param WorkspaceDir The directory of workspace
687 # @param BuildOptions Build options passed from command line
689 def __init__(self
, Target
, WorkspaceDir
, BuildOptions
):
690 self
.WorkspaceDir
= WorkspaceDir
692 self
.PlatformFile
= BuildOptions
.PlatformFile
693 self
.ModuleFile
= BuildOptions
.ModuleFile
694 self
.ArchList
= BuildOptions
.TargetArch
695 self
.ToolChainList
= BuildOptions
.ToolChain
696 self
.BuildTargetList
= BuildOptions
.BuildTarget
697 self
.Fdf
= BuildOptions
.FdfFile
698 self
.FdList
= BuildOptions
.RomImage
699 self
.FvList
= BuildOptions
.FvImage
700 self
.CapList
= BuildOptions
.CapName
701 self
.SilentMode
= BuildOptions
.SilentMode
702 self
.ThreadNumber
= BuildOptions
.ThreadNumber
703 self
.SkipAutoGen
= BuildOptions
.SkipAutoGen
704 self
.Reparse
= BuildOptions
.Reparse
705 self
.SkuId
= BuildOptions
.SkuId
707 GlobalData
.gSKUID_CMD
= self
.SkuId
708 self
.ConfDirectory
= BuildOptions
.ConfDirectory
709 self
.SpawnMode
= True
710 self
.BuildReport
= BuildReport(BuildOptions
.ReportFile
, BuildOptions
.ReportType
)
711 self
.TargetTxt
= TargetTxtClassObject()
712 self
.ToolDef
= ToolDefClassObject()
716 GlobalData
.BuildOptionPcd
= BuildOptions
.OptionPcd
if BuildOptions
.OptionPcd
else []
717 #Set global flag for build mode
718 GlobalData
.gIgnoreSource
= BuildOptions
.IgnoreSources
719 GlobalData
.gUseHashCache
= BuildOptions
.UseHashCache
720 GlobalData
.gBinCacheDest
= BuildOptions
.BinCacheDest
721 GlobalData
.gBinCacheSource
= BuildOptions
.BinCacheSource
722 GlobalData
.gEnableGenfdsMultiThread
= BuildOptions
.GenfdsMultiThread
723 GlobalData
.gDisableIncludePathCheck
= BuildOptions
.DisableIncludePathCheck
725 if GlobalData
.gBinCacheDest
and not GlobalData
.gUseHashCache
:
726 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, ExtraData
="--binary-destination must be used together with --hash.")
728 if GlobalData
.gBinCacheSource
and not GlobalData
.gUseHashCache
:
729 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, ExtraData
="--binary-source must be used together with --hash.")
731 if GlobalData
.gBinCacheDest
and GlobalData
.gBinCacheSource
:
732 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, ExtraData
="--binary-destination can not be used together with --binary-source.")
734 if GlobalData
.gBinCacheSource
:
735 BinCacheSource
= os
.path
.normpath(GlobalData
.gBinCacheSource
)
736 if not os
.path
.isabs(BinCacheSource
):
737 BinCacheSource
= mws
.join(self
.WorkspaceDir
, BinCacheSource
)
738 GlobalData
.gBinCacheSource
= BinCacheSource
740 if GlobalData
.gBinCacheSource
is not None:
741 EdkLogger
.error("build", OPTION_VALUE_INVALID
, ExtraData
="Invalid value of option --binary-source.")
743 if GlobalData
.gBinCacheDest
:
744 BinCacheDest
= os
.path
.normpath(GlobalData
.gBinCacheDest
)
745 if not os
.path
.isabs(BinCacheDest
):
746 BinCacheDest
= mws
.join(self
.WorkspaceDir
, BinCacheDest
)
747 GlobalData
.gBinCacheDest
= BinCacheDest
749 if GlobalData
.gBinCacheDest
is not None:
750 EdkLogger
.error("build", OPTION_VALUE_INVALID
, ExtraData
="Invalid value of option --binary-destination.")
752 if self
.ConfDirectory
:
753 # Get alternate Conf location, if it is absolute, then just use the absolute directory name
754 ConfDirectoryPath
= os
.path
.normpath(self
.ConfDirectory
)
756 if not os
.path
.isabs(ConfDirectoryPath
):
757 # Since alternate directory name is not absolute, the alternate directory is located within the WORKSPACE
758 # This also handles someone specifying the Conf directory in the workspace. Using --conf=Conf
759 ConfDirectoryPath
= mws
.join(self
.WorkspaceDir
, ConfDirectoryPath
)
761 if "CONF_PATH" in os
.environ
:
762 ConfDirectoryPath
= os
.path
.normcase(os
.path
.normpath(os
.environ
["CONF_PATH"]))
764 # Get standard WORKSPACE/Conf use the absolute path to the WORKSPACE/Conf
765 ConfDirectoryPath
= mws
.join(self
.WorkspaceDir
, 'Conf')
766 GlobalData
.gConfDirectory
= ConfDirectoryPath
767 GlobalData
.gDatabasePath
= os
.path
.normpath(os
.path
.join(ConfDirectoryPath
, GlobalData
.gDatabasePath
))
769 self
.Db
= WorkspaceDatabase()
770 self
.BuildDatabase
= self
.Db
.BuildObject
772 self
.ToolChainFamily
= None
773 self
.LoadFixAddress
= 0
774 self
.UniFlag
= BuildOptions
.Flag
775 self
.BuildModules
= []
776 self
.HashSkipModules
= []
778 self
.LaunchPrebuildFlag
= False
779 self
.PlatformBuildPath
= os
.path
.join(GlobalData
.gConfDirectory
, '.cache', '.PlatformBuild')
780 if BuildOptions
.CommandLength
:
781 GlobalData
.gCommandMaxLength
= BuildOptions
.CommandLength
783 # print dot character during doing some time-consuming work
784 self
.Progress
= Utils
.Progressor()
785 # print current build environment and configuration
786 EdkLogger
.quiet("%-16s = %s" % ("WORKSPACE", os
.environ
["WORKSPACE"]))
787 if "PACKAGES_PATH" in os
.environ
:
788 # WORKSPACE env has been converted before. Print the same path style with WORKSPACE env.
789 EdkLogger
.quiet("%-16s = %s" % ("PACKAGES_PATH", os
.path
.normcase(os
.path
.normpath(os
.environ
["PACKAGES_PATH"]))))
790 EdkLogger
.quiet("%-16s = %s" % ("EDK_TOOLS_PATH", os
.environ
["EDK_TOOLS_PATH"]))
791 if "EDK_TOOLS_BIN" in os
.environ
:
792 # Print the same path style with WORKSPACE env.
793 EdkLogger
.quiet("%-16s = %s" % ("EDK_TOOLS_BIN", os
.path
.normcase(os
.path
.normpath(os
.environ
["EDK_TOOLS_BIN"]))))
794 EdkLogger
.quiet("%-16s = %s" % ("CONF_PATH", GlobalData
.gConfDirectory
))
795 if "PYTHON3_ENABLE" in os
.environ
:
796 PYTHON3_ENABLE
= os
.environ
["PYTHON3_ENABLE"]
797 if PYTHON3_ENABLE
!= "TRUE":
798 PYTHON3_ENABLE
= "FALSE"
799 EdkLogger
.quiet("%-16s = %s" % ("PYTHON3_ENABLE", PYTHON3_ENABLE
))
800 if "PYTHON_COMMAND" in os
.environ
:
801 EdkLogger
.quiet("%-16s = %s" % ("PYTHON_COMMAND", os
.environ
["PYTHON_COMMAND"]))
805 EdkLogger
.quiet("%-16s = %s" % ("PREBUILD", self
.Prebuild
))
807 EdkLogger
.quiet("%-16s = %s" % ("POSTBUILD", self
.Postbuild
))
809 self
.LaunchPrebuild()
810 self
.TargetTxt
= TargetTxtClassObject()
811 self
.ToolDef
= ToolDefClassObject()
812 if not (self
.LaunchPrebuildFlag
and os
.path
.exists(self
.PlatformBuildPath
)):
816 os
.chdir(self
.WorkspaceDir
)
818 ## Load configuration
820 # This method will parse target.txt and get the build configurations.
822 def LoadConfiguration(self
):
824 # Check target.txt and tools_def.txt and Init them
826 BuildConfigurationFile
= os
.path
.normpath(os
.path
.join(GlobalData
.gConfDirectory
, gBuildConfiguration
))
827 if os
.path
.isfile(BuildConfigurationFile
) == True:
828 StatusCode
= self
.TargetTxt
.LoadTargetTxtFile(BuildConfigurationFile
)
830 ToolDefinitionFile
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_TOOL_CHAIN_CONF
]
831 if ToolDefinitionFile
== '':
832 ToolDefinitionFile
= gToolsDefinition
833 ToolDefinitionFile
= os
.path
.normpath(mws
.join(self
.WorkspaceDir
, 'Conf', ToolDefinitionFile
))
834 if os
.path
.isfile(ToolDefinitionFile
) == True:
835 StatusCode
= self
.ToolDef
.LoadToolDefFile(ToolDefinitionFile
)
837 EdkLogger
.error("build", FILE_NOT_FOUND
, ExtraData
=ToolDefinitionFile
)
839 EdkLogger
.error("build", FILE_NOT_FOUND
, ExtraData
=BuildConfigurationFile
)
841 # if no ARCH given in command line, get it from target.txt
842 if not self
.ArchList
:
843 self
.ArchList
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_TARGET_ARCH
]
844 self
.ArchList
= tuple(self
.ArchList
)
846 # if no build target given in command line, get it from target.txt
847 if not self
.BuildTargetList
:
848 self
.BuildTargetList
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_TARGET
]
850 # if no tool chain given in command line, get it from target.txt
851 if not self
.ToolChainList
:
852 self
.ToolChainList
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_TOOL_CHAIN_TAG
]
853 if self
.ToolChainList
is None or len(self
.ToolChainList
) == 0:
854 EdkLogger
.error("build", RESOURCE_NOT_AVAILABLE
, ExtraData
="No toolchain given. Don't know how to build.\n")
856 # check if the tool chains are defined or not
857 NewToolChainList
= []
858 for ToolChain
in self
.ToolChainList
:
859 if ToolChain
not in self
.ToolDef
.ToolsDefTxtDatabase
[TAB_TOD_DEFINES_TOOL_CHAIN_TAG
]:
860 EdkLogger
.warn("build", "Tool chain [%s] is not defined" % ToolChain
)
862 NewToolChainList
.append(ToolChain
)
863 # if no tool chain available, break the build
864 if len(NewToolChainList
) == 0:
865 EdkLogger
.error("build", RESOURCE_NOT_AVAILABLE
,
866 ExtraData
="[%s] not defined. No toolchain available for build!\n" % ", ".join(self
.ToolChainList
))
868 self
.ToolChainList
= NewToolChainList
871 ToolDefinition
= self
.ToolDef
.ToolsDefTxtDatabase
872 for Tool
in self
.ToolChainList
:
873 if TAB_TOD_DEFINES_FAMILY
not in ToolDefinition
or Tool
not in ToolDefinition
[TAB_TOD_DEFINES_FAMILY
] \
874 or not ToolDefinition
[TAB_TOD_DEFINES_FAMILY
][Tool
]:
875 EdkLogger
.warn("build", "No tool chain family found in configuration for %s. Default to MSFT." % Tool
)
876 ToolChainFamily
.append(TAB_COMPILER_MSFT
)
878 ToolChainFamily
.append(ToolDefinition
[TAB_TOD_DEFINES_FAMILY
][Tool
])
879 self
.ToolChainFamily
= ToolChainFamily
881 if self
.ThreadNumber
is None:
882 self
.ThreadNumber
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_MAX_CONCURRENT_THREAD_NUMBER
]
883 if self
.ThreadNumber
== '':
884 self
.ThreadNumber
= 0
886 self
.ThreadNumber
= int(self
.ThreadNumber
, 0)
888 if self
.ThreadNumber
== 0:
890 self
.ThreadNumber
= multiprocessing
.cpu_count()
891 except (ImportError, NotImplementedError):
892 self
.ThreadNumber
= 1
894 if not self
.PlatformFile
:
895 PlatformFile
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_ACTIVE_PLATFORM
]
897 # Try to find one in current directory
898 WorkingDirectory
= os
.getcwd()
899 FileList
= glob
.glob(os
.path
.normpath(os
.path
.join(WorkingDirectory
, '*.dsc')))
900 FileNum
= len(FileList
)
902 EdkLogger
.error("build", OPTION_MISSING
,
903 ExtraData
="There are %d DSC files in %s. Use '-p' to specify one.\n" % (FileNum
, WorkingDirectory
))
905 PlatformFile
= FileList
[0]
907 EdkLogger
.error("build", RESOURCE_NOT_AVAILABLE
,
908 ExtraData
="No active platform specified in target.txt or command line! Nothing can be built.\n")
910 self
.PlatformFile
= PathClass(NormFile(PlatformFile
, self
.WorkspaceDir
), self
.WorkspaceDir
)
912 ## Initialize build configuration
914 # This method will parse DSC file and merge the configurations from
915 # command line and target.txt, then get the final build configurations.
918 # parse target.txt, tools_def.txt, and platform file
919 self
.LoadConfiguration()
921 # Allow case-insensitive for those from command line or configuration file
922 ErrorCode
, ErrorInfo
= self
.PlatformFile
.Validate(".dsc", False)
924 EdkLogger
.error("build", ErrorCode
, ExtraData
=ErrorInfo
)
927 def InitPreBuild(self
):
928 self
.LoadConfiguration()
929 ErrorCode
, ErrorInfo
= self
.PlatformFile
.Validate(".dsc", False)
931 EdkLogger
.error("build", ErrorCode
, ExtraData
=ErrorInfo
)
932 if self
.BuildTargetList
:
933 GlobalData
.gGlobalDefines
['TARGET'] = self
.BuildTargetList
[0]
935 GlobalData
.gGlobalDefines
['ARCH'] = self
.ArchList
[0]
936 if self
.ToolChainList
:
937 GlobalData
.gGlobalDefines
['TOOLCHAIN'] = self
.ToolChainList
[0]
938 GlobalData
.gGlobalDefines
['TOOL_CHAIN_TAG'] = self
.ToolChainList
[0]
939 if self
.ToolChainFamily
:
940 GlobalData
.gGlobalDefines
['FAMILY'] = self
.ToolChainFamily
[0]
941 if 'PREBUILD' in GlobalData
.gCommandLineDefines
:
942 self
.Prebuild
= GlobalData
.gCommandLineDefines
.get('PREBUILD')
945 Platform
= self
.Db
.MapPlatform(str(self
.PlatformFile
))
946 self
.Prebuild
= str(Platform
.Prebuild
)
950 # Evaluate all arguments and convert arguments that are WORKSPACE
951 # relative paths to absolute paths. Filter arguments that look like
952 # flags or do not follow the file/dir naming rules to avoid false
953 # positives on this conversion.
955 for Arg
in self
.Prebuild
.split():
957 # Do not modify Arg if it looks like a flag or an absolute file path
959 if Arg
.startswith('-') or os
.path
.isabs(Arg
):
960 PrebuildList
.append(Arg
)
963 # Do not modify Arg if it does not look like a Workspace relative
964 # path that starts with a valid package directory name
966 if not Arg
[0].isalpha() or os
.path
.dirname(Arg
) == '':
967 PrebuildList
.append(Arg
)
970 # If Arg looks like a WORKSPACE relative path, then convert to an
971 # absolute path and check to see if the file exists.
973 Temp
= mws
.join(self
.WorkspaceDir
, Arg
)
974 if os
.path
.isfile(Temp
):
976 PrebuildList
.append(Arg
)
977 self
.Prebuild
= ' '.join(PrebuildList
)
978 self
.Prebuild
+= self
.PassCommandOption(self
.BuildTargetList
, self
.ArchList
, self
.ToolChainList
, self
.PlatformFile
, self
.Target
)
980 def InitPostBuild(self
):
981 if 'POSTBUILD' in GlobalData
.gCommandLineDefines
:
982 self
.Postbuild
= GlobalData
.gCommandLineDefines
.get('POSTBUILD')
984 Platform
= self
.Db
.MapPlatform(str(self
.PlatformFile
))
985 self
.Postbuild
= str(Platform
.Postbuild
)
989 # Evaluate all arguments and convert arguments that are WORKSPACE
990 # relative paths to absolute paths. Filter arguments that look like
991 # flags or do not follow the file/dir naming rules to avoid false
992 # positives on this conversion.
994 for Arg
in self
.Postbuild
.split():
996 # Do not modify Arg if it looks like a flag or an absolute file path
998 if Arg
.startswith('-') or os
.path
.isabs(Arg
):
999 PostbuildList
.append(Arg
)
1002 # Do not modify Arg if it does not look like a Workspace relative
1003 # path that starts with a valid package directory name
1005 if not Arg
[0].isalpha() or os
.path
.dirname(Arg
) == '':
1006 PostbuildList
.append(Arg
)
1009 # If Arg looks like a WORKSPACE relative path, then convert to an
1010 # absolute path and check to see if the file exists.
1012 Temp
= mws
.join(self
.WorkspaceDir
, Arg
)
1013 if os
.path
.isfile(Temp
):
1015 PostbuildList
.append(Arg
)
1016 self
.Postbuild
= ' '.join(PostbuildList
)
1017 self
.Postbuild
+= self
.PassCommandOption(self
.BuildTargetList
, self
.ArchList
, self
.ToolChainList
, self
.PlatformFile
, self
.Target
)
1019 def PassCommandOption(self
, BuildTarget
, TargetArch
, ToolChain
, PlatformFile
, Target
):
1021 if GlobalData
.gCommand
and isinstance(GlobalData
.gCommand
, list):
1022 BuildStr
+= ' ' + ' '.join(GlobalData
.gCommand
)
1025 ToolChainFlag
= False
1026 PlatformFileFlag
= False
1028 if GlobalData
.gOptions
and not GlobalData
.gOptions
.BuildTarget
:
1030 if GlobalData
.gOptions
and not GlobalData
.gOptions
.TargetArch
:
1032 if GlobalData
.gOptions
and not GlobalData
.gOptions
.ToolChain
:
1033 ToolChainFlag
= True
1034 if GlobalData
.gOptions
and not GlobalData
.gOptions
.PlatformFile
:
1035 PlatformFileFlag
= True
1037 if TargetFlag
and BuildTarget
:
1038 if isinstance(BuildTarget
, list) or isinstance(BuildTarget
, tuple):
1039 BuildStr
+= ' -b ' + ' -b '.join(BuildTarget
)
1040 elif isinstance(BuildTarget
, str):
1041 BuildStr
+= ' -b ' + BuildTarget
1042 if ArchFlag
and TargetArch
:
1043 if isinstance(TargetArch
, list) or isinstance(TargetArch
, tuple):
1044 BuildStr
+= ' -a ' + ' -a '.join(TargetArch
)
1045 elif isinstance(TargetArch
, str):
1046 BuildStr
+= ' -a ' + TargetArch
1047 if ToolChainFlag
and ToolChain
:
1048 if isinstance(ToolChain
, list) or isinstance(ToolChain
, tuple):
1049 BuildStr
+= ' -t ' + ' -t '.join(ToolChain
)
1050 elif isinstance(ToolChain
, str):
1051 BuildStr
+= ' -t ' + ToolChain
1052 if PlatformFileFlag
and PlatformFile
:
1053 if isinstance(PlatformFile
, list) or isinstance(PlatformFile
, tuple):
1054 BuildStr
+= ' -p ' + ' -p '.join(PlatformFile
)
1055 elif isinstance(PlatformFile
, str):
1056 BuildStr
+= ' -p' + PlatformFile
1057 BuildStr
+= ' --conf=' + GlobalData
.gConfDirectory
1059 BuildStr
+= ' ' + Target
1063 def LaunchPrebuild(self
):
1065 EdkLogger
.info("\n- Prebuild Start -\n")
1066 self
.LaunchPrebuildFlag
= True
1068 # The purpose of .PrebuildEnv file is capture environment variable settings set by the prebuild script
1069 # and preserve them for the rest of the main build step, because the child process environment will
1070 # evaporate as soon as it exits, we cannot get it in build step.
1072 PrebuildEnvFile
= os
.path
.join(GlobalData
.gConfDirectory
, '.cache', '.PrebuildEnv')
1073 if os
.path
.isfile(PrebuildEnvFile
):
1074 os
.remove(PrebuildEnvFile
)
1075 if os
.path
.isfile(self
.PlatformBuildPath
):
1076 os
.remove(self
.PlatformBuildPath
)
1077 if sys
.platform
== "win32":
1078 args
= ' && '.join((self
.Prebuild
, 'set > ' + PrebuildEnvFile
))
1079 Process
= Popen(args
, stdout
=PIPE
, stderr
=PIPE
, shell
=True)
1081 args
= ' && '.join((self
.Prebuild
, 'env > ' + PrebuildEnvFile
))
1082 Process
= Popen(args
, stdout
=PIPE
, stderr
=PIPE
, shell
=True)
1084 # launch two threads to read the STDOUT and STDERR
1085 EndOfProcedure
= Event()
1086 EndOfProcedure
.clear()
1088 StdOutThread
= Thread(target
=ReadMessage
, args
=(Process
.stdout
, EdkLogger
.info
, EndOfProcedure
))
1089 StdOutThread
.setName("STDOUT-Redirector")
1090 StdOutThread
.setDaemon(False)
1091 StdOutThread
.start()
1094 StdErrThread
= Thread(target
=ReadMessage
, args
=(Process
.stderr
, EdkLogger
.quiet
, EndOfProcedure
))
1095 StdErrThread
.setName("STDERR-Redirector")
1096 StdErrThread
.setDaemon(False)
1097 StdErrThread
.start()
1098 # waiting for program exit
1105 if Process
.returncode
!= 0 :
1106 EdkLogger
.error("Prebuild", PREBUILD_ERROR
, 'Prebuild process is not success!')
1108 if os
.path
.exists(PrebuildEnvFile
):
1109 f
= open(PrebuildEnvFile
)
1110 envs
= f
.readlines()
1112 envs
= [l
.split("=", 1) for l
in envs
]
1113 envs
= [[I
.strip() for I
in item
] for item
in envs
if len(item
) == 2]
1114 os
.environ
.update(dict(envs
))
1115 EdkLogger
.info("\n- Prebuild Done -\n")
1117 def LaunchPostbuild(self
):
1119 EdkLogger
.info("\n- Postbuild Start -\n")
1120 if sys
.platform
== "win32":
1121 Process
= Popen(self
.Postbuild
, stdout
=PIPE
, stderr
=PIPE
, shell
=True)
1123 Process
= Popen(self
.Postbuild
, stdout
=PIPE
, stderr
=PIPE
, shell
=True)
1124 # launch two threads to read the STDOUT and STDERR
1125 EndOfProcedure
= Event()
1126 EndOfProcedure
.clear()
1128 StdOutThread
= Thread(target
=ReadMessage
, args
=(Process
.stdout
, EdkLogger
.info
, EndOfProcedure
))
1129 StdOutThread
.setName("STDOUT-Redirector")
1130 StdOutThread
.setDaemon(False)
1131 StdOutThread
.start()
1134 StdErrThread
= Thread(target
=ReadMessage
, args
=(Process
.stderr
, EdkLogger
.quiet
, EndOfProcedure
))
1135 StdErrThread
.setName("STDERR-Redirector")
1136 StdErrThread
.setDaemon(False)
1137 StdErrThread
.start()
1138 # waiting for program exit
1145 if Process
.returncode
!= 0 :
1146 EdkLogger
.error("Postbuild", POSTBUILD_ERROR
, 'Postbuild process is not success!')
1147 EdkLogger
.info("\n- Postbuild Done -\n")
1149 ## Error handling for hash feature
1151 # On BuildTask error, iterate through the Module Build tracking
1152 # dictionary to determine wheather a module failed to build. Invalidate
1153 # the hash associated with that module by removing it from storage.
1156 def invalidateHash(self
):
1157 # GlobalData.gModuleBuildTracking contains only modules that cannot be skipped by hash
1158 for moduleAutoGenObj
in GlobalData
.gModuleBuildTracking
.keys():
1159 # False == FAIL : True == Success
1160 # Skip invalidating for Successful module builds
1161 if GlobalData
.gModuleBuildTracking
[moduleAutoGenObj
] == True:
1164 # The module failed to build or failed to start building, from this point on
1166 # Remove .hash from build
1167 if GlobalData
.gUseHashCache
:
1168 ModuleHashFile
= path
.join(moduleAutoGenObj
.BuildDir
, moduleAutoGenObj
.Name
+ ".hash")
1169 if os
.path
.exists(ModuleHashFile
):
1170 os
.remove(ModuleHashFile
)
1172 # Remove .hash file from cache
1173 if GlobalData
.gBinCacheDest
:
1174 FileDir
= path
.join(GlobalData
.gBinCacheDest
, moduleAutoGenObj
.Arch
, moduleAutoGenObj
.SourceDir
, moduleAutoGenObj
.MetaFile
.BaseName
)
1175 HashFile
= path
.join(FileDir
, moduleAutoGenObj
.Name
+ '.hash')
1176 if os
.path
.exists(HashFile
):
1179 ## Build a module or platform
1181 # Create autogen code and makefile for a module or platform, and the launch
1182 # "make" command to build it
1184 # @param Target The target of build command
1185 # @param Platform The platform file
1186 # @param Module The module file
1187 # @param BuildTarget The name of build target, one of "DEBUG", "RELEASE"
1188 # @param ToolChain The name of toolchain to build
1189 # @param Arch The arch of the module/platform
1190 # @param CreateDepModuleCodeFile Flag used to indicate creating code
1191 # for dependent modules/Libraries
1192 # @param CreateDepModuleMakeFile Flag used to indicate creating makefile
1193 # for dependent modules/Libraries
1195 def _BuildPa(self
, Target
, AutoGenObject
, CreateDepsCodeFile
=True, CreateDepsMakeFile
=True, BuildModule
=False, FfsCommand
={}):
1196 if AutoGenObject
is None:
1199 # skip file generation for cleanxxx targets, run and fds target
1200 if Target
not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1201 # for target which must generate AutoGen code and makefile
1202 if not self
.SkipAutoGen
or Target
== 'genc':
1203 self
.Progress
.Start("Generating code")
1204 AutoGenObject
.CreateCodeFile(CreateDepsCodeFile
)
1205 self
.Progress
.Stop("done!")
1206 if Target
== "genc":
1209 if not self
.SkipAutoGen
or Target
== 'genmake':
1210 self
.Progress
.Start("Generating makefile")
1211 AutoGenObject
.CreateMakeFile(CreateDepsMakeFile
, FfsCommand
)
1212 self
.Progress
.Stop("done!")
1213 if Target
== "genmake":
1216 # always recreate top/platform makefile when clean, just in case of inconsistency
1217 AutoGenObject
.CreateCodeFile(False)
1218 AutoGenObject
.CreateMakeFile(False)
1220 if EdkLogger
.GetLevel() == EdkLogger
.QUIET
:
1221 EdkLogger
.quiet("Building ... %s" % repr(AutoGenObject
))
1223 BuildCommand
= AutoGenObject
.BuildCommand
1224 if BuildCommand
is None or len(BuildCommand
) == 0:
1225 EdkLogger
.error("build", OPTION_MISSING
,
1226 "No build command found for this module. "
1227 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %
1228 (AutoGenObject
.BuildTarget
, AutoGenObject
.ToolChain
, AutoGenObject
.Arch
),
1229 ExtraData
=str(AutoGenObject
))
1231 makefile
= GenMake
.BuildFile(AutoGenObject
)._FILE
_NAME
_[GenMake
.gMakeType
]
1235 RunDir
= os
.path
.normpath(os
.path
.join(AutoGenObject
.BuildDir
, GlobalData
.gGlobalDefines
['ARCH']))
1236 Command
= '.\SecMain'
1238 LaunchCommand(Command
, RunDir
)
1243 BuildCommand
= BuildCommand
+ [Target
]
1244 LaunchCommand(BuildCommand
, AutoGenObject
.MakeFileDir
)
1245 self
.CreateAsBuiltInf()
1249 if Target
== 'libraries':
1250 for Lib
in AutoGenObject
.LibraryBuildDirectoryList
:
1251 NewBuildCommand
= BuildCommand
+ ['-f', os
.path
.normpath(os
.path
.join(Lib
, makefile
)), 'pbuild']
1252 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1256 if Target
== 'modules':
1257 for Lib
in AutoGenObject
.LibraryBuildDirectoryList
:
1258 NewBuildCommand
= BuildCommand
+ ['-f', os
.path
.normpath(os
.path
.join(Lib
, makefile
)), 'pbuild']
1259 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1260 for Mod
in AutoGenObject
.ModuleBuildDirectoryList
:
1261 NewBuildCommand
= BuildCommand
+ ['-f', os
.path
.normpath(os
.path
.join(Mod
, makefile
)), 'pbuild']
1262 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1263 self
.CreateAsBuiltInf()
1267 if Target
== 'cleanlib':
1268 for Lib
in AutoGenObject
.LibraryBuildDirectoryList
:
1269 LibMakefile
= os
.path
.normpath(os
.path
.join(Lib
, makefile
))
1270 if os
.path
.exists(LibMakefile
):
1271 NewBuildCommand
= BuildCommand
+ ['-f', LibMakefile
, 'cleanall']
1272 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1276 if Target
== 'clean':
1277 for Mod
in AutoGenObject
.ModuleBuildDirectoryList
:
1278 ModMakefile
= os
.path
.normpath(os
.path
.join(Mod
, makefile
))
1279 if os
.path
.exists(ModMakefile
):
1280 NewBuildCommand
= BuildCommand
+ ['-f', ModMakefile
, 'cleanall']
1281 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1282 for Lib
in AutoGenObject
.LibraryBuildDirectoryList
:
1283 LibMakefile
= os
.path
.normpath(os
.path
.join(Lib
, makefile
))
1284 if os
.path
.exists(LibMakefile
):
1285 NewBuildCommand
= BuildCommand
+ ['-f', LibMakefile
, 'cleanall']
1286 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1290 if Target
== 'cleanall':
1292 #os.rmdir(AutoGenObject.BuildDir)
1293 RemoveDirectory(AutoGenObject
.BuildDir
, True)
1294 except WindowsError as X
:
1295 EdkLogger
.error("build", FILE_DELETE_FAILURE
, ExtraData
=str(X
))
1298 ## Build a module or platform
1300 # Create autogen code and makefile for a module or platform, and the launch
1301 # "make" command to build it
1303 # @param Target The target of build command
1304 # @param Platform The platform file
1305 # @param Module The module file
1306 # @param BuildTarget The name of build target, one of "DEBUG", "RELEASE"
1307 # @param ToolChain The name of toolchain to build
1308 # @param Arch The arch of the module/platform
1309 # @param CreateDepModuleCodeFile Flag used to indicate creating code
1310 # for dependent modules/Libraries
1311 # @param CreateDepModuleMakeFile Flag used to indicate creating makefile
1312 # for dependent modules/Libraries
1314 def _Build(self
, Target
, AutoGenObject
, CreateDepsCodeFile
=True, CreateDepsMakeFile
=True, BuildModule
=False):
1315 if AutoGenObject
is None:
1318 # skip file generation for cleanxxx targets, run and fds target
1319 if Target
not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1320 # for target which must generate AutoGen code and makefile
1321 if not self
.SkipAutoGen
or Target
== 'genc':
1322 self
.Progress
.Start("Generating code")
1323 AutoGenObject
.CreateCodeFile(CreateDepsCodeFile
)
1324 self
.Progress
.Stop("done!")
1325 if Target
== "genc":
1328 if not self
.SkipAutoGen
or Target
== 'genmake':
1329 self
.Progress
.Start("Generating makefile")
1330 AutoGenObject
.CreateMakeFile(CreateDepsMakeFile
)
1331 #AutoGenObject.CreateAsBuiltInf()
1332 self
.Progress
.Stop("done!")
1333 if Target
== "genmake":
1336 # always recreate top/platform makefile when clean, just in case of inconsistency
1337 AutoGenObject
.CreateCodeFile(False)
1338 AutoGenObject
.CreateMakeFile(False)
1340 if EdkLogger
.GetLevel() == EdkLogger
.QUIET
:
1341 EdkLogger
.quiet("Building ... %s" % repr(AutoGenObject
))
1343 BuildCommand
= AutoGenObject
.BuildCommand
1344 if BuildCommand
is None or len(BuildCommand
) == 0:
1345 EdkLogger
.error("build", OPTION_MISSING
,
1346 "No build command found for this module. "
1347 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %
1348 (AutoGenObject
.BuildTarget
, AutoGenObject
.ToolChain
, AutoGenObject
.Arch
),
1349 ExtraData
=str(AutoGenObject
))
1354 BuildCommand
= BuildCommand
+ [Target
]
1355 AutoGenObject
.BuildTime
= LaunchCommand(BuildCommand
, AutoGenObject
.MakeFileDir
)
1356 self
.CreateAsBuiltInf()
1361 if GenFdsApi(AutoGenObject
.GenFdsCommandDict
, self
.Db
):
1362 EdkLogger
.error("build", COMMAND_FAILURE
)
1367 RunDir
= os
.path
.normpath(os
.path
.join(AutoGenObject
.BuildDir
, GlobalData
.gGlobalDefines
['ARCH']))
1368 Command
= '.\SecMain'
1370 LaunchCommand(Command
, RunDir
)
1374 if Target
== 'libraries':
1381 if Target
== 'cleanall':
1383 #os.rmdir(AutoGenObject.BuildDir)
1384 RemoveDirectory(AutoGenObject
.BuildDir
, True)
1385 except WindowsError as X
:
1386 EdkLogger
.error("build", FILE_DELETE_FAILURE
, ExtraData
=str(X
))
1389 ## Rebase module image and Get function address for the input module list.
1391 def _RebaseModule (self
, MapBuffer
, BaseAddress
, ModuleList
, AddrIsOffset
= True, ModeIsSmm
= False):
1393 AddrIsOffset
= False
1394 for InfFile
in ModuleList
:
1395 sys
.stdout
.write (".")
1397 ModuleInfo
= ModuleList
[InfFile
]
1398 ModuleName
= ModuleInfo
.BaseName
1399 ModuleOutputImage
= ModuleInfo
.Image
.FileName
1400 ModuleDebugImage
= os
.path
.join(ModuleInfo
.DebugDir
, ModuleInfo
.BaseName
+ '.efi')
1401 ## for SMM module in SMRAM, the SMRAM will be allocated from base to top.
1403 BaseAddress
= BaseAddress
- ModuleInfo
.Image
.Size
1405 # Update Image to new BaseAddress by GenFw tool
1407 LaunchCommand(["GenFw", "--rebase", str(BaseAddress
), "-r", ModuleOutputImage
], ModuleInfo
.OutputDir
)
1408 LaunchCommand(["GenFw", "--rebase", str(BaseAddress
), "-r", ModuleDebugImage
], ModuleInfo
.DebugDir
)
1411 # Set new address to the section header only for SMM driver.
1413 LaunchCommand(["GenFw", "--address", str(BaseAddress
), "-r", ModuleOutputImage
], ModuleInfo
.OutputDir
)
1414 LaunchCommand(["GenFw", "--address", str(BaseAddress
), "-r", ModuleDebugImage
], ModuleInfo
.DebugDir
)
1416 # Collect function address from Map file
1418 ImageMapTable
= ModuleOutputImage
.replace('.efi', '.map')
1420 if os
.path
.exists(ImageMapTable
):
1421 OrigImageBaseAddress
= 0
1422 ImageMap
= open(ImageMapTable
, 'r')
1423 for LinStr
in ImageMap
:
1424 if len (LinStr
.strip()) == 0:
1427 # Get the preferred address set on link time.
1429 if LinStr
.find ('Preferred load address is') != -1:
1430 StrList
= LinStr
.split()
1431 OrigImageBaseAddress
= int (StrList
[len(StrList
) - 1], 16)
1433 StrList
= LinStr
.split()
1434 if len (StrList
) > 4:
1435 if StrList
[3] == 'f' or StrList
[3] == 'F':
1437 RelativeAddress
= int (StrList
[2], 16) - OrigImageBaseAddress
1438 FunctionList
.append ((Name
, RelativeAddress
))
1442 # Add general information.
1445 MapBuffer
.append('\n\n%s (Fixed SMRAM Offset, BaseAddress=0x%010X, EntryPoint=0x%010X)\n' % (ModuleName
, BaseAddress
, BaseAddress
+ ModuleInfo
.Image
.EntryPoint
))
1447 MapBuffer
.append('\n\n%s (Fixed Memory Offset, BaseAddress=-0x%010X, EntryPoint=-0x%010X)\n' % (ModuleName
, 0 - BaseAddress
, 0 - (BaseAddress
+ ModuleInfo
.Image
.EntryPoint
)))
1449 MapBuffer
.append('\n\n%s (Fixed Memory Address, BaseAddress=0x%010X, EntryPoint=0x%010X)\n' % (ModuleName
, BaseAddress
, BaseAddress
+ ModuleInfo
.Image
.EntryPoint
))
1451 # Add guid and general seciton section.
1453 TextSectionAddress
= 0
1454 DataSectionAddress
= 0
1455 for SectionHeader
in ModuleInfo
.Image
.SectionHeaderList
:
1456 if SectionHeader
[0] == '.text':
1457 TextSectionAddress
= SectionHeader
[1]
1458 elif SectionHeader
[0] in ['.data', '.sdata']:
1459 DataSectionAddress
= SectionHeader
[1]
1461 MapBuffer
.append('(GUID=%s, .textbaseaddress=-0x%010X, .databaseaddress=-0x%010X)\n' % (ModuleInfo
.Guid
, 0 - (BaseAddress
+ TextSectionAddress
), 0 - (BaseAddress
+ DataSectionAddress
)))
1463 MapBuffer
.append('(GUID=%s, .textbaseaddress=0x%010X, .databaseaddress=0x%010X)\n' % (ModuleInfo
.Guid
, BaseAddress
+ TextSectionAddress
, BaseAddress
+ DataSectionAddress
))
1465 # Add debug image full path.
1467 MapBuffer
.append('(IMAGE=%s)\n\n' % (ModuleDebugImage
))
1469 # Add function address
1471 for Function
in FunctionList
:
1473 MapBuffer
.append(' -0x%010X %s\n' % (0 - (BaseAddress
+ Function
[1]), Function
[0]))
1475 MapBuffer
.append(' 0x%010X %s\n' % (BaseAddress
+ Function
[1], Function
[0]))
1479 # for SMM module in SMRAM, the SMRAM will be allocated from base to top.
1482 BaseAddress
= BaseAddress
+ ModuleInfo
.Image
.Size
1484 ## Collect MAP information of all FVs
1486 def _CollectFvMapBuffer (self
, MapBuffer
, Wa
, ModuleList
):
1488 # First get the XIP base address for FV map file.
1489 GuidPattern
= re
.compile("[-a-fA-F0-9]+")
1490 GuidName
= re
.compile("\(GUID=[-a-fA-F0-9]+")
1491 for FvName
in Wa
.FdfProfile
.FvDict
:
1492 FvMapBuffer
= os
.path
.join(Wa
.FvDir
, FvName
+ '.Fv.map')
1493 if not os
.path
.exists(FvMapBuffer
):
1495 FvMap
= open(FvMapBuffer
, 'r')
1496 #skip FV size information
1502 MatchGuid
= GuidPattern
.match(Line
)
1503 if MatchGuid
is not None:
1505 # Replace GUID with module name
1507 GuidString
= MatchGuid
.group()
1508 if GuidString
.upper() in ModuleList
:
1509 Line
= Line
.replace(GuidString
, ModuleList
[GuidString
.upper()].Name
)
1510 MapBuffer
.append(Line
)
1512 # Add the debug image full path.
1514 MatchGuid
= GuidName
.match(Line
)
1515 if MatchGuid
is not None:
1516 GuidString
= MatchGuid
.group().split("=")[1]
1517 if GuidString
.upper() in ModuleList
:
1518 MapBuffer
.append('(IMAGE=%s)\n' % (os
.path
.join(ModuleList
[GuidString
.upper()].DebugDir
, ModuleList
[GuidString
.upper()].Name
+ '.efi')))
1522 ## Collect MAP information of all modules
1524 def _CollectModuleMapBuffer (self
, MapBuffer
, ModuleList
):
1525 sys
.stdout
.write ("Generate Load Module At Fix Address Map")
1527 PatchEfiImageList
= []
1535 # reserve 4K size in SMRAM to make SMM module address not from 0.
1537 for ModuleGuid
in ModuleList
:
1538 Module
= ModuleList
[ModuleGuid
]
1539 GlobalData
.gProcessingFile
= "%s [%s, %s, %s]" % (Module
.MetaFile
, Module
.Arch
, Module
.ToolChain
, Module
.BuildTarget
)
1541 OutputImageFile
= ''
1542 for ResultFile
in Module
.CodaTargetList
:
1543 if str(ResultFile
.Target
).endswith('.efi'):
1545 # module list for PEI, DXE, RUNTIME and SMM
1547 OutputImageFile
= os
.path
.join(Module
.OutputDir
, Module
.Name
+ '.efi')
1548 ImageClass
= PeImageClass (OutputImageFile
)
1549 if not ImageClass
.IsValid
:
1550 EdkLogger
.error("build", FILE_PARSE_FAILURE
, ExtraData
=ImageClass
.ErrorInfo
)
1551 ImageInfo
= PeImageInfo(Module
.Name
, Module
.Guid
, Module
.Arch
, Module
.OutputDir
, Module
.DebugDir
, ImageClass
)
1552 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
]:
1553 PeiModuleList
[Module
.MetaFile
] = ImageInfo
1554 PeiSize
+= ImageInfo
.Image
.Size
1555 elif Module
.ModuleType
in [EDK_COMPONENT_TYPE_BS_DRIVER
, SUP_MODULE_DXE_DRIVER
, SUP_MODULE_UEFI_DRIVER
]:
1556 BtModuleList
[Module
.MetaFile
] = ImageInfo
1557 BtSize
+= ImageInfo
.Image
.Size
1558 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
]:
1559 RtModuleList
[Module
.MetaFile
] = ImageInfo
1560 RtSize
+= ImageInfo
.Image
.Size
1561 elif Module
.ModuleType
in [SUP_MODULE_SMM_CORE
, SUP_MODULE_DXE_SMM_DRIVER
, SUP_MODULE_MM_STANDALONE
, SUP_MODULE_MM_CORE_STANDALONE
]:
1562 SmmModuleList
[Module
.MetaFile
] = ImageInfo
1563 SmmSize
+= ImageInfo
.Image
.Size
1564 if Module
.ModuleType
== SUP_MODULE_DXE_SMM_DRIVER
:
1565 PiSpecVersion
= Module
.Module
.Specification
.get('PI_SPECIFICATION_VERSION', '0x00000000')
1566 # for PI specification < PI1.1, DXE_SMM_DRIVER also runs as BOOT time driver.
1567 if int(PiSpecVersion
, 16) < 0x0001000A:
1568 BtModuleList
[Module
.MetaFile
] = ImageInfo
1569 BtSize
+= ImageInfo
.Image
.Size
1572 # EFI image is final target.
1573 # Check EFI image contains patchable FixAddress related PCDs.
1575 if OutputImageFile
!= '':
1576 ModuleIsPatch
= False
1577 for Pcd
in Module
.ModulePcdList
:
1578 if Pcd
.Type
== TAB_PCDS_PATCHABLE_IN_MODULE
and Pcd
.TokenCName
in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SET
:
1579 ModuleIsPatch
= True
1581 if not ModuleIsPatch
:
1582 for Pcd
in Module
.LibraryPcdList
:
1583 if Pcd
.Type
== TAB_PCDS_PATCHABLE_IN_MODULE
and Pcd
.TokenCName
in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SET
:
1584 ModuleIsPatch
= True
1587 if not ModuleIsPatch
:
1590 # Module includes the patchable load fix address PCDs.
1591 # It will be fixed up later.
1593 PatchEfiImageList
.append (OutputImageFile
)
1596 # Get Top Memory address
1598 ReservedRuntimeMemorySize
= 0
1599 TopMemoryAddress
= 0
1600 if self
.LoadFixAddress
== 0xFFFFFFFFFFFFFFFF:
1601 TopMemoryAddress
= 0
1603 TopMemoryAddress
= self
.LoadFixAddress
1604 if TopMemoryAddress
< RtSize
+ BtSize
+ PeiSize
:
1605 EdkLogger
.error("build", PARAMETER_INVALID
, "FIX_LOAD_TOP_MEMORY_ADDRESS is too low to load driver")
1608 # Patch FixAddress related PCDs into EFI image
1610 for EfiImage
in PatchEfiImageList
:
1611 EfiImageMap
= EfiImage
.replace('.efi', '.map')
1612 if not os
.path
.exists(EfiImageMap
):
1615 # Get PCD offset in EFI image by GenPatchPcdTable function
1617 PcdTable
= parsePcdInfoFromMapFile(EfiImageMap
, EfiImage
)
1619 # Patch real PCD value by PatchPcdValue tool
1621 for PcdInfo
in PcdTable
:
1623 if PcdInfo
[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE
:
1624 ReturnValue
, ErrorInfo
= PatchBinaryFile (EfiImage
, PcdInfo
[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE_DATA_TYPE
, str (PeiSize
// 0x1000))
1625 elif PcdInfo
[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE
:
1626 ReturnValue
, ErrorInfo
= PatchBinaryFile (EfiImage
, PcdInfo
[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE_DATA_TYPE
, str (BtSize
// 0x1000))
1627 elif PcdInfo
[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE
:
1628 ReturnValue
, ErrorInfo
= PatchBinaryFile (EfiImage
, PcdInfo
[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE_DATA_TYPE
, str (RtSize
// 0x1000))
1629 elif PcdInfo
[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE
and len (SmmModuleList
) > 0:
1630 ReturnValue
, ErrorInfo
= PatchBinaryFile (EfiImage
, PcdInfo
[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE_DATA_TYPE
, str (SmmSize
// 0x1000))
1631 if ReturnValue
!= 0:
1632 EdkLogger
.error("build", PARAMETER_INVALID
, "Patch PCD value failed", ExtraData
=ErrorInfo
)
1634 MapBuffer
.append('PEI_CODE_PAGE_NUMBER = 0x%x\n' % (PeiSize
// 0x1000))
1635 MapBuffer
.append('BOOT_CODE_PAGE_NUMBER = 0x%x\n' % (BtSize
// 0x1000))
1636 MapBuffer
.append('RUNTIME_CODE_PAGE_NUMBER = 0x%x\n' % (RtSize
// 0x1000))
1637 if len (SmmModuleList
) > 0:
1638 MapBuffer
.append('SMM_CODE_PAGE_NUMBER = 0x%x\n' % (SmmSize
// 0x1000))
1640 PeiBaseAddr
= TopMemoryAddress
- RtSize
- BtSize
1641 BtBaseAddr
= TopMemoryAddress
- RtSize
1642 RtBaseAddr
= TopMemoryAddress
- ReservedRuntimeMemorySize
1644 self
._RebaseModule
(MapBuffer
, PeiBaseAddr
, PeiModuleList
, TopMemoryAddress
== 0)
1645 self
._RebaseModule
(MapBuffer
, BtBaseAddr
, BtModuleList
, TopMemoryAddress
== 0)
1646 self
._RebaseModule
(MapBuffer
, RtBaseAddr
, RtModuleList
, TopMemoryAddress
== 0)
1647 self
._RebaseModule
(MapBuffer
, 0x1000, SmmModuleList
, AddrIsOffset
=False, ModeIsSmm
=True)
1648 MapBuffer
.append('\n\n')
1649 sys
.stdout
.write ("\n")
1652 ## Save platform Map file
1654 def _SaveMapFile (self
, MapBuffer
, Wa
):
1656 # Map file path is got.
1658 MapFilePath
= os
.path
.join(Wa
.BuildDir
, Wa
.Name
+ '.map')
1660 # Save address map into MAP file.
1662 SaveFileOnChange(MapFilePath
, ''.join(MapBuffer
), False)
1663 if self
.LoadFixAddress
!= 0:
1664 sys
.stdout
.write ("\nLoad Module At Fix Address Map file can be found at %s\n" % (MapFilePath
))
1667 ## Build active platform for different build targets and different tool chains
1669 def _BuildPlatform(self
):
1670 SaveFileOnChange(self
.PlatformBuildPath
, '# DO NOT EDIT \n# FILE auto-generated\n', False)
1671 for BuildTarget
in self
.BuildTargetList
:
1672 GlobalData
.gGlobalDefines
['TARGET'] = BuildTarget
1674 for ToolChain
in self
.ToolChainList
:
1675 GlobalData
.gGlobalDefines
['TOOLCHAIN'] = ToolChain
1676 GlobalData
.gGlobalDefines
['TOOL_CHAIN_TAG'] = ToolChain
1677 GlobalData
.gGlobalDefines
['FAMILY'] = self
.ToolChainFamily
[index
]
1679 Wa
= WorkspaceAutoGen(
1696 self
.Fdf
= Wa
.FdfFile
1697 self
.LoadFixAddress
= Wa
.Platform
.LoadFixAddress
1698 self
.BuildReport
.AddPlatformReport(Wa
)
1699 self
.Progress
.Stop("done!")
1701 # Add ffs build to makefile
1703 if GlobalData
.gEnableGenfdsMultiThread
and self
.Fdf
:
1704 CmdListDict
= self
._GenFfsCmd
(Wa
.ArchList
)
1706 for Arch
in Wa
.ArchList
:
1707 GlobalData
.gGlobalDefines
['ARCH'] = Arch
1708 Pa
= PlatformAutoGen(Wa
, self
.PlatformFile
, BuildTarget
, ToolChain
, Arch
)
1709 for Module
in Pa
.Platform
.Modules
:
1710 # Get ModuleAutoGen object to generate C code file and makefile
1711 Ma
= ModuleAutoGen(Wa
, Module
, BuildTarget
, ToolChain
, Arch
, self
.PlatformFile
)
1714 self
.BuildModules
.append(Ma
)
1715 self
._BuildPa
(self
.Target
, Pa
, FfsCommand
=CmdListDict
)
1717 # Create MAP file when Load Fix Address is enabled.
1718 if self
.Target
in ["", "all", "fds"]:
1719 for Arch
in Wa
.ArchList
:
1720 GlobalData
.gGlobalDefines
['ARCH'] = Arch
1722 # Check whether the set fix address is above 4G for 32bit image.
1724 if (Arch
== 'IA32' or Arch
== 'ARM') and self
.LoadFixAddress
!= 0xFFFFFFFFFFFFFFFF and self
.LoadFixAddress
>= 0x100000000:
1725 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")
1730 for Pa
in Wa
.AutoGenObjectList
:
1731 for Ma
in Pa
.ModuleAutoGenList
:
1734 if not Ma
.IsLibrary
:
1735 ModuleList
[Ma
.Guid
.upper()] = Ma
1738 if self
.LoadFixAddress
!= 0:
1740 # Rebase module to the preferred memory address before GenFds
1742 self
._CollectModuleMapBuffer
(MapBuffer
, ModuleList
)
1745 # create FDS again for the updated EFI image
1747 self
._Build
("fds", Wa
)
1749 # Create MAP file for all platform FVs after GenFds.
1751 self
._CollectFvMapBuffer
(MapBuffer
, Wa
, ModuleList
)
1753 # Save MAP buffer into MAP file.
1755 self
._SaveMapFile
(MapBuffer
, Wa
)
1757 ## Build active module for different build targets, different tool chains and different archs
1759 def _BuildModule(self
):
1760 for BuildTarget
in self
.BuildTargetList
:
1761 GlobalData
.gGlobalDefines
['TARGET'] = BuildTarget
1763 for ToolChain
in self
.ToolChainList
:
1764 WorkspaceAutoGenTime
= time
.time()
1765 GlobalData
.gGlobalDefines
['TOOLCHAIN'] = ToolChain
1766 GlobalData
.gGlobalDefines
['TOOL_CHAIN_TAG'] = ToolChain
1767 GlobalData
.gGlobalDefines
['FAMILY'] = self
.ToolChainFamily
[index
]
1770 # module build needs platform build information, so get platform
1773 Wa
= WorkspaceAutoGen(
1791 self
.Fdf
= Wa
.FdfFile
1792 self
.LoadFixAddress
= Wa
.Platform
.LoadFixAddress
1793 Wa
.CreateMakeFile(False)
1794 # Add ffs build to makefile
1796 if GlobalData
.gEnableGenfdsMultiThread
and self
.Fdf
:
1797 CmdListDict
= self
._GenFfsCmd
(Wa
.ArchList
)
1798 self
.Progress
.Stop("done!")
1800 ExitFlag
= threading
.Event()
1802 self
.AutoGenTime
+= int(round((time
.time() - WorkspaceAutoGenTime
)))
1803 for Arch
in Wa
.ArchList
:
1804 AutoGenStart
= time
.time()
1805 GlobalData
.gGlobalDefines
['ARCH'] = Arch
1806 Pa
= PlatformAutoGen(Wa
, self
.PlatformFile
, BuildTarget
, ToolChain
, Arch
)
1807 for Module
in Pa
.Platform
.Modules
:
1808 if self
.ModuleFile
.Dir
== Module
.Dir
and self
.ModuleFile
.Name
== Module
.Name
:
1809 Ma
= ModuleAutoGen(Wa
, Module
, BuildTarget
, ToolChain
, Arch
, self
.PlatformFile
)
1813 if Ma
.CanSkipbyHash():
1814 self
.HashSkipModules
.append(Ma
)
1816 # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'
1817 if self
.Target
not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1818 # for target which must generate AutoGen code and makefile
1819 if not self
.SkipAutoGen
or self
.Target
== 'genc':
1820 self
.Progress
.Start("Generating code")
1821 Ma
.CreateCodeFile(True)
1822 self
.Progress
.Stop("done!")
1823 if self
.Target
== "genc":
1825 if not self
.SkipAutoGen
or self
.Target
== 'genmake':
1826 self
.Progress
.Start("Generating makefile")
1827 if CmdListDict
and self
.Fdf
and (Module
.File
, Arch
) in CmdListDict
:
1828 Ma
.CreateMakeFile(True, CmdListDict
[Module
.File
, Arch
])
1829 del CmdListDict
[Module
.File
, Arch
]
1831 Ma
.CreateMakeFile(True)
1832 self
.Progress
.Stop("done!")
1833 if self
.Target
== "genmake":
1835 self
.BuildModules
.append(Ma
)
1836 # Initialize all modules in tracking to False (FAIL)
1837 if Ma
not in GlobalData
.gModuleBuildTracking
:
1838 GlobalData
.gModuleBuildTracking
[Ma
] = False
1839 self
.AutoGenTime
+= int(round((time
.time() - AutoGenStart
)))
1840 MakeStart
= time
.time()
1841 for Ma
in self
.BuildModules
:
1842 if not Ma
.IsBinaryModule
:
1843 Bt
= BuildTask
.New(ModuleMakeUnit(Ma
, self
.Target
))
1844 # Break build if any build thread has error
1845 if BuildTask
.HasError():
1846 # we need a full version of makefile for platform
1848 BuildTask
.WaitForComplete()
1849 self
.invalidateHash()
1850 Pa
.CreateMakeFile(False)
1851 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
1852 # Start task scheduler
1853 if not BuildTask
.IsOnGoing():
1854 BuildTask
.StartScheduler(self
.ThreadNumber
, ExitFlag
)
1856 # in case there's an interruption. we need a full version of makefile for platform
1857 Pa
.CreateMakeFile(False)
1858 if BuildTask
.HasError():
1859 self
.invalidateHash()
1860 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
1861 self
.MakeTime
+= int(round((time
.time() - MakeStart
)))
1863 MakeContiue
= time
.time()
1865 BuildTask
.WaitForComplete()
1866 self
.CreateAsBuiltInf()
1867 self
.MakeTime
+= int(round((time
.time() - MakeContiue
)))
1868 if BuildTask
.HasError():
1869 self
.invalidateHash()
1870 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
1872 self
.BuildReport
.AddPlatformReport(Wa
, MaList
)
1877 "Module for [%s] is not a component of active platform."\
1878 " Please make sure that the ARCH and inf file path are"\
1879 " given in the same as in [%s]" % \
1880 (', '.join(Wa
.ArchList
), self
.PlatformFile
),
1881 ExtraData
=self
.ModuleFile
1883 # Create MAP file when Load Fix Address is enabled.
1884 if self
.Target
== "fds" and self
.Fdf
:
1885 for Arch
in Wa
.ArchList
:
1887 # Check whether the set fix address is above 4G for 32bit image.
1889 if (Arch
== 'IA32' or Arch
== 'ARM') and self
.LoadFixAddress
!= 0xFFFFFFFFFFFFFFFF and self
.LoadFixAddress
>= 0x100000000:
1890 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")
1895 for Pa
in Wa
.AutoGenObjectList
:
1896 for Ma
in Pa
.ModuleAutoGenList
:
1899 if not Ma
.IsLibrary
:
1900 ModuleList
[Ma
.Guid
.upper()] = Ma
1903 if self
.LoadFixAddress
!= 0:
1905 # Rebase module to the preferred memory address before GenFds
1907 self
._CollectModuleMapBuffer
(MapBuffer
, ModuleList
)
1909 # create FDS again for the updated EFI image
1911 GenFdsStart
= time
.time()
1912 self
._Build
("fds", Wa
)
1913 self
.GenFdsTime
+= int(round((time
.time() - GenFdsStart
)))
1915 # Create MAP file for all platform FVs after GenFds.
1917 self
._CollectFvMapBuffer
(MapBuffer
, Wa
, ModuleList
)
1919 # Save MAP buffer into MAP file.
1921 self
._SaveMapFile
(MapBuffer
, Wa
)
1923 def _GenFfsCmd(self
,ArchList
):
1924 # convert dictionary of Cmd:(Inf,Arch)
1925 # to a new dictionary of (Inf,Arch):Cmd,Cmd,Cmd...
1926 CmdSetDict
= defaultdict(set)
1927 GenFfsDict
= GenFds
.GenFfsMakefile('', GlobalData
.gFdfParser
, self
, ArchList
, GlobalData
)
1928 for Cmd
in GenFfsDict
:
1929 tmpInf
, tmpArch
= GenFfsDict
[Cmd
]
1930 CmdSetDict
[tmpInf
, tmpArch
].add(Cmd
)
1933 ## Build a platform in multi-thread mode
1935 def _MultiThreadBuildPlatform(self
):
1936 SaveFileOnChange(self
.PlatformBuildPath
, '# DO NOT EDIT \n# FILE auto-generated\n', False)
1937 for BuildTarget
in self
.BuildTargetList
:
1938 GlobalData
.gGlobalDefines
['TARGET'] = BuildTarget
1940 for ToolChain
in self
.ToolChainList
:
1941 WorkspaceAutoGenTime
= time
.time()
1942 GlobalData
.gGlobalDefines
['TOOLCHAIN'] = ToolChain
1943 GlobalData
.gGlobalDefines
['TOOL_CHAIN_TAG'] = ToolChain
1944 GlobalData
.gGlobalDefines
['FAMILY'] = self
.ToolChainFamily
[index
]
1946 Wa
= WorkspaceAutoGen(
1963 self
.Fdf
= Wa
.FdfFile
1964 self
.LoadFixAddress
= Wa
.Platform
.LoadFixAddress
1965 self
.BuildReport
.AddPlatformReport(Wa
)
1966 Wa
.CreateMakeFile(False)
1968 # Add ffs build to makefile
1970 if GlobalData
.gEnableGenfdsMultiThread
and self
.Fdf
:
1971 CmdListDict
= self
._GenFfsCmd
(Wa
.ArchList
)
1973 # multi-thread exit flag
1974 ExitFlag
= threading
.Event()
1976 self
.AutoGenTime
+= int(round((time
.time() - WorkspaceAutoGenTime
)))
1977 for Arch
in Wa
.ArchList
:
1978 AutoGenStart
= time
.time()
1979 GlobalData
.gGlobalDefines
['ARCH'] = Arch
1980 Pa
= PlatformAutoGen(Wa
, self
.PlatformFile
, BuildTarget
, ToolChain
, Arch
)
1984 for Inf
in Pa
.Platform
.Modules
:
1985 ModuleList
.append(Inf
)
1986 # Add the INF only list in FDF
1987 if GlobalData
.gFdfParser
is not None:
1988 for InfName
in GlobalData
.gFdfParser
.Profile
.InfList
:
1989 Inf
= PathClass(NormPath(InfName
), self
.WorkspaceDir
, Arch
)
1990 if Inf
in Pa
.Platform
.Modules
:
1992 ModuleList
.append(Inf
)
1993 for Module
in ModuleList
:
1994 # Get ModuleAutoGen object to generate C code file and makefile
1995 Ma
= ModuleAutoGen(Wa
, Module
, BuildTarget
, ToolChain
, Arch
, self
.PlatformFile
)
1999 if Ma
.CanSkipbyHash():
2000 self
.HashSkipModules
.append(Ma
)
2003 # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'
2004 if self
.Target
not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
2005 # for target which must generate AutoGen code and makefile
2006 if not self
.SkipAutoGen
or self
.Target
== 'genc':
2007 Ma
.CreateCodeFile(True)
2008 if self
.Target
== "genc":
2011 if not self
.SkipAutoGen
or self
.Target
== 'genmake':
2012 if CmdListDict
and self
.Fdf
and (Module
.File
, Arch
) in CmdListDict
:
2013 Ma
.CreateMakeFile(True, CmdListDict
[Module
.File
, Arch
])
2014 del CmdListDict
[Module
.File
, Arch
]
2016 Ma
.CreateMakeFile(True)
2017 if self
.Target
== "genmake":
2019 self
.BuildModules
.append(Ma
)
2020 # Initialize all modules in tracking to False (FAIL)
2021 if Ma
not in GlobalData
.gModuleBuildTracking
:
2022 GlobalData
.gModuleBuildTracking
[Ma
] = False
2023 self
.Progress
.Stop("done!")
2024 self
.AutoGenTime
+= int(round((time
.time() - AutoGenStart
)))
2025 MakeStart
= time
.time()
2026 for Ma
in self
.BuildModules
:
2027 # Generate build task for the module
2028 if not Ma
.IsBinaryModule
:
2029 Bt
= BuildTask
.New(ModuleMakeUnit(Ma
, self
.Target
))
2030 # Break build if any build thread has error
2031 if BuildTask
.HasError():
2032 # we need a full version of makefile for platform
2034 BuildTask
.WaitForComplete()
2035 self
.invalidateHash()
2036 Pa
.CreateMakeFile(False)
2037 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
2038 # Start task scheduler
2039 if not BuildTask
.IsOnGoing():
2040 BuildTask
.StartScheduler(self
.ThreadNumber
, ExitFlag
)
2042 # in case there's an interruption. we need a full version of makefile for platform
2043 Pa
.CreateMakeFile(False)
2044 if BuildTask
.HasError():
2045 self
.invalidateHash()
2046 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
2047 self
.MakeTime
+= int(round((time
.time() - MakeStart
)))
2049 MakeContiue
= time
.time()
2053 # All modules have been put in build tasks queue. Tell task scheduler
2054 # to exit if all tasks are completed
2057 BuildTask
.WaitForComplete()
2058 self
.CreateAsBuiltInf()
2059 self
.MakeTime
+= int(round((time
.time() - MakeContiue
)))
2061 # Check for build error, and raise exception if one
2062 # has been signaled.
2064 if BuildTask
.HasError():
2065 self
.invalidateHash()
2066 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
2068 # Create MAP file when Load Fix Address is enabled.
2069 if self
.Target
in ["", "all", "fds"]:
2070 for Arch
in Wa
.ArchList
:
2072 # Check whether the set fix address is above 4G for 32bit image.
2074 if (Arch
== 'IA32' or Arch
== 'ARM') and self
.LoadFixAddress
!= 0xFFFFFFFFFFFFFFFF and self
.LoadFixAddress
>= 0x100000000:
2075 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")
2080 for Pa
in Wa
.AutoGenObjectList
:
2081 for Ma
in Pa
.ModuleAutoGenList
:
2084 if not Ma
.IsLibrary
:
2085 ModuleList
[Ma
.Guid
.upper()] = Ma
2087 # Rebase module to the preferred memory address before GenFds
2090 if self
.LoadFixAddress
!= 0:
2091 self
._CollectModuleMapBuffer
(MapBuffer
, ModuleList
)
2095 # Generate FD image if there's a FDF file found
2097 GenFdsStart
= time
.time()
2098 if GenFdsApi(Wa
.GenFdsCommandDict
, self
.Db
):
2099 EdkLogger
.error("build", COMMAND_FAILURE
)
2102 # Create MAP file for all platform FVs after GenFds.
2104 self
._CollectFvMapBuffer
(MapBuffer
, Wa
, ModuleList
)
2105 self
.GenFdsTime
+= int(round((time
.time() - GenFdsStart
)))
2107 # Save MAP buffer into MAP file.
2109 self
._SaveMapFile
(MapBuffer
, Wa
)
2111 ## Generate GuidedSectionTools.txt in the FV directories.
2113 def CreateGuidedSectionToolsFile(self
):
2114 for BuildTarget
in self
.BuildTargetList
:
2115 for ToolChain
in self
.ToolChainList
:
2116 Wa
= WorkspaceAutoGen(
2133 if not os
.path
.exists(FvDir
):
2136 for Arch
in self
.ArchList
:
2137 # Build up the list of supported architectures for this build
2138 prefix
= '%s_%s_%s_' % (BuildTarget
, ToolChain
, Arch
)
2140 # Look through the tool definitions for GUIDed tools
2142 for (attrib
, value
) in self
.ToolDef
.ToolsDefTxtDictionary
.items():
2143 if attrib
.upper().endswith('_GUID'):
2144 split
= attrib
.split('_')
2145 thisPrefix
= '_'.join(split
[0:3]) + '_'
2146 if thisPrefix
== prefix
:
2147 guid
= self
.ToolDef
.ToolsDefTxtDictionary
[attrib
]
2150 path
= '_'.join(split
[0:4]) + '_PATH'
2151 path
= self
.ToolDef
.ToolsDefTxtDictionary
[path
]
2152 path
= self
.GetFullPathOfTool(path
)
2153 guidAttribs
.append((guid
, toolName
, path
))
2155 # Write out GuidedSecTools.txt
2156 toolsFile
= os
.path
.join(FvDir
, 'GuidedSectionTools.txt')
2157 toolsFile
= open(toolsFile
, 'wt')
2158 for guidedSectionTool
in guidAttribs
:
2159 print(' '.join(guidedSectionTool
), file=toolsFile
)
2162 ## Returns the full path of the tool.
2164 def GetFullPathOfTool (self
, tool
):
2165 if os
.path
.exists(tool
):
2166 return os
.path
.realpath(tool
)
2168 # We need to search for the tool using the
2169 # PATH environment variable.
2170 for dirInPath
in os
.environ
['PATH'].split(os
.pathsep
):
2171 foundPath
= os
.path
.join(dirInPath
, tool
)
2172 if os
.path
.exists(foundPath
):
2173 return os
.path
.realpath(foundPath
)
2175 # If the tool was not found in the path then we just return
2179 ## Launch the module or platform build
2182 if not self
.ModuleFile
:
2183 if not self
.SpawnMode
or self
.Target
not in ["", "all"]:
2184 self
.SpawnMode
= False
2185 self
._BuildPlatform
()
2187 self
._MultiThreadBuildPlatform
()
2188 self
.CreateGuidedSectionToolsFile()
2190 self
.SpawnMode
= False
2193 if self
.Target
== 'cleanall':
2194 RemoveDirectory(os
.path
.dirname(GlobalData
.gDatabasePath
), True)
2196 def CreateAsBuiltInf(self
):
2199 for Module
in self
.BuildModules
:
2200 Module
.CreateAsBuiltInf()
2201 all_mod_set
.add(Module
)
2202 for Module
in self
.HashSkipModules
:
2203 Module
.CreateAsBuiltInf(True)
2204 all_mod_set
.add(Module
)
2205 for Module
in all_mod_set
:
2206 for lib
in Module
.LibraryAutoGenList
:
2207 all_lib_set
.add(lib
)
2208 for lib
in all_lib_set
:
2209 lib
.CreateAsBuiltInf(True)
2212 self
.BuildModules
= []
2213 self
.HashSkipModules
= []
2214 ## Do some clean-up works when error occurred
2215 def Relinquish(self
):
2216 OldLogLevel
= EdkLogger
.GetLevel()
2217 EdkLogger
.SetLevel(EdkLogger
.ERROR
)
2218 Utils
.Progressor
.Abort()
2219 if self
.SpawnMode
== True:
2221 EdkLogger
.SetLevel(OldLogLevel
)
2223 def ParseDefines(DefineList
=[]):
2225 if DefineList
is not None:
2226 for Define
in DefineList
:
2227 DefineTokenList
= Define
.split("=", 1)
2228 if not GlobalData
.gMacroNamePattern
.match(DefineTokenList
[0]):
2229 EdkLogger
.error('build', FORMAT_INVALID
,
2230 "The macro name must be in the pattern [A-Z][A-Z0-9_]*",
2231 ExtraData
=DefineTokenList
[0])
2233 if len(DefineTokenList
) == 1:
2234 DefineDict
[DefineTokenList
[0]] = "TRUE"
2236 DefineDict
[DefineTokenList
[0]] = DefineTokenList
[1].strip()
2240 def SingleCheckCallback(option
, opt_str
, value
, parser
):
2241 if option
not in gParamCheck
:
2242 setattr(parser
.values
, option
.dest
, value
)
2243 gParamCheck
.append(option
)
2245 parser
.error("Option %s only allows one instance in command line!" % option
)
2247 def LogBuildTime(Time
):
2250 TimeDur
= time
.gmtime(Time
)
2251 if TimeDur
.tm_yday
> 1:
2252 TimeDurStr
= time
.strftime("%H:%M:%S", TimeDur
) + ", %d day(s)" % (TimeDur
.tm_yday
- 1)
2254 TimeDurStr
= time
.strftime("%H:%M:%S", TimeDur
)
2259 ## Parse command line options
2261 # Using standard Python module optparse to parse command line option of this tool.
2263 # @retval Opt A optparse.Values object containing the parsed options
2264 # @retval Args Target of build command
2266 def MyOptionParser():
2267 Parser
= OptionParser(description
=__copyright__
, version
=__version__
, prog
="build.exe", usage
="%prog [options] [all|fds|genc|genmake|clean|cleanall|cleanlib|modules|libraries|run]")
2268 Parser
.add_option("-a", "--arch", action
="append", type="choice", choices
=['IA32', 'X64', 'EBC', 'ARM', 'AARCH64'], dest
="TargetArch",
2269 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.")
2270 Parser
.add_option("-p", "--platform", action
="callback", type="string", dest
="PlatformFile", callback
=SingleCheckCallback
,
2271 help="Build the platform specified by the DSC file name argument, overriding target.txt's ACTIVE_PLATFORM definition.")
2272 Parser
.add_option("-m", "--module", action
="callback", type="string", dest
="ModuleFile", callback
=SingleCheckCallback
,
2273 help="Build the module specified by the INF file name argument.")
2274 Parser
.add_option("-b", "--buildtarget", type="string", dest
="BuildTarget", help="Using the TARGET to build the platform, overriding target.txt's TARGET definition.",
2276 Parser
.add_option("-t", "--tagname", action
="append", type="string", dest
="ToolChain",
2277 help="Using the Tool Chain Tagname to build the platform, overriding target.txt's TOOL_CHAIN_TAG definition.")
2278 Parser
.add_option("-x", "--sku-id", action
="callback", type="string", dest
="SkuId", callback
=SingleCheckCallback
,
2279 help="Using this name of SKU ID to build the platform, overriding SKUID_IDENTIFIER in DSC file.")
2281 Parser
.add_option("-n", action
="callback", type="int", dest
="ThreadNumber", callback
=SingleCheckCallback
,
2282 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 "\
2283 "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.")
2285 Parser
.add_option("-f", "--fdf", action
="callback", type="string", dest
="FdfFile", callback
=SingleCheckCallback
,
2286 help="The name of the FDF file to use, which overrides the setting in the DSC file.")
2287 Parser
.add_option("-r", "--rom-image", action
="append", type="string", dest
="RomImage", default
=[],
2288 help="The name of FD to be generated. The name must be from [FD] section in FDF file.")
2289 Parser
.add_option("-i", "--fv-image", action
="append", type="string", dest
="FvImage", default
=[],
2290 help="The name of FV to be generated. The name must be from [FV] section in FDF file.")
2291 Parser
.add_option("-C", "--capsule-image", action
="append", type="string", dest
="CapName", default
=[],
2292 help="The name of Capsule to be generated. The name must be from [Capsule] section in FDF file.")
2293 Parser
.add_option("-u", "--skip-autogen", action
="store_true", dest
="SkipAutoGen", help="Skip AutoGen step.")
2294 Parser
.add_option("-e", "--re-parse", action
="store_true", dest
="Reparse", help="Re-parse all meta-data files.")
2296 Parser
.add_option("-c", "--case-insensitive", action
="store_true", dest
="CaseInsensitive", default
=False, help="Don't check case of file name.")
2298 Parser
.add_option("-w", "--warning-as-error", action
="store_true", dest
="WarningAsError", help="Treat warning in tools as error.")
2299 Parser
.add_option("-j", "--log", action
="store", dest
="LogFile", help="Put log in specified file as well as on console.")
2301 Parser
.add_option("-s", "--silent", action
="store_true", type=None, dest
="SilentMode",
2302 help="Make use of silent mode of (n)make.")
2303 Parser
.add_option("-q", "--quiet", action
="store_true", type=None, help="Disable all messages except FATAL ERRORS.")
2304 Parser
.add_option("-v", "--verbose", action
="store_true", type=None, help="Turn on verbose output with informational messages printed, "\
2305 "including library instances selected, final dependency expression, "\
2306 "and warning messages, etc.")
2307 Parser
.add_option("-d", "--debug", action
="store", type="int", help="Enable debug messages at specified level.")
2308 Parser
.add_option("-D", "--define", action
="append", type="string", dest
="Macros", help="Macro: \"Name [= Value]\".")
2310 Parser
.add_option("-y", "--report-file", action
="store", dest
="ReportFile", help="Create/overwrite the report to the specified filename.")
2311 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
=[],
2312 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]. "\
2313 "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]")
2314 Parser
.add_option("-F", "--flag", action
="store", type="string", dest
="Flag",
2315 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. "\
2316 "This option can also be specified by setting *_*_*_BUILD_FLAGS in [BuildOptions] section of platform DSC. If they are both specified, this value "\
2317 "will override the setting in [BuildOptions] section of platform DSC.")
2318 Parser
.add_option("-N", "--no-cache", action
="store_true", dest
="DisableCache", default
=False, help="Disable build cache mechanism")
2319 Parser
.add_option("--conf", action
="store", type="string", dest
="ConfDirectory", help="Specify the customized Conf directory.")
2320 Parser
.add_option("--check-usage", action
="store_true", dest
="CheckUsage", default
=False, help="Check usage content of entries listed in INF file.")
2321 Parser
.add_option("--ignore-sources", action
="store_true", dest
="IgnoreSources", default
=False, help="Focus to a binary build and ignore all source files")
2322 Parser
.add_option("--pcd", action
="append", dest
="OptionPcd", help="Set PCD value by command line. Format: \"PcdName=Value\" ")
2323 Parser
.add_option("-l", "--cmd-len", action
="store", type="int", dest
="CommandLength", help="Specify the maximum line length of build command. Default is 4096.")
2324 Parser
.add_option("--hash", action
="store_true", dest
="UseHashCache", default
=False, help="Enable hash-based caching during build process.")
2325 Parser
.add_option("--binary-destination", action
="store", type="string", dest
="BinCacheDest", help="Generate a cache of binary files in the specified directory.")
2326 Parser
.add_option("--binary-source", action
="store", type="string", dest
="BinCacheSource", help="Consume a cache of binary files from the specified directory.")
2327 Parser
.add_option("--genfds-multi-thread", action
="store_true", dest
="GenfdsMultiThread", default
=False, help="Enable GenFds multi thread to generate ffs file.")
2328 Parser
.add_option("--disable-include-path-check", action
="store_true", dest
="DisableIncludePathCheck", default
=False, help="Disable the include path check for outside of package.")
2329 (Opt
, Args
) = Parser
.parse_args()
2332 ## Tool entrance method
2334 # This method mainly dispatch specific methods per the command line options.
2335 # If no error found, return zero value so the caller of this tool can know
2336 # if it's executed successfully or not.
2338 # @retval 0 Tool was successful
2339 # @retval 1 Tool failed
2342 StartTime
= time
.time()
2344 # Initialize log system
2345 EdkLogger
.Initialize()
2346 GlobalData
.gCommand
= sys
.argv
[1:]
2348 # Parse the options and args
2350 (Option
, Target
) = MyOptionParser()
2351 GlobalData
.gOptions
= Option
2352 GlobalData
.gCaseInsensitive
= Option
.CaseInsensitive
2355 if Option
.verbose
is not None:
2356 EdkLogger
.SetLevel(EdkLogger
.VERBOSE
)
2357 elif Option
.quiet
is not None:
2358 EdkLogger
.SetLevel(EdkLogger
.QUIET
)
2359 elif Option
.debug
is not None:
2360 EdkLogger
.SetLevel(Option
.debug
+ 1)
2362 EdkLogger
.SetLevel(EdkLogger
.INFO
)
2364 if Option
.LogFile
is not None:
2365 EdkLogger
.SetLogFile(Option
.LogFile
)
2367 if Option
.WarningAsError
== True:
2368 EdkLogger
.SetWarningAsError()
2370 if platform
.platform().find("Windows") >= 0:
2371 GlobalData
.gIsWindows
= True
2373 GlobalData
.gIsWindows
= False
2375 EdkLogger
.quiet("Build environment: %s" % platform
.platform())
2376 EdkLogger
.quiet(time
.strftime("Build start time: %H:%M:%S, %b.%d %Y\n", time
.localtime()));
2381 if len(Target
) == 0:
2383 elif len(Target
) >= 2:
2384 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, "More than one targets are not supported.",
2385 ExtraData
="Please select one of: %s" % (' '.join(gSupportedTarget
)))
2387 Target
= Target
[0].lower()
2389 if Target
not in gSupportedTarget
:
2390 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, "Not supported target [%s]." % Target
,
2391 ExtraData
="Please select one of: %s" % (' '.join(gSupportedTarget
)))
2394 # Check environment variable: EDK_TOOLS_PATH, WORKSPACE, PATH
2397 GlobalData
.gCommandLineDefines
.update(ParseDefines(Option
.Macros
))
2399 Workspace
= os
.getenv("WORKSPACE")
2401 # Get files real name in workspace dir
2403 GlobalData
.gAllFiles
= Utils
.DirCache(Workspace
)
2405 WorkingDirectory
= os
.getcwd()
2406 if not Option
.ModuleFile
:
2407 FileList
= glob
.glob(os
.path
.normpath(os
.path
.join(WorkingDirectory
, '*.inf')))
2408 FileNum
= len(FileList
)
2410 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, "There are %d INF files in %s." % (FileNum
, WorkingDirectory
),
2411 ExtraData
="Please use '-m <INF_FILE_PATH>' switch to choose one.")
2413 Option
.ModuleFile
= NormFile(FileList
[0], Workspace
)
2415 if Option
.ModuleFile
:
2416 if os
.path
.isabs (Option
.ModuleFile
):
2417 if os
.path
.normcase (os
.path
.normpath(Option
.ModuleFile
)).find (Workspace
) == 0:
2418 Option
.ModuleFile
= NormFile(os
.path
.normpath(Option
.ModuleFile
), Workspace
)
2419 Option
.ModuleFile
= PathClass(Option
.ModuleFile
, Workspace
)
2420 ErrorCode
, ErrorInfo
= Option
.ModuleFile
.Validate(".inf", False)
2422 EdkLogger
.error("build", ErrorCode
, ExtraData
=ErrorInfo
)
2424 if Option
.PlatformFile
is not None:
2425 if os
.path
.isabs (Option
.PlatformFile
):
2426 if os
.path
.normcase (os
.path
.normpath(Option
.PlatformFile
)).find (Workspace
) == 0:
2427 Option
.PlatformFile
= NormFile(os
.path
.normpath(Option
.PlatformFile
), Workspace
)
2428 Option
.PlatformFile
= PathClass(Option
.PlatformFile
, Workspace
)
2430 if Option
.FdfFile
is not None:
2431 if os
.path
.isabs (Option
.FdfFile
):
2432 if os
.path
.normcase (os
.path
.normpath(Option
.FdfFile
)).find (Workspace
) == 0:
2433 Option
.FdfFile
= NormFile(os
.path
.normpath(Option
.FdfFile
), Workspace
)
2434 Option
.FdfFile
= PathClass(Option
.FdfFile
, Workspace
)
2435 ErrorCode
, ErrorInfo
= Option
.FdfFile
.Validate(".fdf", False)
2437 EdkLogger
.error("build", ErrorCode
, ExtraData
=ErrorInfo
)
2439 if Option
.Flag
is not None and Option
.Flag
not in ['-c', '-s']:
2440 EdkLogger
.error("build", OPTION_VALUE_INVALID
, "UNI flag must be one of -c or -s")
2442 MyBuild
= Build(Target
, Workspace
, Option
)
2443 GlobalData
.gCommandLineDefines
['ARCH'] = ' '.join(MyBuild
.ArchList
)
2444 if not (MyBuild
.LaunchPrebuildFlag
and os
.path
.exists(MyBuild
.PlatformBuildPath
)):
2448 # All job done, no error found and no exception raised
2451 except FatalError
as X
:
2452 if MyBuild
is not None:
2453 # for multi-thread build exits safely
2454 MyBuild
.Relinquish()
2455 if Option
is not None and Option
.debug
is not None:
2456 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
2457 ReturnCode
= X
.args
[0]
2458 except Warning as X
:
2459 # error from Fdf parser
2460 if MyBuild
is not None:
2461 # for multi-thread build exits safely
2462 MyBuild
.Relinquish()
2463 if Option
is not None and Option
.debug
is not None:
2464 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
2466 EdkLogger
.error(X
.ToolName
, FORMAT_INVALID
, File
=X
.FileName
, Line
=X
.LineNumber
, ExtraData
=X
.Message
, RaiseError
=False)
2467 ReturnCode
= FORMAT_INVALID
2468 except KeyboardInterrupt:
2469 ReturnCode
= ABORT_ERROR
2470 if Option
is not None and Option
.debug
is not None:
2471 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
2473 if MyBuild
is not None:
2474 # for multi-thread build exits safely
2475 MyBuild
.Relinquish()
2477 # try to get the meta-file from the object causing exception
2478 Tb
= sys
.exc_info()[-1]
2479 MetaFile
= GlobalData
.gProcessingFile
2480 while Tb
is not None:
2481 if 'self' in Tb
.tb_frame
.f_locals
and hasattr(Tb
.tb_frame
.f_locals
['self'], 'MetaFile'):
2482 MetaFile
= Tb
.tb_frame
.f_locals
['self'].MetaFile
2487 "Unknown fatal error when processing [%s]" % MetaFile
,
2488 ExtraData
="\n(Please send email to %s for help, attaching following call stack trace!)\n" % MSG_EDKII_MAIL_ADDR
,
2491 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
2492 ReturnCode
= CODE_ERROR
2494 Utils
.Progressor
.Abort()
2495 Utils
.ClearDuplicatedInf()
2499 MyBuild
.LaunchPostbuild()
2502 Conclusion
= "Failed"
2503 elif ReturnCode
== ABORT_ERROR
:
2504 Conclusion
= "Aborted"
2506 Conclusion
= "Failed"
2507 FinishTime
= time
.time()
2508 BuildDuration
= time
.gmtime(int(round(FinishTime
- StartTime
)))
2509 BuildDurationStr
= ""
2510 if BuildDuration
.tm_yday
> 1:
2511 BuildDurationStr
= time
.strftime("%H:%M:%S", BuildDuration
) + ", %d day(s)" % (BuildDuration
.tm_yday
- 1)
2513 BuildDurationStr
= time
.strftime("%H:%M:%S", BuildDuration
)
2514 if MyBuild
is not None:
2516 MyBuild
.BuildReport
.GenerateReport(BuildDurationStr
, LogBuildTime(MyBuild
.AutoGenTime
), LogBuildTime(MyBuild
.MakeTime
), LogBuildTime(MyBuild
.GenFdsTime
))
2518 EdkLogger
.SetLevel(EdkLogger
.QUIET
)
2519 EdkLogger
.quiet("\n- %s -" % Conclusion
)
2520 EdkLogger
.quiet(time
.strftime("Build end time: %H:%M:%S, %b.%d %Y", time
.localtime()))
2521 EdkLogger
.quiet("Build total time: %s\n" % BuildDurationStr
)
2524 if __name__
== '__main__':
2526 ## 0-127 is a safe return range, and 1 is a standard default error
2527 if r
< 0 or r
> 127: r
= 1