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 # This program and the accompanying materials
9 # are licensed and made available under the terms and conditions of the BSD License
10 # which accompanies this distribution. The full text of the license may be found at
11 # http://opensource.org/licenses/bsd-license.php
13 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
14 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
20 from __future__
import print_function
21 import Common
.LongFilePathOs
as os
28 import encodings
.ascii
29 import multiprocessing
32 from threading
import *
34 from optparse
import OptionParser
35 from subprocess
import *
36 from Common
import Misc
as Utils
38 from Common
.LongFilePathSupport
import OpenLongFilePath
as open
39 from Common
.TargetTxtClassObject
import TargetTxtClassObject
40 from Common
.ToolDefClassObject
import ToolDefClassObject
41 from Common
.DataType
import *
42 from Common
.BuildVersion
import gBUILD_VERSION
43 from AutoGen
.AutoGen
import *
44 from Common
.BuildToolError
import *
45 from Workspace
.WorkspaceDatabase
import WorkspaceDatabase
46 from Common
.MultipleWorkspace
import MultipleWorkspace
as mws
48 from BuildReport
import BuildReport
49 from GenPatchPcdTable
.GenPatchPcdTable
import *
50 from PatchPcdValue
.PatchPcdValue
import *
52 import Common
.EdkLogger
53 import Common
.GlobalData
as GlobalData
54 from GenFds
.GenFds
import GenFds
, GenFdsApi
56 from collections
import OrderedDict
, defaultdict
58 # Version and Copyright
59 VersionNumber
= "0.60" + ' ' + gBUILD_VERSION
60 __version__
= "%prog Version " + VersionNumber
61 __copyright__
= "Copyright (c) 2007 - 2018, Intel Corporation All rights reserved."
63 ## standard targets of build command
64 gSupportedTarget
= ['all', 'genc', 'genmake', 'modules', 'libraries', 'fds', 'clean', 'cleanall', 'cleanlib', 'run']
66 ## build configuration file
67 gBuildConfiguration
= "target.txt"
68 gToolsDefinition
= "tools_def.txt"
70 TemporaryTablePattern
= re
.compile(r
'^_\d+_\d+_[a-fA-F0-9]+$')
73 ## Check environment PATH variable to make sure the specified tool is found
75 # If the tool is found in the PATH, then True is returned
76 # Otherwise, False is returned
78 def IsToolInPath(tool
):
79 if 'PATHEXT' in os
.environ
:
80 extns
= os
.environ
['PATHEXT'].split(os
.path
.pathsep
)
83 for pathDir
in os
.environ
['PATH'].split(os
.path
.pathsep
):
85 if os
.path
.exists(os
.path
.join(pathDir
, tool
+ ext
)):
89 ## Check environment variables
91 # Check environment variables that must be set for build. Currently they are
93 # WORKSPACE The directory all packages/platforms start from
94 # EDK_TOOLS_PATH The directory contains all tools needed by the build
95 # PATH $(EDK_TOOLS_PATH)/Bin/<sys> must be set in PATH
97 # If any of above environment variable is not set or has error, the build
100 def CheckEnvVariable():
102 if "WORKSPACE" not in os
.environ
:
103 EdkLogger
.error("build", ATTRIBUTE_NOT_AVAILABLE
, "Environment variable not found",
104 ExtraData
="WORKSPACE")
106 WorkspaceDir
= os
.path
.normcase(os
.path
.normpath(os
.environ
["WORKSPACE"]))
107 if not os
.path
.exists(WorkspaceDir
):
108 EdkLogger
.error("build", FILE_NOT_FOUND
, "WORKSPACE doesn't exist", ExtraData
=WorkspaceDir
)
109 elif ' ' in WorkspaceDir
:
110 EdkLogger
.error("build", FORMAT_NOT_SUPPORTED
, "No space is allowed in WORKSPACE path",
111 ExtraData
=WorkspaceDir
)
112 os
.environ
["WORKSPACE"] = WorkspaceDir
114 # set multiple workspace
115 PackagesPath
= os
.getenv("PACKAGES_PATH")
116 mws
.setWs(WorkspaceDir
, PackagesPath
)
117 if mws
.PACKAGES_PATH
:
118 for Path
in mws
.PACKAGES_PATH
:
119 if not os
.path
.exists(Path
):
120 EdkLogger
.error("build", FILE_NOT_FOUND
, "One Path in PACKAGES_PATH doesn't exist", ExtraData
=Path
)
122 EdkLogger
.error("build", FORMAT_NOT_SUPPORTED
, "No space is allowed in PACKAGES_PATH", ExtraData
=Path
)
125 os
.environ
["EDK_TOOLS_PATH"] = os
.path
.normcase(os
.environ
["EDK_TOOLS_PATH"])
127 # check EDK_TOOLS_PATH
128 if "EDK_TOOLS_PATH" not in os
.environ
:
129 EdkLogger
.error("build", ATTRIBUTE_NOT_AVAILABLE
, "Environment variable not found",
130 ExtraData
="EDK_TOOLS_PATH")
133 if "PATH" not in os
.environ
:
134 EdkLogger
.error("build", ATTRIBUTE_NOT_AVAILABLE
, "Environment variable not found",
137 GlobalData
.gWorkspace
= WorkspaceDir
139 GlobalData
.gGlobalDefines
["WORKSPACE"] = WorkspaceDir
140 GlobalData
.gGlobalDefines
["EDK_TOOLS_PATH"] = os
.environ
["EDK_TOOLS_PATH"]
142 ## Get normalized file path
144 # Convert the path to be local format, and remove the WORKSPACE path at the
145 # beginning if the file path is given in full path.
147 # @param FilePath File path to be normalized
148 # @param Workspace Workspace path which the FilePath will be checked against
150 # @retval string The normalized file path
152 def NormFile(FilePath
, Workspace
):
153 # check if the path is absolute or relative
154 if os
.path
.isabs(FilePath
):
155 FileFullPath
= os
.path
.normpath(FilePath
)
157 FileFullPath
= os
.path
.normpath(mws
.join(Workspace
, FilePath
))
158 Workspace
= mws
.getWs(Workspace
, FilePath
)
160 # check if the file path exists or not
161 if not os
.path
.isfile(FileFullPath
):
162 EdkLogger
.error("build", FILE_NOT_FOUND
, ExtraData
="\t%s (Please give file in absolute path or relative to WORKSPACE)" % FileFullPath
)
164 # remove workspace directory from the beginning part of the file path
165 if Workspace
[-1] in ["\\", "/"]:
166 return FileFullPath
[len(Workspace
):]
168 return FileFullPath
[(len(Workspace
) + 1):]
170 ## Get the output of an external program
172 # This is the entrance method of thread reading output of an external program and
173 # putting them in STDOUT/STDERR of current program.
175 # @param From The stream message read from
176 # @param To The stream message put on
177 # @param ExitFlag The flag used to indicate stopping reading
179 def ReadMessage(From
, To
, ExitFlag
):
181 # read one line a time
182 Line
= From
.readline()
183 # empty string means "end"
184 if Line
is not None and Line
!= b
"":
185 To(Line
.rstrip().decode(encoding
='utf-8', errors
='ignore'))
191 ## Launch an external program
193 # This method will call subprocess.Popen to execute an external program with
194 # given options in specified directory. Because of the dead-lock issue during
195 # redirecting output of the external program, threads are used to to do the
198 # @param Command A list or string containing the call of the program
199 # @param WorkingDir The directory in which the program will be running
201 def LaunchCommand(Command
, WorkingDir
):
202 BeginTime
= time
.time()
203 # if working directory doesn't exist, Popen() will raise an exception
204 if not os
.path
.isdir(WorkingDir
):
205 EdkLogger
.error("build", FILE_NOT_FOUND
, ExtraData
=WorkingDir
)
207 # Command is used as the first Argument in following Popen().
208 # It could be a string or sequence. We find that if command is a string in following Popen(),
209 # ubuntu may fail with an error message that the command is not found.
210 # So here we may need convert command from string to list instance.
211 if platform
.system() != 'Windows':
212 if not isinstance(Command
, list):
213 Command
= Command
.split()
214 Command
= ' '.join(Command
)
217 EndOfProcedure
= None
220 Proc
= Popen(Command
, stdout
=PIPE
, stderr
=PIPE
, env
=os
.environ
, cwd
=WorkingDir
, bufsize
=-1, shell
=True)
222 # launch two threads to read the STDOUT and STDERR
223 EndOfProcedure
= Event()
224 EndOfProcedure
.clear()
226 StdOutThread
= Thread(target
=ReadMessage
, args
=(Proc
.stdout
, EdkLogger
.info
, EndOfProcedure
))
227 StdOutThread
.setName("STDOUT-Redirector")
228 StdOutThread
.setDaemon(False)
232 StdErrThread
= Thread(target
=ReadMessage
, args
=(Proc
.stderr
, EdkLogger
.quiet
, EndOfProcedure
))
233 StdErrThread
.setName("STDERR-Redirector")
234 StdErrThread
.setDaemon(False)
237 # waiting for program exit
239 except: # in case of aborting
240 # terminate the threads redirecting the program output
241 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
242 if EndOfProcedure
is not None:
245 if not isinstance(Command
, type("")):
246 Command
= " ".join(Command
)
247 EdkLogger
.error("build", COMMAND_FAILURE
, "Failed to start command", ExtraData
="%s [%s]" % (Command
, WorkingDir
))
254 # check the return code of the program
255 if Proc
.returncode
!= 0:
256 if not isinstance(Command
, type("")):
257 Command
= " ".join(Command
)
258 # print out the Response file and its content when make failure
259 RespFile
= os
.path
.join(WorkingDir
, 'OUTPUT', 'respfilelist.txt')
260 if os
.path
.isfile(RespFile
):
262 RespContent
= f
.read()
264 EdkLogger
.info(RespContent
)
266 EdkLogger
.error("build", COMMAND_FAILURE
, ExtraData
="%s [%s]" % (Command
, WorkingDir
))
267 return "%dms" % (int(round((time
.time() - BeginTime
) * 1000)))
269 ## The smallest unit that can be built in multi-thread build mode
271 # This is the base class of build unit. The "Obj" parameter must provide
272 # __str__(), __eq__() and __hash__() methods. Otherwise there could be build units
275 # Currently the "Obj" should be only ModuleAutoGen or PlatformAutoGen objects.
280 # @param self The object pointer
281 # @param Obj The object the build is working on
282 # @param Target The build target name, one of gSupportedTarget
283 # @param Dependency The BuildUnit(s) which must be completed in advance
284 # @param WorkingDir The directory build command starts in
286 def __init__(self
, Obj
, BuildCommand
, Target
, Dependency
, WorkingDir
="."):
287 self
.BuildObject
= Obj
288 self
.Dependency
= Dependency
289 self
.WorkingDir
= WorkingDir
291 self
.BuildCommand
= BuildCommand
293 EdkLogger
.error("build", OPTION_MISSING
,
294 "No build command found for this module. "
295 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %
296 (Obj
.BuildTarget
, Obj
.ToolChain
, Obj
.Arch
),
302 # It just returns the string representation of self.BuildObject
304 # @param self The object pointer
307 return str(self
.BuildObject
)
309 ## "==" operator method
311 # It just compares self.BuildObject with "Other". So self.BuildObject must
312 # provide its own __eq__() method.
314 # @param self The object pointer
315 # @param Other The other BuildUnit object compared to
317 def __eq__(self
, Other
):
318 return Other
and self
.BuildObject
== Other
.BuildObject \
319 and Other
.BuildObject \
320 and self
.BuildObject
.Arch
== Other
.BuildObject
.Arch
324 # It just returns the hash value of self.BuildObject which must be hashable.
326 # @param self The object pointer
329 return hash(self
.BuildObject
) + hash(self
.BuildObject
.Arch
)
332 return repr(self
.BuildObject
)
334 ## The smallest module unit that can be built by nmake/make command in multi-thread build mode
336 # This class is for module build by nmake/make build system. The "Obj" parameter
337 # must provide __str__(), __eq__() and __hash__() methods. Otherwise there could
338 # be make units missing build.
340 # Currently the "Obj" should be only ModuleAutoGen object.
342 class ModuleMakeUnit(BuildUnit
):
345 # @param self The object pointer
346 # @param Obj The ModuleAutoGen object the build is working on
347 # @param Target The build target name, one of gSupportedTarget
349 def __init__(self
, Obj
, Target
):
350 Dependency
= [ModuleMakeUnit(La
, Target
) for La
in Obj
.LibraryAutoGenList
]
351 BuildUnit
.__init
__(self
, Obj
, Obj
.BuildCommand
, Target
, Dependency
, Obj
.MakeFileDir
)
352 if Target
in [None, "", "all"]:
353 self
.Target
= "tbuild"
355 ## The smallest platform unit that can be built by nmake/make command in multi-thread build mode
357 # This class is for platform build by nmake/make build system. The "Obj" parameter
358 # must provide __str__(), __eq__() and __hash__() methods. Otherwise there could
359 # be make units missing build.
361 # Currently the "Obj" should be only PlatformAutoGen object.
363 class PlatformMakeUnit(BuildUnit
):
366 # @param self The object pointer
367 # @param Obj The PlatformAutoGen object the build is working on
368 # @param Target The build target name, one of gSupportedTarget
370 def __init__(self
, Obj
, Target
):
371 Dependency
= [ModuleMakeUnit(Lib
, Target
) for Lib
in self
.BuildObject
.LibraryAutoGenList
]
372 Dependency
.extend([ModuleMakeUnit(Mod
, Target
) for Mod
in self
.BuildObject
.ModuleAutoGenList
])
373 BuildUnit
.__init
__(self
, Obj
, Obj
.BuildCommand
, Target
, Dependency
, Obj
.MakeFileDir
)
375 ## The class representing the task of a module build or platform build
377 # This class manages the build tasks in multi-thread build mode. Its jobs include
378 # scheduling thread running, catching thread error, monitor the thread status, etc.
381 # queue for tasks waiting for schedule
382 _PendingQueue
= OrderedDict()
383 _PendingQueueLock
= threading
.Lock()
385 # queue for tasks ready for running
386 _ReadyQueue
= OrderedDict()
387 _ReadyQueueLock
= threading
.Lock()
389 # queue for run tasks
390 _RunningQueue
= OrderedDict()
391 _RunningQueueLock
= threading
.Lock()
393 # queue containing all build tasks, in case duplicate build
394 _TaskQueue
= OrderedDict()
396 # flag indicating error occurs in a running thread
397 _ErrorFlag
= threading
.Event()
401 # BoundedSemaphore object used to control the number of running threads
404 # flag indicating if the scheduler is started or not
405 _SchedulerStopped
= threading
.Event()
406 _SchedulerStopped
.set()
408 ## Start the task scheduler thread
410 # @param MaxThreadNumber The maximum thread number
411 # @param ExitFlag Flag used to end the scheduler
414 def StartScheduler(MaxThreadNumber
, ExitFlag
):
415 SchedulerThread
= Thread(target
=BuildTask
.Scheduler
, args
=(MaxThreadNumber
, ExitFlag
))
416 SchedulerThread
.setName("Build-Task-Scheduler")
417 SchedulerThread
.setDaemon(False)
418 SchedulerThread
.start()
419 # wait for the scheduler to be started, especially useful in Linux
420 while not BuildTask
.IsOnGoing():
425 # @param MaxThreadNumber The maximum thread number
426 # @param ExitFlag Flag used to end the scheduler
429 def Scheduler(MaxThreadNumber
, ExitFlag
):
430 BuildTask
._SchedulerStopped
.clear()
432 # use BoundedSemaphore to control the maximum running threads
433 BuildTask
._Thread
= BoundedSemaphore(MaxThreadNumber
)
435 # scheduling loop, which will exits when no pending/ready task and
436 # indicated to do so, or there's error in running thread
438 while (len(BuildTask
._PendingQueue
) > 0 or len(BuildTask
._ReadyQueue
) > 0 \
439 or not ExitFlag
.isSet()) and not BuildTask
._ErrorFlag
.isSet():
440 EdkLogger
.debug(EdkLogger
.DEBUG_8
, "Pending Queue (%d), Ready Queue (%d)"
441 % (len(BuildTask
._PendingQueue
), len(BuildTask
._ReadyQueue
)))
443 # get all pending tasks
444 BuildTask
._PendingQueueLock
.acquire()
445 BuildObjectList
= list(BuildTask
._PendingQueue
.keys())
447 # check if their dependency is resolved, and if true, move them
450 for BuildObject
in BuildObjectList
:
451 Bt
= BuildTask
._PendingQueue
[BuildObject
]
453 BuildTask
._ReadyQueue
[BuildObject
] = BuildTask
._PendingQueue
.pop(BuildObject
)
454 BuildTask
._PendingQueueLock
.release()
456 # launch build thread until the maximum number of threads is reached
457 while not BuildTask
._ErrorFlag
.isSet():
458 # empty ready queue, do nothing further
459 if len(BuildTask
._ReadyQueue
) == 0:
462 # wait for active thread(s) exit
463 BuildTask
._Thread
.acquire(True)
465 # start a new build thread
466 Bo
, Bt
= BuildTask
._ReadyQueue
.popitem()
468 # move into running queue
469 BuildTask
._RunningQueueLock
.acquire()
470 BuildTask
._RunningQueue
[Bo
] = Bt
471 BuildTask
._RunningQueueLock
.release()
480 # wait for all running threads exit
481 if BuildTask
._ErrorFlag
.isSet():
482 EdkLogger
.quiet("\nWaiting for all build threads exit...")
483 # while not BuildTask._ErrorFlag.isSet() and \
484 while len(BuildTask
._RunningQueue
) > 0:
485 EdkLogger
.verbose("Waiting for thread ending...(%d)" % len(BuildTask
._RunningQueue
))
486 EdkLogger
.debug(EdkLogger
.DEBUG_8
, "Threads [%s]" % ", ".join(Th
.getName() for Th
in threading
.enumerate()))
489 except BaseException
as X
:
491 # TRICK: hide the output of threads left running, so that the user can
492 # catch the error message easily
494 EdkLogger
.SetLevel(EdkLogger
.ERROR
)
495 BuildTask
._ErrorFlag
.set()
496 BuildTask
._ErrorMessage
= "build thread scheduler error\n\t%s" % str(X
)
498 BuildTask
._PendingQueue
.clear()
499 BuildTask
._ReadyQueue
.clear()
500 BuildTask
._RunningQueue
.clear()
501 BuildTask
._TaskQueue
.clear()
502 BuildTask
._SchedulerStopped
.set()
504 ## Wait for all running method exit
507 def WaitForComplete():
508 BuildTask
._SchedulerStopped
.wait()
510 ## Check if the scheduler is running or not
514 return not BuildTask
._SchedulerStopped
.isSet()
519 if BuildTask
.IsOnGoing():
520 BuildTask
._ErrorFlag
.set()
521 BuildTask
.WaitForComplete()
523 ## Check if there's error in running thread
525 # Since the main thread cannot catch exceptions in other thread, we have to
526 # use threading.Event to communicate this formation to main thread.
530 return BuildTask
._ErrorFlag
.isSet()
532 ## Get error message in running thread
534 # Since the main thread cannot catch exceptions in other thread, we have to
535 # use a static variable to communicate this message to main thread.
538 def GetErrorMessage():
539 return BuildTask
._ErrorMessage
541 ## Factory method to create a BuildTask object
543 # This method will check if a module is building or has been built. And if
544 # true, just return the associated BuildTask object in the _TaskQueue. If
545 # not, create and return a new BuildTask object. The new BuildTask object
546 # will be appended to the _PendingQueue for scheduling later.
548 # @param BuildItem A BuildUnit object representing a build object
549 # @param Dependency The dependent build object of BuildItem
552 def New(BuildItem
, Dependency
=None):
553 if BuildItem
in BuildTask
._TaskQueue
:
554 Bt
= BuildTask
._TaskQueue
[BuildItem
]
558 Bt
._Init
(BuildItem
, Dependency
)
559 BuildTask
._TaskQueue
[BuildItem
] = Bt
561 BuildTask
._PendingQueueLock
.acquire()
562 BuildTask
._PendingQueue
[BuildItem
] = Bt
563 BuildTask
._PendingQueueLock
.release()
567 ## The real constructor of BuildTask
569 # @param BuildItem A BuildUnit object representing a build object
570 # @param Dependency The dependent build object of BuildItem
572 def _Init(self
, BuildItem
, Dependency
=None):
573 self
.BuildItem
= BuildItem
575 self
.DependencyList
= []
576 if Dependency
is None:
577 Dependency
= BuildItem
.Dependency
579 Dependency
.extend(BuildItem
.Dependency
)
580 self
.AddDependency(Dependency
)
581 # flag indicating build completes, used to avoid unnecessary re-build
582 self
.CompleteFlag
= False
584 ## Check if all dependent build tasks are completed or not
588 for Dep
in self
.DependencyList
:
589 if Dep
.CompleteFlag
== True:
596 ## Add dependent build task
598 # @param Dependency The list of dependent build objects
600 def AddDependency(self
, Dependency
):
601 for Dep
in Dependency
:
602 if not Dep
.BuildObject
.IsBinaryModule
:
603 self
.DependencyList
.append(BuildTask
.New(Dep
)) # BuildTask list
605 ## The thread wrapper of LaunchCommand function
607 # @param Command A list or string contains the call of the command
608 # @param WorkingDir The directory in which the program will be running
610 def _CommandThread(self
, Command
, WorkingDir
):
612 self
.BuildItem
.BuildObject
.BuildTime
= LaunchCommand(Command
, WorkingDir
)
613 self
.CompleteFlag
= True
616 # TRICK: hide the output of threads left running, so that the user can
617 # catch the error message easily
619 if not BuildTask
._ErrorFlag
.isSet():
620 GlobalData
.gBuildingModule
= "%s [%s, %s, %s]" % (str(self
.BuildItem
.BuildObject
),
621 self
.BuildItem
.BuildObject
.Arch
,
622 self
.BuildItem
.BuildObject
.ToolChain
,
623 self
.BuildItem
.BuildObject
.BuildTarget
625 EdkLogger
.SetLevel(EdkLogger
.ERROR
)
626 BuildTask
._ErrorFlag
.set()
627 BuildTask
._ErrorMessage
= "%s broken\n %s [%s]" % \
628 (threading
.currentThread().getName(), Command
, WorkingDir
)
629 # indicate there's a thread is available for another build task
630 BuildTask
._RunningQueueLock
.acquire()
631 BuildTask
._RunningQueue
.pop(self
.BuildItem
)
632 BuildTask
._RunningQueueLock
.release()
633 BuildTask
._Thread
.release()
635 ## Start build task thread
638 EdkLogger
.quiet("Building ... %s" % repr(self
.BuildItem
))
639 Command
= self
.BuildItem
.BuildCommand
+ [self
.BuildItem
.Target
]
640 self
.BuildTread
= Thread(target
=self
._CommandThread
, args
=(Command
, self
.BuildItem
.WorkingDir
))
641 self
.BuildTread
.setName("build thread")
642 self
.BuildTread
.setDaemon(False)
643 self
.BuildTread
.start()
645 ## The class contains the information related to EFI image
650 # Constructor will load all required image information.
652 # @param BaseName The full file path of image.
653 # @param Guid The GUID for image.
654 # @param Arch Arch of this image.
655 # @param OutputDir The output directory for image.
656 # @param DebugDir The debug directory for image.
657 # @param ImageClass PeImage Information
659 def __init__(self
, BaseName
, Guid
, Arch
, OutputDir
, DebugDir
, ImageClass
):
660 self
.BaseName
= BaseName
663 self
.OutputDir
= OutputDir
664 self
.DebugDir
= DebugDir
665 self
.Image
= ImageClass
666 self
.Image
.Size
= (self
.Image
.Size
// 0x1000 + 1) * 0x1000
668 ## The class implementing the EDK2 build process
670 # The build process includes:
671 # 1. Load configuration from target.txt and tools_def.txt in $(WORKSPACE)/Conf
672 # 2. Parse DSC file of active platform
673 # 3. Parse FDF file if any
674 # 4. Establish build database, including parse all other files (module, package)
675 # 5. Create AutoGen files (C code file, depex file, makefile) if necessary
676 # 6. Call build command
681 # Constructor will load all necessary configurations, parse platform, modules
682 # and packages and the establish a database for AutoGen.
684 # @param Target The build command target, one of gSupportedTarget
685 # @param WorkspaceDir The directory of workspace
686 # @param BuildOptions Build options passed from command line
688 def __init__(self
, Target
, WorkspaceDir
, BuildOptions
):
689 self
.WorkspaceDir
= WorkspaceDir
691 self
.PlatformFile
= BuildOptions
.PlatformFile
692 self
.ModuleFile
= BuildOptions
.ModuleFile
693 self
.ArchList
= BuildOptions
.TargetArch
694 self
.ToolChainList
= BuildOptions
.ToolChain
695 self
.BuildTargetList
= BuildOptions
.BuildTarget
696 self
.Fdf
= BuildOptions
.FdfFile
697 self
.FdList
= BuildOptions
.RomImage
698 self
.FvList
= BuildOptions
.FvImage
699 self
.CapList
= BuildOptions
.CapName
700 self
.SilentMode
= BuildOptions
.SilentMode
701 self
.ThreadNumber
= BuildOptions
.ThreadNumber
702 self
.SkipAutoGen
= BuildOptions
.SkipAutoGen
703 self
.Reparse
= BuildOptions
.Reparse
704 self
.SkuId
= BuildOptions
.SkuId
706 GlobalData
.gSKUID_CMD
= self
.SkuId
707 self
.ConfDirectory
= BuildOptions
.ConfDirectory
708 self
.SpawnMode
= True
709 self
.BuildReport
= BuildReport(BuildOptions
.ReportFile
, BuildOptions
.ReportType
)
710 self
.TargetTxt
= TargetTxtClassObject()
711 self
.ToolDef
= ToolDefClassObject()
715 GlobalData
.BuildOptionPcd
= BuildOptions
.OptionPcd
if BuildOptions
.OptionPcd
else []
716 #Set global flag for build mode
717 GlobalData
.gIgnoreSource
= BuildOptions
.IgnoreSources
718 GlobalData
.gUseHashCache
= BuildOptions
.UseHashCache
719 GlobalData
.gBinCacheDest
= BuildOptions
.BinCacheDest
720 GlobalData
.gBinCacheSource
= BuildOptions
.BinCacheSource
721 GlobalData
.gEnableGenfdsMultiThread
= BuildOptions
.GenfdsMultiThread
722 GlobalData
.gDisableIncludePathCheck
= BuildOptions
.DisableIncludePathCheck
724 if GlobalData
.gBinCacheDest
and not GlobalData
.gUseHashCache
:
725 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, ExtraData
="--binary-destination must be used together with --hash.")
727 if GlobalData
.gBinCacheSource
and not GlobalData
.gUseHashCache
:
728 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, ExtraData
="--binary-source must be used together with --hash.")
730 if GlobalData
.gBinCacheDest
and GlobalData
.gBinCacheSource
:
731 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, ExtraData
="--binary-destination can not be used together with --binary-source.")
733 if GlobalData
.gBinCacheSource
:
734 BinCacheSource
= os
.path
.normpath(GlobalData
.gBinCacheSource
)
735 if not os
.path
.isabs(BinCacheSource
):
736 BinCacheSource
= mws
.join(self
.WorkspaceDir
, BinCacheSource
)
737 GlobalData
.gBinCacheSource
= BinCacheSource
739 if GlobalData
.gBinCacheSource
is not None:
740 EdkLogger
.error("build", OPTION_VALUE_INVALID
, ExtraData
="Invalid value of option --binary-source.")
742 if GlobalData
.gBinCacheDest
:
743 BinCacheDest
= os
.path
.normpath(GlobalData
.gBinCacheDest
)
744 if not os
.path
.isabs(BinCacheDest
):
745 BinCacheDest
= mws
.join(self
.WorkspaceDir
, BinCacheDest
)
746 GlobalData
.gBinCacheDest
= BinCacheDest
748 if GlobalData
.gBinCacheDest
is not None:
749 EdkLogger
.error("build", OPTION_VALUE_INVALID
, ExtraData
="Invalid value of option --binary-destination.")
751 if self
.ConfDirectory
:
752 # Get alternate Conf location, if it is absolute, then just use the absolute directory name
753 ConfDirectoryPath
= os
.path
.normpath(self
.ConfDirectory
)
755 if not os
.path
.isabs(ConfDirectoryPath
):
756 # Since alternate directory name is not absolute, the alternate directory is located within the WORKSPACE
757 # This also handles someone specifying the Conf directory in the workspace. Using --conf=Conf
758 ConfDirectoryPath
= mws
.join(self
.WorkspaceDir
, ConfDirectoryPath
)
760 if "CONF_PATH" in os
.environ
:
761 ConfDirectoryPath
= os
.path
.normcase(os
.path
.normpath(os
.environ
["CONF_PATH"]))
763 # Get standard WORKSPACE/Conf use the absolute path to the WORKSPACE/Conf
764 ConfDirectoryPath
= mws
.join(self
.WorkspaceDir
, 'Conf')
765 GlobalData
.gConfDirectory
= ConfDirectoryPath
766 GlobalData
.gDatabasePath
= os
.path
.normpath(os
.path
.join(ConfDirectoryPath
, GlobalData
.gDatabasePath
))
768 self
.Db
= WorkspaceDatabase()
769 self
.BuildDatabase
= self
.Db
.BuildObject
771 self
.ToolChainFamily
= None
772 self
.LoadFixAddress
= 0
773 self
.UniFlag
= BuildOptions
.Flag
774 self
.BuildModules
= []
775 self
.HashSkipModules
= []
777 self
.LaunchPrebuildFlag
= False
778 self
.PlatformBuildPath
= os
.path
.join(GlobalData
.gConfDirectory
, '.cache', '.PlatformBuild')
779 if BuildOptions
.CommandLength
:
780 GlobalData
.gCommandMaxLength
= BuildOptions
.CommandLength
782 # print dot character during doing some time-consuming work
783 self
.Progress
= Utils
.Progressor()
784 # print current build environment and configuration
785 EdkLogger
.quiet("%-16s = %s" % ("WORKSPACE", os
.environ
["WORKSPACE"]))
786 if "PACKAGES_PATH" in os
.environ
:
787 # WORKSPACE env has been converted before. Print the same path style with WORKSPACE env.
788 EdkLogger
.quiet("%-16s = %s" % ("PACKAGES_PATH", os
.path
.normcase(os
.path
.normpath(os
.environ
["PACKAGES_PATH"]))))
789 EdkLogger
.quiet("%-16s = %s" % ("EDK_TOOLS_PATH", os
.environ
["EDK_TOOLS_PATH"]))
790 if "EDK_TOOLS_BIN" in os
.environ
:
791 # Print the same path style with WORKSPACE env.
792 EdkLogger
.quiet("%-16s = %s" % ("EDK_TOOLS_BIN", os
.path
.normcase(os
.path
.normpath(os
.environ
["EDK_TOOLS_BIN"]))))
793 EdkLogger
.quiet("%-16s = %s" % ("CONF_PATH", GlobalData
.gConfDirectory
))
794 if "PYTHON3_ENABLE" in os
.environ
:
795 PYTHON3_ENABLE
= os
.environ
["PYTHON3_ENABLE"]
796 if PYTHON3_ENABLE
!= "TRUE":
797 PYTHON3_ENABLE
= "FALSE"
798 EdkLogger
.quiet("%-16s = %s" % ("PYTHON3_ENABLE", PYTHON3_ENABLE
))
799 if "PYTHON_COMMAND" in os
.environ
:
800 EdkLogger
.quiet("%-16s = %s" % ("PYTHON_COMMAND", os
.environ
["PYTHON_COMMAND"]))
804 EdkLogger
.quiet("%-16s = %s" % ("PREBUILD", self
.Prebuild
))
806 EdkLogger
.quiet("%-16s = %s" % ("POSTBUILD", self
.Postbuild
))
808 self
.LaunchPrebuild()
809 self
.TargetTxt
= TargetTxtClassObject()
810 self
.ToolDef
= ToolDefClassObject()
811 if not (self
.LaunchPrebuildFlag
and os
.path
.exists(self
.PlatformBuildPath
)):
815 os
.chdir(self
.WorkspaceDir
)
817 ## Load configuration
819 # This method will parse target.txt and get the build configurations.
821 def LoadConfiguration(self
):
823 # Check target.txt and tools_def.txt and Init them
825 BuildConfigurationFile
= os
.path
.normpath(os
.path
.join(GlobalData
.gConfDirectory
, gBuildConfiguration
))
826 if os
.path
.isfile(BuildConfigurationFile
) == True:
827 StatusCode
= self
.TargetTxt
.LoadTargetTxtFile(BuildConfigurationFile
)
829 ToolDefinitionFile
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_TOOL_CHAIN_CONF
]
830 if ToolDefinitionFile
== '':
831 ToolDefinitionFile
= gToolsDefinition
832 ToolDefinitionFile
= os
.path
.normpath(mws
.join(self
.WorkspaceDir
, 'Conf', ToolDefinitionFile
))
833 if os
.path
.isfile(ToolDefinitionFile
) == True:
834 StatusCode
= self
.ToolDef
.LoadToolDefFile(ToolDefinitionFile
)
836 EdkLogger
.error("build", FILE_NOT_FOUND
, ExtraData
=ToolDefinitionFile
)
838 EdkLogger
.error("build", FILE_NOT_FOUND
, ExtraData
=BuildConfigurationFile
)
840 # if no ARCH given in command line, get it from target.txt
841 if not self
.ArchList
:
842 self
.ArchList
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_TARGET_ARCH
]
843 self
.ArchList
= tuple(self
.ArchList
)
845 # if no build target given in command line, get it from target.txt
846 if not self
.BuildTargetList
:
847 self
.BuildTargetList
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_TARGET
]
849 # if no tool chain given in command line, get it from target.txt
850 if not self
.ToolChainList
:
851 self
.ToolChainList
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_TOOL_CHAIN_TAG
]
852 if self
.ToolChainList
is None or len(self
.ToolChainList
) == 0:
853 EdkLogger
.error("build", RESOURCE_NOT_AVAILABLE
, ExtraData
="No toolchain given. Don't know how to build.\n")
855 # check if the tool chains are defined or not
856 NewToolChainList
= []
857 for ToolChain
in self
.ToolChainList
:
858 if ToolChain
not in self
.ToolDef
.ToolsDefTxtDatabase
[TAB_TOD_DEFINES_TOOL_CHAIN_TAG
]:
859 EdkLogger
.warn("build", "Tool chain [%s] is not defined" % ToolChain
)
861 NewToolChainList
.append(ToolChain
)
862 # if no tool chain available, break the build
863 if len(NewToolChainList
) == 0:
864 EdkLogger
.error("build", RESOURCE_NOT_AVAILABLE
,
865 ExtraData
="[%s] not defined. No toolchain available for build!\n" % ", ".join(self
.ToolChainList
))
867 self
.ToolChainList
= NewToolChainList
870 ToolDefinition
= self
.ToolDef
.ToolsDefTxtDatabase
871 for Tool
in self
.ToolChainList
:
872 if TAB_TOD_DEFINES_FAMILY
not in ToolDefinition
or Tool
not in ToolDefinition
[TAB_TOD_DEFINES_FAMILY
] \
873 or not ToolDefinition
[TAB_TOD_DEFINES_FAMILY
][Tool
]:
874 EdkLogger
.warn("build", "No tool chain family found in configuration for %s. Default to MSFT." % Tool
)
875 ToolChainFamily
.append(TAB_COMPILER_MSFT
)
877 ToolChainFamily
.append(ToolDefinition
[TAB_TOD_DEFINES_FAMILY
][Tool
])
878 self
.ToolChainFamily
= ToolChainFamily
880 if self
.ThreadNumber
is None:
881 self
.ThreadNumber
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_MAX_CONCURRENT_THREAD_NUMBER
]
882 if self
.ThreadNumber
== '':
883 self
.ThreadNumber
= 0
885 self
.ThreadNumber
= int(self
.ThreadNumber
, 0)
887 if self
.ThreadNumber
== 0:
889 self
.ThreadNumber
= multiprocessing
.cpu_count()
890 except (ImportError, NotImplementedError):
891 self
.ThreadNumber
= 1
893 if not self
.PlatformFile
:
894 PlatformFile
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_ACTIVE_PLATFORM
]
896 # Try to find one in current directory
897 WorkingDirectory
= os
.getcwd()
898 FileList
= glob
.glob(os
.path
.normpath(os
.path
.join(WorkingDirectory
, '*.dsc')))
899 FileNum
= len(FileList
)
901 EdkLogger
.error("build", OPTION_MISSING
,
902 ExtraData
="There are %d DSC files in %s. Use '-p' to specify one.\n" % (FileNum
, WorkingDirectory
))
904 PlatformFile
= FileList
[0]
906 EdkLogger
.error("build", RESOURCE_NOT_AVAILABLE
,
907 ExtraData
="No active platform specified in target.txt or command line! Nothing can be built.\n")
909 self
.PlatformFile
= PathClass(NormFile(PlatformFile
, self
.WorkspaceDir
), self
.WorkspaceDir
)
911 ## Initialize build configuration
913 # This method will parse DSC file and merge the configurations from
914 # command line and target.txt, then get the final build configurations.
917 # parse target.txt, tools_def.txt, and platform file
918 self
.LoadConfiguration()
920 # Allow case-insensitive for those from command line or configuration file
921 ErrorCode
, ErrorInfo
= self
.PlatformFile
.Validate(".dsc", False)
923 EdkLogger
.error("build", ErrorCode
, ExtraData
=ErrorInfo
)
926 def InitPreBuild(self
):
927 self
.LoadConfiguration()
928 ErrorCode
, ErrorInfo
= self
.PlatformFile
.Validate(".dsc", False)
930 EdkLogger
.error("build", ErrorCode
, ExtraData
=ErrorInfo
)
931 if self
.BuildTargetList
:
932 GlobalData
.gGlobalDefines
['TARGET'] = self
.BuildTargetList
[0]
934 GlobalData
.gGlobalDefines
['ARCH'] = self
.ArchList
[0]
935 if self
.ToolChainList
:
936 GlobalData
.gGlobalDefines
['TOOLCHAIN'] = self
.ToolChainList
[0]
937 GlobalData
.gGlobalDefines
['TOOL_CHAIN_TAG'] = self
.ToolChainList
[0]
938 if self
.ToolChainFamily
:
939 GlobalData
.gGlobalDefines
['FAMILY'] = self
.ToolChainFamily
[0]
940 if 'PREBUILD' in GlobalData
.gCommandLineDefines
:
941 self
.Prebuild
= GlobalData
.gCommandLineDefines
.get('PREBUILD')
944 Platform
= self
.Db
.MapPlatform(str(self
.PlatformFile
))
945 self
.Prebuild
= str(Platform
.Prebuild
)
949 # Evaluate all arguments and convert arguments that are WORKSPACE
950 # relative paths to absolute paths. Filter arguments that look like
951 # flags or do not follow the file/dir naming rules to avoid false
952 # positives on this conversion.
954 for Arg
in self
.Prebuild
.split():
956 # Do not modify Arg if it looks like a flag or an absolute file path
958 if Arg
.startswith('-') or os
.path
.isabs(Arg
):
959 PrebuildList
.append(Arg
)
962 # Do not modify Arg if it does not look like a Workspace relative
963 # path that starts with a valid package directory name
965 if not Arg
[0].isalpha() or os
.path
.dirname(Arg
) == '':
966 PrebuildList
.append(Arg
)
969 # If Arg looks like a WORKSPACE relative path, then convert to an
970 # absolute path and check to see if the file exists.
972 Temp
= mws
.join(self
.WorkspaceDir
, Arg
)
973 if os
.path
.isfile(Temp
):
975 PrebuildList
.append(Arg
)
976 self
.Prebuild
= ' '.join(PrebuildList
)
977 self
.Prebuild
+= self
.PassCommandOption(self
.BuildTargetList
, self
.ArchList
, self
.ToolChainList
, self
.PlatformFile
, self
.Target
)
979 def InitPostBuild(self
):
980 if 'POSTBUILD' in GlobalData
.gCommandLineDefines
:
981 self
.Postbuild
= GlobalData
.gCommandLineDefines
.get('POSTBUILD')
983 Platform
= self
.Db
.MapPlatform(str(self
.PlatformFile
))
984 self
.Postbuild
= str(Platform
.Postbuild
)
988 # Evaluate all arguments and convert arguments that are WORKSPACE
989 # relative paths to absolute paths. Filter arguments that look like
990 # flags or do not follow the file/dir naming rules to avoid false
991 # positives on this conversion.
993 for Arg
in self
.Postbuild
.split():
995 # Do not modify Arg if it looks like a flag or an absolute file path
997 if Arg
.startswith('-') or os
.path
.isabs(Arg
):
998 PostbuildList
.append(Arg
)
1001 # Do not modify Arg if it does not look like a Workspace relative
1002 # path that starts with a valid package directory name
1004 if not Arg
[0].isalpha() or os
.path
.dirname(Arg
) == '':
1005 PostbuildList
.append(Arg
)
1008 # If Arg looks like a WORKSPACE relative path, then convert to an
1009 # absolute path and check to see if the file exists.
1011 Temp
= mws
.join(self
.WorkspaceDir
, Arg
)
1012 if os
.path
.isfile(Temp
):
1014 PostbuildList
.append(Arg
)
1015 self
.Postbuild
= ' '.join(PostbuildList
)
1016 self
.Postbuild
+= self
.PassCommandOption(self
.BuildTargetList
, self
.ArchList
, self
.ToolChainList
, self
.PlatformFile
, self
.Target
)
1018 def PassCommandOption(self
, BuildTarget
, TargetArch
, ToolChain
, PlatformFile
, Target
):
1020 if GlobalData
.gCommand
and isinstance(GlobalData
.gCommand
, list):
1021 BuildStr
+= ' ' + ' '.join(GlobalData
.gCommand
)
1024 ToolChainFlag
= False
1025 PlatformFileFlag
= False
1027 if GlobalData
.gOptions
and not GlobalData
.gOptions
.BuildTarget
:
1029 if GlobalData
.gOptions
and not GlobalData
.gOptions
.TargetArch
:
1031 if GlobalData
.gOptions
and not GlobalData
.gOptions
.ToolChain
:
1032 ToolChainFlag
= True
1033 if GlobalData
.gOptions
and not GlobalData
.gOptions
.PlatformFile
:
1034 PlatformFileFlag
= True
1036 if TargetFlag
and BuildTarget
:
1037 if isinstance(BuildTarget
, list) or isinstance(BuildTarget
, tuple):
1038 BuildStr
+= ' -b ' + ' -b '.join(BuildTarget
)
1039 elif isinstance(BuildTarget
, str):
1040 BuildStr
+= ' -b ' + BuildTarget
1041 if ArchFlag
and TargetArch
:
1042 if isinstance(TargetArch
, list) or isinstance(TargetArch
, tuple):
1043 BuildStr
+= ' -a ' + ' -a '.join(TargetArch
)
1044 elif isinstance(TargetArch
, str):
1045 BuildStr
+= ' -a ' + TargetArch
1046 if ToolChainFlag
and ToolChain
:
1047 if isinstance(ToolChain
, list) or isinstance(ToolChain
, tuple):
1048 BuildStr
+= ' -t ' + ' -t '.join(ToolChain
)
1049 elif isinstance(ToolChain
, str):
1050 BuildStr
+= ' -t ' + ToolChain
1051 if PlatformFileFlag
and PlatformFile
:
1052 if isinstance(PlatformFile
, list) or isinstance(PlatformFile
, tuple):
1053 BuildStr
+= ' -p ' + ' -p '.join(PlatformFile
)
1054 elif isinstance(PlatformFile
, str):
1055 BuildStr
+= ' -p' + PlatformFile
1056 BuildStr
+= ' --conf=' + GlobalData
.gConfDirectory
1058 BuildStr
+= ' ' + Target
1062 def LaunchPrebuild(self
):
1064 EdkLogger
.info("\n- Prebuild Start -\n")
1065 self
.LaunchPrebuildFlag
= True
1067 # The purpose of .PrebuildEnv file is capture environment variable settings set by the prebuild script
1068 # and preserve them for the rest of the main build step, because the child process environment will
1069 # evaporate as soon as it exits, we cannot get it in build step.
1071 PrebuildEnvFile
= os
.path
.join(GlobalData
.gConfDirectory
, '.cache', '.PrebuildEnv')
1072 if os
.path
.isfile(PrebuildEnvFile
):
1073 os
.remove(PrebuildEnvFile
)
1074 if os
.path
.isfile(self
.PlatformBuildPath
):
1075 os
.remove(self
.PlatformBuildPath
)
1076 if sys
.platform
== "win32":
1077 args
= ' && '.join((self
.Prebuild
, 'set > ' + PrebuildEnvFile
))
1078 Process
= Popen(args
, stdout
=PIPE
, stderr
=PIPE
, shell
=True)
1080 args
= ' && '.join((self
.Prebuild
, 'env > ' + PrebuildEnvFile
))
1081 Process
= Popen(args
, stdout
=PIPE
, stderr
=PIPE
, shell
=True)
1083 # launch two threads to read the STDOUT and STDERR
1084 EndOfProcedure
= Event()
1085 EndOfProcedure
.clear()
1087 StdOutThread
= Thread(target
=ReadMessage
, args
=(Process
.stdout
, EdkLogger
.info
, EndOfProcedure
))
1088 StdOutThread
.setName("STDOUT-Redirector")
1089 StdOutThread
.setDaemon(False)
1090 StdOutThread
.start()
1093 StdErrThread
= Thread(target
=ReadMessage
, args
=(Process
.stderr
, EdkLogger
.quiet
, EndOfProcedure
))
1094 StdErrThread
.setName("STDERR-Redirector")
1095 StdErrThread
.setDaemon(False)
1096 StdErrThread
.start()
1097 # waiting for program exit
1104 if Process
.returncode
!= 0 :
1105 EdkLogger
.error("Prebuild", PREBUILD_ERROR
, 'Prebuild process is not success!')
1107 if os
.path
.exists(PrebuildEnvFile
):
1108 f
= open(PrebuildEnvFile
)
1109 envs
= f
.readlines()
1111 envs
= [l
.split("=", 1) for l
in envs
]
1112 envs
= [[I
.strip() for I
in item
] for item
in envs
if len(item
) == 2]
1113 os
.environ
.update(dict(envs
))
1114 EdkLogger
.info("\n- Prebuild Done -\n")
1116 def LaunchPostbuild(self
):
1118 EdkLogger
.info("\n- Postbuild Start -\n")
1119 if sys
.platform
== "win32":
1120 Process
= Popen(self
.Postbuild
, stdout
=PIPE
, stderr
=PIPE
, shell
=True)
1122 Process
= Popen(self
.Postbuild
, stdout
=PIPE
, stderr
=PIPE
, shell
=True)
1123 # launch two threads to read the STDOUT and STDERR
1124 EndOfProcedure
= Event()
1125 EndOfProcedure
.clear()
1127 StdOutThread
= Thread(target
=ReadMessage
, args
=(Process
.stdout
, EdkLogger
.info
, EndOfProcedure
))
1128 StdOutThread
.setName("STDOUT-Redirector")
1129 StdOutThread
.setDaemon(False)
1130 StdOutThread
.start()
1133 StdErrThread
= Thread(target
=ReadMessage
, args
=(Process
.stderr
, EdkLogger
.quiet
, EndOfProcedure
))
1134 StdErrThread
.setName("STDERR-Redirector")
1135 StdErrThread
.setDaemon(False)
1136 StdErrThread
.start()
1137 # waiting for program exit
1144 if Process
.returncode
!= 0 :
1145 EdkLogger
.error("Postbuild", POSTBUILD_ERROR
, 'Postbuild process is not success!')
1146 EdkLogger
.info("\n- Postbuild Done -\n")
1147 ## Build a module or platform
1149 # Create autogen code and makefile for a module or platform, and the launch
1150 # "make" command to build it
1152 # @param Target The target of build command
1153 # @param Platform The platform file
1154 # @param Module The module file
1155 # @param BuildTarget The name of build target, one of "DEBUG", "RELEASE"
1156 # @param ToolChain The name of toolchain to build
1157 # @param Arch The arch of the module/platform
1158 # @param CreateDepModuleCodeFile Flag used to indicate creating code
1159 # for dependent modules/Libraries
1160 # @param CreateDepModuleMakeFile Flag used to indicate creating makefile
1161 # for dependent modules/Libraries
1163 def _BuildPa(self
, Target
, AutoGenObject
, CreateDepsCodeFile
=True, CreateDepsMakeFile
=True, BuildModule
=False, FfsCommand
={}):
1164 if AutoGenObject
is None:
1167 # skip file generation for cleanxxx targets, run and fds target
1168 if Target
not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1169 # for target which must generate AutoGen code and makefile
1170 if not self
.SkipAutoGen
or Target
== 'genc':
1171 self
.Progress
.Start("Generating code")
1172 AutoGenObject
.CreateCodeFile(CreateDepsCodeFile
)
1173 self
.Progress
.Stop("done!")
1174 if Target
== "genc":
1177 if not self
.SkipAutoGen
or Target
== 'genmake':
1178 self
.Progress
.Start("Generating makefile")
1179 AutoGenObject
.CreateMakeFile(CreateDepsMakeFile
, FfsCommand
)
1180 self
.Progress
.Stop("done!")
1181 if Target
== "genmake":
1184 # always recreate top/platform makefile when clean, just in case of inconsistency
1185 AutoGenObject
.CreateCodeFile(False)
1186 AutoGenObject
.CreateMakeFile(False)
1188 if EdkLogger
.GetLevel() == EdkLogger
.QUIET
:
1189 EdkLogger
.quiet("Building ... %s" % repr(AutoGenObject
))
1191 BuildCommand
= AutoGenObject
.BuildCommand
1192 if BuildCommand
is None or len(BuildCommand
) == 0:
1193 EdkLogger
.error("build", OPTION_MISSING
,
1194 "No build command found for this module. "
1195 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %
1196 (AutoGenObject
.BuildTarget
, AutoGenObject
.ToolChain
, AutoGenObject
.Arch
),
1197 ExtraData
=str(AutoGenObject
))
1199 makefile
= GenMake
.BuildFile(AutoGenObject
)._FILE
_NAME
_[GenMake
.gMakeType
]
1203 RunDir
= os
.path
.normpath(os
.path
.join(AutoGenObject
.BuildDir
, GlobalData
.gGlobalDefines
['ARCH']))
1204 Command
= '.\SecMain'
1206 LaunchCommand(Command
, RunDir
)
1211 BuildCommand
= BuildCommand
+ [Target
]
1212 LaunchCommand(BuildCommand
, AutoGenObject
.MakeFileDir
)
1213 self
.CreateAsBuiltInf()
1217 if Target
== 'libraries':
1218 for Lib
in AutoGenObject
.LibraryBuildDirectoryList
:
1219 NewBuildCommand
= BuildCommand
+ ['-f', os
.path
.normpath(os
.path
.join(Lib
, makefile
)), 'pbuild']
1220 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1224 if Target
== 'modules':
1225 for Lib
in AutoGenObject
.LibraryBuildDirectoryList
:
1226 NewBuildCommand
= BuildCommand
+ ['-f', os
.path
.normpath(os
.path
.join(Lib
, makefile
)), 'pbuild']
1227 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1228 for Mod
in AutoGenObject
.ModuleBuildDirectoryList
:
1229 NewBuildCommand
= BuildCommand
+ ['-f', os
.path
.normpath(os
.path
.join(Mod
, makefile
)), 'pbuild']
1230 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1231 self
.CreateAsBuiltInf()
1235 if Target
== 'cleanlib':
1236 for Lib
in AutoGenObject
.LibraryBuildDirectoryList
:
1237 LibMakefile
= os
.path
.normpath(os
.path
.join(Lib
, makefile
))
1238 if os
.path
.exists(LibMakefile
):
1239 NewBuildCommand
= BuildCommand
+ ['-f', LibMakefile
, 'cleanall']
1240 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1244 if Target
== 'clean':
1245 for Mod
in AutoGenObject
.ModuleBuildDirectoryList
:
1246 ModMakefile
= os
.path
.normpath(os
.path
.join(Mod
, makefile
))
1247 if os
.path
.exists(ModMakefile
):
1248 NewBuildCommand
= BuildCommand
+ ['-f', ModMakefile
, 'cleanall']
1249 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1250 for Lib
in AutoGenObject
.LibraryBuildDirectoryList
:
1251 LibMakefile
= os
.path
.normpath(os
.path
.join(Lib
, makefile
))
1252 if os
.path
.exists(LibMakefile
):
1253 NewBuildCommand
= BuildCommand
+ ['-f', LibMakefile
, 'cleanall']
1254 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1258 if Target
== 'cleanall':
1260 #os.rmdir(AutoGenObject.BuildDir)
1261 RemoveDirectory(AutoGenObject
.BuildDir
, True)
1262 except WindowsError as X
:
1263 EdkLogger
.error("build", FILE_DELETE_FAILURE
, ExtraData
=str(X
))
1266 ## Build a module or platform
1268 # Create autogen code and makefile for a module or platform, and the launch
1269 # "make" command to build it
1271 # @param Target The target of build command
1272 # @param Platform The platform file
1273 # @param Module The module file
1274 # @param BuildTarget The name of build target, one of "DEBUG", "RELEASE"
1275 # @param ToolChain The name of toolchain to build
1276 # @param Arch The arch of the module/platform
1277 # @param CreateDepModuleCodeFile Flag used to indicate creating code
1278 # for dependent modules/Libraries
1279 # @param CreateDepModuleMakeFile Flag used to indicate creating makefile
1280 # for dependent modules/Libraries
1282 def _Build(self
, Target
, AutoGenObject
, CreateDepsCodeFile
=True, CreateDepsMakeFile
=True, BuildModule
=False):
1283 if AutoGenObject
is None:
1286 # skip file generation for cleanxxx targets, run and fds target
1287 if Target
not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1288 # for target which must generate AutoGen code and makefile
1289 if not self
.SkipAutoGen
or Target
== 'genc':
1290 self
.Progress
.Start("Generating code")
1291 AutoGenObject
.CreateCodeFile(CreateDepsCodeFile
)
1292 self
.Progress
.Stop("done!")
1293 if Target
== "genc":
1296 if not self
.SkipAutoGen
or Target
== 'genmake':
1297 self
.Progress
.Start("Generating makefile")
1298 AutoGenObject
.CreateMakeFile(CreateDepsMakeFile
)
1299 #AutoGenObject.CreateAsBuiltInf()
1300 self
.Progress
.Stop("done!")
1301 if Target
== "genmake":
1304 # always recreate top/platform makefile when clean, just in case of inconsistency
1305 AutoGenObject
.CreateCodeFile(False)
1306 AutoGenObject
.CreateMakeFile(False)
1308 if EdkLogger
.GetLevel() == EdkLogger
.QUIET
:
1309 EdkLogger
.quiet("Building ... %s" % repr(AutoGenObject
))
1311 BuildCommand
= AutoGenObject
.BuildCommand
1312 if BuildCommand
is None or len(BuildCommand
) == 0:
1313 EdkLogger
.error("build", OPTION_MISSING
,
1314 "No build command found for this module. "
1315 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %
1316 (AutoGenObject
.BuildTarget
, AutoGenObject
.ToolChain
, AutoGenObject
.Arch
),
1317 ExtraData
=str(AutoGenObject
))
1322 BuildCommand
= BuildCommand
+ [Target
]
1323 AutoGenObject
.BuildTime
= LaunchCommand(BuildCommand
, AutoGenObject
.MakeFileDir
)
1324 self
.CreateAsBuiltInf()
1329 if GenFdsApi(AutoGenObject
.GenFdsCommandDict
, self
.Db
):
1330 EdkLogger
.error("build", COMMAND_FAILURE
)
1335 RunDir
= os
.path
.normpath(os
.path
.join(AutoGenObject
.BuildDir
, GlobalData
.gGlobalDefines
['ARCH']))
1336 Command
= '.\SecMain'
1338 LaunchCommand(Command
, RunDir
)
1342 if Target
== 'libraries':
1349 if Target
== 'cleanall':
1351 #os.rmdir(AutoGenObject.BuildDir)
1352 RemoveDirectory(AutoGenObject
.BuildDir
, True)
1353 except WindowsError as X
:
1354 EdkLogger
.error("build", FILE_DELETE_FAILURE
, ExtraData
=str(X
))
1357 ## Rebase module image and Get function address for the input module list.
1359 def _RebaseModule (self
, MapBuffer
, BaseAddress
, ModuleList
, AddrIsOffset
= True, ModeIsSmm
= False):
1361 AddrIsOffset
= False
1362 for InfFile
in ModuleList
:
1363 sys
.stdout
.write (".")
1365 ModuleInfo
= ModuleList
[InfFile
]
1366 ModuleName
= ModuleInfo
.BaseName
1367 ModuleOutputImage
= ModuleInfo
.Image
.FileName
1368 ModuleDebugImage
= os
.path
.join(ModuleInfo
.DebugDir
, ModuleInfo
.BaseName
+ '.efi')
1369 ## for SMM module in SMRAM, the SMRAM will be allocated from base to top.
1371 BaseAddress
= BaseAddress
- ModuleInfo
.Image
.Size
1373 # Update Image to new BaseAddress by GenFw tool
1375 LaunchCommand(["GenFw", "--rebase", str(BaseAddress
), "-r", ModuleOutputImage
], ModuleInfo
.OutputDir
)
1376 LaunchCommand(["GenFw", "--rebase", str(BaseAddress
), "-r", ModuleDebugImage
], ModuleInfo
.DebugDir
)
1379 # Set new address to the section header only for SMM driver.
1381 LaunchCommand(["GenFw", "--address", str(BaseAddress
), "-r", ModuleOutputImage
], ModuleInfo
.OutputDir
)
1382 LaunchCommand(["GenFw", "--address", str(BaseAddress
), "-r", ModuleDebugImage
], ModuleInfo
.DebugDir
)
1384 # Collect function address from Map file
1386 ImageMapTable
= ModuleOutputImage
.replace('.efi', '.map')
1388 if os
.path
.exists(ImageMapTable
):
1389 OrigImageBaseAddress
= 0
1390 ImageMap
= open(ImageMapTable
, 'r')
1391 for LinStr
in ImageMap
:
1392 if len (LinStr
.strip()) == 0:
1395 # Get the preferred address set on link time.
1397 if LinStr
.find ('Preferred load address is') != -1:
1398 StrList
= LinStr
.split()
1399 OrigImageBaseAddress
= int (StrList
[len(StrList
) - 1], 16)
1401 StrList
= LinStr
.split()
1402 if len (StrList
) > 4:
1403 if StrList
[3] == 'f' or StrList
[3] == 'F':
1405 RelativeAddress
= int (StrList
[2], 16) - OrigImageBaseAddress
1406 FunctionList
.append ((Name
, RelativeAddress
))
1410 # Add general information.
1413 MapBuffer
.append('\n\n%s (Fixed SMRAM Offset, BaseAddress=0x%010X, EntryPoint=0x%010X)\n' % (ModuleName
, BaseAddress
, BaseAddress
+ ModuleInfo
.Image
.EntryPoint
))
1415 MapBuffer
.append('\n\n%s (Fixed Memory Offset, BaseAddress=-0x%010X, EntryPoint=-0x%010X)\n' % (ModuleName
, 0 - BaseAddress
, 0 - (BaseAddress
+ ModuleInfo
.Image
.EntryPoint
)))
1417 MapBuffer
.append('\n\n%s (Fixed Memory Address, BaseAddress=0x%010X, EntryPoint=0x%010X)\n' % (ModuleName
, BaseAddress
, BaseAddress
+ ModuleInfo
.Image
.EntryPoint
))
1419 # Add guid and general seciton section.
1421 TextSectionAddress
= 0
1422 DataSectionAddress
= 0
1423 for SectionHeader
in ModuleInfo
.Image
.SectionHeaderList
:
1424 if SectionHeader
[0] == '.text':
1425 TextSectionAddress
= SectionHeader
[1]
1426 elif SectionHeader
[0] in ['.data', '.sdata']:
1427 DataSectionAddress
= SectionHeader
[1]
1429 MapBuffer
.append('(GUID=%s, .textbaseaddress=-0x%010X, .databaseaddress=-0x%010X)\n' % (ModuleInfo
.Guid
, 0 - (BaseAddress
+ TextSectionAddress
), 0 - (BaseAddress
+ DataSectionAddress
)))
1431 MapBuffer
.append('(GUID=%s, .textbaseaddress=0x%010X, .databaseaddress=0x%010X)\n' % (ModuleInfo
.Guid
, BaseAddress
+ TextSectionAddress
, BaseAddress
+ DataSectionAddress
))
1433 # Add debug image full path.
1435 MapBuffer
.append('(IMAGE=%s)\n\n' % (ModuleDebugImage
))
1437 # Add function address
1439 for Function
in FunctionList
:
1441 MapBuffer
.append(' -0x%010X %s\n' % (0 - (BaseAddress
+ Function
[1]), Function
[0]))
1443 MapBuffer
.append(' 0x%010X %s\n' % (BaseAddress
+ Function
[1], Function
[0]))
1447 # for SMM module in SMRAM, the SMRAM will be allocated from base to top.
1450 BaseAddress
= BaseAddress
+ ModuleInfo
.Image
.Size
1452 ## Collect MAP information of all FVs
1454 def _CollectFvMapBuffer (self
, MapBuffer
, Wa
, ModuleList
):
1456 # First get the XIP base address for FV map file.
1457 GuidPattern
= re
.compile("[-a-fA-F0-9]+")
1458 GuidName
= re
.compile("\(GUID=[-a-fA-F0-9]+")
1459 for FvName
in Wa
.FdfProfile
.FvDict
:
1460 FvMapBuffer
= os
.path
.join(Wa
.FvDir
, FvName
+ '.Fv.map')
1461 if not os
.path
.exists(FvMapBuffer
):
1463 FvMap
= open(FvMapBuffer
, 'r')
1464 #skip FV size information
1470 MatchGuid
= GuidPattern
.match(Line
)
1471 if MatchGuid
is not None:
1473 # Replace GUID with module name
1475 GuidString
= MatchGuid
.group()
1476 if GuidString
.upper() in ModuleList
:
1477 Line
= Line
.replace(GuidString
, ModuleList
[GuidString
.upper()].Name
)
1478 MapBuffer
.append(Line
)
1480 # Add the debug image full path.
1482 MatchGuid
= GuidName
.match(Line
)
1483 if MatchGuid
is not None:
1484 GuidString
= MatchGuid
.group().split("=")[1]
1485 if GuidString
.upper() in ModuleList
:
1486 MapBuffer
.append('(IMAGE=%s)\n' % (os
.path
.join(ModuleList
[GuidString
.upper()].DebugDir
, ModuleList
[GuidString
.upper()].Name
+ '.efi')))
1490 ## Collect MAP information of all modules
1492 def _CollectModuleMapBuffer (self
, MapBuffer
, ModuleList
):
1493 sys
.stdout
.write ("Generate Load Module At Fix Address Map")
1495 PatchEfiImageList
= []
1503 # reserve 4K size in SMRAM to make SMM module address not from 0.
1505 for ModuleGuid
in ModuleList
:
1506 Module
= ModuleList
[ModuleGuid
]
1507 GlobalData
.gProcessingFile
= "%s [%s, %s, %s]" % (Module
.MetaFile
, Module
.Arch
, Module
.ToolChain
, Module
.BuildTarget
)
1509 OutputImageFile
= ''
1510 for ResultFile
in Module
.CodaTargetList
:
1511 if str(ResultFile
.Target
).endswith('.efi'):
1513 # module list for PEI, DXE, RUNTIME and SMM
1515 OutputImageFile
= os
.path
.join(Module
.OutputDir
, Module
.Name
+ '.efi')
1516 ImageClass
= PeImageClass (OutputImageFile
)
1517 if not ImageClass
.IsValid
:
1518 EdkLogger
.error("build", FILE_PARSE_FAILURE
, ExtraData
=ImageClass
.ErrorInfo
)
1519 ImageInfo
= PeImageInfo(Module
.Name
, Module
.Guid
, Module
.Arch
, Module
.OutputDir
, Module
.DebugDir
, ImageClass
)
1520 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
]:
1521 PeiModuleList
[Module
.MetaFile
] = ImageInfo
1522 PeiSize
+= ImageInfo
.Image
.Size
1523 elif Module
.ModuleType
in [EDK_COMPONENT_TYPE_BS_DRIVER
, SUP_MODULE_DXE_DRIVER
, SUP_MODULE_UEFI_DRIVER
]:
1524 BtModuleList
[Module
.MetaFile
] = ImageInfo
1525 BtSize
+= ImageInfo
.Image
.Size
1526 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
]:
1527 RtModuleList
[Module
.MetaFile
] = ImageInfo
1528 RtSize
+= ImageInfo
.Image
.Size
1529 elif Module
.ModuleType
in [SUP_MODULE_SMM_CORE
, SUP_MODULE_DXE_SMM_DRIVER
, SUP_MODULE_MM_STANDALONE
, SUP_MODULE_MM_CORE_STANDALONE
]:
1530 SmmModuleList
[Module
.MetaFile
] = ImageInfo
1531 SmmSize
+= ImageInfo
.Image
.Size
1532 if Module
.ModuleType
== SUP_MODULE_DXE_SMM_DRIVER
:
1533 PiSpecVersion
= Module
.Module
.Specification
.get('PI_SPECIFICATION_VERSION', '0x00000000')
1534 # for PI specification < PI1.1, DXE_SMM_DRIVER also runs as BOOT time driver.
1535 if int(PiSpecVersion
, 16) < 0x0001000A:
1536 BtModuleList
[Module
.MetaFile
] = ImageInfo
1537 BtSize
+= ImageInfo
.Image
.Size
1540 # EFI image is final target.
1541 # Check EFI image contains patchable FixAddress related PCDs.
1543 if OutputImageFile
!= '':
1544 ModuleIsPatch
= False
1545 for Pcd
in Module
.ModulePcdList
:
1546 if Pcd
.Type
== TAB_PCDS_PATCHABLE_IN_MODULE
and Pcd
.TokenCName
in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SET
:
1547 ModuleIsPatch
= True
1549 if not ModuleIsPatch
:
1550 for Pcd
in Module
.LibraryPcdList
:
1551 if Pcd
.Type
== TAB_PCDS_PATCHABLE_IN_MODULE
and Pcd
.TokenCName
in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SET
:
1552 ModuleIsPatch
= True
1555 if not ModuleIsPatch
:
1558 # Module includes the patchable load fix address PCDs.
1559 # It will be fixed up later.
1561 PatchEfiImageList
.append (OutputImageFile
)
1564 # Get Top Memory address
1566 ReservedRuntimeMemorySize
= 0
1567 TopMemoryAddress
= 0
1568 if self
.LoadFixAddress
== 0xFFFFFFFFFFFFFFFF:
1569 TopMemoryAddress
= 0
1571 TopMemoryAddress
= self
.LoadFixAddress
1572 if TopMemoryAddress
< RtSize
+ BtSize
+ PeiSize
:
1573 EdkLogger
.error("build", PARAMETER_INVALID
, "FIX_LOAD_TOP_MEMORY_ADDRESS is too low to load driver")
1576 # Patch FixAddress related PCDs into EFI image
1578 for EfiImage
in PatchEfiImageList
:
1579 EfiImageMap
= EfiImage
.replace('.efi', '.map')
1580 if not os
.path
.exists(EfiImageMap
):
1583 # Get PCD offset in EFI image by GenPatchPcdTable function
1585 PcdTable
= parsePcdInfoFromMapFile(EfiImageMap
, EfiImage
)
1587 # Patch real PCD value by PatchPcdValue tool
1589 for PcdInfo
in PcdTable
:
1591 if PcdInfo
[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE
:
1592 ReturnValue
, ErrorInfo
= PatchBinaryFile (EfiImage
, PcdInfo
[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE_DATA_TYPE
, str (PeiSize
// 0x1000))
1593 elif PcdInfo
[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE
:
1594 ReturnValue
, ErrorInfo
= PatchBinaryFile (EfiImage
, PcdInfo
[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE_DATA_TYPE
, str (BtSize
// 0x1000))
1595 elif PcdInfo
[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE
:
1596 ReturnValue
, ErrorInfo
= PatchBinaryFile (EfiImage
, PcdInfo
[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE_DATA_TYPE
, str (RtSize
// 0x1000))
1597 elif PcdInfo
[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE
and len (SmmModuleList
) > 0:
1598 ReturnValue
, ErrorInfo
= PatchBinaryFile (EfiImage
, PcdInfo
[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE_DATA_TYPE
, str (SmmSize
// 0x1000))
1599 if ReturnValue
!= 0:
1600 EdkLogger
.error("build", PARAMETER_INVALID
, "Patch PCD value failed", ExtraData
=ErrorInfo
)
1602 MapBuffer
.append('PEI_CODE_PAGE_NUMBER = 0x%x\n' % (PeiSize
// 0x1000))
1603 MapBuffer
.append('BOOT_CODE_PAGE_NUMBER = 0x%x\n' % (BtSize
// 0x1000))
1604 MapBuffer
.append('RUNTIME_CODE_PAGE_NUMBER = 0x%x\n' % (RtSize
// 0x1000))
1605 if len (SmmModuleList
) > 0:
1606 MapBuffer
.append('SMM_CODE_PAGE_NUMBER = 0x%x\n' % (SmmSize
// 0x1000))
1608 PeiBaseAddr
= TopMemoryAddress
- RtSize
- BtSize
1609 BtBaseAddr
= TopMemoryAddress
- RtSize
1610 RtBaseAddr
= TopMemoryAddress
- ReservedRuntimeMemorySize
1612 self
._RebaseModule
(MapBuffer
, PeiBaseAddr
, PeiModuleList
, TopMemoryAddress
== 0)
1613 self
._RebaseModule
(MapBuffer
, BtBaseAddr
, BtModuleList
, TopMemoryAddress
== 0)
1614 self
._RebaseModule
(MapBuffer
, RtBaseAddr
, RtModuleList
, TopMemoryAddress
== 0)
1615 self
._RebaseModule
(MapBuffer
, 0x1000, SmmModuleList
, AddrIsOffset
=False, ModeIsSmm
=True)
1616 MapBuffer
.append('\n\n')
1617 sys
.stdout
.write ("\n")
1620 ## Save platform Map file
1622 def _SaveMapFile (self
, MapBuffer
, Wa
):
1624 # Map file path is got.
1626 MapFilePath
= os
.path
.join(Wa
.BuildDir
, Wa
.Name
+ '.map')
1628 # Save address map into MAP file.
1630 SaveFileOnChange(MapFilePath
, ''.join(MapBuffer
), False)
1631 if self
.LoadFixAddress
!= 0:
1632 sys
.stdout
.write ("\nLoad Module At Fix Address Map file can be found at %s\n" % (MapFilePath
))
1635 ## Build active platform for different build targets and different tool chains
1637 def _BuildPlatform(self
):
1638 SaveFileOnChange(self
.PlatformBuildPath
, '# DO NOT EDIT \n# FILE auto-generated\n', False)
1639 for BuildTarget
in self
.BuildTargetList
:
1640 GlobalData
.gGlobalDefines
['TARGET'] = BuildTarget
1642 for ToolChain
in self
.ToolChainList
:
1643 GlobalData
.gGlobalDefines
['TOOLCHAIN'] = ToolChain
1644 GlobalData
.gGlobalDefines
['TOOL_CHAIN_TAG'] = ToolChain
1645 GlobalData
.gGlobalDefines
['FAMILY'] = self
.ToolChainFamily
[index
]
1647 Wa
= WorkspaceAutoGen(
1664 self
.Fdf
= Wa
.FdfFile
1665 self
.LoadFixAddress
= Wa
.Platform
.LoadFixAddress
1666 self
.BuildReport
.AddPlatformReport(Wa
)
1667 self
.Progress
.Stop("done!")
1669 # Add ffs build to makefile
1671 if GlobalData
.gEnableGenfdsMultiThread
and self
.Fdf
:
1672 CmdListDict
= self
._GenFfsCmd
()
1674 for Arch
in Wa
.ArchList
:
1675 GlobalData
.gGlobalDefines
['ARCH'] = Arch
1676 Pa
= PlatformAutoGen(Wa
, self
.PlatformFile
, BuildTarget
, ToolChain
, Arch
)
1677 for Module
in Pa
.Platform
.Modules
:
1678 # Get ModuleAutoGen object to generate C code file and makefile
1679 Ma
= ModuleAutoGen(Wa
, Module
, BuildTarget
, ToolChain
, Arch
, self
.PlatformFile
)
1682 self
.BuildModules
.append(Ma
)
1683 self
._BuildPa
(self
.Target
, Pa
, FfsCommand
=CmdListDict
)
1685 # Create MAP file when Load Fix Address is enabled.
1686 if self
.Target
in ["", "all", "fds"]:
1687 for Arch
in Wa
.ArchList
:
1688 GlobalData
.gGlobalDefines
['ARCH'] = Arch
1690 # Check whether the set fix address is above 4G for 32bit image.
1692 if (Arch
== 'IA32' or Arch
== 'ARM') and self
.LoadFixAddress
!= 0xFFFFFFFFFFFFFFFF and self
.LoadFixAddress
>= 0x100000000:
1693 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")
1698 for Pa
in Wa
.AutoGenObjectList
:
1699 for Ma
in Pa
.ModuleAutoGenList
:
1702 if not Ma
.IsLibrary
:
1703 ModuleList
[Ma
.Guid
.upper()] = Ma
1706 if self
.LoadFixAddress
!= 0:
1708 # Rebase module to the preferred memory address before GenFds
1710 self
._CollectModuleMapBuffer
(MapBuffer
, ModuleList
)
1713 # create FDS again for the updated EFI image
1715 self
._Build
("fds", Wa
)
1717 # Create MAP file for all platform FVs after GenFds.
1719 self
._CollectFvMapBuffer
(MapBuffer
, Wa
, ModuleList
)
1721 # Save MAP buffer into MAP file.
1723 self
._SaveMapFile
(MapBuffer
, Wa
)
1725 ## Build active module for different build targets, different tool chains and different archs
1727 def _BuildModule(self
):
1728 for BuildTarget
in self
.BuildTargetList
:
1729 GlobalData
.gGlobalDefines
['TARGET'] = BuildTarget
1731 for ToolChain
in self
.ToolChainList
:
1732 WorkspaceAutoGenTime
= time
.time()
1733 GlobalData
.gGlobalDefines
['TOOLCHAIN'] = ToolChain
1734 GlobalData
.gGlobalDefines
['TOOL_CHAIN_TAG'] = ToolChain
1735 GlobalData
.gGlobalDefines
['FAMILY'] = self
.ToolChainFamily
[index
]
1738 # module build needs platform build information, so get platform
1741 Wa
= WorkspaceAutoGen(
1759 self
.Fdf
= Wa
.FdfFile
1760 self
.LoadFixAddress
= Wa
.Platform
.LoadFixAddress
1761 Wa
.CreateMakeFile(False)
1762 # Add ffs build to makefile
1764 if GlobalData
.gEnableGenfdsMultiThread
and self
.Fdf
:
1765 CmdListDict
= self
._GenFfsCmd
()
1766 self
.Progress
.Stop("done!")
1768 ExitFlag
= threading
.Event()
1770 self
.AutoGenTime
+= int(round((time
.time() - WorkspaceAutoGenTime
)))
1771 for Arch
in Wa
.ArchList
:
1772 AutoGenStart
= time
.time()
1773 GlobalData
.gGlobalDefines
['ARCH'] = Arch
1774 Pa
= PlatformAutoGen(Wa
, self
.PlatformFile
, BuildTarget
, ToolChain
, Arch
)
1775 for Module
in Pa
.Platform
.Modules
:
1776 if self
.ModuleFile
.Dir
== Module
.Dir
and self
.ModuleFile
.Name
== Module
.Name
:
1777 Ma
= ModuleAutoGen(Wa
, Module
, BuildTarget
, ToolChain
, Arch
, self
.PlatformFile
)
1778 if Ma
is None: continue
1780 if Ma
.CanSkipbyHash():
1781 self
.HashSkipModules
.append(Ma
)
1783 # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'
1784 if self
.Target
not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1785 # for target which must generate AutoGen code and makefile
1786 if not self
.SkipAutoGen
or self
.Target
== 'genc':
1787 self
.Progress
.Start("Generating code")
1788 Ma
.CreateCodeFile(True)
1789 self
.Progress
.Stop("done!")
1790 if self
.Target
== "genc":
1792 if not self
.SkipAutoGen
or self
.Target
== 'genmake':
1793 self
.Progress
.Start("Generating makefile")
1794 if CmdListDict
and self
.Fdf
and (Module
.File
, Arch
) in CmdListDict
:
1795 Ma
.CreateMakeFile(True, CmdListDict
[Module
.File
, Arch
])
1796 del CmdListDict
[Module
.File
, Arch
]
1798 Ma
.CreateMakeFile(True)
1799 self
.Progress
.Stop("done!")
1800 if self
.Target
== "genmake":
1802 self
.BuildModules
.append(Ma
)
1803 self
.AutoGenTime
+= int(round((time
.time() - AutoGenStart
)))
1804 MakeStart
= time
.time()
1805 for Ma
in self
.BuildModules
:
1806 if not Ma
.IsBinaryModule
:
1807 Bt
= BuildTask
.New(ModuleMakeUnit(Ma
, self
.Target
))
1808 # Break build if any build thread has error
1809 if BuildTask
.HasError():
1810 # we need a full version of makefile for platform
1812 BuildTask
.WaitForComplete()
1813 Pa
.CreateMakeFile(False)
1814 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
1815 # Start task scheduler
1816 if not BuildTask
.IsOnGoing():
1817 BuildTask
.StartScheduler(self
.ThreadNumber
, ExitFlag
)
1819 # in case there's an interruption. we need a full version of makefile for platform
1820 Pa
.CreateMakeFile(False)
1821 if BuildTask
.HasError():
1822 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
1823 self
.MakeTime
+= int(round((time
.time() - MakeStart
)))
1825 MakeContiue
= time
.time()
1827 BuildTask
.WaitForComplete()
1828 self
.CreateAsBuiltInf()
1829 self
.MakeTime
+= int(round((time
.time() - MakeContiue
)))
1830 if BuildTask
.HasError():
1831 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
1833 self
.BuildReport
.AddPlatformReport(Wa
, MaList
)
1838 "Module for [%s] is not a component of active platform."\
1839 " Please make sure that the ARCH and inf file path are"\
1840 " given in the same as in [%s]" % \
1841 (', '.join(Wa
.ArchList
), self
.PlatformFile
),
1842 ExtraData
=self
.ModuleFile
1844 # Create MAP file when Load Fix Address is enabled.
1845 if self
.Target
== "fds" and self
.Fdf
:
1846 for Arch
in Wa
.ArchList
:
1848 # Check whether the set fix address is above 4G for 32bit image.
1850 if (Arch
== 'IA32' or Arch
== 'ARM') and self
.LoadFixAddress
!= 0xFFFFFFFFFFFFFFFF and self
.LoadFixAddress
>= 0x100000000:
1851 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")
1856 for Pa
in Wa
.AutoGenObjectList
:
1857 for Ma
in Pa
.ModuleAutoGenList
:
1860 if not Ma
.IsLibrary
:
1861 ModuleList
[Ma
.Guid
.upper()] = Ma
1864 if self
.LoadFixAddress
!= 0:
1866 # Rebase module to the preferred memory address before GenFds
1868 self
._CollectModuleMapBuffer
(MapBuffer
, ModuleList
)
1870 # create FDS again for the updated EFI image
1872 GenFdsStart
= time
.time()
1873 self
._Build
("fds", Wa
)
1874 self
.GenFdsTime
+= int(round((time
.time() - GenFdsStart
)))
1876 # Create MAP file for all platform FVs after GenFds.
1878 self
._CollectFvMapBuffer
(MapBuffer
, Wa
, ModuleList
)
1880 # Save MAP buffer into MAP file.
1882 self
._SaveMapFile
(MapBuffer
, Wa
)
1884 def _GenFfsCmd(self
):
1885 # convert dictionary of Cmd:(Inf,Arch)
1886 # to a new dictionary of (Inf,Arch):Cmd,Cmd,Cmd...
1887 CmdSetDict
= defaultdict(set)
1888 GenFfsDict
= GenFds
.GenFfsMakefile('', GlobalData
.gFdfParser
, self
, self
.ArchList
, GlobalData
)
1889 for Cmd
in GenFfsDict
:
1890 tmpInf
, tmpArch
= GenFfsDict
[Cmd
]
1891 CmdSetDict
[tmpInf
, tmpArch
].add(Cmd
)
1894 ## Build a platform in multi-thread mode
1896 def _MultiThreadBuildPlatform(self
):
1897 SaveFileOnChange(self
.PlatformBuildPath
, '# DO NOT EDIT \n# FILE auto-generated\n', False)
1898 for BuildTarget
in self
.BuildTargetList
:
1899 GlobalData
.gGlobalDefines
['TARGET'] = BuildTarget
1901 for ToolChain
in self
.ToolChainList
:
1902 WorkspaceAutoGenTime
= time
.time()
1903 GlobalData
.gGlobalDefines
['TOOLCHAIN'] = ToolChain
1904 GlobalData
.gGlobalDefines
['TOOL_CHAIN_TAG'] = ToolChain
1905 GlobalData
.gGlobalDefines
['FAMILY'] = self
.ToolChainFamily
[index
]
1907 Wa
= WorkspaceAutoGen(
1924 self
.Fdf
= Wa
.FdfFile
1925 self
.LoadFixAddress
= Wa
.Platform
.LoadFixAddress
1926 self
.BuildReport
.AddPlatformReport(Wa
)
1927 Wa
.CreateMakeFile(False)
1929 # Add ffs build to makefile
1931 if GlobalData
.gEnableGenfdsMultiThread
and self
.Fdf
:
1932 CmdListDict
= self
._GenFfsCmd
()
1934 # multi-thread exit flag
1935 ExitFlag
= threading
.Event()
1937 self
.AutoGenTime
+= int(round((time
.time() - WorkspaceAutoGenTime
)))
1938 for Arch
in Wa
.ArchList
:
1939 AutoGenStart
= time
.time()
1940 GlobalData
.gGlobalDefines
['ARCH'] = Arch
1941 Pa
= PlatformAutoGen(Wa
, self
.PlatformFile
, BuildTarget
, ToolChain
, Arch
)
1945 for Inf
in Pa
.Platform
.Modules
:
1946 ModuleList
.append(Inf
)
1947 # Add the INF only list in FDF
1948 if GlobalData
.gFdfParser
is not None:
1949 for InfName
in GlobalData
.gFdfParser
.Profile
.InfList
:
1950 Inf
= PathClass(NormPath(InfName
), self
.WorkspaceDir
, Arch
)
1951 if Inf
in Pa
.Platform
.Modules
:
1953 ModuleList
.append(Inf
)
1954 for Module
in ModuleList
:
1955 # Get ModuleAutoGen object to generate C code file and makefile
1956 Ma
= ModuleAutoGen(Wa
, Module
, BuildTarget
, ToolChain
, Arch
, self
.PlatformFile
)
1960 if Ma
.CanSkipbyHash():
1961 self
.HashSkipModules
.append(Ma
)
1964 # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'
1965 if self
.Target
not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1966 # for target which must generate AutoGen code and makefile
1967 if not self
.SkipAutoGen
or self
.Target
== 'genc':
1968 Ma
.CreateCodeFile(True)
1969 if self
.Target
== "genc":
1972 if not self
.SkipAutoGen
or self
.Target
== 'genmake':
1973 if CmdListDict
and self
.Fdf
and (Module
.File
, Arch
) in CmdListDict
:
1974 Ma
.CreateMakeFile(True, CmdListDict
[Module
.File
, Arch
])
1975 del CmdListDict
[Module
.File
, Arch
]
1977 Ma
.CreateMakeFile(True)
1978 if self
.Target
== "genmake":
1980 self
.BuildModules
.append(Ma
)
1981 self
.Progress
.Stop("done!")
1982 self
.AutoGenTime
+= int(round((time
.time() - AutoGenStart
)))
1983 MakeStart
= time
.time()
1984 for Ma
in self
.BuildModules
:
1985 # Generate build task for the module
1986 if not Ma
.IsBinaryModule
:
1987 Bt
= BuildTask
.New(ModuleMakeUnit(Ma
, self
.Target
))
1988 # Break build if any build thread has error
1989 if BuildTask
.HasError():
1990 # we need a full version of makefile for platform
1992 BuildTask
.WaitForComplete()
1993 Pa
.CreateMakeFile(False)
1994 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
1995 # Start task scheduler
1996 if not BuildTask
.IsOnGoing():
1997 BuildTask
.StartScheduler(self
.ThreadNumber
, ExitFlag
)
1999 # in case there's an interruption. we need a full version of makefile for platform
2000 Pa
.CreateMakeFile(False)
2001 if BuildTask
.HasError():
2002 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
2003 self
.MakeTime
+= int(round((time
.time() - MakeStart
)))
2005 MakeContiue
= time
.time()
2009 # All modules have been put in build tasks queue. Tell task scheduler
2010 # to exit if all tasks are completed
2013 BuildTask
.WaitForComplete()
2014 self
.CreateAsBuiltInf()
2015 self
.MakeTime
+= int(round((time
.time() - MakeContiue
)))
2017 # Check for build error, and raise exception if one
2018 # has been signaled.
2020 if BuildTask
.HasError():
2021 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
2023 # Create MAP file when Load Fix Address is enabled.
2024 if self
.Target
in ["", "all", "fds"]:
2025 for Arch
in Wa
.ArchList
:
2027 # Check whether the set fix address is above 4G for 32bit image.
2029 if (Arch
== 'IA32' or Arch
== 'ARM') and self
.LoadFixAddress
!= 0xFFFFFFFFFFFFFFFF and self
.LoadFixAddress
>= 0x100000000:
2030 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")
2035 for Pa
in Wa
.AutoGenObjectList
:
2036 for Ma
in Pa
.ModuleAutoGenList
:
2039 if not Ma
.IsLibrary
:
2040 ModuleList
[Ma
.Guid
.upper()] = Ma
2042 # Rebase module to the preferred memory address before GenFds
2045 if self
.LoadFixAddress
!= 0:
2046 self
._CollectModuleMapBuffer
(MapBuffer
, ModuleList
)
2050 # Generate FD image if there's a FDF file found
2052 GenFdsStart
= time
.time()
2053 if GenFdsApi(Wa
.GenFdsCommandDict
, self
.Db
):
2054 EdkLogger
.error("build", COMMAND_FAILURE
)
2057 # Create MAP file for all platform FVs after GenFds.
2059 self
._CollectFvMapBuffer
(MapBuffer
, Wa
, ModuleList
)
2060 self
.GenFdsTime
+= int(round((time
.time() - GenFdsStart
)))
2062 # Save MAP buffer into MAP file.
2064 self
._SaveMapFile
(MapBuffer
, Wa
)
2066 ## Generate GuidedSectionTools.txt in the FV directories.
2068 def CreateGuidedSectionToolsFile(self
):
2069 for BuildTarget
in self
.BuildTargetList
:
2070 for ToolChain
in self
.ToolChainList
:
2071 Wa
= WorkspaceAutoGen(
2088 if not os
.path
.exists(FvDir
):
2091 for Arch
in self
.ArchList
:
2092 # Build up the list of supported architectures for this build
2093 prefix
= '%s_%s_%s_' % (BuildTarget
, ToolChain
, Arch
)
2095 # Look through the tool definitions for GUIDed tools
2097 for (attrib
, value
) in self
.ToolDef
.ToolsDefTxtDictionary
.items():
2098 if attrib
.upper().endswith('_GUID'):
2099 split
= attrib
.split('_')
2100 thisPrefix
= '_'.join(split
[0:3]) + '_'
2101 if thisPrefix
== prefix
:
2102 guid
= self
.ToolDef
.ToolsDefTxtDictionary
[attrib
]
2105 path
= '_'.join(split
[0:4]) + '_PATH'
2106 path
= self
.ToolDef
.ToolsDefTxtDictionary
[path
]
2107 path
= self
.GetFullPathOfTool(path
)
2108 guidAttribs
.append((guid
, toolName
, path
))
2110 # Write out GuidedSecTools.txt
2111 toolsFile
= os
.path
.join(FvDir
, 'GuidedSectionTools.txt')
2112 toolsFile
= open(toolsFile
, 'wt')
2113 for guidedSectionTool
in guidAttribs
:
2114 print(' '.join(guidedSectionTool
), file=toolsFile
)
2117 ## Returns the full path of the tool.
2119 def GetFullPathOfTool (self
, tool
):
2120 if os
.path
.exists(tool
):
2121 return os
.path
.realpath(tool
)
2123 # We need to search for the tool using the
2124 # PATH environment variable.
2125 for dirInPath
in os
.environ
['PATH'].split(os
.pathsep
):
2126 foundPath
= os
.path
.join(dirInPath
, tool
)
2127 if os
.path
.exists(foundPath
):
2128 return os
.path
.realpath(foundPath
)
2130 # If the tool was not found in the path then we just return
2134 ## Launch the module or platform build
2137 if not self
.ModuleFile
:
2138 if not self
.SpawnMode
or self
.Target
not in ["", "all"]:
2139 self
.SpawnMode
= False
2140 self
._BuildPlatform
()
2142 self
._MultiThreadBuildPlatform
()
2143 self
.CreateGuidedSectionToolsFile()
2145 self
.SpawnMode
= False
2148 if self
.Target
== 'cleanall':
2149 RemoveDirectory(os
.path
.dirname(GlobalData
.gDatabasePath
), True)
2151 def CreateAsBuiltInf(self
):
2152 for Module
in self
.BuildModules
:
2153 Module
.CreateAsBuiltInf()
2154 for Module
in self
.HashSkipModules
:
2155 Module
.CreateAsBuiltInf(True)
2156 self
.BuildModules
= []
2157 self
.HashSkipModules
= []
2158 ## Do some clean-up works when error occurred
2159 def Relinquish(self
):
2160 OldLogLevel
= EdkLogger
.GetLevel()
2161 EdkLogger
.SetLevel(EdkLogger
.ERROR
)
2162 Utils
.Progressor
.Abort()
2163 if self
.SpawnMode
== True:
2165 EdkLogger
.SetLevel(OldLogLevel
)
2167 def ParseDefines(DefineList
=[]):
2169 if DefineList
is not None:
2170 for Define
in DefineList
:
2171 DefineTokenList
= Define
.split("=", 1)
2172 if not GlobalData
.gMacroNamePattern
.match(DefineTokenList
[0]):
2173 EdkLogger
.error('build', FORMAT_INVALID
,
2174 "The macro name must be in the pattern [A-Z][A-Z0-9_]*",
2175 ExtraData
=DefineTokenList
[0])
2177 if len(DefineTokenList
) == 1:
2178 DefineDict
[DefineTokenList
[0]] = "TRUE"
2180 DefineDict
[DefineTokenList
[0]] = DefineTokenList
[1].strip()
2184 def SingleCheckCallback(option
, opt_str
, value
, parser
):
2185 if option
not in gParamCheck
:
2186 setattr(parser
.values
, option
.dest
, value
)
2187 gParamCheck
.append(option
)
2189 parser
.error("Option %s only allows one instance in command line!" % option
)
2191 def LogBuildTime(Time
):
2194 TimeDur
= time
.gmtime(Time
)
2195 if TimeDur
.tm_yday
> 1:
2196 TimeDurStr
= time
.strftime("%H:%M:%S", TimeDur
) + ", %d day(s)" % (TimeDur
.tm_yday
- 1)
2198 TimeDurStr
= time
.strftime("%H:%M:%S", TimeDur
)
2203 ## Parse command line options
2205 # Using standard Python module optparse to parse command line option of this tool.
2207 # @retval Opt A optparse.Values object containing the parsed options
2208 # @retval Args Target of build command
2210 def MyOptionParser():
2211 Parser
= OptionParser(description
=__copyright__
, version
=__version__
, prog
="build.exe", usage
="%prog [options] [all|fds|genc|genmake|clean|cleanall|cleanlib|modules|libraries|run]")
2212 Parser
.add_option("-a", "--arch", action
="append", type="choice", choices
=['IA32', 'X64', 'EBC', 'ARM', 'AARCH64'], dest
="TargetArch",
2213 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.")
2214 Parser
.add_option("-p", "--platform", action
="callback", type="string", dest
="PlatformFile", callback
=SingleCheckCallback
,
2215 help="Build the platform specified by the DSC file name argument, overriding target.txt's ACTIVE_PLATFORM definition.")
2216 Parser
.add_option("-m", "--module", action
="callback", type="string", dest
="ModuleFile", callback
=SingleCheckCallback
,
2217 help="Build the module specified by the INF file name argument.")
2218 Parser
.add_option("-b", "--buildtarget", type="string", dest
="BuildTarget", help="Using the TARGET to build the platform, overriding target.txt's TARGET definition.",
2220 Parser
.add_option("-t", "--tagname", action
="append", type="string", dest
="ToolChain",
2221 help="Using the Tool Chain Tagname to build the platform, overriding target.txt's TOOL_CHAIN_TAG definition.")
2222 Parser
.add_option("-x", "--sku-id", action
="callback", type="string", dest
="SkuId", callback
=SingleCheckCallback
,
2223 help="Using this name of SKU ID to build the platform, overriding SKUID_IDENTIFIER in DSC file.")
2225 Parser
.add_option("-n", action
="callback", type="int", dest
="ThreadNumber", callback
=SingleCheckCallback
,
2226 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 "\
2227 "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.")
2229 Parser
.add_option("-f", "--fdf", action
="callback", type="string", dest
="FdfFile", callback
=SingleCheckCallback
,
2230 help="The name of the FDF file to use, which overrides the setting in the DSC file.")
2231 Parser
.add_option("-r", "--rom-image", action
="append", type="string", dest
="RomImage", default
=[],
2232 help="The name of FD to be generated. The name must be from [FD] section in FDF file.")
2233 Parser
.add_option("-i", "--fv-image", action
="append", type="string", dest
="FvImage", default
=[],
2234 help="The name of FV to be generated. The name must be from [FV] section in FDF file.")
2235 Parser
.add_option("-C", "--capsule-image", action
="append", type="string", dest
="CapName", default
=[],
2236 help="The name of Capsule to be generated. The name must be from [Capsule] section in FDF file.")
2237 Parser
.add_option("-u", "--skip-autogen", action
="store_true", dest
="SkipAutoGen", help="Skip AutoGen step.")
2238 Parser
.add_option("-e", "--re-parse", action
="store_true", dest
="Reparse", help="Re-parse all meta-data files.")
2240 Parser
.add_option("-c", "--case-insensitive", action
="store_true", dest
="CaseInsensitive", default
=False, help="Don't check case of file name.")
2242 Parser
.add_option("-w", "--warning-as-error", action
="store_true", dest
="WarningAsError", help="Treat warning in tools as error.")
2243 Parser
.add_option("-j", "--log", action
="store", dest
="LogFile", help="Put log in specified file as well as on console.")
2245 Parser
.add_option("-s", "--silent", action
="store_true", type=None, dest
="SilentMode",
2246 help="Make use of silent mode of (n)make.")
2247 Parser
.add_option("-q", "--quiet", action
="store_true", type=None, help="Disable all messages except FATAL ERRORS.")
2248 Parser
.add_option("-v", "--verbose", action
="store_true", type=None, help="Turn on verbose output with informational messages printed, "\
2249 "including library instances selected, final dependency expression, "\
2250 "and warning messages, etc.")
2251 Parser
.add_option("-d", "--debug", action
="store", type="int", help="Enable debug messages at specified level.")
2252 Parser
.add_option("-D", "--define", action
="append", type="string", dest
="Macros", help="Macro: \"Name [= Value]\".")
2254 Parser
.add_option("-y", "--report-file", action
="store", dest
="ReportFile", help="Create/overwrite the report to the specified filename.")
2255 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
=[],
2256 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]. "\
2257 "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]")
2258 Parser
.add_option("-F", "--flag", action
="store", type="string", dest
="Flag",
2259 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. "\
2260 "This option can also be specified by setting *_*_*_BUILD_FLAGS in [BuildOptions] section of platform DSC. If they are both specified, this value "\
2261 "will override the setting in [BuildOptions] section of platform DSC.")
2262 Parser
.add_option("-N", "--no-cache", action
="store_true", dest
="DisableCache", default
=False, help="Disable build cache mechanism")
2263 Parser
.add_option("--conf", action
="store", type="string", dest
="ConfDirectory", help="Specify the customized Conf directory.")
2264 Parser
.add_option("--check-usage", action
="store_true", dest
="CheckUsage", default
=False, help="Check usage content of entries listed in INF file.")
2265 Parser
.add_option("--ignore-sources", action
="store_true", dest
="IgnoreSources", default
=False, help="Focus to a binary build and ignore all source files")
2266 Parser
.add_option("--pcd", action
="append", dest
="OptionPcd", help="Set PCD value by command line. Format: \"PcdName=Value\" ")
2267 Parser
.add_option("-l", "--cmd-len", action
="store", type="int", dest
="CommandLength", help="Specify the maximum line length of build command. Default is 4096.")
2268 Parser
.add_option("--hash", action
="store_true", dest
="UseHashCache", default
=False, help="Enable hash-based caching during build process.")
2269 Parser
.add_option("--binary-destination", action
="store", type="string", dest
="BinCacheDest", help="Generate a cache of binary files in the specified directory.")
2270 Parser
.add_option("--binary-source", action
="store", type="string", dest
="BinCacheSource", help="Consume a cache of binary files from the specified directory.")
2271 Parser
.add_option("--genfds-multi-thread", action
="store_true", dest
="GenfdsMultiThread", default
=False, help="Enable GenFds multi thread to generate ffs file.")
2272 Parser
.add_option("--disable-include-path-check", action
="store_true", dest
="DisableIncludePathCheck", default
=False, help="Disable the include path check for outside of package.")
2273 (Opt
, Args
) = Parser
.parse_args()
2276 ## Tool entrance method
2278 # This method mainly dispatch specific methods per the command line options.
2279 # If no error found, return zero value so the caller of this tool can know
2280 # if it's executed successfully or not.
2282 # @retval 0 Tool was successful
2283 # @retval 1 Tool failed
2286 StartTime
= time
.time()
2288 # Initialize log system
2289 EdkLogger
.Initialize()
2290 GlobalData
.gCommand
= sys
.argv
[1:]
2292 # Parse the options and args
2294 (Option
, Target
) = MyOptionParser()
2295 GlobalData
.gOptions
= Option
2296 GlobalData
.gCaseInsensitive
= Option
.CaseInsensitive
2299 if Option
.verbose
is not None:
2300 EdkLogger
.SetLevel(EdkLogger
.VERBOSE
)
2301 elif Option
.quiet
is not None:
2302 EdkLogger
.SetLevel(EdkLogger
.QUIET
)
2303 elif Option
.debug
is not None:
2304 EdkLogger
.SetLevel(Option
.debug
+ 1)
2306 EdkLogger
.SetLevel(EdkLogger
.INFO
)
2308 if Option
.LogFile
is not None:
2309 EdkLogger
.SetLogFile(Option
.LogFile
)
2311 if Option
.WarningAsError
== True:
2312 EdkLogger
.SetWarningAsError()
2314 if platform
.platform().find("Windows") >= 0:
2315 GlobalData
.gIsWindows
= True
2317 GlobalData
.gIsWindows
= False
2319 EdkLogger
.quiet("Build environment: %s" % platform
.platform())
2320 EdkLogger
.quiet(time
.strftime("Build start time: %H:%M:%S, %b.%d %Y\n", time
.localtime()));
2325 if len(Target
) == 0:
2327 elif len(Target
) >= 2:
2328 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, "More than one targets are not supported.",
2329 ExtraData
="Please select one of: %s" % (' '.join(gSupportedTarget
)))
2331 Target
= Target
[0].lower()
2333 if Target
not in gSupportedTarget
:
2334 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, "Not supported target [%s]." % Target
,
2335 ExtraData
="Please select one of: %s" % (' '.join(gSupportedTarget
)))
2338 # Check environment variable: EDK_TOOLS_PATH, WORKSPACE, PATH
2341 GlobalData
.gCommandLineDefines
.update(ParseDefines(Option
.Macros
))
2343 Workspace
= os
.getenv("WORKSPACE")
2345 # Get files real name in workspace dir
2347 GlobalData
.gAllFiles
= Utils
.DirCache(Workspace
)
2349 WorkingDirectory
= os
.getcwd()
2350 if not Option
.ModuleFile
:
2351 FileList
= glob
.glob(os
.path
.normpath(os
.path
.join(WorkingDirectory
, '*.inf')))
2352 FileNum
= len(FileList
)
2354 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, "There are %d INF files in %s." % (FileNum
, WorkingDirectory
),
2355 ExtraData
="Please use '-m <INF_FILE_PATH>' switch to choose one.")
2357 Option
.ModuleFile
= NormFile(FileList
[0], Workspace
)
2359 if Option
.ModuleFile
:
2360 if os
.path
.isabs (Option
.ModuleFile
):
2361 if os
.path
.normcase (os
.path
.normpath(Option
.ModuleFile
)).find (Workspace
) == 0:
2362 Option
.ModuleFile
= NormFile(os
.path
.normpath(Option
.ModuleFile
), Workspace
)
2363 Option
.ModuleFile
= PathClass(Option
.ModuleFile
, Workspace
)
2364 ErrorCode
, ErrorInfo
= Option
.ModuleFile
.Validate(".inf", False)
2366 EdkLogger
.error("build", ErrorCode
, ExtraData
=ErrorInfo
)
2368 if Option
.PlatformFile
is not None:
2369 if os
.path
.isabs (Option
.PlatformFile
):
2370 if os
.path
.normcase (os
.path
.normpath(Option
.PlatformFile
)).find (Workspace
) == 0:
2371 Option
.PlatformFile
= NormFile(os
.path
.normpath(Option
.PlatformFile
), Workspace
)
2372 Option
.PlatformFile
= PathClass(Option
.PlatformFile
, Workspace
)
2374 if Option
.FdfFile
is not None:
2375 if os
.path
.isabs (Option
.FdfFile
):
2376 if os
.path
.normcase (os
.path
.normpath(Option
.FdfFile
)).find (Workspace
) == 0:
2377 Option
.FdfFile
= NormFile(os
.path
.normpath(Option
.FdfFile
), Workspace
)
2378 Option
.FdfFile
= PathClass(Option
.FdfFile
, Workspace
)
2379 ErrorCode
, ErrorInfo
= Option
.FdfFile
.Validate(".fdf", False)
2381 EdkLogger
.error("build", ErrorCode
, ExtraData
=ErrorInfo
)
2383 if Option
.Flag
is not None and Option
.Flag
not in ['-c', '-s']:
2384 EdkLogger
.error("build", OPTION_VALUE_INVALID
, "UNI flag must be one of -c or -s")
2386 MyBuild
= Build(Target
, Workspace
, Option
)
2387 GlobalData
.gCommandLineDefines
['ARCH'] = ' '.join(MyBuild
.ArchList
)
2388 if not (MyBuild
.LaunchPrebuildFlag
and os
.path
.exists(MyBuild
.PlatformBuildPath
)):
2392 # All job done, no error found and no exception raised
2395 except FatalError
as X
:
2396 if MyBuild
is not None:
2397 # for multi-thread build exits safely
2398 MyBuild
.Relinquish()
2399 if Option
is not None and Option
.debug
is not None:
2400 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
2401 ReturnCode
= X
.args
[0]
2402 except Warning as X
:
2403 # error from Fdf parser
2404 if MyBuild
is not None:
2405 # for multi-thread build exits safely
2406 MyBuild
.Relinquish()
2407 if Option
is not None and Option
.debug
is not None:
2408 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
2410 EdkLogger
.error(X
.ToolName
, FORMAT_INVALID
, File
=X
.FileName
, Line
=X
.LineNumber
, ExtraData
=X
.Message
, RaiseError
=False)
2411 ReturnCode
= FORMAT_INVALID
2412 except KeyboardInterrupt:
2413 ReturnCode
= ABORT_ERROR
2414 if Option
is not None and Option
.debug
is not None:
2415 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
2417 if MyBuild
is not None:
2418 # for multi-thread build exits safely
2419 MyBuild
.Relinquish()
2421 # try to get the meta-file from the object causing exception
2422 Tb
= sys
.exc_info()[-1]
2423 MetaFile
= GlobalData
.gProcessingFile
2424 while Tb
is not None:
2425 if 'self' in Tb
.tb_frame
.f_locals
and hasattr(Tb
.tb_frame
.f_locals
['self'], 'MetaFile'):
2426 MetaFile
= Tb
.tb_frame
.f_locals
['self'].MetaFile
2431 "Unknown fatal error when processing [%s]" % MetaFile
,
2432 ExtraData
="\n(Please send email to edk2-devel@lists.01.org for help, attaching following call stack trace!)\n",
2435 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
2436 ReturnCode
= CODE_ERROR
2438 Utils
.Progressor
.Abort()
2439 Utils
.ClearDuplicatedInf()
2443 MyBuild
.LaunchPostbuild()
2446 Conclusion
= "Failed"
2447 elif ReturnCode
== ABORT_ERROR
:
2448 Conclusion
= "Aborted"
2450 Conclusion
= "Failed"
2451 FinishTime
= time
.time()
2452 BuildDuration
= time
.gmtime(int(round(FinishTime
- StartTime
)))
2453 BuildDurationStr
= ""
2454 if BuildDuration
.tm_yday
> 1:
2455 BuildDurationStr
= time
.strftime("%H:%M:%S", BuildDuration
) + ", %d day(s)" % (BuildDuration
.tm_yday
- 1)
2457 BuildDurationStr
= time
.strftime("%H:%M:%S", BuildDuration
)
2458 if MyBuild
is not None:
2460 MyBuild
.BuildReport
.GenerateReport(BuildDurationStr
, LogBuildTime(MyBuild
.AutoGenTime
), LogBuildTime(MyBuild
.MakeTime
), LogBuildTime(MyBuild
.GenFdsTime
))
2462 EdkLogger
.SetLevel(EdkLogger
.QUIET
)
2463 EdkLogger
.quiet("\n- %s -" % Conclusion
)
2464 EdkLogger
.quiet(time
.strftime("Build end time: %H:%M:%S, %b.%d %Y", time
.localtime()))
2465 EdkLogger
.quiet("Build total time: %s\n" % BuildDurationStr
)
2468 if __name__
== '__main__':
2470 ## 0-127 is a safe return range, and 1 is a standard default error
2471 if r
< 0 or r
> 127: r
= 1