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
)
629 # Set the value used by hash invalidation flow in GlobalData.gModuleBuildTracking to 'SUCCESS'
630 # If Module or Lib is being tracked, it did not fail header check test, and built successfully
631 if (self
.BuildItem
.BuildObject
.Arch
in GlobalData
.gModuleBuildTracking
and
632 self
.BuildItem
.BuildObject
in GlobalData
.gModuleBuildTracking
[self
.BuildItem
.BuildObject
.Arch
] and
633 GlobalData
.gModuleBuildTracking
[self
.BuildItem
.BuildObject
.Arch
][self
.BuildItem
.BuildObject
] != 'FAIL_METAFILE' and
634 not BuildTask
._ErrorFlag
.isSet()
636 GlobalData
.gModuleBuildTracking
[self
.BuildItem
.BuildObject
.Arch
][self
.BuildItem
.BuildObject
] = 'SUCCESS'
638 # indicate there's a thread is available for another build task
639 BuildTask
._RunningQueueLock
.acquire()
640 BuildTask
._RunningQueue
.pop(self
.BuildItem
)
641 BuildTask
._RunningQueueLock
.release()
642 BuildTask
._Thread
.release()
644 ## Start build task thread
647 EdkLogger
.quiet("Building ... %s" % repr(self
.BuildItem
))
648 Command
= self
.BuildItem
.BuildCommand
+ [self
.BuildItem
.Target
]
649 self
.BuildTread
= Thread(target
=self
._CommandThread
, args
=(Command
, self
.BuildItem
.WorkingDir
))
650 self
.BuildTread
.setName("build thread")
651 self
.BuildTread
.setDaemon(False)
652 self
.BuildTread
.start()
654 ## The class contains the information related to EFI image
659 # Constructor will load all required image information.
661 # @param BaseName The full file path of image.
662 # @param Guid The GUID for image.
663 # @param Arch Arch of this image.
664 # @param OutputDir The output directory for image.
665 # @param DebugDir The debug directory for image.
666 # @param ImageClass PeImage Information
668 def __init__(self
, BaseName
, Guid
, Arch
, OutputDir
, DebugDir
, ImageClass
):
669 self
.BaseName
= BaseName
672 self
.OutputDir
= OutputDir
673 self
.DebugDir
= DebugDir
674 self
.Image
= ImageClass
675 self
.Image
.Size
= (self
.Image
.Size
// 0x1000 + 1) * 0x1000
677 ## The class implementing the EDK2 build process
679 # The build process includes:
680 # 1. Load configuration from target.txt and tools_def.txt in $(WORKSPACE)/Conf
681 # 2. Parse DSC file of active platform
682 # 3. Parse FDF file if any
683 # 4. Establish build database, including parse all other files (module, package)
684 # 5. Create AutoGen files (C code file, depex file, makefile) if necessary
685 # 6. Call build command
690 # Constructor will load all necessary configurations, parse platform, modules
691 # and packages and the establish a database for AutoGen.
693 # @param Target The build command target, one of gSupportedTarget
694 # @param WorkspaceDir The directory of workspace
695 # @param BuildOptions Build options passed from command line
697 def __init__(self
, Target
, WorkspaceDir
, BuildOptions
):
698 self
.WorkspaceDir
= WorkspaceDir
700 self
.PlatformFile
= BuildOptions
.PlatformFile
701 self
.ModuleFile
= BuildOptions
.ModuleFile
702 self
.ArchList
= BuildOptions
.TargetArch
703 self
.ToolChainList
= BuildOptions
.ToolChain
704 self
.BuildTargetList
= BuildOptions
.BuildTarget
705 self
.Fdf
= BuildOptions
.FdfFile
706 self
.FdList
= BuildOptions
.RomImage
707 self
.FvList
= BuildOptions
.FvImage
708 self
.CapList
= BuildOptions
.CapName
709 self
.SilentMode
= BuildOptions
.SilentMode
710 self
.ThreadNumber
= BuildOptions
.ThreadNumber
711 self
.SkipAutoGen
= BuildOptions
.SkipAutoGen
712 self
.Reparse
= BuildOptions
.Reparse
713 self
.SkuId
= BuildOptions
.SkuId
715 GlobalData
.gSKUID_CMD
= self
.SkuId
716 self
.ConfDirectory
= BuildOptions
.ConfDirectory
717 self
.SpawnMode
= True
718 self
.BuildReport
= BuildReport(BuildOptions
.ReportFile
, BuildOptions
.ReportType
)
719 self
.TargetTxt
= TargetTxtClassObject()
720 self
.ToolDef
= ToolDefClassObject()
724 GlobalData
.BuildOptionPcd
= BuildOptions
.OptionPcd
if BuildOptions
.OptionPcd
else []
725 #Set global flag for build mode
726 GlobalData
.gIgnoreSource
= BuildOptions
.IgnoreSources
727 GlobalData
.gUseHashCache
= BuildOptions
.UseHashCache
728 GlobalData
.gBinCacheDest
= BuildOptions
.BinCacheDest
729 GlobalData
.gBinCacheSource
= BuildOptions
.BinCacheSource
730 GlobalData
.gEnableGenfdsMultiThread
= BuildOptions
.GenfdsMultiThread
731 GlobalData
.gDisableIncludePathCheck
= BuildOptions
.DisableIncludePathCheck
733 if GlobalData
.gBinCacheDest
and not GlobalData
.gUseHashCache
:
734 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, ExtraData
="--binary-destination must be used together with --hash.")
736 if GlobalData
.gBinCacheSource
and not GlobalData
.gUseHashCache
:
737 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, ExtraData
="--binary-source must be used together with --hash.")
739 if GlobalData
.gBinCacheDest
and GlobalData
.gBinCacheSource
:
740 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, ExtraData
="--binary-destination can not be used together with --binary-source.")
742 if GlobalData
.gBinCacheSource
:
743 BinCacheSource
= os
.path
.normpath(GlobalData
.gBinCacheSource
)
744 if not os
.path
.isabs(BinCacheSource
):
745 BinCacheSource
= mws
.join(self
.WorkspaceDir
, BinCacheSource
)
746 GlobalData
.gBinCacheSource
= BinCacheSource
748 if GlobalData
.gBinCacheSource
is not None:
749 EdkLogger
.error("build", OPTION_VALUE_INVALID
, ExtraData
="Invalid value of option --binary-source.")
751 if GlobalData
.gBinCacheDest
:
752 BinCacheDest
= os
.path
.normpath(GlobalData
.gBinCacheDest
)
753 if not os
.path
.isabs(BinCacheDest
):
754 BinCacheDest
= mws
.join(self
.WorkspaceDir
, BinCacheDest
)
755 GlobalData
.gBinCacheDest
= BinCacheDest
757 if GlobalData
.gBinCacheDest
is not None:
758 EdkLogger
.error("build", OPTION_VALUE_INVALID
, ExtraData
="Invalid value of option --binary-destination.")
760 if self
.ConfDirectory
:
761 # Get alternate Conf location, if it is absolute, then just use the absolute directory name
762 ConfDirectoryPath
= os
.path
.normpath(self
.ConfDirectory
)
764 if not os
.path
.isabs(ConfDirectoryPath
):
765 # Since alternate directory name is not absolute, the alternate directory is located within the WORKSPACE
766 # This also handles someone specifying the Conf directory in the workspace. Using --conf=Conf
767 ConfDirectoryPath
= mws
.join(self
.WorkspaceDir
, ConfDirectoryPath
)
769 if "CONF_PATH" in os
.environ
:
770 ConfDirectoryPath
= os
.path
.normcase(os
.path
.normpath(os
.environ
["CONF_PATH"]))
772 # Get standard WORKSPACE/Conf use the absolute path to the WORKSPACE/Conf
773 ConfDirectoryPath
= mws
.join(self
.WorkspaceDir
, 'Conf')
774 GlobalData
.gConfDirectory
= ConfDirectoryPath
775 GlobalData
.gDatabasePath
= os
.path
.normpath(os
.path
.join(ConfDirectoryPath
, GlobalData
.gDatabasePath
))
777 self
.Db
= WorkspaceDatabase()
778 self
.BuildDatabase
= self
.Db
.BuildObject
780 self
.ToolChainFamily
= None
781 self
.LoadFixAddress
= 0
782 self
.UniFlag
= BuildOptions
.Flag
783 self
.BuildModules
= []
784 self
.HashSkipModules
= []
786 self
.LaunchPrebuildFlag
= False
787 self
.PlatformBuildPath
= os
.path
.join(GlobalData
.gConfDirectory
, '.cache', '.PlatformBuild')
788 if BuildOptions
.CommandLength
:
789 GlobalData
.gCommandMaxLength
= BuildOptions
.CommandLength
791 # print dot character during doing some time-consuming work
792 self
.Progress
= Utils
.Progressor()
793 # print current build environment and configuration
794 EdkLogger
.quiet("%-16s = %s" % ("WORKSPACE", os
.environ
["WORKSPACE"]))
795 if "PACKAGES_PATH" in os
.environ
:
796 # WORKSPACE env has been converted before. Print the same path style with WORKSPACE env.
797 EdkLogger
.quiet("%-16s = %s" % ("PACKAGES_PATH", os
.path
.normcase(os
.path
.normpath(os
.environ
["PACKAGES_PATH"]))))
798 EdkLogger
.quiet("%-16s = %s" % ("EDK_TOOLS_PATH", os
.environ
["EDK_TOOLS_PATH"]))
799 if "EDK_TOOLS_BIN" in os
.environ
:
800 # Print the same path style with WORKSPACE env.
801 EdkLogger
.quiet("%-16s = %s" % ("EDK_TOOLS_BIN", os
.path
.normcase(os
.path
.normpath(os
.environ
["EDK_TOOLS_BIN"]))))
802 EdkLogger
.quiet("%-16s = %s" % ("CONF_PATH", GlobalData
.gConfDirectory
))
803 if "PYTHON3_ENABLE" in os
.environ
:
804 PYTHON3_ENABLE
= os
.environ
["PYTHON3_ENABLE"]
805 if PYTHON3_ENABLE
!= "TRUE":
806 PYTHON3_ENABLE
= "FALSE"
807 EdkLogger
.quiet("%-16s = %s" % ("PYTHON3_ENABLE", PYTHON3_ENABLE
))
808 if "PYTHON_COMMAND" in os
.environ
:
809 EdkLogger
.quiet("%-16s = %s" % ("PYTHON_COMMAND", os
.environ
["PYTHON_COMMAND"]))
813 EdkLogger
.quiet("%-16s = %s" % ("PREBUILD", self
.Prebuild
))
815 EdkLogger
.quiet("%-16s = %s" % ("POSTBUILD", self
.Postbuild
))
817 self
.LaunchPrebuild()
818 self
.TargetTxt
= TargetTxtClassObject()
819 self
.ToolDef
= ToolDefClassObject()
820 if not (self
.LaunchPrebuildFlag
and os
.path
.exists(self
.PlatformBuildPath
)):
824 os
.chdir(self
.WorkspaceDir
)
826 ## Load configuration
828 # This method will parse target.txt and get the build configurations.
830 def LoadConfiguration(self
):
832 # Check target.txt and tools_def.txt and Init them
834 BuildConfigurationFile
= os
.path
.normpath(os
.path
.join(GlobalData
.gConfDirectory
, gBuildConfiguration
))
835 if os
.path
.isfile(BuildConfigurationFile
) == True:
836 StatusCode
= self
.TargetTxt
.LoadTargetTxtFile(BuildConfigurationFile
)
838 ToolDefinitionFile
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_TOOL_CHAIN_CONF
]
839 if ToolDefinitionFile
== '':
840 ToolDefinitionFile
= gToolsDefinition
841 ToolDefinitionFile
= os
.path
.normpath(mws
.join(self
.WorkspaceDir
, 'Conf', ToolDefinitionFile
))
842 if os
.path
.isfile(ToolDefinitionFile
) == True:
843 StatusCode
= self
.ToolDef
.LoadToolDefFile(ToolDefinitionFile
)
845 EdkLogger
.error("build", FILE_NOT_FOUND
, ExtraData
=ToolDefinitionFile
)
847 EdkLogger
.error("build", FILE_NOT_FOUND
, ExtraData
=BuildConfigurationFile
)
849 # if no ARCH given in command line, get it from target.txt
850 if not self
.ArchList
:
851 self
.ArchList
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_TARGET_ARCH
]
852 self
.ArchList
= tuple(self
.ArchList
)
854 # if no build target given in command line, get it from target.txt
855 if not self
.BuildTargetList
:
856 self
.BuildTargetList
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_TARGET
]
858 # if no tool chain given in command line, get it from target.txt
859 if not self
.ToolChainList
:
860 self
.ToolChainList
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_TOOL_CHAIN_TAG
]
861 if self
.ToolChainList
is None or len(self
.ToolChainList
) == 0:
862 EdkLogger
.error("build", RESOURCE_NOT_AVAILABLE
, ExtraData
="No toolchain given. Don't know how to build.\n")
864 # check if the tool chains are defined or not
865 NewToolChainList
= []
866 for ToolChain
in self
.ToolChainList
:
867 if ToolChain
not in self
.ToolDef
.ToolsDefTxtDatabase
[TAB_TOD_DEFINES_TOOL_CHAIN_TAG
]:
868 EdkLogger
.warn("build", "Tool chain [%s] is not defined" % ToolChain
)
870 NewToolChainList
.append(ToolChain
)
871 # if no tool chain available, break the build
872 if len(NewToolChainList
) == 0:
873 EdkLogger
.error("build", RESOURCE_NOT_AVAILABLE
,
874 ExtraData
="[%s] not defined. No toolchain available for build!\n" % ", ".join(self
.ToolChainList
))
876 self
.ToolChainList
= NewToolChainList
879 ToolDefinition
= self
.ToolDef
.ToolsDefTxtDatabase
880 for Tool
in self
.ToolChainList
:
881 if TAB_TOD_DEFINES_FAMILY
not in ToolDefinition
or Tool
not in ToolDefinition
[TAB_TOD_DEFINES_FAMILY
] \
882 or not ToolDefinition
[TAB_TOD_DEFINES_FAMILY
][Tool
]:
883 EdkLogger
.warn("build", "No tool chain family found in configuration for %s. Default to MSFT." % Tool
)
884 ToolChainFamily
.append(TAB_COMPILER_MSFT
)
886 ToolChainFamily
.append(ToolDefinition
[TAB_TOD_DEFINES_FAMILY
][Tool
])
887 self
.ToolChainFamily
= ToolChainFamily
889 if self
.ThreadNumber
is None:
890 self
.ThreadNumber
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_MAX_CONCURRENT_THREAD_NUMBER
]
891 if self
.ThreadNumber
== '':
892 self
.ThreadNumber
= 0
894 self
.ThreadNumber
= int(self
.ThreadNumber
, 0)
896 if self
.ThreadNumber
== 0:
898 self
.ThreadNumber
= multiprocessing
.cpu_count()
899 except (ImportError, NotImplementedError):
900 self
.ThreadNumber
= 1
902 if not self
.PlatformFile
:
903 PlatformFile
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_ACTIVE_PLATFORM
]
905 # Try to find one in current directory
906 WorkingDirectory
= os
.getcwd()
907 FileList
= glob
.glob(os
.path
.normpath(os
.path
.join(WorkingDirectory
, '*.dsc')))
908 FileNum
= len(FileList
)
910 EdkLogger
.error("build", OPTION_MISSING
,
911 ExtraData
="There are %d DSC files in %s. Use '-p' to specify one.\n" % (FileNum
, WorkingDirectory
))
913 PlatformFile
= FileList
[0]
915 EdkLogger
.error("build", RESOURCE_NOT_AVAILABLE
,
916 ExtraData
="No active platform specified in target.txt or command line! Nothing can be built.\n")
918 self
.PlatformFile
= PathClass(NormFile(PlatformFile
, self
.WorkspaceDir
), self
.WorkspaceDir
)
920 ## Initialize build configuration
922 # This method will parse DSC file and merge the configurations from
923 # command line and target.txt, then get the final build configurations.
926 # parse target.txt, tools_def.txt, and platform file
927 self
.LoadConfiguration()
929 # Allow case-insensitive for those from command line or configuration file
930 ErrorCode
, ErrorInfo
= self
.PlatformFile
.Validate(".dsc", False)
932 EdkLogger
.error("build", ErrorCode
, ExtraData
=ErrorInfo
)
935 def InitPreBuild(self
):
936 self
.LoadConfiguration()
937 ErrorCode
, ErrorInfo
= self
.PlatformFile
.Validate(".dsc", False)
939 EdkLogger
.error("build", ErrorCode
, ExtraData
=ErrorInfo
)
940 if self
.BuildTargetList
:
941 GlobalData
.gGlobalDefines
['TARGET'] = self
.BuildTargetList
[0]
943 GlobalData
.gGlobalDefines
['ARCH'] = self
.ArchList
[0]
944 if self
.ToolChainList
:
945 GlobalData
.gGlobalDefines
['TOOLCHAIN'] = self
.ToolChainList
[0]
946 GlobalData
.gGlobalDefines
['TOOL_CHAIN_TAG'] = self
.ToolChainList
[0]
947 if self
.ToolChainFamily
:
948 GlobalData
.gGlobalDefines
['FAMILY'] = self
.ToolChainFamily
[0]
949 if 'PREBUILD' in GlobalData
.gCommandLineDefines
:
950 self
.Prebuild
= GlobalData
.gCommandLineDefines
.get('PREBUILD')
953 Platform
= self
.Db
.MapPlatform(str(self
.PlatformFile
))
954 self
.Prebuild
= str(Platform
.Prebuild
)
958 # Evaluate all arguments and convert arguments that are WORKSPACE
959 # relative paths to absolute paths. Filter arguments that look like
960 # flags or do not follow the file/dir naming rules to avoid false
961 # positives on this conversion.
963 for Arg
in self
.Prebuild
.split():
965 # Do not modify Arg if it looks like a flag or an absolute file path
967 if Arg
.startswith('-') or os
.path
.isabs(Arg
):
968 PrebuildList
.append(Arg
)
971 # Do not modify Arg if it does not look like a Workspace relative
972 # path that starts with a valid package directory name
974 if not Arg
[0].isalpha() or os
.path
.dirname(Arg
) == '':
975 PrebuildList
.append(Arg
)
978 # If Arg looks like a WORKSPACE relative path, then convert to an
979 # absolute path and check to see if the file exists.
981 Temp
= mws
.join(self
.WorkspaceDir
, Arg
)
982 if os
.path
.isfile(Temp
):
984 PrebuildList
.append(Arg
)
985 self
.Prebuild
= ' '.join(PrebuildList
)
986 self
.Prebuild
+= self
.PassCommandOption(self
.BuildTargetList
, self
.ArchList
, self
.ToolChainList
, self
.PlatformFile
, self
.Target
)
988 def InitPostBuild(self
):
989 if 'POSTBUILD' in GlobalData
.gCommandLineDefines
:
990 self
.Postbuild
= GlobalData
.gCommandLineDefines
.get('POSTBUILD')
992 Platform
= self
.Db
.MapPlatform(str(self
.PlatformFile
))
993 self
.Postbuild
= str(Platform
.Postbuild
)
997 # Evaluate all arguments and convert arguments that are WORKSPACE
998 # relative paths to absolute paths. Filter arguments that look like
999 # flags or do not follow the file/dir naming rules to avoid false
1000 # positives on this conversion.
1002 for Arg
in self
.Postbuild
.split():
1004 # Do not modify Arg if it looks like a flag or an absolute file path
1006 if Arg
.startswith('-') or os
.path
.isabs(Arg
):
1007 PostbuildList
.append(Arg
)
1010 # Do not modify Arg if it does not look like a Workspace relative
1011 # path that starts with a valid package directory name
1013 if not Arg
[0].isalpha() or os
.path
.dirname(Arg
) == '':
1014 PostbuildList
.append(Arg
)
1017 # If Arg looks like a WORKSPACE relative path, then convert to an
1018 # absolute path and check to see if the file exists.
1020 Temp
= mws
.join(self
.WorkspaceDir
, Arg
)
1021 if os
.path
.isfile(Temp
):
1023 PostbuildList
.append(Arg
)
1024 self
.Postbuild
= ' '.join(PostbuildList
)
1025 self
.Postbuild
+= self
.PassCommandOption(self
.BuildTargetList
, self
.ArchList
, self
.ToolChainList
, self
.PlatformFile
, self
.Target
)
1027 def PassCommandOption(self
, BuildTarget
, TargetArch
, ToolChain
, PlatformFile
, Target
):
1029 if GlobalData
.gCommand
and isinstance(GlobalData
.gCommand
, list):
1030 BuildStr
+= ' ' + ' '.join(GlobalData
.gCommand
)
1033 ToolChainFlag
= False
1034 PlatformFileFlag
= False
1036 if GlobalData
.gOptions
and not GlobalData
.gOptions
.BuildTarget
:
1038 if GlobalData
.gOptions
and not GlobalData
.gOptions
.TargetArch
:
1040 if GlobalData
.gOptions
and not GlobalData
.gOptions
.ToolChain
:
1041 ToolChainFlag
= True
1042 if GlobalData
.gOptions
and not GlobalData
.gOptions
.PlatformFile
:
1043 PlatformFileFlag
= True
1045 if TargetFlag
and BuildTarget
:
1046 if isinstance(BuildTarget
, list) or isinstance(BuildTarget
, tuple):
1047 BuildStr
+= ' -b ' + ' -b '.join(BuildTarget
)
1048 elif isinstance(BuildTarget
, str):
1049 BuildStr
+= ' -b ' + BuildTarget
1050 if ArchFlag
and TargetArch
:
1051 if isinstance(TargetArch
, list) or isinstance(TargetArch
, tuple):
1052 BuildStr
+= ' -a ' + ' -a '.join(TargetArch
)
1053 elif isinstance(TargetArch
, str):
1054 BuildStr
+= ' -a ' + TargetArch
1055 if ToolChainFlag
and ToolChain
:
1056 if isinstance(ToolChain
, list) or isinstance(ToolChain
, tuple):
1057 BuildStr
+= ' -t ' + ' -t '.join(ToolChain
)
1058 elif isinstance(ToolChain
, str):
1059 BuildStr
+= ' -t ' + ToolChain
1060 if PlatformFileFlag
and PlatformFile
:
1061 if isinstance(PlatformFile
, list) or isinstance(PlatformFile
, tuple):
1062 BuildStr
+= ' -p ' + ' -p '.join(PlatformFile
)
1063 elif isinstance(PlatformFile
, str):
1064 BuildStr
+= ' -p' + PlatformFile
1065 BuildStr
+= ' --conf=' + GlobalData
.gConfDirectory
1067 BuildStr
+= ' ' + Target
1071 def LaunchPrebuild(self
):
1073 EdkLogger
.info("\n- Prebuild Start -\n")
1074 self
.LaunchPrebuildFlag
= True
1076 # The purpose of .PrebuildEnv file is capture environment variable settings set by the prebuild script
1077 # and preserve them for the rest of the main build step, because the child process environment will
1078 # evaporate as soon as it exits, we cannot get it in build step.
1080 PrebuildEnvFile
= os
.path
.join(GlobalData
.gConfDirectory
, '.cache', '.PrebuildEnv')
1081 if os
.path
.isfile(PrebuildEnvFile
):
1082 os
.remove(PrebuildEnvFile
)
1083 if os
.path
.isfile(self
.PlatformBuildPath
):
1084 os
.remove(self
.PlatformBuildPath
)
1085 if sys
.platform
== "win32":
1086 args
= ' && '.join((self
.Prebuild
, 'set > ' + PrebuildEnvFile
))
1087 Process
= Popen(args
, stdout
=PIPE
, stderr
=PIPE
, shell
=True)
1089 args
= ' && '.join((self
.Prebuild
, 'env > ' + PrebuildEnvFile
))
1090 Process
= Popen(args
, stdout
=PIPE
, stderr
=PIPE
, shell
=True)
1092 # launch two threads to read the STDOUT and STDERR
1093 EndOfProcedure
= Event()
1094 EndOfProcedure
.clear()
1096 StdOutThread
= Thread(target
=ReadMessage
, args
=(Process
.stdout
, EdkLogger
.info
, EndOfProcedure
))
1097 StdOutThread
.setName("STDOUT-Redirector")
1098 StdOutThread
.setDaemon(False)
1099 StdOutThread
.start()
1102 StdErrThread
= Thread(target
=ReadMessage
, args
=(Process
.stderr
, EdkLogger
.quiet
, EndOfProcedure
))
1103 StdErrThread
.setName("STDERR-Redirector")
1104 StdErrThread
.setDaemon(False)
1105 StdErrThread
.start()
1106 # waiting for program exit
1113 if Process
.returncode
!= 0 :
1114 EdkLogger
.error("Prebuild", PREBUILD_ERROR
, 'Prebuild process is not success!')
1116 if os
.path
.exists(PrebuildEnvFile
):
1117 f
= open(PrebuildEnvFile
)
1118 envs
= f
.readlines()
1120 envs
= [l
.split("=", 1) for l
in envs
]
1121 envs
= [[I
.strip() for I
in item
] for item
in envs
if len(item
) == 2]
1122 os
.environ
.update(dict(envs
))
1123 EdkLogger
.info("\n- Prebuild Done -\n")
1125 def LaunchPostbuild(self
):
1127 EdkLogger
.info("\n- Postbuild Start -\n")
1128 if sys
.platform
== "win32":
1129 Process
= Popen(self
.Postbuild
, stdout
=PIPE
, stderr
=PIPE
, shell
=True)
1131 Process
= Popen(self
.Postbuild
, stdout
=PIPE
, stderr
=PIPE
, shell
=True)
1132 # launch two threads to read the STDOUT and STDERR
1133 EndOfProcedure
= Event()
1134 EndOfProcedure
.clear()
1136 StdOutThread
= Thread(target
=ReadMessage
, args
=(Process
.stdout
, EdkLogger
.info
, EndOfProcedure
))
1137 StdOutThread
.setName("STDOUT-Redirector")
1138 StdOutThread
.setDaemon(False)
1139 StdOutThread
.start()
1142 StdErrThread
= Thread(target
=ReadMessage
, args
=(Process
.stderr
, EdkLogger
.quiet
, EndOfProcedure
))
1143 StdErrThread
.setName("STDERR-Redirector")
1144 StdErrThread
.setDaemon(False)
1145 StdErrThread
.start()
1146 # waiting for program exit
1153 if Process
.returncode
!= 0 :
1154 EdkLogger
.error("Postbuild", POSTBUILD_ERROR
, 'Postbuild process is not success!')
1155 EdkLogger
.info("\n- Postbuild Done -\n")
1157 ## Error handling for hash feature
1159 # On BuildTask error, iterate through the Module Build tracking
1160 # dictionary to determine wheather a module failed to build. Invalidate
1161 # the hash associated with that module by removing it from storage.
1164 def invalidateHash(self
):
1165 # Only for hashing feature
1166 if not GlobalData
.gUseHashCache
:
1169 # GlobalData.gModuleBuildTracking contains only modules or libs that cannot be skipped by hash
1170 for moduleAutoGenObjArch
in GlobalData
.gModuleBuildTracking
.keys():
1171 for moduleAutoGenObj
in GlobalData
.gModuleBuildTracking
[moduleAutoGenObjArch
].keys():
1172 # Skip invalidating for Successful Module/Lib builds
1173 if GlobalData
.gModuleBuildTracking
[moduleAutoGenObjArch
][moduleAutoGenObj
] == 'SUCCESS':
1176 # The module failed to build, failed to start building, or failed the header check test from this point on
1178 # Remove .hash from build
1179 ModuleHashFile
= os
.path
.join(moduleAutoGenObj
.BuildDir
, moduleAutoGenObj
.Name
+ ".hash")
1180 if os
.path
.exists(ModuleHashFile
):
1181 os
.remove(ModuleHashFile
)
1183 # Remove .hash file from cache
1184 if GlobalData
.gBinCacheDest
:
1185 FileDir
= os
.path
.join(GlobalData
.gBinCacheDest
, moduleAutoGenObj
.Arch
, moduleAutoGenObj
.SourceDir
, moduleAutoGenObj
.MetaFile
.BaseName
)
1186 HashFile
= os
.path
.join(FileDir
, moduleAutoGenObj
.Name
+ '.hash')
1187 if os
.path
.exists(HashFile
):
1190 ## Build a module or platform
1192 # Create autogen code and makefile for a module or platform, and the launch
1193 # "make" command to build it
1195 # @param Target The target of build command
1196 # @param Platform The platform file
1197 # @param Module The module file
1198 # @param BuildTarget The name of build target, one of "DEBUG", "RELEASE"
1199 # @param ToolChain The name of toolchain to build
1200 # @param Arch The arch of the module/platform
1201 # @param CreateDepModuleCodeFile Flag used to indicate creating code
1202 # for dependent modules/Libraries
1203 # @param CreateDepModuleMakeFile Flag used to indicate creating makefile
1204 # for dependent modules/Libraries
1206 def _BuildPa(self
, Target
, AutoGenObject
, CreateDepsCodeFile
=True, CreateDepsMakeFile
=True, BuildModule
=False, FfsCommand
={}):
1207 if AutoGenObject
is None:
1210 # skip file generation for cleanxxx targets, run and fds target
1211 if Target
not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1212 # for target which must generate AutoGen code and makefile
1213 if not self
.SkipAutoGen
or Target
== 'genc':
1214 self
.Progress
.Start("Generating code")
1215 AutoGenObject
.CreateCodeFile(CreateDepsCodeFile
)
1216 self
.Progress
.Stop("done!")
1217 if Target
== "genc":
1220 if not self
.SkipAutoGen
or Target
== 'genmake':
1221 self
.Progress
.Start("Generating makefile")
1222 AutoGenObject
.CreateMakeFile(CreateDepsMakeFile
, FfsCommand
)
1223 self
.Progress
.Stop("done!")
1224 if Target
== "genmake":
1227 # always recreate top/platform makefile when clean, just in case of inconsistency
1228 AutoGenObject
.CreateCodeFile(False)
1229 AutoGenObject
.CreateMakeFile(False)
1231 if EdkLogger
.GetLevel() == EdkLogger
.QUIET
:
1232 EdkLogger
.quiet("Building ... %s" % repr(AutoGenObject
))
1234 BuildCommand
= AutoGenObject
.BuildCommand
1235 if BuildCommand
is None or len(BuildCommand
) == 0:
1236 EdkLogger
.error("build", OPTION_MISSING
,
1237 "No build command found for this module. "
1238 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %
1239 (AutoGenObject
.BuildTarget
, AutoGenObject
.ToolChain
, AutoGenObject
.Arch
),
1240 ExtraData
=str(AutoGenObject
))
1242 makefile
= GenMake
.BuildFile(AutoGenObject
)._FILE
_NAME
_[GenMake
.gMakeType
]
1250 BuildCommand
= BuildCommand
+ [Target
]
1251 LaunchCommand(BuildCommand
, AutoGenObject
.MakeFileDir
)
1252 self
.CreateAsBuiltInf()
1253 if GlobalData
.gBinCacheDest
:
1254 self
.UpdateBuildCache()
1255 self
.BuildModules
= []
1259 if Target
== 'libraries':
1260 for Lib
in AutoGenObject
.LibraryBuildDirectoryList
:
1261 NewBuildCommand
= BuildCommand
+ ['-f', os
.path
.normpath(os
.path
.join(Lib
, makefile
)), 'pbuild']
1262 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1266 if Target
== 'modules':
1267 for Lib
in AutoGenObject
.LibraryBuildDirectoryList
:
1268 NewBuildCommand
= BuildCommand
+ ['-f', os
.path
.normpath(os
.path
.join(Lib
, makefile
)), 'pbuild']
1269 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1270 for Mod
in AutoGenObject
.ModuleBuildDirectoryList
:
1271 NewBuildCommand
= BuildCommand
+ ['-f', os
.path
.normpath(os
.path
.join(Mod
, makefile
)), 'pbuild']
1272 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1273 self
.CreateAsBuiltInf()
1274 if GlobalData
.gBinCacheDest
:
1275 self
.UpdateBuildCache()
1276 self
.BuildModules
= []
1280 if Target
== 'cleanlib':
1281 for Lib
in AutoGenObject
.LibraryBuildDirectoryList
:
1282 LibMakefile
= os
.path
.normpath(os
.path
.join(Lib
, makefile
))
1283 if os
.path
.exists(LibMakefile
):
1284 NewBuildCommand
= BuildCommand
+ ['-f', LibMakefile
, 'cleanall']
1285 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1289 if Target
== 'clean':
1290 for Mod
in AutoGenObject
.ModuleBuildDirectoryList
:
1291 ModMakefile
= os
.path
.normpath(os
.path
.join(Mod
, makefile
))
1292 if os
.path
.exists(ModMakefile
):
1293 NewBuildCommand
= BuildCommand
+ ['-f', ModMakefile
, 'cleanall']
1294 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1295 for Lib
in AutoGenObject
.LibraryBuildDirectoryList
:
1296 LibMakefile
= os
.path
.normpath(os
.path
.join(Lib
, makefile
))
1297 if os
.path
.exists(LibMakefile
):
1298 NewBuildCommand
= BuildCommand
+ ['-f', LibMakefile
, 'cleanall']
1299 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1303 if Target
== 'cleanall':
1305 #os.rmdir(AutoGenObject.BuildDir)
1306 RemoveDirectory(AutoGenObject
.BuildDir
, True)
1307 except WindowsError as X
:
1308 EdkLogger
.error("build", FILE_DELETE_FAILURE
, ExtraData
=str(X
))
1311 ## Build a module or platform
1313 # Create autogen code and makefile for a module or platform, and the launch
1314 # "make" command to build it
1316 # @param Target The target of build command
1317 # @param Platform The platform file
1318 # @param Module The module file
1319 # @param BuildTarget The name of build target, one of "DEBUG", "RELEASE"
1320 # @param ToolChain The name of toolchain to build
1321 # @param Arch The arch of the module/platform
1322 # @param CreateDepModuleCodeFile Flag used to indicate creating code
1323 # for dependent modules/Libraries
1324 # @param CreateDepModuleMakeFile Flag used to indicate creating makefile
1325 # for dependent modules/Libraries
1327 def _Build(self
, Target
, AutoGenObject
, CreateDepsCodeFile
=True, CreateDepsMakeFile
=True, BuildModule
=False):
1328 if AutoGenObject
is None:
1331 # skip file generation for cleanxxx targets, run and fds target
1332 if Target
not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1333 # for target which must generate AutoGen code and makefile
1334 if not self
.SkipAutoGen
or Target
== 'genc':
1335 self
.Progress
.Start("Generating code")
1336 AutoGenObject
.CreateCodeFile(CreateDepsCodeFile
)
1337 self
.Progress
.Stop("done!")
1338 if Target
== "genc":
1341 if not self
.SkipAutoGen
or Target
== 'genmake':
1342 self
.Progress
.Start("Generating makefile")
1343 AutoGenObject
.CreateMakeFile(CreateDepsMakeFile
)
1344 #AutoGenObject.CreateAsBuiltInf()
1345 self
.Progress
.Stop("done!")
1346 if Target
== "genmake":
1349 # always recreate top/platform makefile when clean, just in case of inconsistency
1350 AutoGenObject
.CreateCodeFile(False)
1351 AutoGenObject
.CreateMakeFile(False)
1353 if EdkLogger
.GetLevel() == EdkLogger
.QUIET
:
1354 EdkLogger
.quiet("Building ... %s" % repr(AutoGenObject
))
1356 BuildCommand
= AutoGenObject
.BuildCommand
1357 if BuildCommand
is None or len(BuildCommand
) == 0:
1358 EdkLogger
.error("build", OPTION_MISSING
,
1359 "No build command found for this module. "
1360 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %
1361 (AutoGenObject
.BuildTarget
, AutoGenObject
.ToolChain
, AutoGenObject
.Arch
),
1362 ExtraData
=str(AutoGenObject
))
1367 BuildCommand
= BuildCommand
+ [Target
]
1368 AutoGenObject
.BuildTime
= LaunchCommand(BuildCommand
, AutoGenObject
.MakeFileDir
)
1369 self
.CreateAsBuiltInf()
1370 if GlobalData
.gBinCacheDest
:
1371 self
.UpdateBuildCache()
1372 self
.BuildModules
= []
1377 if GenFdsApi(AutoGenObject
.GenFdsCommandDict
, self
.Db
):
1378 EdkLogger
.error("build", COMMAND_FAILURE
)
1386 if Target
== 'libraries':
1393 if Target
== 'cleanall':
1395 #os.rmdir(AutoGenObject.BuildDir)
1396 RemoveDirectory(AutoGenObject
.BuildDir
, True)
1397 except WindowsError as X
:
1398 EdkLogger
.error("build", FILE_DELETE_FAILURE
, ExtraData
=str(X
))
1401 ## Rebase module image and Get function address for the input module list.
1403 def _RebaseModule (self
, MapBuffer
, BaseAddress
, ModuleList
, AddrIsOffset
= True, ModeIsSmm
= False):
1405 AddrIsOffset
= False
1406 for InfFile
in ModuleList
:
1407 sys
.stdout
.write (".")
1409 ModuleInfo
= ModuleList
[InfFile
]
1410 ModuleName
= ModuleInfo
.BaseName
1411 ModuleOutputImage
= ModuleInfo
.Image
.FileName
1412 ModuleDebugImage
= os
.path
.join(ModuleInfo
.DebugDir
, ModuleInfo
.BaseName
+ '.efi')
1413 ## for SMM module in SMRAM, the SMRAM will be allocated from base to top.
1415 BaseAddress
= BaseAddress
- ModuleInfo
.Image
.Size
1417 # Update Image to new BaseAddress by GenFw tool
1419 LaunchCommand(["GenFw", "--rebase", str(BaseAddress
), "-r", ModuleOutputImage
], ModuleInfo
.OutputDir
)
1420 LaunchCommand(["GenFw", "--rebase", str(BaseAddress
), "-r", ModuleDebugImage
], ModuleInfo
.DebugDir
)
1423 # Set new address to the section header only for SMM driver.
1425 LaunchCommand(["GenFw", "--address", str(BaseAddress
), "-r", ModuleOutputImage
], ModuleInfo
.OutputDir
)
1426 LaunchCommand(["GenFw", "--address", str(BaseAddress
), "-r", ModuleDebugImage
], ModuleInfo
.DebugDir
)
1428 # Collect function address from Map file
1430 ImageMapTable
= ModuleOutputImage
.replace('.efi', '.map')
1432 if os
.path
.exists(ImageMapTable
):
1433 OrigImageBaseAddress
= 0
1434 ImageMap
= open(ImageMapTable
, 'r')
1435 for LinStr
in ImageMap
:
1436 if len (LinStr
.strip()) == 0:
1439 # Get the preferred address set on link time.
1441 if LinStr
.find ('Preferred load address is') != -1:
1442 StrList
= LinStr
.split()
1443 OrigImageBaseAddress
= int (StrList
[len(StrList
) - 1], 16)
1445 StrList
= LinStr
.split()
1446 if len (StrList
) > 4:
1447 if StrList
[3] == 'f' or StrList
[3] == 'F':
1449 RelativeAddress
= int (StrList
[2], 16) - OrigImageBaseAddress
1450 FunctionList
.append ((Name
, RelativeAddress
))
1454 # Add general information.
1457 MapBuffer
.append('\n\n%s (Fixed SMRAM Offset, BaseAddress=0x%010X, EntryPoint=0x%010X)\n' % (ModuleName
, BaseAddress
, BaseAddress
+ ModuleInfo
.Image
.EntryPoint
))
1459 MapBuffer
.append('\n\n%s (Fixed Memory Offset, BaseAddress=-0x%010X, EntryPoint=-0x%010X)\n' % (ModuleName
, 0 - BaseAddress
, 0 - (BaseAddress
+ ModuleInfo
.Image
.EntryPoint
)))
1461 MapBuffer
.append('\n\n%s (Fixed Memory Address, BaseAddress=0x%010X, EntryPoint=0x%010X)\n' % (ModuleName
, BaseAddress
, BaseAddress
+ ModuleInfo
.Image
.EntryPoint
))
1463 # Add guid and general seciton section.
1465 TextSectionAddress
= 0
1466 DataSectionAddress
= 0
1467 for SectionHeader
in ModuleInfo
.Image
.SectionHeaderList
:
1468 if SectionHeader
[0] == '.text':
1469 TextSectionAddress
= SectionHeader
[1]
1470 elif SectionHeader
[0] in ['.data', '.sdata']:
1471 DataSectionAddress
= SectionHeader
[1]
1473 MapBuffer
.append('(GUID=%s, .textbaseaddress=-0x%010X, .databaseaddress=-0x%010X)\n' % (ModuleInfo
.Guid
, 0 - (BaseAddress
+ TextSectionAddress
), 0 - (BaseAddress
+ DataSectionAddress
)))
1475 MapBuffer
.append('(GUID=%s, .textbaseaddress=0x%010X, .databaseaddress=0x%010X)\n' % (ModuleInfo
.Guid
, BaseAddress
+ TextSectionAddress
, BaseAddress
+ DataSectionAddress
))
1477 # Add debug image full path.
1479 MapBuffer
.append('(IMAGE=%s)\n\n' % (ModuleDebugImage
))
1481 # Add function address
1483 for Function
in FunctionList
:
1485 MapBuffer
.append(' -0x%010X %s\n' % (0 - (BaseAddress
+ Function
[1]), Function
[0]))
1487 MapBuffer
.append(' 0x%010X %s\n' % (BaseAddress
+ Function
[1], Function
[0]))
1491 # for SMM module in SMRAM, the SMRAM will be allocated from base to top.
1494 BaseAddress
= BaseAddress
+ ModuleInfo
.Image
.Size
1496 ## Collect MAP information of all FVs
1498 def _CollectFvMapBuffer (self
, MapBuffer
, Wa
, ModuleList
):
1500 # First get the XIP base address for FV map file.
1501 GuidPattern
= re
.compile("[-a-fA-F0-9]+")
1502 GuidName
= re
.compile(r
"\(GUID=[-a-fA-F0-9]+")
1503 for FvName
in Wa
.FdfProfile
.FvDict
:
1504 FvMapBuffer
= os
.path
.join(Wa
.FvDir
, FvName
+ '.Fv.map')
1505 if not os
.path
.exists(FvMapBuffer
):
1507 FvMap
= open(FvMapBuffer
, 'r')
1508 #skip FV size information
1514 MatchGuid
= GuidPattern
.match(Line
)
1515 if MatchGuid
is not None:
1517 # Replace GUID with module name
1519 GuidString
= MatchGuid
.group()
1520 if GuidString
.upper() in ModuleList
:
1521 Line
= Line
.replace(GuidString
, ModuleList
[GuidString
.upper()].Name
)
1522 MapBuffer
.append(Line
)
1524 # Add the debug image full path.
1526 MatchGuid
= GuidName
.match(Line
)
1527 if MatchGuid
is not None:
1528 GuidString
= MatchGuid
.group().split("=")[1]
1529 if GuidString
.upper() in ModuleList
:
1530 MapBuffer
.append('(IMAGE=%s)\n' % (os
.path
.join(ModuleList
[GuidString
.upper()].DebugDir
, ModuleList
[GuidString
.upper()].Name
+ '.efi')))
1534 ## Collect MAP information of all modules
1536 def _CollectModuleMapBuffer (self
, MapBuffer
, ModuleList
):
1537 sys
.stdout
.write ("Generate Load Module At Fix Address Map")
1539 PatchEfiImageList
= []
1547 # reserve 4K size in SMRAM to make SMM module address not from 0.
1549 for ModuleGuid
in ModuleList
:
1550 Module
= ModuleList
[ModuleGuid
]
1551 GlobalData
.gProcessingFile
= "%s [%s, %s, %s]" % (Module
.MetaFile
, Module
.Arch
, Module
.ToolChain
, Module
.BuildTarget
)
1553 OutputImageFile
= ''
1554 for ResultFile
in Module
.CodaTargetList
:
1555 if str(ResultFile
.Target
).endswith('.efi'):
1557 # module list for PEI, DXE, RUNTIME and SMM
1559 OutputImageFile
= os
.path
.join(Module
.OutputDir
, Module
.Name
+ '.efi')
1560 ImageClass
= PeImageClass (OutputImageFile
)
1561 if not ImageClass
.IsValid
:
1562 EdkLogger
.error("build", FILE_PARSE_FAILURE
, ExtraData
=ImageClass
.ErrorInfo
)
1563 ImageInfo
= PeImageInfo(Module
.Name
, Module
.Guid
, Module
.Arch
, Module
.OutputDir
, Module
.DebugDir
, ImageClass
)
1564 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
]:
1565 PeiModuleList
[Module
.MetaFile
] = ImageInfo
1566 PeiSize
+= ImageInfo
.Image
.Size
1567 elif Module
.ModuleType
in [EDK_COMPONENT_TYPE_BS_DRIVER
, SUP_MODULE_DXE_DRIVER
, SUP_MODULE_UEFI_DRIVER
]:
1568 BtModuleList
[Module
.MetaFile
] = ImageInfo
1569 BtSize
+= ImageInfo
.Image
.Size
1570 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
]:
1571 RtModuleList
[Module
.MetaFile
] = ImageInfo
1572 RtSize
+= ImageInfo
.Image
.Size
1573 elif Module
.ModuleType
in [SUP_MODULE_SMM_CORE
, SUP_MODULE_DXE_SMM_DRIVER
, SUP_MODULE_MM_STANDALONE
, SUP_MODULE_MM_CORE_STANDALONE
]:
1574 SmmModuleList
[Module
.MetaFile
] = ImageInfo
1575 SmmSize
+= ImageInfo
.Image
.Size
1576 if Module
.ModuleType
== SUP_MODULE_DXE_SMM_DRIVER
:
1577 PiSpecVersion
= Module
.Module
.Specification
.get('PI_SPECIFICATION_VERSION', '0x00000000')
1578 # for PI specification < PI1.1, DXE_SMM_DRIVER also runs as BOOT time driver.
1579 if int(PiSpecVersion
, 16) < 0x0001000A:
1580 BtModuleList
[Module
.MetaFile
] = ImageInfo
1581 BtSize
+= ImageInfo
.Image
.Size
1584 # EFI image is final target.
1585 # Check EFI image contains patchable FixAddress related PCDs.
1587 if OutputImageFile
!= '':
1588 ModuleIsPatch
= False
1589 for Pcd
in Module
.ModulePcdList
:
1590 if Pcd
.Type
== TAB_PCDS_PATCHABLE_IN_MODULE
and Pcd
.TokenCName
in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SET
:
1591 ModuleIsPatch
= True
1593 if not ModuleIsPatch
:
1594 for Pcd
in Module
.LibraryPcdList
:
1595 if Pcd
.Type
== TAB_PCDS_PATCHABLE_IN_MODULE
and Pcd
.TokenCName
in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SET
:
1596 ModuleIsPatch
= True
1599 if not ModuleIsPatch
:
1602 # Module includes the patchable load fix address PCDs.
1603 # It will be fixed up later.
1605 PatchEfiImageList
.append (OutputImageFile
)
1608 # Get Top Memory address
1610 ReservedRuntimeMemorySize
= 0
1611 TopMemoryAddress
= 0
1612 if self
.LoadFixAddress
== 0xFFFFFFFFFFFFFFFF:
1613 TopMemoryAddress
= 0
1615 TopMemoryAddress
= self
.LoadFixAddress
1616 if TopMemoryAddress
< RtSize
+ BtSize
+ PeiSize
:
1617 EdkLogger
.error("build", PARAMETER_INVALID
, "FIX_LOAD_TOP_MEMORY_ADDRESS is too low to load driver")
1620 # Patch FixAddress related PCDs into EFI image
1622 for EfiImage
in PatchEfiImageList
:
1623 EfiImageMap
= EfiImage
.replace('.efi', '.map')
1624 if not os
.path
.exists(EfiImageMap
):
1627 # Get PCD offset in EFI image by GenPatchPcdTable function
1629 PcdTable
= parsePcdInfoFromMapFile(EfiImageMap
, EfiImage
)
1631 # Patch real PCD value by PatchPcdValue tool
1633 for PcdInfo
in PcdTable
:
1635 if PcdInfo
[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE
:
1636 ReturnValue
, ErrorInfo
= PatchBinaryFile (EfiImage
, PcdInfo
[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE_DATA_TYPE
, str (PeiSize
// 0x1000))
1637 elif PcdInfo
[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE
:
1638 ReturnValue
, ErrorInfo
= PatchBinaryFile (EfiImage
, PcdInfo
[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE_DATA_TYPE
, str (BtSize
// 0x1000))
1639 elif PcdInfo
[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE
:
1640 ReturnValue
, ErrorInfo
= PatchBinaryFile (EfiImage
, PcdInfo
[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE_DATA_TYPE
, str (RtSize
// 0x1000))
1641 elif PcdInfo
[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE
and len (SmmModuleList
) > 0:
1642 ReturnValue
, ErrorInfo
= PatchBinaryFile (EfiImage
, PcdInfo
[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE_DATA_TYPE
, str (SmmSize
// 0x1000))
1643 if ReturnValue
!= 0:
1644 EdkLogger
.error("build", PARAMETER_INVALID
, "Patch PCD value failed", ExtraData
=ErrorInfo
)
1646 MapBuffer
.append('PEI_CODE_PAGE_NUMBER = 0x%x\n' % (PeiSize
// 0x1000))
1647 MapBuffer
.append('BOOT_CODE_PAGE_NUMBER = 0x%x\n' % (BtSize
// 0x1000))
1648 MapBuffer
.append('RUNTIME_CODE_PAGE_NUMBER = 0x%x\n' % (RtSize
// 0x1000))
1649 if len (SmmModuleList
) > 0:
1650 MapBuffer
.append('SMM_CODE_PAGE_NUMBER = 0x%x\n' % (SmmSize
// 0x1000))
1652 PeiBaseAddr
= TopMemoryAddress
- RtSize
- BtSize
1653 BtBaseAddr
= TopMemoryAddress
- RtSize
1654 RtBaseAddr
= TopMemoryAddress
- ReservedRuntimeMemorySize
1656 self
._RebaseModule
(MapBuffer
, PeiBaseAddr
, PeiModuleList
, TopMemoryAddress
== 0)
1657 self
._RebaseModule
(MapBuffer
, BtBaseAddr
, BtModuleList
, TopMemoryAddress
== 0)
1658 self
._RebaseModule
(MapBuffer
, RtBaseAddr
, RtModuleList
, TopMemoryAddress
== 0)
1659 self
._RebaseModule
(MapBuffer
, 0x1000, SmmModuleList
, AddrIsOffset
=False, ModeIsSmm
=True)
1660 MapBuffer
.append('\n\n')
1661 sys
.stdout
.write ("\n")
1664 ## Save platform Map file
1666 def _SaveMapFile (self
, MapBuffer
, Wa
):
1668 # Map file path is got.
1670 MapFilePath
= os
.path
.join(Wa
.BuildDir
, Wa
.Name
+ '.map')
1672 # Save address map into MAP file.
1674 SaveFileOnChange(MapFilePath
, ''.join(MapBuffer
), False)
1675 if self
.LoadFixAddress
!= 0:
1676 sys
.stdout
.write ("\nLoad Module At Fix Address Map file can be found at %s\n" % (MapFilePath
))
1679 ## Build active platform for different build targets and different tool chains
1681 def _BuildPlatform(self
):
1682 SaveFileOnChange(self
.PlatformBuildPath
, '# DO NOT EDIT \n# FILE auto-generated\n', False)
1683 for BuildTarget
in self
.BuildTargetList
:
1684 GlobalData
.gGlobalDefines
['TARGET'] = BuildTarget
1686 for ToolChain
in self
.ToolChainList
:
1687 GlobalData
.gGlobalDefines
['TOOLCHAIN'] = ToolChain
1688 GlobalData
.gGlobalDefines
['TOOL_CHAIN_TAG'] = ToolChain
1689 GlobalData
.gGlobalDefines
['FAMILY'] = self
.ToolChainFamily
[index
]
1691 Wa
= WorkspaceAutoGen(
1708 self
.Fdf
= Wa
.FdfFile
1709 self
.LoadFixAddress
= Wa
.Platform
.LoadFixAddress
1710 self
.BuildReport
.AddPlatformReport(Wa
)
1711 self
.Progress
.Stop("done!")
1713 # Add ffs build to makefile
1715 if GlobalData
.gEnableGenfdsMultiThread
and self
.Fdf
:
1716 CmdListDict
= self
._GenFfsCmd
(Wa
.ArchList
)
1718 for Arch
in Wa
.ArchList
:
1719 GlobalData
.gGlobalDefines
['ARCH'] = Arch
1720 Pa
= PlatformAutoGen(Wa
, self
.PlatformFile
, BuildTarget
, ToolChain
, Arch
)
1721 for Module
in Pa
.Platform
.Modules
:
1722 # Get ModuleAutoGen object to generate C code file and makefile
1723 Ma
= ModuleAutoGen(Wa
, Module
, BuildTarget
, ToolChain
, Arch
, self
.PlatformFile
)
1726 self
.BuildModules
.append(Ma
)
1727 self
._BuildPa
(self
.Target
, Pa
, FfsCommand
=CmdListDict
)
1729 # Create MAP file when Load Fix Address is enabled.
1730 if self
.Target
in ["", "all", "fds"]:
1731 for Arch
in Wa
.ArchList
:
1732 GlobalData
.gGlobalDefines
['ARCH'] = Arch
1734 # Check whether the set fix address is above 4G for 32bit image.
1736 if (Arch
== 'IA32' or Arch
== 'ARM') and self
.LoadFixAddress
!= 0xFFFFFFFFFFFFFFFF and self
.LoadFixAddress
>= 0x100000000:
1737 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")
1742 for Pa
in Wa
.AutoGenObjectList
:
1743 for Ma
in Pa
.ModuleAutoGenList
:
1746 if not Ma
.IsLibrary
:
1747 ModuleList
[Ma
.Guid
.upper()] = Ma
1750 if self
.LoadFixAddress
!= 0:
1752 # Rebase module to the preferred memory address before GenFds
1754 self
._CollectModuleMapBuffer
(MapBuffer
, ModuleList
)
1757 # create FDS again for the updated EFI image
1759 self
._Build
("fds", Wa
)
1761 # Create MAP file for all platform FVs after GenFds.
1763 self
._CollectFvMapBuffer
(MapBuffer
, Wa
, ModuleList
)
1765 # Save MAP buffer into MAP file.
1767 self
._SaveMapFile
(MapBuffer
, Wa
)
1769 ## Build active module for different build targets, different tool chains and different archs
1771 def _BuildModule(self
):
1772 for BuildTarget
in self
.BuildTargetList
:
1773 GlobalData
.gGlobalDefines
['TARGET'] = BuildTarget
1775 for ToolChain
in self
.ToolChainList
:
1776 WorkspaceAutoGenTime
= time
.time()
1777 GlobalData
.gGlobalDefines
['TOOLCHAIN'] = ToolChain
1778 GlobalData
.gGlobalDefines
['TOOL_CHAIN_TAG'] = ToolChain
1779 GlobalData
.gGlobalDefines
['FAMILY'] = self
.ToolChainFamily
[index
]
1782 # module build needs platform build information, so get platform
1785 Wa
= WorkspaceAutoGen(
1803 self
.Fdf
= Wa
.FdfFile
1804 self
.LoadFixAddress
= Wa
.Platform
.LoadFixAddress
1805 Wa
.CreateMakeFile(False)
1806 # Add ffs build to makefile
1808 if GlobalData
.gEnableGenfdsMultiThread
and self
.Fdf
:
1809 CmdListDict
= self
._GenFfsCmd
(Wa
.ArchList
)
1810 self
.Progress
.Stop("done!")
1812 ExitFlag
= threading
.Event()
1814 self
.AutoGenTime
+= int(round((time
.time() - WorkspaceAutoGenTime
)))
1815 for Arch
in Wa
.ArchList
:
1816 AutoGenStart
= time
.time()
1817 GlobalData
.gGlobalDefines
['ARCH'] = Arch
1818 Pa
= PlatformAutoGen(Wa
, self
.PlatformFile
, BuildTarget
, ToolChain
, Arch
)
1819 for Module
in Pa
.Platform
.Modules
:
1820 if self
.ModuleFile
.Dir
== Module
.Dir
and self
.ModuleFile
.Name
== Module
.Name
:
1821 Ma
= ModuleAutoGen(Wa
, Module
, BuildTarget
, ToolChain
, Arch
, self
.PlatformFile
)
1825 if Ma
.CanSkipbyHash():
1826 self
.HashSkipModules
.append(Ma
)
1827 if GlobalData
.gBinCacheSource
:
1828 EdkLogger
.quiet("cache hit: %s[%s]" % (Ma
.MetaFile
.Path
, Ma
.Arch
))
1831 if GlobalData
.gBinCacheSource
:
1832 EdkLogger
.quiet("cache miss: %s[%s]" % (Ma
.MetaFile
.Path
, Ma
.Arch
))
1833 # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'
1834 if self
.Target
not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1835 # for target which must generate AutoGen code and makefile
1836 if not self
.SkipAutoGen
or self
.Target
== 'genc':
1837 self
.Progress
.Start("Generating code")
1838 Ma
.CreateCodeFile(True)
1839 self
.Progress
.Stop("done!")
1840 if self
.Target
== "genc":
1842 if not self
.SkipAutoGen
or self
.Target
== 'genmake':
1843 self
.Progress
.Start("Generating makefile")
1844 if CmdListDict
and self
.Fdf
and (Module
.File
, Arch
) in CmdListDict
:
1845 Ma
.CreateMakeFile(True, CmdListDict
[Module
.File
, Arch
])
1846 del CmdListDict
[Module
.File
, Arch
]
1848 Ma
.CreateMakeFile(True)
1849 self
.Progress
.Stop("done!")
1850 if self
.Target
== "genmake":
1852 self
.BuildModules
.append(Ma
)
1853 # Initialize all modules in tracking to 'FAIL'
1854 if Ma
.Arch
not in GlobalData
.gModuleBuildTracking
:
1855 GlobalData
.gModuleBuildTracking
[Ma
.Arch
] = dict()
1856 if Ma
not in GlobalData
.gModuleBuildTracking
[Ma
.Arch
]:
1857 GlobalData
.gModuleBuildTracking
[Ma
.Arch
][Ma
] = 'FAIL'
1858 self
.AutoGenTime
+= int(round((time
.time() - AutoGenStart
)))
1859 MakeStart
= time
.time()
1860 for Ma
in self
.BuildModules
:
1861 if not Ma
.IsBinaryModule
:
1862 Bt
= BuildTask
.New(ModuleMakeUnit(Ma
, self
.Target
))
1863 # Break build if any build thread has error
1864 if BuildTask
.HasError():
1865 # we need a full version of makefile for platform
1867 BuildTask
.WaitForComplete()
1868 self
.invalidateHash()
1869 Pa
.CreateMakeFile(False)
1870 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
1871 # Start task scheduler
1872 if not BuildTask
.IsOnGoing():
1873 BuildTask
.StartScheduler(self
.ThreadNumber
, ExitFlag
)
1875 # in case there's an interruption. we need a full version of makefile for platform
1876 Pa
.CreateMakeFile(False)
1877 if BuildTask
.HasError():
1878 self
.invalidateHash()
1879 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
1880 self
.MakeTime
+= int(round((time
.time() - MakeStart
)))
1882 MakeContiue
= time
.time()
1884 BuildTask
.WaitForComplete()
1885 self
.CreateAsBuiltInf()
1886 if GlobalData
.gBinCacheDest
:
1887 self
.UpdateBuildCache()
1888 self
.BuildModules
= []
1889 self
.MakeTime
+= int(round((time
.time() - MakeContiue
)))
1890 if BuildTask
.HasError():
1891 self
.invalidateHash()
1892 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
1894 self
.BuildReport
.AddPlatformReport(Wa
, MaList
)
1899 "Module for [%s] is not a component of active platform."\
1900 " Please make sure that the ARCH and inf file path are"\
1901 " given in the same as in [%s]" % \
1902 (', '.join(Wa
.ArchList
), self
.PlatformFile
),
1903 ExtraData
=self
.ModuleFile
1905 # Create MAP file when Load Fix Address is enabled.
1906 if self
.Target
== "fds" and self
.Fdf
:
1907 for Arch
in Wa
.ArchList
:
1909 # Check whether the set fix address is above 4G for 32bit image.
1911 if (Arch
== 'IA32' or Arch
== 'ARM') and self
.LoadFixAddress
!= 0xFFFFFFFFFFFFFFFF and self
.LoadFixAddress
>= 0x100000000:
1912 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")
1917 for Pa
in Wa
.AutoGenObjectList
:
1918 for Ma
in Pa
.ModuleAutoGenList
:
1921 if not Ma
.IsLibrary
:
1922 ModuleList
[Ma
.Guid
.upper()] = Ma
1925 if self
.LoadFixAddress
!= 0:
1927 # Rebase module to the preferred memory address before GenFds
1929 self
._CollectModuleMapBuffer
(MapBuffer
, ModuleList
)
1931 # create FDS again for the updated EFI image
1933 GenFdsStart
= time
.time()
1934 self
._Build
("fds", Wa
)
1935 self
.GenFdsTime
+= int(round((time
.time() - GenFdsStart
)))
1937 # Create MAP file for all platform FVs after GenFds.
1939 self
._CollectFvMapBuffer
(MapBuffer
, Wa
, ModuleList
)
1941 # Save MAP buffer into MAP file.
1943 self
._SaveMapFile
(MapBuffer
, Wa
)
1944 self
.invalidateHash()
1946 def _GenFfsCmd(self
,ArchList
):
1947 # convert dictionary of Cmd:(Inf,Arch)
1948 # to a new dictionary of (Inf,Arch):Cmd,Cmd,Cmd...
1949 CmdSetDict
= defaultdict(set)
1950 GenFfsDict
= GenFds
.GenFfsMakefile('', GlobalData
.gFdfParser
, self
, ArchList
, GlobalData
)
1951 for Cmd
in GenFfsDict
:
1952 tmpInf
, tmpArch
= GenFfsDict
[Cmd
]
1953 CmdSetDict
[tmpInf
, tmpArch
].add(Cmd
)
1956 ## Build a platform in multi-thread mode
1958 def _MultiThreadBuildPlatform(self
):
1959 SaveFileOnChange(self
.PlatformBuildPath
, '# DO NOT EDIT \n# FILE auto-generated\n', False)
1960 for BuildTarget
in self
.BuildTargetList
:
1961 GlobalData
.gGlobalDefines
['TARGET'] = BuildTarget
1963 for ToolChain
in self
.ToolChainList
:
1964 WorkspaceAutoGenTime
= time
.time()
1965 GlobalData
.gGlobalDefines
['TOOLCHAIN'] = ToolChain
1966 GlobalData
.gGlobalDefines
['TOOL_CHAIN_TAG'] = ToolChain
1967 GlobalData
.gGlobalDefines
['FAMILY'] = self
.ToolChainFamily
[index
]
1969 Wa
= WorkspaceAutoGen(
1986 self
.Fdf
= Wa
.FdfFile
1987 self
.LoadFixAddress
= Wa
.Platform
.LoadFixAddress
1988 self
.BuildReport
.AddPlatformReport(Wa
)
1989 Wa
.CreateMakeFile(False)
1991 # Add ffs build to makefile
1993 if GlobalData
.gEnableGenfdsMultiThread
and self
.Fdf
:
1994 CmdListDict
= self
._GenFfsCmd
(Wa
.ArchList
)
1996 # multi-thread exit flag
1997 ExitFlag
= threading
.Event()
1999 self
.AutoGenTime
+= int(round((time
.time() - WorkspaceAutoGenTime
)))
2000 for Arch
in Wa
.ArchList
:
2001 AutoGenStart
= time
.time()
2002 GlobalData
.gGlobalDefines
['ARCH'] = Arch
2003 Pa
= PlatformAutoGen(Wa
, self
.PlatformFile
, BuildTarget
, ToolChain
, Arch
)
2007 for Inf
in Pa
.Platform
.Modules
:
2008 ModuleList
.append(Inf
)
2009 # Add the INF only list in FDF
2010 if GlobalData
.gFdfParser
is not None:
2011 for InfName
in GlobalData
.gFdfParser
.Profile
.InfList
:
2012 Inf
= PathClass(NormPath(InfName
), self
.WorkspaceDir
, Arch
)
2013 if Inf
in Pa
.Platform
.Modules
:
2015 ModuleList
.append(Inf
)
2016 for Module
in ModuleList
:
2017 # Get ModuleAutoGen object to generate C code file and makefile
2018 Ma
= ModuleAutoGen(Wa
, Module
, BuildTarget
, ToolChain
, Arch
, self
.PlatformFile
)
2022 if Ma
.CanSkipbyHash():
2023 self
.HashSkipModules
.append(Ma
)
2024 if GlobalData
.gBinCacheSource
:
2025 EdkLogger
.quiet("cache hit: %s[%s]" % (Ma
.MetaFile
.Path
, Ma
.Arch
))
2028 if GlobalData
.gBinCacheSource
:
2029 EdkLogger
.quiet("cache miss: %s[%s]" % (Ma
.MetaFile
.Path
, Ma
.Arch
))
2031 # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'
2032 if self
.Target
not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
2033 # for target which must generate AutoGen code and makefile
2034 if not self
.SkipAutoGen
or self
.Target
== 'genc':
2035 Ma
.CreateCodeFile(True)
2036 if self
.Target
== "genc":
2039 if not self
.SkipAutoGen
or self
.Target
== 'genmake':
2040 if CmdListDict
and self
.Fdf
and (Module
.File
, Arch
) in CmdListDict
:
2041 Ma
.CreateMakeFile(True, CmdListDict
[Module
.File
, Arch
])
2042 del CmdListDict
[Module
.File
, Arch
]
2044 Ma
.CreateMakeFile(True)
2045 if self
.Target
== "genmake":
2047 self
.BuildModules
.append(Ma
)
2048 # Initialize all modules in tracking to 'FAIL'
2049 if Ma
.Arch
not in GlobalData
.gModuleBuildTracking
:
2050 GlobalData
.gModuleBuildTracking
[Ma
.Arch
] = dict()
2051 if Ma
not in GlobalData
.gModuleBuildTracking
[Ma
.Arch
]:
2052 GlobalData
.gModuleBuildTracking
[Ma
.Arch
][Ma
] = 'FAIL'
2053 self
.Progress
.Stop("done!")
2054 self
.AutoGenTime
+= int(round((time
.time() - AutoGenStart
)))
2055 MakeStart
= time
.time()
2056 for Ma
in self
.BuildModules
:
2057 # Generate build task for the module
2058 if not Ma
.IsBinaryModule
:
2059 Bt
= BuildTask
.New(ModuleMakeUnit(Ma
, self
.Target
))
2060 # Break build if any build thread has error
2061 if BuildTask
.HasError():
2062 # we need a full version of makefile for platform
2064 BuildTask
.WaitForComplete()
2065 self
.invalidateHash()
2066 Pa
.CreateMakeFile(False)
2067 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
2068 # Start task scheduler
2069 if not BuildTask
.IsOnGoing():
2070 BuildTask
.StartScheduler(self
.ThreadNumber
, ExitFlag
)
2072 # in case there's an interruption. we need a full version of makefile for platform
2073 Pa
.CreateMakeFile(False)
2074 if BuildTask
.HasError():
2075 self
.invalidateHash()
2076 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
2077 self
.MakeTime
+= int(round((time
.time() - MakeStart
)))
2079 MakeContiue
= time
.time()
2083 # All modules have been put in build tasks queue. Tell task scheduler
2084 # to exit if all tasks are completed
2087 BuildTask
.WaitForComplete()
2088 self
.CreateAsBuiltInf()
2089 if GlobalData
.gBinCacheDest
:
2090 self
.UpdateBuildCache()
2091 self
.BuildModules
= []
2092 self
.MakeTime
+= int(round((time
.time() - MakeContiue
)))
2094 # Check for build error, and raise exception if one
2095 # has been signaled.
2097 if BuildTask
.HasError():
2098 self
.invalidateHash()
2099 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
2101 # Create MAP file when Load Fix Address is enabled.
2102 if self
.Target
in ["", "all", "fds"]:
2103 for Arch
in Wa
.ArchList
:
2105 # Check whether the set fix address is above 4G for 32bit image.
2107 if (Arch
== 'IA32' or Arch
== 'ARM') and self
.LoadFixAddress
!= 0xFFFFFFFFFFFFFFFF and self
.LoadFixAddress
>= 0x100000000:
2108 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")
2113 for Pa
in Wa
.AutoGenObjectList
:
2114 for Ma
in Pa
.ModuleAutoGenList
:
2117 if not Ma
.IsLibrary
:
2118 ModuleList
[Ma
.Guid
.upper()] = Ma
2120 # Rebase module to the preferred memory address before GenFds
2123 if self
.LoadFixAddress
!= 0:
2124 self
._CollectModuleMapBuffer
(MapBuffer
, ModuleList
)
2128 # Generate FD image if there's a FDF file found
2130 GenFdsStart
= time
.time()
2131 if GenFdsApi(Wa
.GenFdsCommandDict
, self
.Db
):
2132 EdkLogger
.error("build", COMMAND_FAILURE
)
2135 # Create MAP file for all platform FVs after GenFds.
2137 self
._CollectFvMapBuffer
(MapBuffer
, Wa
, ModuleList
)
2138 self
.GenFdsTime
+= int(round((time
.time() - GenFdsStart
)))
2140 # Save MAP buffer into MAP file.
2142 self
._SaveMapFile
(MapBuffer
, Wa
)
2143 self
.invalidateHash()
2145 ## Generate GuidedSectionTools.txt in the FV directories.
2147 def CreateGuidedSectionToolsFile(self
):
2148 for BuildTarget
in self
.BuildTargetList
:
2149 for ToolChain
in self
.ToolChainList
:
2150 Wa
= WorkspaceAutoGen(
2167 if not os
.path
.exists(FvDir
):
2170 for Arch
in self
.ArchList
:
2171 # Build up the list of supported architectures for this build
2172 prefix
= '%s_%s_%s_' % (BuildTarget
, ToolChain
, Arch
)
2174 # Look through the tool definitions for GUIDed tools
2176 for (attrib
, value
) in self
.ToolDef
.ToolsDefTxtDictionary
.items():
2177 if attrib
.upper().endswith('_GUID'):
2178 split
= attrib
.split('_')
2179 thisPrefix
= '_'.join(split
[0:3]) + '_'
2180 if thisPrefix
== prefix
:
2181 guid
= self
.ToolDef
.ToolsDefTxtDictionary
[attrib
]
2184 path
= '_'.join(split
[0:4]) + '_PATH'
2185 path
= self
.ToolDef
.ToolsDefTxtDictionary
[path
]
2186 path
= self
.GetFullPathOfTool(path
)
2187 guidAttribs
.append((guid
, toolName
, path
))
2189 # Write out GuidedSecTools.txt
2190 toolsFile
= os
.path
.join(FvDir
, 'GuidedSectionTools.txt')
2191 toolsFile
= open(toolsFile
, 'wt')
2192 for guidedSectionTool
in guidAttribs
:
2193 print(' '.join(guidedSectionTool
), file=toolsFile
)
2196 ## Returns the full path of the tool.
2198 def GetFullPathOfTool (self
, tool
):
2199 if os
.path
.exists(tool
):
2200 return os
.path
.realpath(tool
)
2202 # We need to search for the tool using the
2203 # PATH environment variable.
2204 for dirInPath
in os
.environ
['PATH'].split(os
.pathsep
):
2205 foundPath
= os
.path
.join(dirInPath
, tool
)
2206 if os
.path
.exists(foundPath
):
2207 return os
.path
.realpath(foundPath
)
2209 # If the tool was not found in the path then we just return
2213 ## Launch the module or platform build
2216 if not self
.ModuleFile
:
2217 if not self
.SpawnMode
or self
.Target
not in ["", "all"]:
2218 self
.SpawnMode
= False
2219 self
._BuildPlatform
()
2221 self
._MultiThreadBuildPlatform
()
2222 self
.CreateGuidedSectionToolsFile()
2224 self
.SpawnMode
= False
2227 if self
.Target
== 'cleanall':
2228 RemoveDirectory(os
.path
.dirname(GlobalData
.gDatabasePath
), True)
2230 def CreateAsBuiltInf(self
):
2231 for Module
in self
.BuildModules
:
2232 Module
.CreateAsBuiltInf()
2234 def UpdateBuildCache(self
):
2237 for Module
in self
.BuildModules
:
2238 Module
.CopyModuleToCache()
2239 all_mod_set
.add(Module
)
2240 for Module
in self
.HashSkipModules
:
2241 Module
.CopyModuleToCache()
2242 all_mod_set
.add(Module
)
2243 for Module
in all_mod_set
:
2244 for lib
in Module
.LibraryAutoGenList
:
2245 all_lib_set
.add(lib
)
2246 for lib
in all_lib_set
:
2247 lib
.CopyModuleToCache()
2250 self
.HashSkipModules
= []
2251 ## Do some clean-up works when error occurred
2252 def Relinquish(self
):
2253 OldLogLevel
= EdkLogger
.GetLevel()
2254 EdkLogger
.SetLevel(EdkLogger
.ERROR
)
2255 Utils
.Progressor
.Abort()
2256 if self
.SpawnMode
== True:
2258 EdkLogger
.SetLevel(OldLogLevel
)
2260 def ParseDefines(DefineList
=[]):
2262 if DefineList
is not None:
2263 for Define
in DefineList
:
2264 DefineTokenList
= Define
.split("=", 1)
2265 if not GlobalData
.gMacroNamePattern
.match(DefineTokenList
[0]):
2266 EdkLogger
.error('build', FORMAT_INVALID
,
2267 "The macro name must be in the pattern [A-Z][A-Z0-9_]*",
2268 ExtraData
=DefineTokenList
[0])
2270 if len(DefineTokenList
) == 1:
2271 DefineDict
[DefineTokenList
[0]] = "TRUE"
2273 DefineDict
[DefineTokenList
[0]] = DefineTokenList
[1].strip()
2277 def SingleCheckCallback(option
, opt_str
, value
, parser
):
2278 if option
not in gParamCheck
:
2279 setattr(parser
.values
, option
.dest
, value
)
2280 gParamCheck
.append(option
)
2282 parser
.error("Option %s only allows one instance in command line!" % option
)
2284 def LogBuildTime(Time
):
2287 TimeDur
= time
.gmtime(Time
)
2288 if TimeDur
.tm_yday
> 1:
2289 TimeDurStr
= time
.strftime("%H:%M:%S", TimeDur
) + ", %d day(s)" % (TimeDur
.tm_yday
- 1)
2291 TimeDurStr
= time
.strftime("%H:%M:%S", TimeDur
)
2296 ## Parse command line options
2298 # Using standard Python module optparse to parse command line option of this tool.
2300 # @retval Opt A optparse.Values object containing the parsed options
2301 # @retval Args Target of build command
2303 def MyOptionParser():
2304 Parser
= OptionParser(description
=__copyright__
, version
=__version__
, prog
="build.exe", usage
="%prog [options] [all|fds|genc|genmake|clean|cleanall|cleanlib|modules|libraries|run]")
2305 Parser
.add_option("-a", "--arch", action
="append", type="choice", choices
=['IA32', 'X64', 'EBC', 'ARM', 'AARCH64'], dest
="TargetArch",
2306 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.")
2307 Parser
.add_option("-p", "--platform", action
="callback", type="string", dest
="PlatformFile", callback
=SingleCheckCallback
,
2308 help="Build the platform specified by the DSC file name argument, overriding target.txt's ACTIVE_PLATFORM definition.")
2309 Parser
.add_option("-m", "--module", action
="callback", type="string", dest
="ModuleFile", callback
=SingleCheckCallback
,
2310 help="Build the module specified by the INF file name argument.")
2311 Parser
.add_option("-b", "--buildtarget", type="string", dest
="BuildTarget", help="Using the TARGET to build the platform, overriding target.txt's TARGET definition.",
2313 Parser
.add_option("-t", "--tagname", action
="append", type="string", dest
="ToolChain",
2314 help="Using the Tool Chain Tagname to build the platform, overriding target.txt's TOOL_CHAIN_TAG definition.")
2315 Parser
.add_option("-x", "--sku-id", action
="callback", type="string", dest
="SkuId", callback
=SingleCheckCallback
,
2316 help="Using this name of SKU ID to build the platform, overriding SKUID_IDENTIFIER in DSC file.")
2318 Parser
.add_option("-n", action
="callback", type="int", dest
="ThreadNumber", callback
=SingleCheckCallback
,
2319 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 "\
2320 "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.")
2322 Parser
.add_option("-f", "--fdf", action
="callback", type="string", dest
="FdfFile", callback
=SingleCheckCallback
,
2323 help="The name of the FDF file to use, which overrides the setting in the DSC file.")
2324 Parser
.add_option("-r", "--rom-image", action
="append", type="string", dest
="RomImage", default
=[],
2325 help="The name of FD to be generated. The name must be from [FD] section in FDF file.")
2326 Parser
.add_option("-i", "--fv-image", action
="append", type="string", dest
="FvImage", default
=[],
2327 help="The name of FV to be generated. The name must be from [FV] section in FDF file.")
2328 Parser
.add_option("-C", "--capsule-image", action
="append", type="string", dest
="CapName", default
=[],
2329 help="The name of Capsule to be generated. The name must be from [Capsule] section in FDF file.")
2330 Parser
.add_option("-u", "--skip-autogen", action
="store_true", dest
="SkipAutoGen", help="Skip AutoGen step.")
2331 Parser
.add_option("-e", "--re-parse", action
="store_true", dest
="Reparse", help="Re-parse all meta-data files.")
2333 Parser
.add_option("-c", "--case-insensitive", action
="store_true", dest
="CaseInsensitive", default
=False, help="Don't check case of file name.")
2335 Parser
.add_option("-w", "--warning-as-error", action
="store_true", dest
="WarningAsError", help="Treat warning in tools as error.")
2336 Parser
.add_option("-j", "--log", action
="store", dest
="LogFile", help="Put log in specified file as well as on console.")
2338 Parser
.add_option("-s", "--silent", action
="store_true", type=None, dest
="SilentMode",
2339 help="Make use of silent mode of (n)make.")
2340 Parser
.add_option("-q", "--quiet", action
="store_true", type=None, help="Disable all messages except FATAL ERRORS.")
2341 Parser
.add_option("-v", "--verbose", action
="store_true", type=None, help="Turn on verbose output with informational messages printed, "\
2342 "including library instances selected, final dependency expression, "\
2343 "and warning messages, etc.")
2344 Parser
.add_option("-d", "--debug", action
="store", type="int", help="Enable debug messages at specified level.")
2345 Parser
.add_option("-D", "--define", action
="append", type="string", dest
="Macros", help="Macro: \"Name [= Value]\".")
2347 Parser
.add_option("-y", "--report-file", action
="store", dest
="ReportFile", help="Create/overwrite the report to the specified filename.")
2348 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
=[],
2349 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]. "\
2350 "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]")
2351 Parser
.add_option("-F", "--flag", action
="store", type="string", dest
="Flag",
2352 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. "\
2353 "This option can also be specified by setting *_*_*_BUILD_FLAGS in [BuildOptions] section of platform DSC. If they are both specified, this value "\
2354 "will override the setting in [BuildOptions] section of platform DSC.")
2355 Parser
.add_option("-N", "--no-cache", action
="store_true", dest
="DisableCache", default
=False, help="Disable build cache mechanism")
2356 Parser
.add_option("--conf", action
="store", type="string", dest
="ConfDirectory", help="Specify the customized Conf directory.")
2357 Parser
.add_option("--check-usage", action
="store_true", dest
="CheckUsage", default
=False, help="Check usage content of entries listed in INF file.")
2358 Parser
.add_option("--ignore-sources", action
="store_true", dest
="IgnoreSources", default
=False, help="Focus to a binary build and ignore all source files")
2359 Parser
.add_option("--pcd", action
="append", dest
="OptionPcd", help="Set PCD value by command line. Format: \"PcdName=Value\" ")
2360 Parser
.add_option("-l", "--cmd-len", action
="store", type="int", dest
="CommandLength", help="Specify the maximum line length of build command. Default is 4096.")
2361 Parser
.add_option("--hash", action
="store_true", dest
="UseHashCache", default
=False, help="Enable hash-based caching during build process.")
2362 Parser
.add_option("--binary-destination", action
="store", type="string", dest
="BinCacheDest", help="Generate a cache of binary files in the specified directory.")
2363 Parser
.add_option("--binary-source", action
="store", type="string", dest
="BinCacheSource", help="Consume a cache of binary files from the specified directory.")
2364 Parser
.add_option("--genfds-multi-thread", action
="store_true", dest
="GenfdsMultiThread", default
=False, help="Enable GenFds multi thread to generate ffs file.")
2365 Parser
.add_option("--disable-include-path-check", action
="store_true", dest
="DisableIncludePathCheck", default
=False, help="Disable the include path check for outside of package.")
2366 (Opt
, Args
) = Parser
.parse_args()
2369 ## Tool entrance method
2371 # This method mainly dispatch specific methods per the command line options.
2372 # If no error found, return zero value so the caller of this tool can know
2373 # if it's executed successfully or not.
2375 # @retval 0 Tool was successful
2376 # @retval 1 Tool failed
2379 StartTime
= time
.time()
2381 # Initialize log system
2382 EdkLogger
.Initialize()
2383 GlobalData
.gCommand
= sys
.argv
[1:]
2385 # Parse the options and args
2387 (Option
, Target
) = MyOptionParser()
2388 GlobalData
.gOptions
= Option
2389 GlobalData
.gCaseInsensitive
= Option
.CaseInsensitive
2392 if Option
.verbose
is not None:
2393 EdkLogger
.SetLevel(EdkLogger
.VERBOSE
)
2394 elif Option
.quiet
is not None:
2395 EdkLogger
.SetLevel(EdkLogger
.QUIET
)
2396 elif Option
.debug
is not None:
2397 EdkLogger
.SetLevel(Option
.debug
+ 1)
2399 EdkLogger
.SetLevel(EdkLogger
.INFO
)
2401 if Option
.LogFile
is not None:
2402 EdkLogger
.SetLogFile(Option
.LogFile
)
2404 if Option
.WarningAsError
== True:
2405 EdkLogger
.SetWarningAsError()
2407 if platform
.platform().find("Windows") >= 0:
2408 GlobalData
.gIsWindows
= True
2410 GlobalData
.gIsWindows
= False
2412 EdkLogger
.quiet("Build environment: %s" % platform
.platform())
2413 EdkLogger
.quiet(time
.strftime("Build start time: %H:%M:%S, %b.%d %Y\n", time
.localtime()));
2418 if len(Target
) == 0:
2420 elif len(Target
) >= 2:
2421 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, "More than one targets are not supported.",
2422 ExtraData
="Please select one of: %s" % (' '.join(gSupportedTarget
)))
2424 Target
= Target
[0].lower()
2426 if Target
not in gSupportedTarget
:
2427 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, "Not supported target [%s]." % Target
,
2428 ExtraData
="Please select one of: %s" % (' '.join(gSupportedTarget
)))
2431 # Check environment variable: EDK_TOOLS_PATH, WORKSPACE, PATH
2434 GlobalData
.gCommandLineDefines
.update(ParseDefines(Option
.Macros
))
2436 Workspace
= os
.getenv("WORKSPACE")
2438 # Get files real name in workspace dir
2440 GlobalData
.gAllFiles
= Utils
.DirCache(Workspace
)
2442 WorkingDirectory
= os
.getcwd()
2443 if not Option
.ModuleFile
:
2444 FileList
= glob
.glob(os
.path
.normpath(os
.path
.join(WorkingDirectory
, '*.inf')))
2445 FileNum
= len(FileList
)
2447 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, "There are %d INF files in %s." % (FileNum
, WorkingDirectory
),
2448 ExtraData
="Please use '-m <INF_FILE_PATH>' switch to choose one.")
2450 Option
.ModuleFile
= NormFile(FileList
[0], Workspace
)
2452 if Option
.ModuleFile
:
2453 if os
.path
.isabs (Option
.ModuleFile
):
2454 if os
.path
.normcase (os
.path
.normpath(Option
.ModuleFile
)).find (Workspace
) == 0:
2455 Option
.ModuleFile
= NormFile(os
.path
.normpath(Option
.ModuleFile
), Workspace
)
2456 Option
.ModuleFile
= PathClass(Option
.ModuleFile
, Workspace
)
2457 ErrorCode
, ErrorInfo
= Option
.ModuleFile
.Validate(".inf", False)
2459 EdkLogger
.error("build", ErrorCode
, ExtraData
=ErrorInfo
)
2461 if Option
.PlatformFile
is not None:
2462 if os
.path
.isabs (Option
.PlatformFile
):
2463 if os
.path
.normcase (os
.path
.normpath(Option
.PlatformFile
)).find (Workspace
) == 0:
2464 Option
.PlatformFile
= NormFile(os
.path
.normpath(Option
.PlatformFile
), Workspace
)
2465 Option
.PlatformFile
= PathClass(Option
.PlatformFile
, Workspace
)
2467 if Option
.FdfFile
is not None:
2468 if os
.path
.isabs (Option
.FdfFile
):
2469 if os
.path
.normcase (os
.path
.normpath(Option
.FdfFile
)).find (Workspace
) == 0:
2470 Option
.FdfFile
= NormFile(os
.path
.normpath(Option
.FdfFile
), Workspace
)
2471 Option
.FdfFile
= PathClass(Option
.FdfFile
, Workspace
)
2472 ErrorCode
, ErrorInfo
= Option
.FdfFile
.Validate(".fdf", False)
2474 EdkLogger
.error("build", ErrorCode
, ExtraData
=ErrorInfo
)
2476 if Option
.Flag
is not None and Option
.Flag
not in ['-c', '-s']:
2477 EdkLogger
.error("build", OPTION_VALUE_INVALID
, "UNI flag must be one of -c or -s")
2479 MyBuild
= Build(Target
, Workspace
, Option
)
2480 GlobalData
.gCommandLineDefines
['ARCH'] = ' '.join(MyBuild
.ArchList
)
2481 if not (MyBuild
.LaunchPrebuildFlag
and os
.path
.exists(MyBuild
.PlatformBuildPath
)):
2485 # All job done, no error found and no exception raised
2488 except FatalError
as X
:
2489 if MyBuild
is not None:
2490 # for multi-thread build exits safely
2491 MyBuild
.Relinquish()
2492 if Option
is not None and Option
.debug
is not None:
2493 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
2494 ReturnCode
= X
.args
[0]
2495 except Warning as X
:
2496 # error from Fdf parser
2497 if MyBuild
is not None:
2498 # for multi-thread build exits safely
2499 MyBuild
.Relinquish()
2500 if Option
is not None and Option
.debug
is not None:
2501 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
2503 EdkLogger
.error(X
.ToolName
, FORMAT_INVALID
, File
=X
.FileName
, Line
=X
.LineNumber
, ExtraData
=X
.Message
, RaiseError
=False)
2504 ReturnCode
= FORMAT_INVALID
2505 except KeyboardInterrupt:
2506 ReturnCode
= ABORT_ERROR
2507 if Option
is not None and Option
.debug
is not None:
2508 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
2510 if MyBuild
is not None:
2511 # for multi-thread build exits safely
2512 MyBuild
.Relinquish()
2514 # try to get the meta-file from the object causing exception
2515 Tb
= sys
.exc_info()[-1]
2516 MetaFile
= GlobalData
.gProcessingFile
2517 while Tb
is not None:
2518 if 'self' in Tb
.tb_frame
.f_locals
and hasattr(Tb
.tb_frame
.f_locals
['self'], 'MetaFile'):
2519 MetaFile
= Tb
.tb_frame
.f_locals
['self'].MetaFile
2524 "Unknown fatal error when processing [%s]" % MetaFile
,
2525 ExtraData
="\n(Please send email to %s for help, attaching following call stack trace!)\n" % MSG_EDKII_MAIL_ADDR
,
2528 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
2529 ReturnCode
= CODE_ERROR
2531 Utils
.Progressor
.Abort()
2532 Utils
.ClearDuplicatedInf()
2536 MyBuild
.LaunchPostbuild()
2539 Conclusion
= "Failed"
2540 elif ReturnCode
== ABORT_ERROR
:
2541 Conclusion
= "Aborted"
2543 Conclusion
= "Failed"
2544 FinishTime
= time
.time()
2545 BuildDuration
= time
.gmtime(int(round(FinishTime
- StartTime
)))
2546 BuildDurationStr
= ""
2547 if BuildDuration
.tm_yday
> 1:
2548 BuildDurationStr
= time
.strftime("%H:%M:%S", BuildDuration
) + ", %d day(s)" % (BuildDuration
.tm_yday
- 1)
2550 BuildDurationStr
= time
.strftime("%H:%M:%S", BuildDuration
)
2551 if MyBuild
is not None:
2553 MyBuild
.BuildReport
.GenerateReport(BuildDurationStr
, LogBuildTime(MyBuild
.AutoGenTime
), LogBuildTime(MyBuild
.MakeTime
), LogBuildTime(MyBuild
.GenFdsTime
))
2555 EdkLogger
.SetLevel(EdkLogger
.QUIET
)
2556 EdkLogger
.quiet("\n- %s -" % Conclusion
)
2557 EdkLogger
.quiet(time
.strftime("Build end time: %H:%M:%S, %b.%d %Y", time
.localtime()))
2558 EdkLogger
.quiet("Build total time: %s\n" % BuildDurationStr
)
2561 if __name__
== '__main__':
2563 ## 0-127 is a safe return range, and 1 is a standard default error
2564 if r
< 0 or r
> 127: r
= 1