2 # build a platform or a module
4 # Copyright (c) 2014, Hewlett-Packard Development Company, L.P.<BR>
5 # Copyright (c) 2007 - 2018, 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
23 from io
import BytesIO
29 import encodings
.ascii
31 import multiprocessing
34 from threading
import *
35 from optparse
import OptionParser
36 from subprocess
import *
37 from Common
import Misc
as Utils
39 from Common
.LongFilePathSupport
import OpenLongFilePath
as open
40 from Common
.TargetTxtClassObject
import TargetTxtClassObject
41 from Common
.ToolDefClassObject
import ToolDefClassObject
42 from Common
.DataType
import *
43 from Common
.BuildVersion
import gBUILD_VERSION
44 from AutoGen
.AutoGen
import *
45 from Common
.BuildToolError
import *
46 from Workspace
.WorkspaceDatabase
import WorkspaceDatabase
47 from Common
.MultipleWorkspace
import MultipleWorkspace
as mws
49 from BuildReport
import BuildReport
50 from GenPatchPcdTable
.GenPatchPcdTable
import *
51 from PatchPcdValue
.PatchPcdValue
import *
53 import Common
.EdkLogger
54 import Common
.GlobalData
as GlobalData
55 from GenFds
.GenFds
import GenFds
, GenFdsApi
57 from collections
import OrderedDict
, defaultdict
59 # Version and Copyright
60 VersionNumber
= "0.60" + ' ' + gBUILD_VERSION
61 __version__
= "%prog Version " + VersionNumber
62 __copyright__
= "Copyright (c) 2007 - 2018, Intel Corporation All rights reserved."
64 ## standard targets of build command
65 gSupportedTarget
= ['all', 'genc', 'genmake', 'modules', 'libraries', 'fds', 'clean', 'cleanall', 'cleanlib', 'run']
67 ## build configuration file
68 gBuildConfiguration
= "target.txt"
69 gToolsDefinition
= "tools_def.txt"
71 TemporaryTablePattern
= re
.compile(r
'^_\d+_\d+_[a-fA-F0-9]+$')
74 ## Check environment PATH variable to make sure the specified tool is found
76 # If the tool is found in the PATH, then True is returned
77 # Otherwise, False is returned
79 def IsToolInPath(tool
):
80 if 'PATHEXT' in os
.environ
:
81 extns
= os
.environ
['PATHEXT'].split(os
.path
.pathsep
)
84 for pathDir
in os
.environ
['PATH'].split(os
.path
.pathsep
):
86 if os
.path
.exists(os
.path
.join(pathDir
, tool
+ ext
)):
90 ## Check environment variables
92 # Check environment variables that must be set for build. Currently they are
94 # WORKSPACE The directory all packages/platforms start from
95 # EDK_TOOLS_PATH The directory contains all tools needed by the build
96 # PATH $(EDK_TOOLS_PATH)/Bin/<sys> must be set in PATH
98 # If any of above environment variable is not set or has error, the build
101 def CheckEnvVariable():
103 if "WORKSPACE" not in os
.environ
:
104 EdkLogger
.error("build", ATTRIBUTE_NOT_AVAILABLE
, "Environment variable not found",
105 ExtraData
="WORKSPACE")
107 WorkspaceDir
= os
.path
.normcase(os
.path
.normpath(os
.environ
["WORKSPACE"]))
108 if not os
.path
.exists(WorkspaceDir
):
109 EdkLogger
.error("build", FILE_NOT_FOUND
, "WORKSPACE doesn't exist", ExtraData
=WorkspaceDir
)
110 elif ' ' in WorkspaceDir
:
111 EdkLogger
.error("build", FORMAT_NOT_SUPPORTED
, "No space is allowed in WORKSPACE path",
112 ExtraData
=WorkspaceDir
)
113 os
.environ
["WORKSPACE"] = WorkspaceDir
115 # set multiple workspace
116 PackagesPath
= os
.getenv("PACKAGES_PATH")
117 mws
.setWs(WorkspaceDir
, PackagesPath
)
118 if mws
.PACKAGES_PATH
:
119 for Path
in mws
.PACKAGES_PATH
:
120 if not os
.path
.exists(Path
):
121 EdkLogger
.error("build", FILE_NOT_FOUND
, "One Path in PACKAGES_PATH doesn't exist", ExtraData
=Path
)
123 EdkLogger
.error("build", FORMAT_NOT_SUPPORTED
, "No space is allowed in PACKAGES_PATH", ExtraData
=Path
)
126 os
.environ
["EDK_TOOLS_PATH"] = os
.path
.normcase(os
.environ
["EDK_TOOLS_PATH"])
128 # check EDK_TOOLS_PATH
129 if "EDK_TOOLS_PATH" not in os
.environ
:
130 EdkLogger
.error("build", ATTRIBUTE_NOT_AVAILABLE
, "Environment variable not found",
131 ExtraData
="EDK_TOOLS_PATH")
134 if "PATH" not in os
.environ
:
135 EdkLogger
.error("build", ATTRIBUTE_NOT_AVAILABLE
, "Environment variable not found",
138 GlobalData
.gWorkspace
= WorkspaceDir
140 GlobalData
.gGlobalDefines
["WORKSPACE"] = WorkspaceDir
141 GlobalData
.gGlobalDefines
["EDK_TOOLS_PATH"] = os
.environ
["EDK_TOOLS_PATH"]
143 ## Get normalized file path
145 # Convert the path to be local format, and remove the WORKSPACE path at the
146 # beginning if the file path is given in full path.
148 # @param FilePath File path to be normalized
149 # @param Workspace Workspace path which the FilePath will be checked against
151 # @retval string The normalized file path
153 def NormFile(FilePath
, Workspace
):
154 # check if the path is absolute or relative
155 if os
.path
.isabs(FilePath
):
156 FileFullPath
= os
.path
.normpath(FilePath
)
158 FileFullPath
= os
.path
.normpath(mws
.join(Workspace
, FilePath
))
159 Workspace
= mws
.getWs(Workspace
, FilePath
)
161 # check if the file path exists or not
162 if not os
.path
.isfile(FileFullPath
):
163 EdkLogger
.error("build", FILE_NOT_FOUND
, ExtraData
="\t%s (Please give file in absolute path or relative to WORKSPACE)" % FileFullPath
)
165 # remove workspace directory from the beginning part of the file path
166 if Workspace
[-1] in ["\\", "/"]:
167 return FileFullPath
[len(Workspace
):]
169 return FileFullPath
[(len(Workspace
) + 1):]
171 ## Get the output of an external program
173 # This is the entrance method of thread reading output of an external program and
174 # putting them in STDOUT/STDERR of current program.
176 # @param From The stream message read from
177 # @param To The stream message put on
178 # @param ExitFlag The flag used to indicate stopping reading
180 def ReadMessage(From
, To
, ExitFlag
):
182 # read one line a time
183 Line
= From
.readline()
184 # empty string means "end"
185 if Line
is not None and Line
!= "":
192 ## Launch an external program
194 # This method will call subprocess.Popen to execute an external program with
195 # given options in specified directory. Because of the dead-lock issue during
196 # redirecting output of the external program, threads are used to to do the
199 # @param Command A list or string containing the call of the program
200 # @param WorkingDir The directory in which the program will be running
202 def LaunchCommand(Command
, WorkingDir
):
203 BeginTime
= time
.time()
204 # if working directory doesn't exist, Popen() will raise an exception
205 if not os
.path
.isdir(WorkingDir
):
206 EdkLogger
.error("build", FILE_NOT_FOUND
, ExtraData
=WorkingDir
)
208 # Command is used as the first Argument in following Popen().
209 # It could be a string or sequence. We find that if command is a string in following Popen(),
210 # ubuntu may fail with an error message that the command is not found.
211 # So here we may need convert command from string to list instance.
212 if platform
.system() != 'Windows':
213 if not isinstance(Command
, list):
214 Command
= Command
.split()
215 Command
= ' '.join(Command
)
218 EndOfProcedure
= None
221 Proc
= Popen(Command
, stdout
=PIPE
, stderr
=PIPE
, env
=os
.environ
, cwd
=WorkingDir
, bufsize
=-1, shell
=True)
223 # launch two threads to read the STDOUT and STDERR
224 EndOfProcedure
= Event()
225 EndOfProcedure
.clear()
227 StdOutThread
= Thread(target
=ReadMessage
, args
=(Proc
.stdout
, EdkLogger
.info
, EndOfProcedure
))
228 StdOutThread
.setName("STDOUT-Redirector")
229 StdOutThread
.setDaemon(False)
233 StdErrThread
= Thread(target
=ReadMessage
, args
=(Proc
.stderr
, EdkLogger
.quiet
, EndOfProcedure
))
234 StdErrThread
.setName("STDERR-Redirector")
235 StdErrThread
.setDaemon(False)
238 # waiting for program exit
240 except: # in case of aborting
241 # terminate the threads redirecting the program output
242 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
243 if EndOfProcedure
is not None:
246 if not isinstance(Command
, type("")):
247 Command
= " ".join(Command
)
248 EdkLogger
.error("build", COMMAND_FAILURE
, "Failed to start command", ExtraData
="%s [%s]" % (Command
, WorkingDir
))
255 # check the return code of the program
256 if Proc
.returncode
!= 0:
257 if not isinstance(Command
, type("")):
258 Command
= " ".join(Command
)
259 # print out the Response file and its content when make failure
260 RespFile
= os
.path
.join(WorkingDir
, 'OUTPUT', 'respfilelist.txt')
261 if os
.path
.isfile(RespFile
):
263 RespContent
= f
.read()
265 EdkLogger
.info(RespContent
)
267 EdkLogger
.error("build", COMMAND_FAILURE
, ExtraData
="%s [%s]" % (Command
, WorkingDir
))
268 return "%dms" % (int(round((time
.time() - BeginTime
) * 1000)))
270 ## The smallest unit that can be built in multi-thread build mode
272 # This is the base class of build unit. The "Obj" parameter must provide
273 # __str__(), __eq__() and __hash__() methods. Otherwise there could be build units
276 # Currently the "Obj" should be only ModuleAutoGen or PlatformAutoGen objects.
281 # @param self The object pointer
282 # @param Obj The object the build is working on
283 # @param Target The build target name, one of gSupportedTarget
284 # @param Dependency The BuildUnit(s) which must be completed in advance
285 # @param WorkingDir The directory build command starts in
287 def __init__(self
, Obj
, BuildCommand
, Target
, Dependency
, WorkingDir
="."):
288 self
.BuildObject
= Obj
289 self
.Dependency
= Dependency
290 self
.WorkingDir
= WorkingDir
292 self
.BuildCommand
= BuildCommand
294 EdkLogger
.error("build", OPTION_MISSING
,
295 "No build command found for this module. "
296 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %
297 (Obj
.BuildTarget
, Obj
.ToolChain
, Obj
.Arch
),
303 # It just returns the string representation of self.BuildObject
305 # @param self The object pointer
308 return str(self
.BuildObject
)
310 ## "==" operator method
312 # It just compares self.BuildObject with "Other". So self.BuildObject must
313 # provide its own __eq__() method.
315 # @param self The object pointer
316 # @param Other The other BuildUnit object compared to
318 def __eq__(self
, Other
):
319 return Other
and self
.BuildObject
== Other
.BuildObject \
320 and Other
.BuildObject \
321 and self
.BuildObject
.Arch
== Other
.BuildObject
.Arch
325 # It just returns the hash value of self.BuildObject which must be hashable.
327 # @param self The object pointer
330 return hash(self
.BuildObject
) + hash(self
.BuildObject
.Arch
)
333 return repr(self
.BuildObject
)
335 ## The smallest module unit that can be built by nmake/make command in multi-thread build mode
337 # This class is for module build by nmake/make build system. The "Obj" parameter
338 # must provide __str__(), __eq__() and __hash__() methods. Otherwise there could
339 # be make units missing build.
341 # Currently the "Obj" should be only ModuleAutoGen object.
343 class ModuleMakeUnit(BuildUnit
):
346 # @param self The object pointer
347 # @param Obj The ModuleAutoGen object the build is working on
348 # @param Target The build target name, one of gSupportedTarget
350 def __init__(self
, Obj
, Target
):
351 Dependency
= [ModuleMakeUnit(La
, Target
) for La
in Obj
.LibraryAutoGenList
]
352 BuildUnit
.__init
__(self
, Obj
, Obj
.BuildCommand
, Target
, Dependency
, Obj
.MakeFileDir
)
353 if Target
in [None, "", "all"]:
354 self
.Target
= "tbuild"
356 ## The smallest platform unit that can be built by nmake/make command in multi-thread build mode
358 # This class is for platform build by nmake/make build system. The "Obj" parameter
359 # must provide __str__(), __eq__() and __hash__() methods. Otherwise there could
360 # be make units missing build.
362 # Currently the "Obj" should be only PlatformAutoGen object.
364 class PlatformMakeUnit(BuildUnit
):
367 # @param self The object pointer
368 # @param Obj The PlatformAutoGen object the build is working on
369 # @param Target The build target name, one of gSupportedTarget
371 def __init__(self
, Obj
, Target
):
372 Dependency
= [ModuleMakeUnit(Lib
, Target
) for Lib
in self
.BuildObject
.LibraryAutoGenList
]
373 Dependency
.extend([ModuleMakeUnit(Mod
, Target
) for Mod
in self
.BuildObject
.ModuleAutoGenList
])
374 BuildUnit
.__init
__(self
, Obj
, Obj
.BuildCommand
, Target
, Dependency
, Obj
.MakeFileDir
)
376 ## The class representing the task of a module build or platform build
378 # This class manages the build tasks in multi-thread build mode. Its jobs include
379 # scheduling thread running, catching thread error, monitor the thread status, etc.
382 # queue for tasks waiting for schedule
383 _PendingQueue
= OrderedDict()
384 _PendingQueueLock
= threading
.Lock()
386 # queue for tasks ready for running
387 _ReadyQueue
= OrderedDict()
388 _ReadyQueueLock
= threading
.Lock()
390 # queue for run tasks
391 _RunningQueue
= OrderedDict()
392 _RunningQueueLock
= threading
.Lock()
394 # queue containing all build tasks, in case duplicate build
395 _TaskQueue
= OrderedDict()
397 # flag indicating error occurs in a running thread
398 _ErrorFlag
= threading
.Event()
402 # BoundedSemaphore object used to control the number of running threads
405 # flag indicating if the scheduler is started or not
406 _SchedulerStopped
= threading
.Event()
407 _SchedulerStopped
.set()
409 ## Start the task scheduler thread
411 # @param MaxThreadNumber The maximum thread number
412 # @param ExitFlag Flag used to end the scheduler
415 def StartScheduler(MaxThreadNumber
, ExitFlag
):
416 SchedulerThread
= Thread(target
=BuildTask
.Scheduler
, args
=(MaxThreadNumber
, ExitFlag
))
417 SchedulerThread
.setName("Build-Task-Scheduler")
418 SchedulerThread
.setDaemon(False)
419 SchedulerThread
.start()
420 # wait for the scheduler to be started, especially useful in Linux
421 while not BuildTask
.IsOnGoing():
426 # @param MaxThreadNumber The maximum thread number
427 # @param ExitFlag Flag used to end the scheduler
430 def Scheduler(MaxThreadNumber
, ExitFlag
):
431 BuildTask
._SchedulerStopped
.clear()
433 # use BoundedSemaphore to control the maximum running threads
434 BuildTask
._Thread
= BoundedSemaphore(MaxThreadNumber
)
436 # scheduling loop, which will exits when no pending/ready task and
437 # indicated to do so, or there's error in running thread
439 while (len(BuildTask
._PendingQueue
) > 0 or len(BuildTask
._ReadyQueue
) > 0 \
440 or not ExitFlag
.isSet()) and not BuildTask
._ErrorFlag
.isSet():
441 EdkLogger
.debug(EdkLogger
.DEBUG_8
, "Pending Queue (%d), Ready Queue (%d)"
442 % (len(BuildTask
._PendingQueue
), len(BuildTask
._ReadyQueue
)))
444 # get all pending tasks
445 BuildTask
._PendingQueueLock
.acquire()
446 BuildObjectList
= BuildTask
._PendingQueue
.keys()
448 # check if their dependency is resolved, and if true, move them
451 for BuildObject
in BuildObjectList
:
452 Bt
= BuildTask
._PendingQueue
[BuildObject
]
454 BuildTask
._ReadyQueue
[BuildObject
] = BuildTask
._PendingQueue
.pop(BuildObject
)
455 BuildTask
._PendingQueueLock
.release()
457 # launch build thread until the maximum number of threads is reached
458 while not BuildTask
._ErrorFlag
.isSet():
459 # empty ready queue, do nothing further
460 if len(BuildTask
._ReadyQueue
) == 0:
463 # wait for active thread(s) exit
464 BuildTask
._Thread
.acquire(True)
466 # start a new build thread
467 Bo
, Bt
= BuildTask
._ReadyQueue
.popitem()
469 # move into running queue
470 BuildTask
._RunningQueueLock
.acquire()
471 BuildTask
._RunningQueue
[Bo
] = Bt
472 BuildTask
._RunningQueueLock
.release()
481 # wait for all running threads exit
482 if BuildTask
._ErrorFlag
.isSet():
483 EdkLogger
.quiet("\nWaiting for all build threads exit...")
484 # while not BuildTask._ErrorFlag.isSet() and \
485 while len(BuildTask
._RunningQueue
) > 0:
486 EdkLogger
.verbose("Waiting for thread ending...(%d)" % len(BuildTask
._RunningQueue
))
487 EdkLogger
.debug(EdkLogger
.DEBUG_8
, "Threads [%s]" % ", ".join(Th
.getName() for Th
in threading
.enumerate()))
490 except BaseException
as X
:
492 # TRICK: hide the output of threads left runing, so that the user can
493 # catch the error message easily
495 EdkLogger
.SetLevel(EdkLogger
.ERROR
)
496 BuildTask
._ErrorFlag
.set()
497 BuildTask
._ErrorMessage
= "build thread scheduler error\n\t%s" % str(X
)
499 BuildTask
._PendingQueue
.clear()
500 BuildTask
._ReadyQueue
.clear()
501 BuildTask
._RunningQueue
.clear()
502 BuildTask
._TaskQueue
.clear()
503 BuildTask
._SchedulerStopped
.set()
505 ## Wait for all running method exit
508 def WaitForComplete():
509 BuildTask
._SchedulerStopped
.wait()
511 ## Check if the scheduler is running or not
515 return not BuildTask
._SchedulerStopped
.isSet()
520 if BuildTask
.IsOnGoing():
521 BuildTask
._ErrorFlag
.set()
522 BuildTask
.WaitForComplete()
524 ## Check if there's error in running thread
526 # Since the main thread cannot catch exceptions in other thread, we have to
527 # use threading.Event to communicate this formation to main thread.
531 return BuildTask
._ErrorFlag
.isSet()
533 ## Get error message in running thread
535 # Since the main thread cannot catch exceptions in other thread, we have to
536 # use a static variable to communicate this message to main thread.
539 def GetErrorMessage():
540 return BuildTask
._ErrorMessage
542 ## Factory method to create a BuildTask object
544 # This method will check if a module is building or has been built. And if
545 # true, just return the associated BuildTask object in the _TaskQueue. If
546 # not, create and return a new BuildTask object. The new BuildTask object
547 # will be appended to the _PendingQueue for scheduling later.
549 # @param BuildItem A BuildUnit object representing a build object
550 # @param Dependency The dependent build object of BuildItem
553 def New(BuildItem
, Dependency
=None):
554 if BuildItem
in BuildTask
._TaskQueue
:
555 Bt
= BuildTask
._TaskQueue
[BuildItem
]
559 Bt
._Init
(BuildItem
, Dependency
)
560 BuildTask
._TaskQueue
[BuildItem
] = Bt
562 BuildTask
._PendingQueueLock
.acquire()
563 BuildTask
._PendingQueue
[BuildItem
] = Bt
564 BuildTask
._PendingQueueLock
.release()
568 ## The real constructor of BuildTask
570 # @param BuildItem A BuildUnit object representing a build object
571 # @param Dependency The dependent build object of BuildItem
573 def _Init(self
, BuildItem
, Dependency
=None):
574 self
.BuildItem
= BuildItem
576 self
.DependencyList
= []
577 if Dependency
is None:
578 Dependency
= BuildItem
.Dependency
580 Dependency
.extend(BuildItem
.Dependency
)
581 self
.AddDependency(Dependency
)
582 # flag indicating build completes, used to avoid unnecessary re-build
583 self
.CompleteFlag
= False
585 ## Check if all dependent build tasks are completed or not
589 for Dep
in self
.DependencyList
:
590 if Dep
.CompleteFlag
== True:
597 ## Add dependent build task
599 # @param Dependency The list of dependent build objects
601 def AddDependency(self
, Dependency
):
602 for Dep
in Dependency
:
603 if not Dep
.BuildObject
.IsBinaryModule
:
604 self
.DependencyList
.append(BuildTask
.New(Dep
)) # BuildTask list
606 ## The thread wrapper of LaunchCommand function
608 # @param Command A list or string contains the call of the command
609 # @param WorkingDir The directory in which the program will be running
611 def _CommandThread(self
, Command
, WorkingDir
):
613 self
.BuildItem
.BuildObject
.BuildTime
= LaunchCommand(Command
, WorkingDir
)
614 self
.CompleteFlag
= True
617 # TRICK: hide the output of threads left runing, so that the user can
618 # catch the error message easily
620 if not BuildTask
._ErrorFlag
.isSet():
621 GlobalData
.gBuildingModule
= "%s [%s, %s, %s]" % (str(self
.BuildItem
.BuildObject
),
622 self
.BuildItem
.BuildObject
.Arch
,
623 self
.BuildItem
.BuildObject
.ToolChain
,
624 self
.BuildItem
.BuildObject
.BuildTarget
626 EdkLogger
.SetLevel(EdkLogger
.ERROR
)
627 BuildTask
._ErrorFlag
.set()
628 BuildTask
._ErrorMessage
= "%s broken\n %s [%s]" % \
629 (threading
.currentThread().getName(), Command
, WorkingDir
)
630 # indicate there's a thread is available for another build task
631 BuildTask
._RunningQueueLock
.acquire()
632 BuildTask
._RunningQueue
.pop(self
.BuildItem
)
633 BuildTask
._RunningQueueLock
.release()
634 BuildTask
._Thread
.release()
636 ## Start build task thread
639 EdkLogger
.quiet("Building ... %s" % repr(self
.BuildItem
))
640 Command
= self
.BuildItem
.BuildCommand
+ [self
.BuildItem
.Target
]
641 self
.BuildTread
= Thread(target
=self
._CommandThread
, args
=(Command
, self
.BuildItem
.WorkingDir
))
642 self
.BuildTread
.setName("build thread")
643 self
.BuildTread
.setDaemon(False)
644 self
.BuildTread
.start()
646 ## The class contains the information related to EFI image
651 # Constructor will load all required image information.
653 # @param BaseName The full file path of image.
654 # @param Guid The GUID for image.
655 # @param Arch Arch of this image.
656 # @param OutputDir The output directory for image.
657 # @param DebugDir The debug directory for image.
658 # @param ImageClass PeImage Information
660 def __init__(self
, BaseName
, Guid
, Arch
, OutputDir
, DebugDir
, ImageClass
):
661 self
.BaseName
= BaseName
664 self
.OutputDir
= OutputDir
665 self
.DebugDir
= DebugDir
666 self
.Image
= ImageClass
667 self
.Image
.Size
= (self
.Image
.Size
/ 0x1000 + 1) * 0x1000
669 ## The class implementing the EDK2 build process
671 # The build process includes:
672 # 1. Load configuration from target.txt and tools_def.txt in $(WORKSPACE)/Conf
673 # 2. Parse DSC file of active platform
674 # 3. Parse FDF file if any
675 # 4. Establish build database, including parse all other files (module, package)
676 # 5. Create AutoGen files (C code file, depex file, makefile) if necessary
677 # 6. Call build command
682 # Constructor will load all necessary configurations, parse platform, modules
683 # and packages and the establish a database for AutoGen.
685 # @param Target The build command target, one of gSupportedTarget
686 # @param WorkspaceDir The directory of workspace
687 # @param BuildOptions Build options passed from command line
689 def __init__(self
, Target
, WorkspaceDir
, BuildOptions
):
690 self
.WorkspaceDir
= WorkspaceDir
692 self
.PlatformFile
= BuildOptions
.PlatformFile
693 self
.ModuleFile
= BuildOptions
.ModuleFile
694 self
.ArchList
= BuildOptions
.TargetArch
695 self
.ToolChainList
= BuildOptions
.ToolChain
696 self
.BuildTargetList
= BuildOptions
.BuildTarget
697 self
.Fdf
= BuildOptions
.FdfFile
698 self
.FdList
= BuildOptions
.RomImage
699 self
.FvList
= BuildOptions
.FvImage
700 self
.CapList
= BuildOptions
.CapName
701 self
.SilentMode
= BuildOptions
.SilentMode
702 self
.ThreadNumber
= BuildOptions
.ThreadNumber
703 self
.SkipAutoGen
= BuildOptions
.SkipAutoGen
704 self
.Reparse
= BuildOptions
.Reparse
705 self
.SkuId
= BuildOptions
.SkuId
707 GlobalData
.gSKUID_CMD
= self
.SkuId
708 self
.ConfDirectory
= BuildOptions
.ConfDirectory
709 self
.SpawnMode
= True
710 self
.BuildReport
= BuildReport(BuildOptions
.ReportFile
, BuildOptions
.ReportType
)
711 self
.TargetTxt
= TargetTxtClassObject()
712 self
.ToolDef
= ToolDefClassObject()
716 GlobalData
.BuildOptionPcd
= BuildOptions
.OptionPcd
if BuildOptions
.OptionPcd
else []
717 #Set global flag for build mode
718 GlobalData
.gIgnoreSource
= BuildOptions
.IgnoreSources
719 GlobalData
.gUseHashCache
= BuildOptions
.UseHashCache
720 GlobalData
.gBinCacheDest
= BuildOptions
.BinCacheDest
721 GlobalData
.gBinCacheSource
= BuildOptions
.BinCacheSource
722 GlobalData
.gEnableGenfdsMultiThread
= BuildOptions
.GenfdsMultiThread
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
))
797 EdkLogger
.quiet("%-16s = %s" % ("PREBUILD", self
.Prebuild
))
799 EdkLogger
.quiet("%-16s = %s" % ("POSTBUILD", self
.Postbuild
))
801 self
.LaunchPrebuild()
802 self
.TargetTxt
= TargetTxtClassObject()
803 self
.ToolDef
= ToolDefClassObject()
804 if not (self
.LaunchPrebuildFlag
and os
.path
.exists(self
.PlatformBuildPath
)):
808 os
.chdir(self
.WorkspaceDir
)
810 ## Load configuration
812 # This method will parse target.txt and get the build configurations.
814 def LoadConfiguration(self
):
816 # Check target.txt and tools_def.txt and Init them
818 BuildConfigurationFile
= os
.path
.normpath(os
.path
.join(GlobalData
.gConfDirectory
, gBuildConfiguration
))
819 if os
.path
.isfile(BuildConfigurationFile
) == True:
820 StatusCode
= self
.TargetTxt
.LoadTargetTxtFile(BuildConfigurationFile
)
822 ToolDefinitionFile
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_TOOL_CHAIN_CONF
]
823 if ToolDefinitionFile
== '':
824 ToolDefinitionFile
= gToolsDefinition
825 ToolDefinitionFile
= os
.path
.normpath(mws
.join(self
.WorkspaceDir
, 'Conf', ToolDefinitionFile
))
826 if os
.path
.isfile(ToolDefinitionFile
) == True:
827 StatusCode
= self
.ToolDef
.LoadToolDefFile(ToolDefinitionFile
)
829 EdkLogger
.error("build", FILE_NOT_FOUND
, ExtraData
=ToolDefinitionFile
)
831 EdkLogger
.error("build", FILE_NOT_FOUND
, ExtraData
=BuildConfigurationFile
)
833 # if no ARCH given in command line, get it from target.txt
834 if not self
.ArchList
:
835 self
.ArchList
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_TARGET_ARCH
]
836 self
.ArchList
= tuple(self
.ArchList
)
838 # if no build target given in command line, get it from target.txt
839 if not self
.BuildTargetList
:
840 self
.BuildTargetList
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_TARGET
]
842 # if no tool chain given in command line, get it from target.txt
843 if not self
.ToolChainList
:
844 self
.ToolChainList
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_TOOL_CHAIN_TAG
]
845 if self
.ToolChainList
is None or len(self
.ToolChainList
) == 0:
846 EdkLogger
.error("build", RESOURCE_NOT_AVAILABLE
, ExtraData
="No toolchain given. Don't know how to build.\n")
848 # check if the tool chains are defined or not
849 NewToolChainList
= []
850 for ToolChain
in self
.ToolChainList
:
851 if ToolChain
not in self
.ToolDef
.ToolsDefTxtDatabase
[TAB_TOD_DEFINES_TOOL_CHAIN_TAG
]:
852 EdkLogger
.warn("build", "Tool chain [%s] is not defined" % ToolChain
)
854 NewToolChainList
.append(ToolChain
)
855 # if no tool chain available, break the build
856 if len(NewToolChainList
) == 0:
857 EdkLogger
.error("build", RESOURCE_NOT_AVAILABLE
,
858 ExtraData
="[%s] not defined. No toolchain available for build!\n" % ", ".join(self
.ToolChainList
))
860 self
.ToolChainList
= NewToolChainList
863 ToolDefinition
= self
.ToolDef
.ToolsDefTxtDatabase
864 for Tool
in self
.ToolChainList
:
865 if TAB_TOD_DEFINES_FAMILY
not in ToolDefinition
or Tool
not in ToolDefinition
[TAB_TOD_DEFINES_FAMILY
] \
866 or not ToolDefinition
[TAB_TOD_DEFINES_FAMILY
][Tool
]:
867 EdkLogger
.warn("build", "No tool chain family found in configuration for %s. Default to MSFT." % Tool
)
868 ToolChainFamily
.append(TAB_COMPILER_MSFT
)
870 ToolChainFamily
.append(ToolDefinition
[TAB_TOD_DEFINES_FAMILY
][Tool
])
871 self
.ToolChainFamily
= ToolChainFamily
873 if self
.ThreadNumber
is None:
874 self
.ThreadNumber
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_MAX_CONCURRENT_THREAD_NUMBER
]
875 if self
.ThreadNumber
== '':
876 self
.ThreadNumber
= 0
878 self
.ThreadNumber
= int(self
.ThreadNumber
, 0)
880 if self
.ThreadNumber
== 0:
882 self
.ThreadNumber
= multiprocessing
.cpu_count()
883 except (ImportError, NotImplementedError):
884 self
.ThreadNumber
= 1
886 if not self
.PlatformFile
:
887 PlatformFile
= self
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_ACTIVE_PLATFORM
]
889 # Try to find one in current directory
890 WorkingDirectory
= os
.getcwd()
891 FileList
= glob
.glob(os
.path
.normpath(os
.path
.join(WorkingDirectory
, '*.dsc')))
892 FileNum
= len(FileList
)
894 EdkLogger
.error("build", OPTION_MISSING
,
895 ExtraData
="There are %d DSC files in %s. Use '-p' to specify one.\n" % (FileNum
, WorkingDirectory
))
897 PlatformFile
= FileList
[0]
899 EdkLogger
.error("build", RESOURCE_NOT_AVAILABLE
,
900 ExtraData
="No active platform specified in target.txt or command line! Nothing can be built.\n")
902 self
.PlatformFile
= PathClass(NormFile(PlatformFile
, self
.WorkspaceDir
), self
.WorkspaceDir
)
904 ## Initialize build configuration
906 # This method will parse DSC file and merge the configurations from
907 # command line and target.txt, then get the final build configurations.
910 # parse target.txt, tools_def.txt, and platform file
911 self
.LoadConfiguration()
913 # Allow case-insensitive for those from command line or configuration file
914 ErrorCode
, ErrorInfo
= self
.PlatformFile
.Validate(".dsc", False)
916 EdkLogger
.error("build", ErrorCode
, ExtraData
=ErrorInfo
)
919 def InitPreBuild(self
):
920 self
.LoadConfiguration()
921 ErrorCode
, ErrorInfo
= self
.PlatformFile
.Validate(".dsc", False)
923 EdkLogger
.error("build", ErrorCode
, ExtraData
=ErrorInfo
)
924 if self
.BuildTargetList
:
925 GlobalData
.gGlobalDefines
['TARGET'] = self
.BuildTargetList
[0]
927 GlobalData
.gGlobalDefines
['ARCH'] = self
.ArchList
[0]
928 if self
.ToolChainList
:
929 GlobalData
.gGlobalDefines
['TOOLCHAIN'] = self
.ToolChainList
[0]
930 GlobalData
.gGlobalDefines
['TOOL_CHAIN_TAG'] = self
.ToolChainList
[0]
931 if self
.ToolChainFamily
:
932 GlobalData
.gGlobalDefines
['FAMILY'] = self
.ToolChainFamily
[0]
933 if 'PREBUILD' in GlobalData
.gCommandLineDefines
:
934 self
.Prebuild
= GlobalData
.gCommandLineDefines
.get('PREBUILD')
937 Platform
= self
.Db
.MapPlatform(str(self
.PlatformFile
))
938 self
.Prebuild
= str(Platform
.Prebuild
)
942 # Evaluate all arguments and convert arguments that are WORKSPACE
943 # relative paths to absolute paths. Filter arguments that look like
944 # flags or do not follow the file/dir naming rules to avoid false
945 # positives on this conversion.
947 for Arg
in self
.Prebuild
.split():
949 # Do not modify Arg if it looks like a flag or an absolute file path
951 if Arg
.startswith('-') or os
.path
.isabs(Arg
):
952 PrebuildList
.append(Arg
)
955 # Do not modify Arg if it does not look like a Workspace relative
956 # path that starts with a valid package directory name
958 if not Arg
[0].isalpha() or os
.path
.dirname(Arg
) == '':
959 PrebuildList
.append(Arg
)
962 # If Arg looks like a WORKSPACE relative path, then convert to an
963 # absolute path and check to see if the file exists.
965 Temp
= mws
.join(self
.WorkspaceDir
, Arg
)
966 if os
.path
.isfile(Temp
):
968 PrebuildList
.append(Arg
)
969 self
.Prebuild
= ' '.join(PrebuildList
)
970 self
.Prebuild
+= self
.PassCommandOption(self
.BuildTargetList
, self
.ArchList
, self
.ToolChainList
, self
.PlatformFile
, self
.Target
)
972 def InitPostBuild(self
):
973 if 'POSTBUILD' in GlobalData
.gCommandLineDefines
:
974 self
.Postbuild
= GlobalData
.gCommandLineDefines
.get('POSTBUILD')
976 Platform
= self
.Db
.MapPlatform(str(self
.PlatformFile
))
977 self
.Postbuild
= str(Platform
.Postbuild
)
981 # Evaluate all arguments and convert arguments that are WORKSPACE
982 # relative paths to absolute paths. Filter arguments that look like
983 # flags or do not follow the file/dir naming rules to avoid false
984 # positives on this conversion.
986 for Arg
in self
.Postbuild
.split():
988 # Do not modify Arg if it looks like a flag or an absolute file path
990 if Arg
.startswith('-') or os
.path
.isabs(Arg
):
991 PostbuildList
.append(Arg
)
994 # Do not modify Arg if it does not look like a Workspace relative
995 # path that starts with a valid package directory name
997 if not Arg
[0].isalpha() or os
.path
.dirname(Arg
) == '':
998 PostbuildList
.append(Arg
)
1001 # If Arg looks like a WORKSPACE relative path, then convert to an
1002 # absolute path and check to see if the file exists.
1004 Temp
= mws
.join(self
.WorkspaceDir
, Arg
)
1005 if os
.path
.isfile(Temp
):
1007 PostbuildList
.append(Arg
)
1008 self
.Postbuild
= ' '.join(PostbuildList
)
1009 self
.Postbuild
+= self
.PassCommandOption(self
.BuildTargetList
, self
.ArchList
, self
.ToolChainList
, self
.PlatformFile
, self
.Target
)
1011 def PassCommandOption(self
, BuildTarget
, TargetArch
, ToolChain
, PlatformFile
, Target
):
1013 if GlobalData
.gCommand
and isinstance(GlobalData
.gCommand
, list):
1014 BuildStr
+= ' ' + ' '.join(GlobalData
.gCommand
)
1017 ToolChainFlag
= False
1018 PlatformFileFlag
= False
1020 if GlobalData
.gOptions
and not GlobalData
.gOptions
.BuildTarget
:
1022 if GlobalData
.gOptions
and not GlobalData
.gOptions
.TargetArch
:
1024 if GlobalData
.gOptions
and not GlobalData
.gOptions
.ToolChain
:
1025 ToolChainFlag
= True
1026 if GlobalData
.gOptions
and not GlobalData
.gOptions
.PlatformFile
:
1027 PlatformFileFlag
= True
1029 if TargetFlag
and BuildTarget
:
1030 if isinstance(BuildTarget
, list) or isinstance(BuildTarget
, tuple):
1031 BuildStr
+= ' -b ' + ' -b '.join(BuildTarget
)
1032 elif isinstance(BuildTarget
, str):
1033 BuildStr
+= ' -b ' + BuildTarget
1034 if ArchFlag
and TargetArch
:
1035 if isinstance(TargetArch
, list) or isinstance(TargetArch
, tuple):
1036 BuildStr
+= ' -a ' + ' -a '.join(TargetArch
)
1037 elif isinstance(TargetArch
, str):
1038 BuildStr
+= ' -a ' + TargetArch
1039 if ToolChainFlag
and ToolChain
:
1040 if isinstance(ToolChain
, list) or isinstance(ToolChain
, tuple):
1041 BuildStr
+= ' -t ' + ' -t '.join(ToolChain
)
1042 elif isinstance(ToolChain
, str):
1043 BuildStr
+= ' -t ' + ToolChain
1044 if PlatformFileFlag
and PlatformFile
:
1045 if isinstance(PlatformFile
, list) or isinstance(PlatformFile
, tuple):
1046 BuildStr
+= ' -p ' + ' -p '.join(PlatformFile
)
1047 elif isinstance(PlatformFile
, str):
1048 BuildStr
+= ' -p' + PlatformFile
1049 BuildStr
+= ' --conf=' + GlobalData
.gConfDirectory
1051 BuildStr
+= ' ' + Target
1055 def LaunchPrebuild(self
):
1057 EdkLogger
.info("\n- Prebuild Start -\n")
1058 self
.LaunchPrebuildFlag
= True
1060 # The purpose of .PrebuildEnv file is capture environment variable settings set by the prebuild script
1061 # and preserve them for the rest of the main build step, because the child process environment will
1062 # evaporate as soon as it exits, we cannot get it in build step.
1064 PrebuildEnvFile
= os
.path
.join(GlobalData
.gConfDirectory
, '.cache', '.PrebuildEnv')
1065 if os
.path
.isfile(PrebuildEnvFile
):
1066 os
.remove(PrebuildEnvFile
)
1067 if os
.path
.isfile(self
.PlatformBuildPath
):
1068 os
.remove(self
.PlatformBuildPath
)
1069 if sys
.platform
== "win32":
1070 args
= ' && '.join((self
.Prebuild
, 'set > ' + PrebuildEnvFile
))
1071 Process
= Popen(args
, stdout
=PIPE
, stderr
=PIPE
, shell
=True)
1073 args
= ' && '.join((self
.Prebuild
, 'env > ' + PrebuildEnvFile
))
1074 Process
= Popen(args
, stdout
=PIPE
, stderr
=PIPE
, shell
=True)
1076 # launch two threads to read the STDOUT and STDERR
1077 EndOfProcedure
= Event()
1078 EndOfProcedure
.clear()
1080 StdOutThread
= Thread(target
=ReadMessage
, args
=(Process
.stdout
, EdkLogger
.info
, EndOfProcedure
))
1081 StdOutThread
.setName("STDOUT-Redirector")
1082 StdOutThread
.setDaemon(False)
1083 StdOutThread
.start()
1086 StdErrThread
= Thread(target
=ReadMessage
, args
=(Process
.stderr
, EdkLogger
.quiet
, EndOfProcedure
))
1087 StdErrThread
.setName("STDERR-Redirector")
1088 StdErrThread
.setDaemon(False)
1089 StdErrThread
.start()
1090 # waiting for program exit
1097 if Process
.returncode
!= 0 :
1098 EdkLogger
.error("Prebuild", PREBUILD_ERROR
, 'Prebuild process is not success!')
1100 if os
.path
.exists(PrebuildEnvFile
):
1101 f
= open(PrebuildEnvFile
)
1102 envs
= f
.readlines()
1104 envs
= itertools
.imap(lambda l
: l
.split('=', 1), envs
)
1105 envs
= itertools
.ifilter(lambda l
: len(l
) == 2, envs
)
1106 envs
= itertools
.imap(lambda l
: [i
.strip() for i
in l
], envs
)
1107 os
.environ
.update(dict(envs
))
1108 EdkLogger
.info("\n- Prebuild Done -\n")
1110 def LaunchPostbuild(self
):
1112 EdkLogger
.info("\n- Postbuild Start -\n")
1113 if sys
.platform
== "win32":
1114 Process
= Popen(self
.Postbuild
, stdout
=PIPE
, stderr
=PIPE
, shell
=True)
1116 Process
= Popen(self
.Postbuild
, stdout
=PIPE
, stderr
=PIPE
, shell
=True)
1117 # launch two threads to read the STDOUT and STDERR
1118 EndOfProcedure
= Event()
1119 EndOfProcedure
.clear()
1121 StdOutThread
= Thread(target
=ReadMessage
, args
=(Process
.stdout
, EdkLogger
.info
, EndOfProcedure
))
1122 StdOutThread
.setName("STDOUT-Redirector")
1123 StdOutThread
.setDaemon(False)
1124 StdOutThread
.start()
1127 StdErrThread
= Thread(target
=ReadMessage
, args
=(Process
.stderr
, EdkLogger
.quiet
, EndOfProcedure
))
1128 StdErrThread
.setName("STDERR-Redirector")
1129 StdErrThread
.setDaemon(False)
1130 StdErrThread
.start()
1131 # waiting for program exit
1138 if Process
.returncode
!= 0 :
1139 EdkLogger
.error("Postbuild", POSTBUILD_ERROR
, 'Postbuild process is not success!')
1140 EdkLogger
.info("\n- Postbuild Done -\n")
1141 ## Build a module or platform
1143 # Create autogen code and makefile for a module or platform, and the launch
1144 # "make" command to build it
1146 # @param Target The target of build command
1147 # @param Platform The platform file
1148 # @param Module The module file
1149 # @param BuildTarget The name of build target, one of "DEBUG", "RELEASE"
1150 # @param ToolChain The name of toolchain to build
1151 # @param Arch The arch of the module/platform
1152 # @param CreateDepModuleCodeFile Flag used to indicate creating code
1153 # for dependent modules/Libraries
1154 # @param CreateDepModuleMakeFile Flag used to indicate creating makefile
1155 # for dependent modules/Libraries
1157 def _BuildPa(self
, Target
, AutoGenObject
, CreateDepsCodeFile
=True, CreateDepsMakeFile
=True, BuildModule
=False, FfsCommand
={}):
1158 if AutoGenObject
is None:
1161 # skip file generation for cleanxxx targets, run and fds target
1162 if Target
not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1163 # for target which must generate AutoGen code and makefile
1164 if not self
.SkipAutoGen
or Target
== 'genc':
1165 self
.Progress
.Start("Generating code")
1166 AutoGenObject
.CreateCodeFile(CreateDepsCodeFile
)
1167 self
.Progress
.Stop("done!")
1168 if Target
== "genc":
1171 if not self
.SkipAutoGen
or Target
== 'genmake':
1172 self
.Progress
.Start("Generating makefile")
1173 AutoGenObject
.CreateMakeFile(CreateDepsMakeFile
, FfsCommand
)
1174 self
.Progress
.Stop("done!")
1175 if Target
== "genmake":
1178 # always recreate top/platform makefile when clean, just in case of inconsistency
1179 AutoGenObject
.CreateCodeFile(False)
1180 AutoGenObject
.CreateMakeFile(False)
1182 if EdkLogger
.GetLevel() == EdkLogger
.QUIET
:
1183 EdkLogger
.quiet("Building ... %s" % repr(AutoGenObject
))
1185 BuildCommand
= AutoGenObject
.BuildCommand
1186 if BuildCommand
is None or len(BuildCommand
) == 0:
1187 EdkLogger
.error("build", OPTION_MISSING
,
1188 "No build command found for this module. "
1189 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %
1190 (AutoGenObject
.BuildTarget
, AutoGenObject
.ToolChain
, AutoGenObject
.Arch
),
1191 ExtraData
=str(AutoGenObject
))
1193 makefile
= GenMake
.BuildFile(AutoGenObject
)._FILE
_NAME
_[GenMake
.gMakeType
]
1197 RunDir
= os
.path
.normpath(os
.path
.join(AutoGenObject
.BuildDir
, GlobalData
.gGlobalDefines
['ARCH']))
1198 Command
= '.\SecMain'
1200 LaunchCommand(Command
, RunDir
)
1205 BuildCommand
= BuildCommand
+ [Target
]
1206 LaunchCommand(BuildCommand
, AutoGenObject
.MakeFileDir
)
1207 self
.CreateAsBuiltInf()
1211 if Target
== 'libraries':
1212 for Lib
in AutoGenObject
.LibraryBuildDirectoryList
:
1213 NewBuildCommand
= BuildCommand
+ ['-f', os
.path
.normpath(os
.path
.join(Lib
, makefile
)), 'pbuild']
1214 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1218 if Target
== 'modules':
1219 for Lib
in AutoGenObject
.LibraryBuildDirectoryList
:
1220 NewBuildCommand
= BuildCommand
+ ['-f', os
.path
.normpath(os
.path
.join(Lib
, makefile
)), 'pbuild']
1221 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1222 for Mod
in AutoGenObject
.ModuleBuildDirectoryList
:
1223 NewBuildCommand
= BuildCommand
+ ['-f', os
.path
.normpath(os
.path
.join(Mod
, makefile
)), 'pbuild']
1224 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1225 self
.CreateAsBuiltInf()
1229 if Target
== 'cleanlib':
1230 for Lib
in AutoGenObject
.LibraryBuildDirectoryList
:
1231 LibMakefile
= os
.path
.normpath(os
.path
.join(Lib
, makefile
))
1232 if os
.path
.exists(LibMakefile
):
1233 NewBuildCommand
= BuildCommand
+ ['-f', LibMakefile
, 'cleanall']
1234 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1238 if Target
== 'clean':
1239 for Mod
in AutoGenObject
.ModuleBuildDirectoryList
:
1240 ModMakefile
= os
.path
.normpath(os
.path
.join(Mod
, makefile
))
1241 if os
.path
.exists(ModMakefile
):
1242 NewBuildCommand
= BuildCommand
+ ['-f', ModMakefile
, 'cleanall']
1243 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1244 for Lib
in AutoGenObject
.LibraryBuildDirectoryList
:
1245 LibMakefile
= os
.path
.normpath(os
.path
.join(Lib
, makefile
))
1246 if os
.path
.exists(LibMakefile
):
1247 NewBuildCommand
= BuildCommand
+ ['-f', LibMakefile
, 'cleanall']
1248 LaunchCommand(NewBuildCommand
, AutoGenObject
.MakeFileDir
)
1252 if Target
== 'cleanall':
1254 #os.rmdir(AutoGenObject.BuildDir)
1255 RemoveDirectory(AutoGenObject
.BuildDir
, True)
1256 except WindowsError as X
:
1257 EdkLogger
.error("build", FILE_DELETE_FAILURE
, ExtraData
=str(X
))
1260 ## Build a module or platform
1262 # Create autogen code and makefile for a module or platform, and the launch
1263 # "make" command to build it
1265 # @param Target The target of build command
1266 # @param Platform The platform file
1267 # @param Module The module file
1268 # @param BuildTarget The name of build target, one of "DEBUG", "RELEASE"
1269 # @param ToolChain The name of toolchain to build
1270 # @param Arch The arch of the module/platform
1271 # @param CreateDepModuleCodeFile Flag used to indicate creating code
1272 # for dependent modules/Libraries
1273 # @param CreateDepModuleMakeFile Flag used to indicate creating makefile
1274 # for dependent modules/Libraries
1276 def _Build(self
, Target
, AutoGenObject
, CreateDepsCodeFile
=True, CreateDepsMakeFile
=True, BuildModule
=False):
1277 if AutoGenObject
is None:
1280 # skip file generation for cleanxxx targets, run and fds target
1281 if Target
not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1282 # for target which must generate AutoGen code and makefile
1283 if not self
.SkipAutoGen
or Target
== 'genc':
1284 self
.Progress
.Start("Generating code")
1285 AutoGenObject
.CreateCodeFile(CreateDepsCodeFile
)
1286 self
.Progress
.Stop("done!")
1287 if Target
== "genc":
1290 if not self
.SkipAutoGen
or Target
== 'genmake':
1291 self
.Progress
.Start("Generating makefile")
1292 AutoGenObject
.CreateMakeFile(CreateDepsMakeFile
)
1293 #AutoGenObject.CreateAsBuiltInf()
1294 self
.Progress
.Stop("done!")
1295 if Target
== "genmake":
1298 # always recreate top/platform makefile when clean, just in case of inconsistency
1299 AutoGenObject
.CreateCodeFile(False)
1300 AutoGenObject
.CreateMakeFile(False)
1302 if EdkLogger
.GetLevel() == EdkLogger
.QUIET
:
1303 EdkLogger
.quiet("Building ... %s" % repr(AutoGenObject
))
1305 BuildCommand
= AutoGenObject
.BuildCommand
1306 if BuildCommand
is None or len(BuildCommand
) == 0:
1307 EdkLogger
.error("build", OPTION_MISSING
,
1308 "No build command found for this module. "
1309 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %
1310 (AutoGenObject
.BuildTarget
, AutoGenObject
.ToolChain
, AutoGenObject
.Arch
),
1311 ExtraData
=str(AutoGenObject
))
1316 BuildCommand
= BuildCommand
+ [Target
]
1317 AutoGenObject
.BuildTime
= LaunchCommand(BuildCommand
, AutoGenObject
.MakeFileDir
)
1318 self
.CreateAsBuiltInf()
1323 if GenFdsApi(AutoGenObject
.GenFdsCommandDict
, self
.Db
):
1324 EdkLogger
.error("build", COMMAND_FAILURE
)
1329 RunDir
= os
.path
.normpath(os
.path
.join(AutoGenObject
.BuildDir
, GlobalData
.gGlobalDefines
['ARCH']))
1330 Command
= '.\SecMain'
1332 LaunchCommand(Command
, RunDir
)
1336 if Target
== 'libraries':
1343 if Target
== 'cleanall':
1345 #os.rmdir(AutoGenObject.BuildDir)
1346 RemoveDirectory(AutoGenObject
.BuildDir
, True)
1347 except WindowsError as X
:
1348 EdkLogger
.error("build", FILE_DELETE_FAILURE
, ExtraData
=str(X
))
1351 ## Rebase module image and Get function address for the input module list.
1353 def _RebaseModule (self
, MapBuffer
, BaseAddress
, ModuleList
, AddrIsOffset
= True, ModeIsSmm
= False):
1355 AddrIsOffset
= False
1356 for InfFile
in ModuleList
:
1357 sys
.stdout
.write (".")
1359 ModuleInfo
= ModuleList
[InfFile
]
1360 ModuleName
= ModuleInfo
.BaseName
1361 ModuleOutputImage
= ModuleInfo
.Image
.FileName
1362 ModuleDebugImage
= os
.path
.join(ModuleInfo
.DebugDir
, ModuleInfo
.BaseName
+ '.efi')
1363 ## for SMM module in SMRAM, the SMRAM will be allocated from base to top.
1365 BaseAddress
= BaseAddress
- ModuleInfo
.Image
.Size
1367 # Update Image to new BaseAddress by GenFw tool
1369 LaunchCommand(["GenFw", "--rebase", str(BaseAddress
), "-r", ModuleOutputImage
], ModuleInfo
.OutputDir
)
1370 LaunchCommand(["GenFw", "--rebase", str(BaseAddress
), "-r", ModuleDebugImage
], ModuleInfo
.DebugDir
)
1373 # Set new address to the section header only for SMM driver.
1375 LaunchCommand(["GenFw", "--address", str(BaseAddress
), "-r", ModuleOutputImage
], ModuleInfo
.OutputDir
)
1376 LaunchCommand(["GenFw", "--address", str(BaseAddress
), "-r", ModuleDebugImage
], ModuleInfo
.DebugDir
)
1378 # Collect funtion address from Map file
1380 ImageMapTable
= ModuleOutputImage
.replace('.efi', '.map')
1382 if os
.path
.exists(ImageMapTable
):
1383 OrigImageBaseAddress
= 0
1384 ImageMap
= open(ImageMapTable
, 'r')
1385 for LinStr
in ImageMap
:
1386 if len (LinStr
.strip()) == 0:
1389 # Get the preferred address set on link time.
1391 if LinStr
.find ('Preferred load address is') != -1:
1392 StrList
= LinStr
.split()
1393 OrigImageBaseAddress
= int (StrList
[len(StrList
) - 1], 16)
1395 StrList
= LinStr
.split()
1396 if len (StrList
) > 4:
1397 if StrList
[3] == 'f' or StrList
[3] == 'F':
1399 RelativeAddress
= int (StrList
[2], 16) - OrigImageBaseAddress
1400 FunctionList
.append ((Name
, RelativeAddress
))
1401 if ModuleInfo
.Arch
== 'IPF' and Name
.endswith('_ModuleEntryPoint'):
1403 # Get the real entry point address for IPF image.
1405 ModuleInfo
.Image
.EntryPoint
= RelativeAddress
1408 # Add general information.
1411 MapBuffer
.write('\n\n%s (Fixed SMRAM Offset, BaseAddress=0x%010X, EntryPoint=0x%010X)\n' % (ModuleName
, BaseAddress
, BaseAddress
+ ModuleInfo
.Image
.EntryPoint
))
1413 MapBuffer
.write('\n\n%s (Fixed Memory Offset, BaseAddress=-0x%010X, EntryPoint=-0x%010X)\n' % (ModuleName
, 0 - BaseAddress
, 0 - (BaseAddress
+ ModuleInfo
.Image
.EntryPoint
)))
1415 MapBuffer
.write('\n\n%s (Fixed Memory Address, BaseAddress=0x%010X, EntryPoint=0x%010X)\n' % (ModuleName
, BaseAddress
, BaseAddress
+ ModuleInfo
.Image
.EntryPoint
))
1417 # Add guid and general seciton section.
1419 TextSectionAddress
= 0
1420 DataSectionAddress
= 0
1421 for SectionHeader
in ModuleInfo
.Image
.SectionHeaderList
:
1422 if SectionHeader
[0] == '.text':
1423 TextSectionAddress
= SectionHeader
[1]
1424 elif SectionHeader
[0] in ['.data', '.sdata']:
1425 DataSectionAddress
= SectionHeader
[1]
1427 MapBuffer
.write('(GUID=%s, .textbaseaddress=-0x%010X, .databaseaddress=-0x%010X)\n' % (ModuleInfo
.Guid
, 0 - (BaseAddress
+ TextSectionAddress
), 0 - (BaseAddress
+ DataSectionAddress
)))
1429 MapBuffer
.write('(GUID=%s, .textbaseaddress=0x%010X, .databaseaddress=0x%010X)\n' % (ModuleInfo
.Guid
, BaseAddress
+ TextSectionAddress
, BaseAddress
+ DataSectionAddress
))
1431 # Add debug image full path.
1433 MapBuffer
.write('(IMAGE=%s)\n\n' % (ModuleDebugImage
))
1435 # Add funtion address
1437 for Function
in FunctionList
:
1439 MapBuffer
.write(' -0x%010X %s\n' % (0 - (BaseAddress
+ Function
[1]), Function
[0]))
1441 MapBuffer
.write(' 0x%010X %s\n' % (BaseAddress
+ Function
[1], Function
[0]))
1445 # for SMM module in SMRAM, the SMRAM will be allocated from base to top.
1448 BaseAddress
= BaseAddress
+ ModuleInfo
.Image
.Size
1450 ## Collect MAP information of all FVs
1452 def _CollectFvMapBuffer (self
, MapBuffer
, Wa
, ModuleList
):
1454 # First get the XIP base address for FV map file.
1455 GuidPattern
= re
.compile("[-a-fA-F0-9]+")
1456 GuidName
= re
.compile("\(GUID=[-a-fA-F0-9]+")
1457 for FvName
in Wa
.FdfProfile
.FvDict
:
1458 FvMapBuffer
= os
.path
.join(Wa
.FvDir
, FvName
+ '.Fv.map')
1459 if not os
.path
.exists(FvMapBuffer
):
1461 FvMap
= open(FvMapBuffer
, 'r')
1462 #skip FV size information
1468 MatchGuid
= GuidPattern
.match(Line
)
1469 if MatchGuid
is not None:
1471 # Replace GUID with module name
1473 GuidString
= MatchGuid
.group()
1474 if GuidString
.upper() in ModuleList
:
1475 Line
= Line
.replace(GuidString
, ModuleList
[GuidString
.upper()].Name
)
1476 MapBuffer
.write(Line
)
1478 # Add the debug image full path.
1480 MatchGuid
= GuidName
.match(Line
)
1481 if MatchGuid
is not None:
1482 GuidString
= MatchGuid
.group().split("=")[1]
1483 if GuidString
.upper() in ModuleList
:
1484 MapBuffer
.write('(IMAGE=%s)\n' % (os
.path
.join(ModuleList
[GuidString
.upper()].DebugDir
, ModuleList
[GuidString
.upper()].Name
+ '.efi')))
1488 ## Collect MAP information of all modules
1490 def _CollectModuleMapBuffer (self
, MapBuffer
, ModuleList
):
1491 sys
.stdout
.write ("Generate Load Module At Fix Address Map")
1493 PatchEfiImageList
= []
1501 # reserve 4K size in SMRAM to make SMM module address not from 0.
1503 IsIpfPlatform
= False
1504 if 'IPF' in self
.ArchList
:
1505 IsIpfPlatform
= True
1506 for ModuleGuid
in ModuleList
:
1507 Module
= ModuleList
[ModuleGuid
]
1508 GlobalData
.gProcessingFile
= "%s [%s, %s, %s]" % (Module
.MetaFile
, Module
.Arch
, Module
.ToolChain
, Module
.BuildTarget
)
1510 OutputImageFile
= ''
1511 for ResultFile
in Module
.CodaTargetList
:
1512 if str(ResultFile
.Target
).endswith('.efi'):
1514 # module list for PEI, DXE, RUNTIME and SMM
1516 OutputImageFile
= os
.path
.join(Module
.OutputDir
, Module
.Name
+ '.efi')
1517 ImageClass
= PeImageClass (OutputImageFile
)
1518 if not ImageClass
.IsValid
:
1519 EdkLogger
.error("build", FILE_PARSE_FAILURE
, ExtraData
=ImageClass
.ErrorInfo
)
1520 ImageInfo
= PeImageInfo(Module
.Name
, Module
.Guid
, Module
.Arch
, Module
.OutputDir
, Module
.DebugDir
, ImageClass
)
1521 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
]:
1522 PeiModuleList
[Module
.MetaFile
] = ImageInfo
1523 PeiSize
+= ImageInfo
.Image
.Size
1524 elif Module
.ModuleType
in [EDK_COMPONENT_TYPE_BS_DRIVER
, SUP_MODULE_DXE_DRIVER
, SUP_MODULE_UEFI_DRIVER
]:
1525 BtModuleList
[Module
.MetaFile
] = ImageInfo
1526 BtSize
+= ImageInfo
.Image
.Size
1527 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
]:
1528 RtModuleList
[Module
.MetaFile
] = ImageInfo
1529 #IPF runtime driver needs to be at 2 page alignment.
1530 if IsIpfPlatform
and ImageInfo
.Image
.Size
% 0x2000 != 0:
1531 ImageInfo
.Image
.Size
= (ImageInfo
.Image
.Size
/ 0x2000 + 1) * 0x2000
1532 RtSize
+= ImageInfo
.Image
.Size
1533 elif Module
.ModuleType
in [SUP_MODULE_SMM_CORE
, SUP_MODULE_DXE_SMM_DRIVER
, SUP_MODULE_MM_STANDALONE
, SUP_MODULE_MM_CORE_STANDALONE
]:
1534 SmmModuleList
[Module
.MetaFile
] = ImageInfo
1535 SmmSize
+= ImageInfo
.Image
.Size
1536 if Module
.ModuleType
== SUP_MODULE_DXE_SMM_DRIVER
:
1537 PiSpecVersion
= Module
.Module
.Specification
.get('PI_SPECIFICATION_VERSION', '0x00000000')
1538 # for PI specification < PI1.1, DXE_SMM_DRIVER also runs as BOOT time driver.
1539 if int(PiSpecVersion
, 16) < 0x0001000A:
1540 BtModuleList
[Module
.MetaFile
] = ImageInfo
1541 BtSize
+= ImageInfo
.Image
.Size
1544 # EFI image is final target.
1545 # Check EFI image contains patchable FixAddress related PCDs.
1547 if OutputImageFile
!= '':
1548 ModuleIsPatch
= False
1549 for Pcd
in Module
.ModulePcdList
:
1550 if Pcd
.Type
== TAB_PCDS_PATCHABLE_IN_MODULE
and Pcd
.TokenCName
in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SET
:
1551 ModuleIsPatch
= True
1553 if not ModuleIsPatch
:
1554 for Pcd
in Module
.LibraryPcdList
:
1555 if Pcd
.Type
== TAB_PCDS_PATCHABLE_IN_MODULE
and Pcd
.TokenCName
in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SET
:
1556 ModuleIsPatch
= True
1559 if not ModuleIsPatch
:
1562 # Module includes the patchable load fix address PCDs.
1563 # It will be fixed up later.
1565 PatchEfiImageList
.append (OutputImageFile
)
1568 # Get Top Memory address
1570 ReservedRuntimeMemorySize
= 0
1571 TopMemoryAddress
= 0
1572 if self
.LoadFixAddress
== 0xFFFFFFFFFFFFFFFF:
1573 TopMemoryAddress
= 0
1575 TopMemoryAddress
= self
.LoadFixAddress
1576 if TopMemoryAddress
< RtSize
+ BtSize
+ PeiSize
:
1577 EdkLogger
.error("build", PARAMETER_INVALID
, "FIX_LOAD_TOP_MEMORY_ADDRESS is too low to load driver")
1578 # Make IPF runtime driver at 2 page alignment.
1580 ReservedRuntimeMemorySize
= TopMemoryAddress
% 0x2000
1581 RtSize
= RtSize
+ ReservedRuntimeMemorySize
1584 # Patch FixAddress related PCDs into EFI image
1586 for EfiImage
in PatchEfiImageList
:
1587 EfiImageMap
= EfiImage
.replace('.efi', '.map')
1588 if not os
.path
.exists(EfiImageMap
):
1591 # Get PCD offset in EFI image by GenPatchPcdTable function
1593 PcdTable
= parsePcdInfoFromMapFile(EfiImageMap
, EfiImage
)
1595 # Patch real PCD value by PatchPcdValue tool
1597 for PcdInfo
in PcdTable
:
1599 if PcdInfo
[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE
:
1600 ReturnValue
, ErrorInfo
= PatchBinaryFile (EfiImage
, PcdInfo
[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE_DATA_TYPE
, str (PeiSize
/ 0x1000))
1601 elif PcdInfo
[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE
:
1602 ReturnValue
, ErrorInfo
= PatchBinaryFile (EfiImage
, PcdInfo
[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE_DATA_TYPE
, str (BtSize
/ 0x1000))
1603 elif PcdInfo
[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE
:
1604 ReturnValue
, ErrorInfo
= PatchBinaryFile (EfiImage
, PcdInfo
[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE_DATA_TYPE
, str (RtSize
/ 0x1000))
1605 elif PcdInfo
[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE
and len (SmmModuleList
) > 0:
1606 ReturnValue
, ErrorInfo
= PatchBinaryFile (EfiImage
, PcdInfo
[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE_DATA_TYPE
, str (SmmSize
/ 0x1000))
1607 if ReturnValue
!= 0:
1608 EdkLogger
.error("build", PARAMETER_INVALID
, "Patch PCD value failed", ExtraData
=ErrorInfo
)
1610 MapBuffer
.write('PEI_CODE_PAGE_NUMBER = 0x%x\n' % (PeiSize
/ 0x1000))
1611 MapBuffer
.write('BOOT_CODE_PAGE_NUMBER = 0x%x\n' % (BtSize
/ 0x1000))
1612 MapBuffer
.write('RUNTIME_CODE_PAGE_NUMBER = 0x%x\n' % (RtSize
/ 0x1000))
1613 if len (SmmModuleList
) > 0:
1614 MapBuffer
.write('SMM_CODE_PAGE_NUMBER = 0x%x\n' % (SmmSize
/ 0x1000))
1616 PeiBaseAddr
= TopMemoryAddress
- RtSize
- BtSize
1617 BtBaseAddr
= TopMemoryAddress
- RtSize
1618 RtBaseAddr
= TopMemoryAddress
- ReservedRuntimeMemorySize
1620 self
._RebaseModule
(MapBuffer
, PeiBaseAddr
, PeiModuleList
, TopMemoryAddress
== 0)
1621 self
._RebaseModule
(MapBuffer
, BtBaseAddr
, BtModuleList
, TopMemoryAddress
== 0)
1622 self
._RebaseModule
(MapBuffer
, RtBaseAddr
, RtModuleList
, TopMemoryAddress
== 0)
1623 self
._RebaseModule
(MapBuffer
, 0x1000, SmmModuleList
, AddrIsOffset
=False, ModeIsSmm
=True)
1624 MapBuffer
.write('\n\n')
1625 sys
.stdout
.write ("\n")
1628 ## Save platform Map file
1630 def _SaveMapFile (self
, MapBuffer
, Wa
):
1632 # Map file path is got.
1634 MapFilePath
= os
.path
.join(Wa
.BuildDir
, Wa
.Name
+ '.map')
1636 # Save address map into MAP file.
1638 SaveFileOnChange(MapFilePath
, MapBuffer
.getvalue(), False)
1640 if self
.LoadFixAddress
!= 0:
1641 sys
.stdout
.write ("\nLoad Module At Fix Address Map file can be found at %s\n" % (MapFilePath
))
1644 ## Build active platform for different build targets and different tool chains
1646 def _BuildPlatform(self
):
1647 SaveFileOnChange(self
.PlatformBuildPath
, '# DO NOT EDIT \n# FILE auto-generated\n', False)
1648 for BuildTarget
in self
.BuildTargetList
:
1649 GlobalData
.gGlobalDefines
['TARGET'] = BuildTarget
1651 for ToolChain
in self
.ToolChainList
:
1652 GlobalData
.gGlobalDefines
['TOOLCHAIN'] = ToolChain
1653 GlobalData
.gGlobalDefines
['TOOL_CHAIN_TAG'] = ToolChain
1654 GlobalData
.gGlobalDefines
['FAMILY'] = self
.ToolChainFamily
[index
]
1656 Wa
= WorkspaceAutoGen(
1673 self
.Fdf
= Wa
.FdfFile
1674 self
.LoadFixAddress
= Wa
.Platform
.LoadFixAddress
1675 self
.BuildReport
.AddPlatformReport(Wa
)
1676 self
.Progress
.Stop("done!")
1678 # Add ffs build to makefile
1680 if GlobalData
.gEnableGenfdsMultiThread
and self
.Fdf
:
1681 CmdListDict
= self
._GenFfsCmd
()
1683 for Arch
in Wa
.ArchList
:
1684 GlobalData
.gGlobalDefines
['ARCH'] = Arch
1685 Pa
= PlatformAutoGen(Wa
, self
.PlatformFile
, BuildTarget
, ToolChain
, Arch
)
1686 for Module
in Pa
.Platform
.Modules
:
1687 # Get ModuleAutoGen object to generate C code file and makefile
1688 Ma
= ModuleAutoGen(Wa
, Module
, BuildTarget
, ToolChain
, Arch
, self
.PlatformFile
)
1691 self
.BuildModules
.append(Ma
)
1692 self
._BuildPa
(self
.Target
, Pa
, FfsCommand
=CmdListDict
)
1694 # Create MAP file when Load Fix Address is enabled.
1695 if self
.Target
in ["", "all", "fds"]:
1696 for Arch
in Wa
.ArchList
:
1697 GlobalData
.gGlobalDefines
['ARCH'] = Arch
1699 # Check whether the set fix address is above 4G for 32bit image.
1701 if (Arch
== 'IA32' or Arch
== 'ARM') and self
.LoadFixAddress
!= 0xFFFFFFFFFFFFFFFF and self
.LoadFixAddress
>= 0x100000000:
1702 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")
1707 for Pa
in Wa
.AutoGenObjectList
:
1708 for Ma
in Pa
.ModuleAutoGenList
:
1711 if not Ma
.IsLibrary
:
1712 ModuleList
[Ma
.Guid
.upper()] = Ma
1714 MapBuffer
= BytesIO('')
1715 if self
.LoadFixAddress
!= 0:
1717 # Rebase module to the preferred memory address before GenFds
1719 self
._CollectModuleMapBuffer
(MapBuffer
, ModuleList
)
1722 # create FDS again for the updated EFI image
1724 self
._Build
("fds", Wa
)
1726 # Create MAP file for all platform FVs after GenFds.
1728 self
._CollectFvMapBuffer
(MapBuffer
, Wa
, ModuleList
)
1730 # Save MAP buffer into MAP file.
1732 self
._SaveMapFile
(MapBuffer
, Wa
)
1734 ## Build active module for different build targets, different tool chains and different archs
1736 def _BuildModule(self
):
1737 for BuildTarget
in self
.BuildTargetList
:
1738 GlobalData
.gGlobalDefines
['TARGET'] = BuildTarget
1740 for ToolChain
in self
.ToolChainList
:
1741 WorkspaceAutoGenTime
= time
.time()
1742 GlobalData
.gGlobalDefines
['TOOLCHAIN'] = ToolChain
1743 GlobalData
.gGlobalDefines
['TOOL_CHAIN_TAG'] = ToolChain
1744 GlobalData
.gGlobalDefines
['FAMILY'] = self
.ToolChainFamily
[index
]
1747 # module build needs platform build information, so get platform
1750 Wa
= WorkspaceAutoGen(
1768 self
.Fdf
= Wa
.FdfFile
1769 self
.LoadFixAddress
= Wa
.Platform
.LoadFixAddress
1770 Wa
.CreateMakeFile(False)
1771 # Add ffs build to makefile
1773 if GlobalData
.gEnableGenfdsMultiThread
and self
.Fdf
:
1774 CmdListDict
= self
._GenFfsCmd
()
1775 self
.Progress
.Stop("done!")
1777 ExitFlag
= threading
.Event()
1779 self
.AutoGenTime
+= int(round((time
.time() - WorkspaceAutoGenTime
)))
1780 for Arch
in Wa
.ArchList
:
1781 AutoGenStart
= time
.time()
1782 GlobalData
.gGlobalDefines
['ARCH'] = Arch
1783 Pa
= PlatformAutoGen(Wa
, self
.PlatformFile
, BuildTarget
, ToolChain
, Arch
)
1784 for Module
in Pa
.Platform
.Modules
:
1785 if self
.ModuleFile
.Dir
== Module
.Dir
and self
.ModuleFile
.Name
== Module
.Name
:
1786 Ma
= ModuleAutoGen(Wa
, Module
, BuildTarget
, ToolChain
, Arch
, self
.PlatformFile
)
1787 if Ma
is None: continue
1789 if Ma
.CanSkipbyHash():
1790 self
.HashSkipModules
.append(Ma
)
1792 # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'
1793 if self
.Target
not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1794 # for target which must generate AutoGen code and makefile
1795 if not self
.SkipAutoGen
or self
.Target
== 'genc':
1796 self
.Progress
.Start("Generating code")
1797 Ma
.CreateCodeFile(True)
1798 self
.Progress
.Stop("done!")
1799 if self
.Target
== "genc":
1801 if not self
.SkipAutoGen
or self
.Target
== 'genmake':
1802 self
.Progress
.Start("Generating makefile")
1803 if CmdListDict
and self
.Fdf
and (Module
.File
, Arch
) in CmdListDict
:
1804 Ma
.CreateMakeFile(True, CmdListDict
[Module
.File
, Arch
])
1805 del CmdListDict
[Module
.File
, Arch
]
1807 Ma
.CreateMakeFile(True)
1808 self
.Progress
.Stop("done!")
1809 if self
.Target
== "genmake":
1811 self
.BuildModules
.append(Ma
)
1812 self
.AutoGenTime
+= int(round((time
.time() - AutoGenStart
)))
1813 MakeStart
= time
.time()
1814 for Ma
in self
.BuildModules
:
1815 if not Ma
.IsBinaryModule
:
1816 Bt
= BuildTask
.New(ModuleMakeUnit(Ma
, self
.Target
))
1817 # Break build if any build thread has error
1818 if BuildTask
.HasError():
1819 # we need a full version of makefile for platform
1821 BuildTask
.WaitForComplete()
1822 Pa
.CreateMakeFile(False)
1823 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
1824 # Start task scheduler
1825 if not BuildTask
.IsOnGoing():
1826 BuildTask
.StartScheduler(self
.ThreadNumber
, ExitFlag
)
1828 # in case there's an interruption. we need a full version of makefile for platform
1829 Pa
.CreateMakeFile(False)
1830 if BuildTask
.HasError():
1831 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
1832 self
.MakeTime
+= int(round((time
.time() - MakeStart
)))
1834 MakeContiue
= time
.time()
1836 BuildTask
.WaitForComplete()
1837 self
.CreateAsBuiltInf()
1838 self
.MakeTime
+= int(round((time
.time() - MakeContiue
)))
1839 if BuildTask
.HasError():
1840 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
1842 self
.BuildReport
.AddPlatformReport(Wa
, MaList
)
1847 "Module for [%s] is not a component of active platform."\
1848 " Please make sure that the ARCH and inf file path are"\
1849 " given in the same as in [%s]" % \
1850 (', '.join(Wa
.ArchList
), self
.PlatformFile
),
1851 ExtraData
=self
.ModuleFile
1853 # Create MAP file when Load Fix Address is enabled.
1854 if self
.Target
== "fds" and self
.Fdf
:
1855 for Arch
in Wa
.ArchList
:
1857 # Check whether the set fix address is above 4G for 32bit image.
1859 if (Arch
== 'IA32' or Arch
== 'ARM') and self
.LoadFixAddress
!= 0xFFFFFFFFFFFFFFFF and self
.LoadFixAddress
>= 0x100000000:
1860 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")
1865 for Pa
in Wa
.AutoGenObjectList
:
1866 for Ma
in Pa
.ModuleAutoGenList
:
1869 if not Ma
.IsLibrary
:
1870 ModuleList
[Ma
.Guid
.upper()] = Ma
1872 MapBuffer
= BytesIO('')
1873 if self
.LoadFixAddress
!= 0:
1875 # Rebase module to the preferred memory address before GenFds
1877 self
._CollectModuleMapBuffer
(MapBuffer
, ModuleList
)
1879 # create FDS again for the updated EFI image
1881 GenFdsStart
= time
.time()
1882 self
._Build
("fds", Wa
)
1883 self
.GenFdsTime
+= int(round((time
.time() - GenFdsStart
)))
1885 # Create MAP file for all platform FVs after GenFds.
1887 self
._CollectFvMapBuffer
(MapBuffer
, Wa
, ModuleList
)
1889 # Save MAP buffer into MAP file.
1891 self
._SaveMapFile
(MapBuffer
, Wa
)
1893 def _GenFfsCmd(self
):
1894 # convert dictionary of Cmd:(Inf,Arch)
1895 # to a new dictionary of (Inf,Arch):Cmd,Cmd,Cmd...
1896 CmdSetDict
= defaultdict(set)
1897 GenFfsDict
= GenFds
.GenFfsMakefile('', GlobalData
.gFdfParser
, self
, self
.ArchList
, GlobalData
)
1898 for Cmd
in GenFfsDict
:
1899 tmpInf
, tmpArch
= GenFfsDict
[Cmd
]
1900 CmdSetDict
[tmpInf
, tmpArch
].add(Cmd
)
1903 ## Build a platform in multi-thread mode
1905 def _MultiThreadBuildPlatform(self
):
1906 SaveFileOnChange(self
.PlatformBuildPath
, '# DO NOT EDIT \n# FILE auto-generated\n', False)
1907 for BuildTarget
in self
.BuildTargetList
:
1908 GlobalData
.gGlobalDefines
['TARGET'] = BuildTarget
1910 for ToolChain
in self
.ToolChainList
:
1911 WorkspaceAutoGenTime
= time
.time()
1912 GlobalData
.gGlobalDefines
['TOOLCHAIN'] = ToolChain
1913 GlobalData
.gGlobalDefines
['TOOL_CHAIN_TAG'] = ToolChain
1914 GlobalData
.gGlobalDefines
['FAMILY'] = self
.ToolChainFamily
[index
]
1916 Wa
= WorkspaceAutoGen(
1933 self
.Fdf
= Wa
.FdfFile
1934 self
.LoadFixAddress
= Wa
.Platform
.LoadFixAddress
1935 self
.BuildReport
.AddPlatformReport(Wa
)
1936 Wa
.CreateMakeFile(False)
1938 # Add ffs build to makefile
1940 if GlobalData
.gEnableGenfdsMultiThread
and self
.Fdf
:
1941 CmdListDict
= self
._GenFfsCmd
()
1943 # multi-thread exit flag
1944 ExitFlag
= threading
.Event()
1946 self
.AutoGenTime
+= int(round((time
.time() - WorkspaceAutoGenTime
)))
1947 for Arch
in Wa
.ArchList
:
1948 AutoGenStart
= time
.time()
1949 GlobalData
.gGlobalDefines
['ARCH'] = Arch
1950 Pa
= PlatformAutoGen(Wa
, self
.PlatformFile
, BuildTarget
, ToolChain
, Arch
)
1954 for Inf
in Pa
.Platform
.Modules
:
1955 ModuleList
.append(Inf
)
1956 # Add the INF only list in FDF
1957 if GlobalData
.gFdfParser
is not None:
1958 for InfName
in GlobalData
.gFdfParser
.Profile
.InfList
:
1959 Inf
= PathClass(NormPath(InfName
), self
.WorkspaceDir
, Arch
)
1960 if Inf
in Pa
.Platform
.Modules
:
1962 ModuleList
.append(Inf
)
1963 for Module
in ModuleList
:
1964 # Get ModuleAutoGen object to generate C code file and makefile
1965 Ma
= ModuleAutoGen(Wa
, Module
, BuildTarget
, ToolChain
, Arch
, self
.PlatformFile
)
1969 if Ma
.CanSkipbyHash():
1970 self
.HashSkipModules
.append(Ma
)
1973 # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'
1974 if self
.Target
not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1975 # for target which must generate AutoGen code and makefile
1976 if not self
.SkipAutoGen
or self
.Target
== 'genc':
1977 Ma
.CreateCodeFile(True)
1978 if self
.Target
== "genc":
1981 if not self
.SkipAutoGen
or self
.Target
== 'genmake':
1982 if CmdListDict
and self
.Fdf
and (Module
.File
, Arch
) in CmdListDict
:
1983 Ma
.CreateMakeFile(True, CmdListDict
[Module
.File
, Arch
])
1984 del CmdListDict
[Module
.File
, Arch
]
1986 Ma
.CreateMakeFile(True)
1987 if self
.Target
== "genmake":
1989 self
.BuildModules
.append(Ma
)
1990 self
.Progress
.Stop("done!")
1991 self
.AutoGenTime
+= int(round((time
.time() - AutoGenStart
)))
1992 MakeStart
= time
.time()
1993 for Ma
in self
.BuildModules
:
1994 # Generate build task for the module
1995 if not Ma
.IsBinaryModule
:
1996 Bt
= BuildTask
.New(ModuleMakeUnit(Ma
, self
.Target
))
1997 # Break build if any build thread has error
1998 if BuildTask
.HasError():
1999 # we need a full version of makefile for platform
2001 BuildTask
.WaitForComplete()
2002 Pa
.CreateMakeFile(False)
2003 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
2004 # Start task scheduler
2005 if not BuildTask
.IsOnGoing():
2006 BuildTask
.StartScheduler(self
.ThreadNumber
, ExitFlag
)
2008 # in case there's an interruption. we need a full version of makefile for platform
2009 Pa
.CreateMakeFile(False)
2010 if BuildTask
.HasError():
2011 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
2012 self
.MakeTime
+= int(round((time
.time() - MakeStart
)))
2014 MakeContiue
= time
.time()
2018 # All modules have been put in build tasks queue. Tell task scheduler
2019 # to exit if all tasks are completed
2022 BuildTask
.WaitForComplete()
2023 self
.CreateAsBuiltInf()
2024 self
.MakeTime
+= int(round((time
.time() - MakeContiue
)))
2026 # Check for build error, and raise exception if one
2027 # has been signaled.
2029 if BuildTask
.HasError():
2030 EdkLogger
.error("build", BUILD_ERROR
, "Failed to build module", ExtraData
=GlobalData
.gBuildingModule
)
2032 # Create MAP file when Load Fix Address is enabled.
2033 if self
.Target
in ["", "all", "fds"]:
2034 for Arch
in Wa
.ArchList
:
2036 # Check whether the set fix address is above 4G for 32bit image.
2038 if (Arch
== 'IA32' or Arch
== 'ARM') and self
.LoadFixAddress
!= 0xFFFFFFFFFFFFFFFF and self
.LoadFixAddress
>= 0x100000000:
2039 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")
2044 for Pa
in Wa
.AutoGenObjectList
:
2045 for Ma
in Pa
.ModuleAutoGenList
:
2048 if not Ma
.IsLibrary
:
2049 ModuleList
[Ma
.Guid
.upper()] = Ma
2051 # Rebase module to the preferred memory address before GenFds
2053 MapBuffer
= BytesIO('')
2054 if self
.LoadFixAddress
!= 0:
2055 self
._CollectModuleMapBuffer
(MapBuffer
, ModuleList
)
2059 # Generate FD image if there's a FDF file found
2061 GenFdsStart
= time
.time()
2062 if GenFdsApi(Wa
.GenFdsCommandDict
, self
.Db
):
2063 EdkLogger
.error("build", COMMAND_FAILURE
)
2066 # Create MAP file for all platform FVs after GenFds.
2068 self
._CollectFvMapBuffer
(MapBuffer
, Wa
, ModuleList
)
2069 self
.GenFdsTime
+= int(round((time
.time() - GenFdsStart
)))
2071 # Save MAP buffer into MAP file.
2073 self
._SaveMapFile
(MapBuffer
, Wa
)
2075 ## Generate GuidedSectionTools.txt in the FV directories.
2077 def CreateGuidedSectionToolsFile(self
):
2078 for BuildTarget
in self
.BuildTargetList
:
2079 for ToolChain
in self
.ToolChainList
:
2080 Wa
= WorkspaceAutoGen(
2097 if not os
.path
.exists(FvDir
):
2100 for Arch
in self
.ArchList
:
2101 # Build up the list of supported architectures for this build
2102 prefix
= '%s_%s_%s_' % (BuildTarget
, ToolChain
, Arch
)
2104 # Look through the tool definitions for GUIDed tools
2106 for (attrib
, value
) in self
.ToolDef
.ToolsDefTxtDictionary
.iteritems():
2107 if attrib
.upper().endswith('_GUID'):
2108 split
= attrib
.split('_')
2109 thisPrefix
= '_'.join(split
[0:3]) + '_'
2110 if thisPrefix
== prefix
:
2111 guid
= self
.ToolDef
.ToolsDefTxtDictionary
[attrib
]
2114 path
= '_'.join(split
[0:4]) + '_PATH'
2115 path
= self
.ToolDef
.ToolsDefTxtDictionary
[path
]
2116 path
= self
.GetFullPathOfTool(path
)
2117 guidAttribs
.append((guid
, toolName
, path
))
2119 # Write out GuidedSecTools.txt
2120 toolsFile
= os
.path
.join(FvDir
, 'GuidedSectionTools.txt')
2121 toolsFile
= open(toolsFile
, 'wt')
2122 for guidedSectionTool
in guidAttribs
:
2123 print(' '.join(guidedSectionTool
), file=toolsFile
)
2126 ## Returns the full path of the tool.
2128 def GetFullPathOfTool (self
, tool
):
2129 if os
.path
.exists(tool
):
2130 return os
.path
.realpath(tool
)
2132 # We need to search for the tool using the
2133 # PATH environment variable.
2134 for dirInPath
in os
.environ
['PATH'].split(os
.pathsep
):
2135 foundPath
= os
.path
.join(dirInPath
, tool
)
2136 if os
.path
.exists(foundPath
):
2137 return os
.path
.realpath(foundPath
)
2139 # If the tool was not found in the path then we just return
2143 ## Launch the module or platform build
2146 if not self
.ModuleFile
:
2147 if not self
.SpawnMode
or self
.Target
not in ["", "all"]:
2148 self
.SpawnMode
= False
2149 self
._BuildPlatform
()
2151 self
._MultiThreadBuildPlatform
()
2152 self
.CreateGuidedSectionToolsFile()
2154 self
.SpawnMode
= False
2157 if self
.Target
== 'cleanall':
2158 RemoveDirectory(os
.path
.dirname(GlobalData
.gDatabasePath
), True)
2160 def CreateAsBuiltInf(self
):
2161 for Module
in self
.BuildModules
:
2162 Module
.CreateAsBuiltInf()
2163 for Module
in self
.HashSkipModules
:
2164 Module
.CreateAsBuiltInf(True)
2165 self
.BuildModules
= []
2166 self
.HashSkipModules
= []
2167 ## Do some clean-up works when error occurred
2168 def Relinquish(self
):
2169 OldLogLevel
= EdkLogger
.GetLevel()
2170 EdkLogger
.SetLevel(EdkLogger
.ERROR
)
2171 #self.DumpBuildData()
2172 Utils
.Progressor
.Abort()
2173 if self
.SpawnMode
== True:
2175 EdkLogger
.SetLevel(OldLogLevel
)
2177 def DumpBuildData(self
):
2178 CacheDirectory
= os
.path
.dirname(GlobalData
.gDatabasePath
)
2179 Utils
.CreateDirectory(CacheDirectory
)
2180 Utils
.DataDump(Utils
.gFileTimeStampCache
, os
.path
.join(CacheDirectory
, "gFileTimeStampCache"))
2181 Utils
.DataDump(Utils
.gDependencyDatabase
, os
.path
.join(CacheDirectory
, "gDependencyDatabase"))
2183 def RestoreBuildData(self
):
2184 FilePath
= os
.path
.join(os
.path
.dirname(GlobalData
.gDatabasePath
), "gFileTimeStampCache")
2185 if Utils
.gFileTimeStampCache
== {} and os
.path
.isfile(FilePath
):
2186 Utils
.gFileTimeStampCache
= Utils
.DataRestore(FilePath
)
2187 if Utils
.gFileTimeStampCache
is None:
2188 Utils
.gFileTimeStampCache
= {}
2190 FilePath
= os
.path
.join(os
.path
.dirname(GlobalData
.gDatabasePath
), "gDependencyDatabase")
2191 if Utils
.gDependencyDatabase
== {} and os
.path
.isfile(FilePath
):
2192 Utils
.gDependencyDatabase
= Utils
.DataRestore(FilePath
)
2193 if Utils
.gDependencyDatabase
is None:
2194 Utils
.gDependencyDatabase
= {}
2196 def ParseDefines(DefineList
=[]):
2198 if DefineList
is not None:
2199 for Define
in DefineList
:
2200 DefineTokenList
= Define
.split("=", 1)
2201 if not GlobalData
.gMacroNamePattern
.match(DefineTokenList
[0]):
2202 EdkLogger
.error('build', FORMAT_INVALID
,
2203 "The macro name must be in the pattern [A-Z][A-Z0-9_]*",
2204 ExtraData
=DefineTokenList
[0])
2206 if len(DefineTokenList
) == 1:
2207 DefineDict
[DefineTokenList
[0]] = "TRUE"
2209 DefineDict
[DefineTokenList
[0]] = DefineTokenList
[1].strip()
2213 def SingleCheckCallback(option
, opt_str
, value
, parser
):
2214 if option
not in gParamCheck
:
2215 setattr(parser
.values
, option
.dest
, value
)
2216 gParamCheck
.append(option
)
2218 parser
.error("Option %s only allows one instance in command line!" % option
)
2220 def LogBuildTime(Time
):
2223 TimeDur
= time
.gmtime(Time
)
2224 if TimeDur
.tm_yday
> 1:
2225 TimeDurStr
= time
.strftime("%H:%M:%S", TimeDur
) + ", %d day(s)" % (TimeDur
.tm_yday
- 1)
2227 TimeDurStr
= time
.strftime("%H:%M:%S", TimeDur
)
2232 ## Parse command line options
2234 # Using standard Python module optparse to parse command line option of this tool.
2236 # @retval Opt A optparse.Values object containing the parsed options
2237 # @retval Args Target of build command
2239 def MyOptionParser():
2240 Parser
= OptionParser(description
=__copyright__
, version
=__version__
, prog
="build.exe", usage
="%prog [options] [all|fds|genc|genmake|clean|cleanall|cleanlib|modules|libraries|run]")
2241 Parser
.add_option("-a", "--arch", action
="append", type="choice", choices
=['IA32', 'X64', 'IPF', 'EBC', 'ARM', 'AARCH64'], dest
="TargetArch",
2242 help="ARCHS is one of list: IA32, X64, IPF, ARM, AARCH64 or EBC, which overrides target.txt's TARGET_ARCH definition. To specify more archs, please repeat this option.")
2243 Parser
.add_option("-p", "--platform", action
="callback", type="string", dest
="PlatformFile", callback
=SingleCheckCallback
,
2244 help="Build the platform specified by the DSC file name argument, overriding target.txt's ACTIVE_PLATFORM definition.")
2245 Parser
.add_option("-m", "--module", action
="callback", type="string", dest
="ModuleFile", callback
=SingleCheckCallback
,
2246 help="Build the module specified by the INF file name argument.")
2247 Parser
.add_option("-b", "--buildtarget", type="string", dest
="BuildTarget", help="Using the TARGET to build the platform, overriding target.txt's TARGET definition.",
2249 Parser
.add_option("-t", "--tagname", action
="append", type="string", dest
="ToolChain",
2250 help="Using the Tool Chain Tagname to build the platform, overriding target.txt's TOOL_CHAIN_TAG definition.")
2251 Parser
.add_option("-x", "--sku-id", action
="callback", type="string", dest
="SkuId", callback
=SingleCheckCallback
,
2252 help="Using this name of SKU ID to build the platform, overriding SKUID_IDENTIFIER in DSC file.")
2254 Parser
.add_option("-n", action
="callback", type="int", dest
="ThreadNumber", callback
=SingleCheckCallback
,
2255 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 "\
2256 "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.")
2258 Parser
.add_option("-f", "--fdf", action
="callback", type="string", dest
="FdfFile", callback
=SingleCheckCallback
,
2259 help="The name of the FDF file to use, which overrides the setting in the DSC file.")
2260 Parser
.add_option("-r", "--rom-image", action
="append", type="string", dest
="RomImage", default
=[],
2261 help="The name of FD to be generated. The name must be from [FD] section in FDF file.")
2262 Parser
.add_option("-i", "--fv-image", action
="append", type="string", dest
="FvImage", default
=[],
2263 help="The name of FV to be generated. The name must be from [FV] section in FDF file.")
2264 Parser
.add_option("-C", "--capsule-image", action
="append", type="string", dest
="CapName", default
=[],
2265 help="The name of Capsule to be generated. The name must be from [Capsule] section in FDF file.")
2266 Parser
.add_option("-u", "--skip-autogen", action
="store_true", dest
="SkipAutoGen", help="Skip AutoGen step.")
2267 Parser
.add_option("-e", "--re-parse", action
="store_true", dest
="Reparse", help="Re-parse all meta-data files.")
2269 Parser
.add_option("-c", "--case-insensitive", action
="store_true", dest
="CaseInsensitive", default
=False, help="Don't check case of file name.")
2271 Parser
.add_option("-w", "--warning-as-error", action
="store_true", dest
="WarningAsError", help="Treat warning in tools as error.")
2272 Parser
.add_option("-j", "--log", action
="store", dest
="LogFile", help="Put log in specified file as well as on console.")
2274 Parser
.add_option("-s", "--silent", action
="store_true", type=None, dest
="SilentMode",
2275 help="Make use of silent mode of (n)make.")
2276 Parser
.add_option("-q", "--quiet", action
="store_true", type=None, help="Disable all messages except FATAL ERRORS.")
2277 Parser
.add_option("-v", "--verbose", action
="store_true", type=None, help="Turn on verbose output with informational messages printed, "\
2278 "including library instances selected, final dependency expression, "\
2279 "and warning messages, etc.")
2280 Parser
.add_option("-d", "--debug", action
="store", type="int", help="Enable debug messages at specified level.")
2281 Parser
.add_option("-D", "--define", action
="append", type="string", dest
="Macros", help="Macro: \"Name [= Value]\".")
2283 Parser
.add_option("-y", "--report-file", action
="store", dest
="ReportFile", help="Create/overwrite the report to the specified filename.")
2284 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
=[],
2285 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]. "\
2286 "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]")
2287 Parser
.add_option("-F", "--flag", action
="store", type="string", dest
="Flag",
2288 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. "\
2289 "This option can also be specified by setting *_*_*_BUILD_FLAGS in [BuildOptions] section of platform DSC. If they are both specified, this value "\
2290 "will override the setting in [BuildOptions] section of platform DSC.")
2291 Parser
.add_option("-N", "--no-cache", action
="store_true", dest
="DisableCache", default
=False, help="Disable build cache mechanism")
2292 Parser
.add_option("--conf", action
="store", type="string", dest
="ConfDirectory", help="Specify the customized Conf directory.")
2293 Parser
.add_option("--check-usage", action
="store_true", dest
="CheckUsage", default
=False, help="Check usage content of entries listed in INF file.")
2294 Parser
.add_option("--ignore-sources", action
="store_true", dest
="IgnoreSources", default
=False, help="Focus to a binary build and ignore all source files")
2295 Parser
.add_option("--pcd", action
="append", dest
="OptionPcd", help="Set PCD value by command line. Format: \"PcdName=Value\" ")
2296 Parser
.add_option("-l", "--cmd-len", action
="store", type="int", dest
="CommandLength", help="Specify the maximum line length of build command. Default is 4096.")
2297 Parser
.add_option("--hash", action
="store_true", dest
="UseHashCache", default
=False, help="Enable hash-based caching during build process.")
2298 Parser
.add_option("--binary-destination", action
="store", type="string", dest
="BinCacheDest", help="Generate a cache of binary files in the specified directory.")
2299 Parser
.add_option("--binary-source", action
="store", type="string", dest
="BinCacheSource", help="Consume a cache of binary files from the specified directory.")
2300 Parser
.add_option("--genfds-multi-thread", action
="store_true", dest
="GenfdsMultiThread", default
=False, help="Enable GenFds multi thread to generate ffs file.")
2301 (Opt
, Args
) = Parser
.parse_args()
2304 ## Tool entrance method
2306 # This method mainly dispatch specific methods per the command line options.
2307 # If no error found, return zero value so the caller of this tool can know
2308 # if it's executed successfully or not.
2310 # @retval 0 Tool was successful
2311 # @retval 1 Tool failed
2314 StartTime
= time
.time()
2316 # Initialize log system
2317 EdkLogger
.Initialize()
2318 GlobalData
.gCommand
= sys
.argv
[1:]
2320 # Parse the options and args
2322 (Option
, Target
) = MyOptionParser()
2323 GlobalData
.gOptions
= Option
2324 GlobalData
.gCaseInsensitive
= Option
.CaseInsensitive
2327 if Option
.verbose
is not None:
2328 EdkLogger
.SetLevel(EdkLogger
.VERBOSE
)
2329 elif Option
.quiet
is not None:
2330 EdkLogger
.SetLevel(EdkLogger
.QUIET
)
2331 elif Option
.debug
is not None:
2332 EdkLogger
.SetLevel(Option
.debug
+ 1)
2334 EdkLogger
.SetLevel(EdkLogger
.INFO
)
2336 if Option
.LogFile
is not None:
2337 EdkLogger
.SetLogFile(Option
.LogFile
)
2339 if Option
.WarningAsError
== True:
2340 EdkLogger
.SetWarningAsError()
2342 if platform
.platform().find("Windows") >= 0:
2343 GlobalData
.gIsWindows
= True
2345 GlobalData
.gIsWindows
= False
2347 EdkLogger
.quiet("Build environment: %s" % platform
.platform())
2348 EdkLogger
.quiet(time
.strftime("Build start time: %H:%M:%S, %b.%d %Y\n", time
.localtime()));
2353 if len(Target
) == 0:
2355 elif len(Target
) >= 2:
2356 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, "More than one targets are not supported.",
2357 ExtraData
="Please select one of: %s" % (' '.join(gSupportedTarget
)))
2359 Target
= Target
[0].lower()
2361 if Target
not in gSupportedTarget
:
2362 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, "Not supported target [%s]." % Target
,
2363 ExtraData
="Please select one of: %s" % (' '.join(gSupportedTarget
)))
2366 # Check environment variable: EDK_TOOLS_PATH, WORKSPACE, PATH
2369 GlobalData
.gCommandLineDefines
.update(ParseDefines(Option
.Macros
))
2371 Workspace
= os
.getenv("WORKSPACE")
2373 # Get files real name in workspace dir
2375 GlobalData
.gAllFiles
= Utils
.DirCache(Workspace
)
2377 WorkingDirectory
= os
.getcwd()
2378 if not Option
.ModuleFile
:
2379 FileList
= glob
.glob(os
.path
.normpath(os
.path
.join(WorkingDirectory
, '*.inf')))
2380 FileNum
= len(FileList
)
2382 EdkLogger
.error("build", OPTION_NOT_SUPPORTED
, "There are %d INF files in %s." % (FileNum
, WorkingDirectory
),
2383 ExtraData
="Please use '-m <INF_FILE_PATH>' switch to choose one.")
2385 Option
.ModuleFile
= NormFile(FileList
[0], Workspace
)
2387 if Option
.ModuleFile
:
2388 if os
.path
.isabs (Option
.ModuleFile
):
2389 if os
.path
.normcase (os
.path
.normpath(Option
.ModuleFile
)).find (Workspace
) == 0:
2390 Option
.ModuleFile
= NormFile(os
.path
.normpath(Option
.ModuleFile
), Workspace
)
2391 Option
.ModuleFile
= PathClass(Option
.ModuleFile
, Workspace
)
2392 ErrorCode
, ErrorInfo
= Option
.ModuleFile
.Validate(".inf", False)
2394 EdkLogger
.error("build", ErrorCode
, ExtraData
=ErrorInfo
)
2396 if Option
.PlatformFile
is not None:
2397 if os
.path
.isabs (Option
.PlatformFile
):
2398 if os
.path
.normcase (os
.path
.normpath(Option
.PlatformFile
)).find (Workspace
) == 0:
2399 Option
.PlatformFile
= NormFile(os
.path
.normpath(Option
.PlatformFile
), Workspace
)
2400 Option
.PlatformFile
= PathClass(Option
.PlatformFile
, Workspace
)
2402 if Option
.FdfFile
is not None:
2403 if os
.path
.isabs (Option
.FdfFile
):
2404 if os
.path
.normcase (os
.path
.normpath(Option
.FdfFile
)).find (Workspace
) == 0:
2405 Option
.FdfFile
= NormFile(os
.path
.normpath(Option
.FdfFile
), Workspace
)
2406 Option
.FdfFile
= PathClass(Option
.FdfFile
, Workspace
)
2407 ErrorCode
, ErrorInfo
= Option
.FdfFile
.Validate(".fdf", False)
2409 EdkLogger
.error("build", ErrorCode
, ExtraData
=ErrorInfo
)
2411 if Option
.Flag
is not None and Option
.Flag
not in ['-c', '-s']:
2412 EdkLogger
.error("build", OPTION_VALUE_INVALID
, "UNI flag must be one of -c or -s")
2414 MyBuild
= Build(Target
, Workspace
, Option
)
2415 GlobalData
.gCommandLineDefines
['ARCH'] = ' '.join(MyBuild
.ArchList
)
2416 if not (MyBuild
.LaunchPrebuildFlag
and os
.path
.exists(MyBuild
.PlatformBuildPath
)):
2419 #MyBuild.DumpBuildData()
2421 # All job done, no error found and no exception raised
2424 except FatalError
as X
:
2425 if MyBuild
is not None:
2426 # for multi-thread build exits safely
2427 MyBuild
.Relinquish()
2428 if Option
is not None and Option
.debug
is not None:
2429 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
2430 ReturnCode
= X
.args
[0]
2431 except Warning as X
:
2432 # error from Fdf parser
2433 if MyBuild
is not None:
2434 # for multi-thread build exits safely
2435 MyBuild
.Relinquish()
2436 if Option
is not None and Option
.debug
is not None:
2437 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
2439 EdkLogger
.error(X
.ToolName
, FORMAT_INVALID
, File
=X
.FileName
, Line
=X
.LineNumber
, ExtraData
=X
.Message
, RaiseError
=False)
2440 ReturnCode
= FORMAT_INVALID
2441 except KeyboardInterrupt:
2442 ReturnCode
= ABORT_ERROR
2443 if Option
is not None and Option
.debug
is not None:
2444 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
2446 if MyBuild
is not None:
2447 # for multi-thread build exits safely
2448 MyBuild
.Relinquish()
2450 # try to get the meta-file from the object causing exception
2451 Tb
= sys
.exc_info()[-1]
2452 MetaFile
= GlobalData
.gProcessingFile
2453 while Tb
is not None:
2454 if 'self' in Tb
.tb_frame
.f_locals
and hasattr(Tb
.tb_frame
.f_locals
['self'], 'MetaFile'):
2455 MetaFile
= Tb
.tb_frame
.f_locals
['self'].MetaFile
2460 "Unknown fatal error when processing [%s]" % MetaFile
,
2461 ExtraData
="\n(Please send email to edk2-devel@lists.01.org for help, attaching following call stack trace!)\n",
2464 EdkLogger
.quiet("(Python %s on %s) " % (platform
.python_version(), sys
.platform
) + traceback
.format_exc())
2465 ReturnCode
= CODE_ERROR
2467 Utils
.Progressor
.Abort()
2468 Utils
.ClearDuplicatedInf()
2472 MyBuild
.LaunchPostbuild()
2475 Conclusion
= "Failed"
2476 elif ReturnCode
== ABORT_ERROR
:
2477 Conclusion
= "Aborted"
2479 Conclusion
= "Failed"
2480 FinishTime
= time
.time()
2481 BuildDuration
= time
.gmtime(int(round(FinishTime
- StartTime
)))
2482 BuildDurationStr
= ""
2483 if BuildDuration
.tm_yday
> 1:
2484 BuildDurationStr
= time
.strftime("%H:%M:%S", BuildDuration
) + ", %d day(s)" % (BuildDuration
.tm_yday
- 1)
2486 BuildDurationStr
= time
.strftime("%H:%M:%S", BuildDuration
)
2487 if MyBuild
is not None:
2489 MyBuild
.BuildReport
.GenerateReport(BuildDurationStr
, LogBuildTime(MyBuild
.AutoGenTime
), LogBuildTime(MyBuild
.MakeTime
), LogBuildTime(MyBuild
.GenFdsTime
))
2491 EdkLogger
.SetLevel(EdkLogger
.QUIET
)
2492 EdkLogger
.quiet("\n- %s -" % Conclusion
)
2493 EdkLogger
.quiet(time
.strftime("Build end time: %H:%M:%S, %b.%d %Y", time
.localtime()))
2494 EdkLogger
.quiet("Build total time: %s\n" % BuildDurationStr
)
2497 if __name__
== '__main__':
2499 ## 0-127 is a safe return range, and 1 is a standard default error
2500 if r
< 0 or r
> 127: r
= 1