BaseTools/Source/Python/build/build.py

   1 ## @file
   2 # build a platform or a module
   3 #
   4 #  Copyright (c) 2014, Hewlett-Packard Development Company, L.P.<BR>
   5 #  Copyright (c) 2007 - 2019, Intel Corporation. All rights reserved.<BR>
   6 #  Copyright (c) 2018, Hewlett Packard Enterprise Development, L.P.<BR>
   7 #
   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
  12 #
  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.
  15 #
  16
  17 ##
  18 # Import Modules
  19 #
  20 from __future__ import print_function
  21 import Common.LongFilePathOs as os
  22 import re
  23 from io import BytesIO
  24 import sys
  25 import glob
  26 import time
  27 import platform
  28 import traceback
  29 import encodings.ascii
  30 import multiprocessing
  31
  32 from struct import *
  33 from threading import *
  34 import threading
  35 from optparse import OptionParser
  36 from subprocess import *
  37 from Common import Misc as Utils
  38
  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
  48
  49 from BuildReport import BuildReport
  50 from GenPatchPcdTable.GenPatchPcdTable import *
  51 from PatchPcdValue.PatchPcdValue import *
  52
  53 import Common.EdkLogger
  54 import Common.GlobalData as GlobalData
  55 from GenFds.GenFds import GenFds, GenFdsApi
  56
  57 from collections import OrderedDict, defaultdict
  58
  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."
  63
  64 ## standard targets of build command
  65 gSupportedTarget = ['all', 'genc', 'genmake', 'modules', 'libraries', 'fds', 'clean', 'cleanall', 'cleanlib', 'run']
  66
  67 ## build configuration file
  68 gBuildConfiguration = "target.txt"
  69 gToolsDefinition = "tools_def.txt"
  70
  71 TemporaryTablePattern = re.compile(r'^_\d+_\d+_[a-fA-F0-9]+$')
  72 TmpTableDict = {}
  73
  74 ## Check environment PATH variable to make sure the specified tool is found
  75 #
  76 #   If the tool is found in the PATH, then True is returned
  77 #   Otherwise, False is returned
  78 #
  79 def IsToolInPath(tool):
  80     if 'PATHEXT' in os.environ:
  81         extns = os.environ['PATHEXT'].split(os.path.pathsep)
  82     else:
  83         extns = ('',)
  84     for pathDir in os.environ['PATH'].split(os.path.pathsep):
  85         for ext in extns:
  86             if os.path.exists(os.path.join(pathDir, tool + ext)):
  87                 return True
  88     return False
  89
  90 ## Check environment variables
  91 #
  92 #  Check environment variables that must be set for build. Currently they are
  93 #
  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
  97 #
  98 #   If any of above environment variable is not set or has error, the build
  99 #   will be broken.
 100 #
 101 def CheckEnvVariable():
 102     # check WORKSPACE
 103     if "WORKSPACE" not in os.environ:
 104         EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "Environment variable not found",
 105                         ExtraData="WORKSPACE")
 106
 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
 114
 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)
 122             elif ' ' in Path:
 123                 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in PACKAGES_PATH", ExtraData=Path)
 124
 125
 126     os.environ["EDK_TOOLS_PATH"] = os.path.normcase(os.environ["EDK_TOOLS_PATH"])
 127
 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")
 132
 133     # check PATH
 134     if "PATH" not in os.environ:
 135         EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "Environment variable not found",
 136                         ExtraData="PATH")
 137
 138     GlobalData.gWorkspace = WorkspaceDir
 139
 140     GlobalData.gGlobalDefines["WORKSPACE"]  = WorkspaceDir
 141     GlobalData.gGlobalDefines["EDK_TOOLS_PATH"] = os.environ["EDK_TOOLS_PATH"]
 142
 143 ## Get normalized file path
 144 #
 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.
 147 #
 148 # @param  FilePath      File path to be normalized
 149 # @param  Workspace     Workspace path which the FilePath will be checked against
 150 #
 151 # @retval string        The normalized file path
 152 #
 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)
 157     else:
 158         FileFullPath = os.path.normpath(mws.join(Workspace, FilePath))
 159         Workspace = mws.getWs(Workspace, FilePath)
 160
 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)
 164
 165     # remove workspace directory from the beginning part of the file path
 166     if Workspace[-1] in ["\\", "/"]:
 167         return FileFullPath[len(Workspace):]
 168     else:
 169         return FileFullPath[(len(Workspace) + 1):]
 170
 171 ## Get the output of an external program
 172 #
 173 # This is the entrance method of thread reading output of an external program and
 174 # putting them in STDOUT/STDERR of current program.
 175 #
 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
 179 #
 180 def ReadMessage(From, To, ExitFlag):
 181     while True:
 182         # read one line a time
 183         Line = From.readline()
 184         # empty string means "end"
 185         if Line is not None and Line != "":
 186             To(Line.rstrip())
 187         else:
 188             break
 189         if ExitFlag.isSet():
 190             break
 191
 192 ## Launch an external program
 193 #
 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
 197 # redirection work.
 198 #
 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
 201 #
 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)
 207
 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)
 216
 217     Proc = None
 218     EndOfProcedure = None
 219     try:
 220         # launch the command
 221         Proc = Popen(Command, stdout=PIPE, stderr=PIPE, env=os.environ, cwd=WorkingDir, bufsize=-1, shell=True)
 222
 223         # launch two threads to read the STDOUT and STDERR
 224         EndOfProcedure = Event()
 225         EndOfProcedure.clear()
 226         if Proc.stdout:
 227             StdOutThread = Thread(target=ReadMessage, args=(Proc.stdout, EdkLogger.info, EndOfProcedure))
 228             StdOutThread.setName("STDOUT-Redirector")
 229             StdOutThread.setDaemon(False)
 230             StdOutThread.start()
 231
 232         if Proc.stderr:
 233             StdErrThread = Thread(target=ReadMessage, args=(Proc.stderr, EdkLogger.quiet, EndOfProcedure))
 234             StdErrThread.setName("STDERR-Redirector")
 235             StdErrThread.setDaemon(False)
 236             StdErrThread.start()
 237
 238         # waiting for program exit
 239         Proc.wait()
 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:
 244             EndOfProcedure.set()
 245         if Proc is 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))
 249
 250     if Proc.stdout:
 251         StdOutThread.join()
 252     if Proc.stderr:
 253         StdErrThread.join()
 254
 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):
 262             f = open(RespFile)
 263             RespContent = f.read()
 264             f.close()
 265             EdkLogger.info(RespContent)
 266
 267         EdkLogger.error("build", COMMAND_FAILURE, ExtraData="%s [%s]" % (Command, WorkingDir))
 268     return "%dms" % (int(round((time.time() - BeginTime) * 1000)))
 269
 270 ## The smallest unit that can be built in multi-thread build mode
 271 #
 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
 274 # missing build.
 275 #
 276 # Currently the "Obj" should be only ModuleAutoGen or PlatformAutoGen objects.
 277 #
 278 class BuildUnit:
 279     ## The constructor
 280     #
 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
 286     #
 287     def __init__(self, Obj, BuildCommand, Target, Dependency, WorkingDir="."):
 288         self.BuildObject = Obj
 289         self.Dependency = Dependency
 290         self.WorkingDir = WorkingDir
 291         self.Target = Target
 292         self.BuildCommand = BuildCommand
 293         if not 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),
 298                             ExtraData=str(Obj))
 299
 300
 301     ## str() method
 302     #
 303     #   It just returns the string representation of self.BuildObject
 304     #
 305     #   @param  self        The object pointer
 306     #
 307     def __str__(self):
 308         return str(self.BuildObject)
 309
 310     ## "==" operator method
 311     #
 312     #   It just compares self.BuildObject with "Other". So self.BuildObject must
 313     #   provide its own __eq__() method.
 314     #
 315     #   @param  self        The object pointer
 316     #   @param  Other       The other BuildUnit object compared to
 317     #
 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
 322
 323     ## hash() method
 324     #
 325     #   It just returns the hash value of self.BuildObject which must be hashable.
 326     #
 327     #   @param  self        The object pointer
 328     #
 329     def __hash__(self):
 330         return hash(self.BuildObject) + hash(self.BuildObject.Arch)
 331
 332     def __repr__(self):
 333         return repr(self.BuildObject)
 334
 335 ## The smallest module unit that can be built by nmake/make command in multi-thread build mode
 336 #
 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.
 340 #
 341 # Currently the "Obj" should be only ModuleAutoGen object.
 342 #
 343 class ModuleMakeUnit(BuildUnit):
 344     ## The constructor
 345     #
 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
 349     #
 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"
 355
 356 ## The smallest platform unit that can be built by nmake/make command in multi-thread build mode
 357 #
 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.
 361 #
 362 # Currently the "Obj" should be only PlatformAutoGen object.
 363 #
 364 class PlatformMakeUnit(BuildUnit):
 365     ## The constructor
 366     #
 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
 370     #
 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)
 375
 376 ## The class representing the task of a module build or platform build
 377 #
 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.
 380 #
 381 class BuildTask:
 382     # queue for tasks waiting for schedule
 383     _PendingQueue = OrderedDict()
 384     _PendingQueueLock = threading.Lock()
 385
 386     # queue for tasks ready for running
 387     _ReadyQueue = OrderedDict()
 388     _ReadyQueueLock = threading.Lock()
 389
 390     # queue for run tasks
 391     _RunningQueue = OrderedDict()
 392     _RunningQueueLock = threading.Lock()
 393
 394     # queue containing all build tasks, in case duplicate build
 395     _TaskQueue = OrderedDict()
 396
 397     # flag indicating error occurs in a running thread
 398     _ErrorFlag = threading.Event()
 399     _ErrorFlag.clear()
 400     _ErrorMessage = ""
 401
 402     # BoundedSemaphore object used to control the number of running threads
 403     _Thread = None
 404
 405     # flag indicating if the scheduler is started or not
 406     _SchedulerStopped = threading.Event()
 407     _SchedulerStopped.set()
 408
 409     ## Start the task scheduler thread
 410     #
 411     #   @param  MaxThreadNumber     The maximum thread number
 412     #   @param  ExitFlag            Flag used to end the scheduler
 413     #
 414     @staticmethod
 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():
 422             time.sleep(0.01)
 423
 424     ## Scheduler method
 425     #
 426     #   @param  MaxThreadNumber     The maximum thread number
 427     #   @param  ExitFlag            Flag used to end the scheduler
 428     #
 429     @staticmethod
 430     def Scheduler(MaxThreadNumber, ExitFlag):
 431         BuildTask._SchedulerStopped.clear()
 432         try:
 433             # use BoundedSemaphore to control the maximum running threads
 434             BuildTask._Thread = BoundedSemaphore(MaxThreadNumber)
 435             #
 436             # scheduling loop, which will exits when no pending/ready task and
 437             # indicated to do so, or there's error in running thread
 438             #
 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)))
 443
 444                 # get all pending tasks
 445                 BuildTask._PendingQueueLock.acquire()
 446                 BuildObjectList = BuildTask._PendingQueue.keys()
 447                 #
 448                 # check if their dependency is resolved, and if true, move them
 449                 # into ready queue
 450                 #
 451                 for BuildObject in BuildObjectList:
 452                     Bt = BuildTask._PendingQueue[BuildObject]
 453                     if Bt.IsReady():
 454                         BuildTask._ReadyQueue[BuildObject] = BuildTask._PendingQueue.pop(BuildObject)
 455                 BuildTask._PendingQueueLock.release()
 456
 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:
 461                         break
 462
 463                     # wait for active thread(s) exit
 464                     BuildTask._Thread.acquire(True)
 465
 466                     # start a new build thread
 467                     Bo, Bt = BuildTask._ReadyQueue.popitem()
 468
 469                     # move into running queue
 470                     BuildTask._RunningQueueLock.acquire()
 471                     BuildTask._RunningQueue[Bo] = Bt
 472                     BuildTask._RunningQueueLock.release()
 473
 474                     Bt.Start()
 475                     # avoid tense loop
 476                     time.sleep(0.01)
 477
 478                 # avoid tense loop
 479                 time.sleep(0.01)
 480
 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()))
 488                 # avoid tense loop
 489                 time.sleep(0.1)
 490         except BaseException as X:
 491             #
 492             # TRICK: hide the output of threads left runing, so that the user can
 493             #        catch the error message easily
 494             #
 495             EdkLogger.SetLevel(EdkLogger.ERROR)
 496             BuildTask._ErrorFlag.set()
 497             BuildTask._ErrorMessage = "build thread scheduler error\n\t%s" % str(X)
 498
 499         BuildTask._PendingQueue.clear()
 500         BuildTask._ReadyQueue.clear()
 501         BuildTask._RunningQueue.clear()
 502         BuildTask._TaskQueue.clear()
 503         BuildTask._SchedulerStopped.set()
 504
 505     ## Wait for all running method exit
 506     #
 507     @staticmethod
 508     def WaitForComplete():
 509         BuildTask._SchedulerStopped.wait()
 510
 511     ## Check if the scheduler is running or not
 512     #
 513     @staticmethod
 514     def IsOnGoing():
 515         return not BuildTask._SchedulerStopped.isSet()
 516
 517     ## Abort the build
 518     @staticmethod
 519     def Abort():
 520         if BuildTask.IsOnGoing():
 521             BuildTask._ErrorFlag.set()
 522             BuildTask.WaitForComplete()
 523
 524     ## Check if there's error in running thread
 525     #
 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.
 528     #
 529     @staticmethod
 530     def HasError():
 531         return BuildTask._ErrorFlag.isSet()
 532
 533     ## Get error message in running thread
 534     #
 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.
 537     #
 538     @staticmethod
 539     def GetErrorMessage():
 540         return BuildTask._ErrorMessage
 541
 542     ## Factory method to create a BuildTask object
 543     #
 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.
 548     #
 549     #   @param  BuildItem       A BuildUnit object representing a build object
 550     #   @param  Dependency      The dependent build object of BuildItem
 551     #
 552     @staticmethod
 553     def New(BuildItem, Dependency=None):
 554         if BuildItem in BuildTask._TaskQueue:
 555             Bt = BuildTask._TaskQueue[BuildItem]
 556             return Bt
 557
 558         Bt = BuildTask()
 559         Bt._Init(BuildItem, Dependency)
 560         BuildTask._TaskQueue[BuildItem] = Bt
 561
 562         BuildTask._PendingQueueLock.acquire()
 563         BuildTask._PendingQueue[BuildItem] = Bt
 564         BuildTask._PendingQueueLock.release()
 565
 566         return Bt
 567
 568     ## The real constructor of BuildTask
 569     #
 570     #   @param  BuildItem       A BuildUnit object representing a build object
 571     #   @param  Dependency      The dependent build object of BuildItem
 572     #
 573     def _Init(self, BuildItem, Dependency=None):
 574         self.BuildItem = BuildItem
 575
 576         self.DependencyList = []
 577         if Dependency is None:
 578             Dependency = BuildItem.Dependency
 579         else:
 580             Dependency.extend(BuildItem.Dependency)
 581         self.AddDependency(Dependency)
 582         # flag indicating build completes, used to avoid unnecessary re-build
 583         self.CompleteFlag = False
 584
 585     ## Check if all dependent build tasks are completed or not
 586     #
 587     def IsReady(self):
 588         ReadyFlag = True
 589         for Dep in self.DependencyList:
 590             if Dep.CompleteFlag == True:
 591                 continue
 592             ReadyFlag = False
 593             break
 594
 595         return ReadyFlag
 596
 597     ## Add dependent build task
 598     #
 599     #   @param  Dependency      The list of dependent build objects
 600     #
 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
 605
 606     ## The thread wrapper of LaunchCommand function
 607     #
 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
 610     #
 611     def _CommandThread(self, Command, WorkingDir):
 612         try:
 613             self.BuildItem.BuildObject.BuildTime = LaunchCommand(Command, WorkingDir)
 614             self.CompleteFlag = True
 615         except:
 616             #
 617             # TRICK: hide the output of threads left runing, so that the user can
 618             #        catch the error message easily
 619             #
 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
 625                                                                  )
 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()
 635
 636     ## Start build task thread
 637     #
 638     def Start(self):
 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()
 645
 646 ## The class contains the information related to EFI image
 647 #
 648 class PeImageInfo():
 649     ## Constructor
 650     #
 651     # Constructor will load all required image information.
 652     #
 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
 659     #
 660     def __init__(self, BaseName, Guid, Arch, OutputDir, DebugDir, ImageClass):
 661         self.BaseName         = BaseName
 662         self.Guid             = Guid
 663         self.Arch             = Arch
 664         self.OutputDir        = OutputDir
 665         self.DebugDir         = DebugDir
 666         self.Image            = ImageClass
 667         self.Image.Size       = (self.Image.Size // 0x1000 + 1) * 0x1000
 668
 669 ## The class implementing the EDK2 build process
 670 #
 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
 678 #
 679 class Build():
 680     ## Constructor
 681     #
 682     # Constructor will load all necessary configurations, parse platform, modules
 683     # and packages and the establish a database for AutoGen.
 684     #
 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
 688     #
 689     def __init__(self, Target, WorkspaceDir, BuildOptions):
 690         self.WorkspaceDir   = WorkspaceDir
 691         self.Target         = Target
 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
 706         if self.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()
 713         self.AutoGenTime    = 0
 714         self.MakeTime       = 0
 715         self.GenFdsTime     = 0
 716         GlobalData.BuildOptionPcd     = BuildOptions.OptionPcd if BuildOptions.OptionPcd else []
 717         #Set global flag for build mode
 718         GlobalData.gIgnoreSource = BuildOptions.IgnoreSources
 719         GlobalData.gUseHashCache = BuildOptions.UseHashCache
 720         GlobalData.gBinCacheDest   = BuildOptions.BinCacheDest
 721         GlobalData.gBinCacheSource = BuildOptions.BinCacheSource
 722         GlobalData.gEnableGenfdsMultiThread = BuildOptions.GenfdsMultiThread
 723
 724         if GlobalData.gBinCacheDest and not GlobalData.gUseHashCache:
 725             EdkLogger.error("build", OPTION_NOT_SUPPORTED, ExtraData="--binary-destination must be used together with --hash.")
 726
 727         if GlobalData.gBinCacheSource and not GlobalData.gUseHashCache:
 728             EdkLogger.error("build", OPTION_NOT_SUPPORTED, ExtraData="--binary-source must be used together with --hash.")
 729
 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.")
 732
 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
 738         else:
 739             if GlobalData.gBinCacheSource is not None:
 740                 EdkLogger.error("build", OPTION_VALUE_INVALID, ExtraData="Invalid value of option --binary-source.")
 741
 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
 747         else:
 748             if GlobalData.gBinCacheDest is not None:
 749                 EdkLogger.error("build", OPTION_VALUE_INVALID, ExtraData="Invalid value of option --binary-destination.")
 750
 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)
 754
 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)
 759         else:
 760             if "CONF_PATH" in os.environ:
 761                 ConfDirectoryPath = os.path.normcase(os.path.normpath(os.environ["CONF_PATH"]))
 762             else:
 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))
 767
 768         self.Db = WorkspaceDatabase()
 769         self.BuildDatabase = self.Db.BuildObject
 770         self.Platform = None
 771         self.ToolChainFamily = None
 772         self.LoadFixAddress = 0
 773         self.UniFlag        = BuildOptions.Flag
 774         self.BuildModules = []
 775         self.HashSkipModules = []
 776         self.Db_Flag = False
 777         self.LaunchPrebuildFlag = False
 778         self.PlatformBuildPath = os.path.join(GlobalData.gConfDirectory, '.cache', '.PlatformBuild')
 779         if BuildOptions.CommandLength:
 780             GlobalData.gCommandMaxLength = BuildOptions.CommandLength
 781
 782         # print dot character during doing some time-consuming work
 783         self.Progress = Utils.Progressor()
 784         # print current build environment and configuration
 785         EdkLogger.quiet("%-16s = %s" % ("WORKSPACE", os.environ["WORKSPACE"]))
 786         if "PACKAGES_PATH" in os.environ:
 787             # WORKSPACE env has been converted before. Print the same path style with WORKSPACE env.
 788             EdkLogger.quiet("%-16s = %s" % ("PACKAGES_PATH", os.path.normcase(os.path.normpath(os.environ["PACKAGES_PATH"]))))
 789         EdkLogger.quiet("%-16s = %s" % ("EDK_TOOLS_PATH", os.environ["EDK_TOOLS_PATH"]))
 790         if "EDK_TOOLS_BIN" in os.environ:
 791             # Print the same path style with WORKSPACE env.
 792             EdkLogger.quiet("%-16s = %s" % ("EDK_TOOLS_BIN", os.path.normcase(os.path.normpath(os.environ["EDK_TOOLS_BIN"]))))
 793         EdkLogger.quiet("%-16s = %s" % ("CONF_PATH", GlobalData.gConfDirectory))
 794         if "PYTHON3_ENABLE" in os.environ:
 795             PYTHON3_ENABLE = os.environ["PYTHON3_ENABLE"]
 796             if PYTHON3_ENABLE != "TRUE":
 797                 PYTHON3_ENABLE = "FALSE"
 798             EdkLogger.quiet("%-16s = %s" % ("PYTHON3_ENABLE", PYTHON3_ENABLE))
 799         EdkLogger.quiet("%-16s = %s" % ("PYTHON", os.environ["PYTHON"]))
 800         self.InitPreBuild()
 801         self.InitPostBuild()
 802         if self.Prebuild:
 803             EdkLogger.quiet("%-16s = %s" % ("PREBUILD", self.Prebuild))
 804         if self.Postbuild:
 805             EdkLogger.quiet("%-16s = %s" % ("POSTBUILD", self.Postbuild))
 806         if self.Prebuild:
 807             self.LaunchPrebuild()
 808             self.TargetTxt = TargetTxtClassObject()
 809             self.ToolDef   = ToolDefClassObject()
 810         if not (self.LaunchPrebuildFlag and os.path.exists(self.PlatformBuildPath)):
 811             self.InitBuild()
 812
 813         EdkLogger.info("")
 814         os.chdir(self.WorkspaceDir)
 815
 816     ## Load configuration
 817     #
 818     #   This method will parse target.txt and get the build configurations.
 819     #
 820     def LoadConfiguration(self):
 821         #
 822         # Check target.txt and tools_def.txt and Init them
 823         #
 824         BuildConfigurationFile = os.path.normpath(os.path.join(GlobalData.gConfDirectory, gBuildConfiguration))
 825         if os.path.isfile(BuildConfigurationFile) == True:
 826             StatusCode = self.TargetTxt.LoadTargetTxtFile(BuildConfigurationFile)
 827
 828             ToolDefinitionFile = self.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_TOOL_CHAIN_CONF]
 829             if ToolDefinitionFile == '':
 830                 ToolDefinitionFile = gToolsDefinition
 831                 ToolDefinitionFile = os.path.normpath(mws.join(self.WorkspaceDir, 'Conf', ToolDefinitionFile))
 832             if os.path.isfile(ToolDefinitionFile) == True:
 833                 StatusCode = self.ToolDef.LoadToolDefFile(ToolDefinitionFile)
 834             else:
 835                 EdkLogger.error("build", FILE_NOT_FOUND, ExtraData=ToolDefinitionFile)
 836         else:
 837             EdkLogger.error("build", FILE_NOT_FOUND, ExtraData=BuildConfigurationFile)
 838
 839         # if no ARCH given in command line, get it from target.txt
 840         if not self.ArchList:
 841             self.ArchList = self.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_TARGET_ARCH]
 842         self.ArchList = tuple(self.ArchList)
 843
 844         # if no build target given in command line, get it from target.txt
 845         if not self.BuildTargetList:
 846             self.BuildTargetList = self.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_TARGET]
 847
 848         # if no tool chain given in command line, get it from target.txt
 849         if not self.ToolChainList:
 850             self.ToolChainList = self.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_TOOL_CHAIN_TAG]
 851             if self.ToolChainList is None or len(self.ToolChainList) == 0:
 852                 EdkLogger.error("build", RESOURCE_NOT_AVAILABLE, ExtraData="No toolchain given. Don't know how to build.\n")
 853
 854         # check if the tool chains are defined or not
 855         NewToolChainList = []
 856         for ToolChain in self.ToolChainList:
 857             if ToolChain not in self.ToolDef.ToolsDefTxtDatabase[TAB_TOD_DEFINES_TOOL_CHAIN_TAG]:
 858                 EdkLogger.warn("build", "Tool chain [%s] is not defined" % ToolChain)
 859             else:
 860                 NewToolChainList.append(ToolChain)
 861         # if no tool chain available, break the build
 862         if len(NewToolChainList) == 0:
 863             EdkLogger.error("build", RESOURCE_NOT_AVAILABLE,
 864                             ExtraData="[%s] not defined. No toolchain available for build!\n" % ", ".join(self.ToolChainList))
 865         else:
 866             self.ToolChainList = NewToolChainList
 867
 868         ToolChainFamily = []
 869         ToolDefinition = self.ToolDef.ToolsDefTxtDatabase
 870         for Tool in self.ToolChainList:
 871             if TAB_TOD_DEFINES_FAMILY not in ToolDefinition or Tool not in ToolDefinition[TAB_TOD_DEFINES_FAMILY] \
 872                or not ToolDefinition[TAB_TOD_DEFINES_FAMILY][Tool]:
 873                 EdkLogger.warn("build", "No tool chain family found in configuration for %s. Default to MSFT." % Tool)
 874                 ToolChainFamily.append(TAB_COMPILER_MSFT)
 875             else:
 876                 ToolChainFamily.append(ToolDefinition[TAB_TOD_DEFINES_FAMILY][Tool])
 877         self.ToolChainFamily = ToolChainFamily
 878
 879         if self.ThreadNumber is None:
 880             self.ThreadNumber = self.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_MAX_CONCURRENT_THREAD_NUMBER]
 881             if self.ThreadNumber == '':
 882                 self.ThreadNumber = 0
 883             else:
 884                 self.ThreadNumber = int(self.ThreadNumber, 0)
 885
 886         if self.ThreadNumber == 0:
 887             try:
 888                 self.ThreadNumber = multiprocessing.cpu_count()
 889             except (ImportError, NotImplementedError):
 890                 self.ThreadNumber = 1
 891
 892         if not self.PlatformFile:
 893             PlatformFile = self.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_ACTIVE_PLATFORM]
 894             if not PlatformFile:
 895                 # Try to find one in current directory
 896                 WorkingDirectory = os.getcwd()
 897                 FileList = glob.glob(os.path.normpath(os.path.join(WorkingDirectory, '*.dsc')))
 898                 FileNum = len(FileList)
 899                 if FileNum >= 2:
 900                     EdkLogger.error("build", OPTION_MISSING,
 901                                     ExtraData="There are %d DSC files in %s. Use '-p' to specify one.\n" % (FileNum, WorkingDirectory))
 902                 elif FileNum == 1:
 903                     PlatformFile = FileList[0]
 904                 else:
 905                     EdkLogger.error("build", RESOURCE_NOT_AVAILABLE,
 906                                     ExtraData="No active platform specified in target.txt or command line! Nothing can be built.\n")
 907
 908             self.PlatformFile = PathClass(NormFile(PlatformFile, self.WorkspaceDir), self.WorkspaceDir)
 909
 910     ## Initialize build configuration
 911     #
 912     #   This method will parse DSC file and merge the configurations from
 913     #   command line and target.txt, then get the final build configurations.
 914     #
 915     def InitBuild(self):
 916         # parse target.txt, tools_def.txt, and platform file
 917         self.LoadConfiguration()
 918
 919         # Allow case-insensitive for those from command line or configuration file
 920         ErrorCode, ErrorInfo = self.PlatformFile.Validate(".dsc", False)
 921         if ErrorCode != 0:
 922             EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)
 923
 924
 925     def InitPreBuild(self):
 926         self.LoadConfiguration()
 927         ErrorCode, ErrorInfo = self.PlatformFile.Validate(".dsc", False)
 928         if ErrorCode != 0:
 929             EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)
 930         if self.BuildTargetList:
 931             GlobalData.gGlobalDefines['TARGET'] = self.BuildTargetList[0]
 932         if self.ArchList:
 933             GlobalData.gGlobalDefines['ARCH'] = self.ArchList[0]
 934         if self.ToolChainList:
 935             GlobalData.gGlobalDefines['TOOLCHAIN'] = self.ToolChainList[0]
 936             GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = self.ToolChainList[0]
 937         if self.ToolChainFamily:
 938             GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[0]
 939         if 'PREBUILD' in GlobalData.gCommandLineDefines:
 940             self.Prebuild   = GlobalData.gCommandLineDefines.get('PREBUILD')
 941         else:
 942             self.Db_Flag = True
 943             Platform = self.Db.MapPlatform(str(self.PlatformFile))
 944             self.Prebuild = str(Platform.Prebuild)
 945         if self.Prebuild:
 946             PrebuildList = []
 947             #
 948             # Evaluate all arguments and convert arguments that are WORKSPACE
 949             # relative paths to absolute paths.  Filter arguments that look like
 950             # flags or do not follow the file/dir naming rules to avoid false
 951             # positives on this conversion.
 952             #
 953             for Arg in self.Prebuild.split():
 954                 #
 955                 # Do not modify Arg if it looks like a flag or an absolute file path
 956                 #
 957                 if Arg.startswith('-')  or os.path.isabs(Arg):
 958                     PrebuildList.append(Arg)
 959                     continue
 960                 #
 961                 # Do not modify Arg if it does not look like a Workspace relative
 962                 # path that starts with a valid package directory name
 963                 #
 964                 if not Arg[0].isalpha() or os.path.dirname(Arg) == '':
 965                     PrebuildList.append(Arg)
 966                     continue
 967                 #
 968                 # If Arg looks like a WORKSPACE relative path, then convert to an
 969                 # absolute path and check to see if the file exists.
 970                 #
 971                 Temp = mws.join(self.WorkspaceDir, Arg)
 972                 if os.path.isfile(Temp):
 973                     Arg = Temp
 974                 PrebuildList.append(Arg)
 975             self.Prebuild       = ' '.join(PrebuildList)
 976             self.Prebuild += self.PassCommandOption(self.BuildTargetList, self.ArchList, self.ToolChainList, self.PlatformFile, self.Target)
 977
 978     def InitPostBuild(self):
 979         if 'POSTBUILD' in GlobalData.gCommandLineDefines:
 980             self.Postbuild = GlobalData.gCommandLineDefines.get('POSTBUILD')
 981         else:
 982             Platform = self.Db.MapPlatform(str(self.PlatformFile))
 983             self.Postbuild = str(Platform.Postbuild)
 984         if self.Postbuild:
 985             PostbuildList = []
 986             #
 987             # Evaluate all arguments and convert arguments that are WORKSPACE
 988             # relative paths to absolute paths.  Filter arguments that look like
 989             # flags or do not follow the file/dir naming rules to avoid false
 990             # positives on this conversion.
 991             #
 992             for Arg in self.Postbuild.split():
 993                 #
 994                 # Do not modify Arg if it looks like a flag or an absolute file path
 995                 #
 996                 if Arg.startswith('-')  or os.path.isabs(Arg):
 997                     PostbuildList.append(Arg)
 998                     continue
 999                 #
1000                 # Do not modify Arg if it does not look like a Workspace relative
1001                 # path that starts with a valid package directory name
1002                 #
1003                 if not Arg[0].isalpha() or os.path.dirname(Arg) == '':
1004                     PostbuildList.append(Arg)
1005                     continue
1006                 #
1007                 # If Arg looks like a WORKSPACE relative path, then convert to an
1008                 # absolute path and check to see if the file exists.
1009                 #
1010                 Temp = mws.join(self.WorkspaceDir, Arg)
1011                 if os.path.isfile(Temp):
1012                     Arg = Temp
1013                 PostbuildList.append(Arg)
1014             self.Postbuild       = ' '.join(PostbuildList)
1015             self.Postbuild += self.PassCommandOption(self.BuildTargetList, self.ArchList, self.ToolChainList, self.PlatformFile, self.Target)
1016
1017     def PassCommandOption(self, BuildTarget, TargetArch, ToolChain, PlatformFile, Target):
1018         BuildStr = ''
1019         if GlobalData.gCommand and isinstance(GlobalData.gCommand, list):
1020             BuildStr += ' ' + ' '.join(GlobalData.gCommand)
1021         TargetFlag = False
1022         ArchFlag = False
1023         ToolChainFlag = False
1024         PlatformFileFlag = False
1025
1026         if GlobalData.gOptions and not GlobalData.gOptions.BuildTarget:
1027             TargetFlag = True
1028         if GlobalData.gOptions and not GlobalData.gOptions.TargetArch:
1029             ArchFlag = True
1030         if GlobalData.gOptions and not GlobalData.gOptions.ToolChain:
1031             ToolChainFlag = True
1032         if GlobalData.gOptions and not GlobalData.gOptions.PlatformFile:
1033             PlatformFileFlag = True
1034
1035         if TargetFlag and BuildTarget:
1036             if isinstance(BuildTarget, list) or isinstance(BuildTarget, tuple):
1037                 BuildStr += ' -b ' + ' -b '.join(BuildTarget)
1038             elif isinstance(BuildTarget, str):
1039                 BuildStr += ' -b ' + BuildTarget
1040         if ArchFlag and TargetArch:
1041             if isinstance(TargetArch, list) or isinstance(TargetArch, tuple):
1042                 BuildStr += ' -a ' + ' -a '.join(TargetArch)
1043             elif isinstance(TargetArch, str):
1044                 BuildStr += ' -a ' + TargetArch
1045         if ToolChainFlag and ToolChain:
1046             if isinstance(ToolChain, list) or isinstance(ToolChain, tuple):
1047                 BuildStr += ' -t ' + ' -t '.join(ToolChain)
1048             elif isinstance(ToolChain, str):
1049                 BuildStr += ' -t ' + ToolChain
1050         if PlatformFileFlag and PlatformFile:
1051             if isinstance(PlatformFile, list) or isinstance(PlatformFile, tuple):
1052                 BuildStr += ' -p ' + ' -p '.join(PlatformFile)
1053             elif isinstance(PlatformFile, str):
1054                 BuildStr += ' -p' + PlatformFile
1055         BuildStr += ' --conf=' + GlobalData.gConfDirectory
1056         if Target:
1057             BuildStr += ' ' + Target
1058
1059         return BuildStr
1060
1061     def LaunchPrebuild(self):
1062         if self.Prebuild:
1063             EdkLogger.info("\n- Prebuild Start -\n")
1064             self.LaunchPrebuildFlag = True
1065             #
1066             # The purpose of .PrebuildEnv file is capture environment variable settings set by the prebuild script
1067             # and preserve them for the rest of the main build step, because the child process environment will
1068             # evaporate as soon as it exits, we cannot get it in build step.
1069             #
1070             PrebuildEnvFile = os.path.join(GlobalData.gConfDirectory, '.cache', '.PrebuildEnv')
1071             if os.path.isfile(PrebuildEnvFile):
1072                 os.remove(PrebuildEnvFile)
1073             if os.path.isfile(self.PlatformBuildPath):
1074                 os.remove(self.PlatformBuildPath)
1075             if sys.platform == "win32":
1076                 args = ' && '.join((self.Prebuild, 'set > ' + PrebuildEnvFile))
1077                 Process = Popen(args, stdout=PIPE, stderr=PIPE, shell=True)
1078             else:
1079                 args = ' && '.join((self.Prebuild, 'env > ' + PrebuildEnvFile))
1080                 Process = Popen(args, stdout=PIPE, stderr=PIPE, shell=True)
1081
1082             # launch two threads to read the STDOUT and STDERR
1083             EndOfProcedure = Event()
1084             EndOfProcedure.clear()
1085             if Process.stdout:
1086                 StdOutThread = Thread(target=ReadMessage, args=(Process.stdout, EdkLogger.info, EndOfProcedure))
1087                 StdOutThread.setName("STDOUT-Redirector")
1088                 StdOutThread.setDaemon(False)
1089                 StdOutThread.start()
1090
1091             if Process.stderr:
1092                 StdErrThread = Thread(target=ReadMessage, args=(Process.stderr, EdkLogger.quiet, EndOfProcedure))
1093                 StdErrThread.setName("STDERR-Redirector")
1094                 StdErrThread.setDaemon(False)
1095                 StdErrThread.start()
1096             # waiting for program exit
1097             Process.wait()
1098
1099             if Process.stdout:
1100                 StdOutThread.join()
1101             if Process.stderr:
1102                 StdErrThread.join()
1103             if Process.returncode != 0 :
1104                 EdkLogger.error("Prebuild", PREBUILD_ERROR, 'Prebuild process is not success!')
1105
1106             if os.path.exists(PrebuildEnvFile):
1107                 f = open(PrebuildEnvFile)
1108                 envs = f.readlines()
1109                 f.close()
1110                 envs = [l.split("=", 1) for l in envs ]
1111                 envs = [[I.strip() for I in item] for item in envs if len(item) == 2]
1112                 os.environ.update(dict(envs))
1113             EdkLogger.info("\n- Prebuild Done -\n")
1114
1115     def LaunchPostbuild(self):
1116         if self.Postbuild:
1117             EdkLogger.info("\n- Postbuild Start -\n")
1118             if sys.platform == "win32":
1119                 Process = Popen(self.Postbuild, stdout=PIPE, stderr=PIPE, shell=True)
1120             else:
1121                 Process = Popen(self.Postbuild, stdout=PIPE, stderr=PIPE, shell=True)
1122             # launch two threads to read the STDOUT and STDERR
1123             EndOfProcedure = Event()
1124             EndOfProcedure.clear()
1125             if Process.stdout:
1126                 StdOutThread = Thread(target=ReadMessage, args=(Process.stdout, EdkLogger.info, EndOfProcedure))
1127                 StdOutThread.setName("STDOUT-Redirector")
1128                 StdOutThread.setDaemon(False)
1129                 StdOutThread.start()
1130
1131             if Process.stderr:
1132                 StdErrThread = Thread(target=ReadMessage, args=(Process.stderr, EdkLogger.quiet, EndOfProcedure))
1133                 StdErrThread.setName("STDERR-Redirector")
1134                 StdErrThread.setDaemon(False)
1135                 StdErrThread.start()
1136             # waiting for program exit
1137             Process.wait()
1138
1139             if Process.stdout:
1140                 StdOutThread.join()
1141             if Process.stderr:
1142                 StdErrThread.join()
1143             if Process.returncode != 0 :
1144                 EdkLogger.error("Postbuild", POSTBUILD_ERROR, 'Postbuild process is not success!')
1145             EdkLogger.info("\n- Postbuild Done -\n")
1146     ## Build a module or platform
1147     #
1148     # Create autogen code and makefile for a module or platform, and the launch
1149     # "make" command to build it
1150     #
1151     #   @param  Target                      The target of build command
1152     #   @param  Platform                    The platform file
1153     #   @param  Module                      The module file
1154     #   @param  BuildTarget                 The name of build target, one of "DEBUG", "RELEASE"
1155     #   @param  ToolChain                   The name of toolchain to build
1156     #   @param  Arch                        The arch of the module/platform
1157     #   @param  CreateDepModuleCodeFile     Flag used to indicate creating code
1158     #                                       for dependent modules/Libraries
1159     #   @param  CreateDepModuleMakeFile     Flag used to indicate creating makefile
1160     #                                       for dependent modules/Libraries
1161     #
1162     def _BuildPa(self, Target, AutoGenObject, CreateDepsCodeFile=True, CreateDepsMakeFile=True, BuildModule=False, FfsCommand={}):
1163         if AutoGenObject is None:
1164             return False
1165
1166         # skip file generation for cleanxxx targets, run and fds target
1167         if Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1168             # for target which must generate AutoGen code and makefile
1169             if not self.SkipAutoGen or Target == 'genc':
1170                 self.Progress.Start("Generating code")
1171                 AutoGenObject.CreateCodeFile(CreateDepsCodeFile)
1172                 self.Progress.Stop("done!")
1173             if Target == "genc":
1174                 return True
1175
1176             if not self.SkipAutoGen or Target == 'genmake':
1177                 self.Progress.Start("Generating makefile")
1178                 AutoGenObject.CreateMakeFile(CreateDepsMakeFile, FfsCommand)
1179                 self.Progress.Stop("done!")
1180             if Target == "genmake":
1181                 return True
1182         else:
1183             # always recreate top/platform makefile when clean, just in case of inconsistency
1184             AutoGenObject.CreateCodeFile(False)
1185             AutoGenObject.CreateMakeFile(False)
1186
1187         if EdkLogger.GetLevel() == EdkLogger.QUIET:
1188             EdkLogger.quiet("Building ... %s" % repr(AutoGenObject))
1189
1190         BuildCommand = AutoGenObject.BuildCommand
1191         if BuildCommand is None or len(BuildCommand) == 0:
1192             EdkLogger.error("build", OPTION_MISSING,
1193                             "No build command found for this module. "
1194                             "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %
1195                                 (AutoGenObject.BuildTarget, AutoGenObject.ToolChain, AutoGenObject.Arch),
1196                             ExtraData=str(AutoGenObject))
1197
1198         makefile = GenMake.BuildFile(AutoGenObject)._FILE_NAME_[GenMake.gMakeType]
1199
1200         # run
1201         if Target == 'run':
1202             RunDir = os.path.normpath(os.path.join(AutoGenObject.BuildDir, GlobalData.gGlobalDefines['ARCH']))
1203             Command = '.\SecMain'
1204             os.chdir(RunDir)
1205             LaunchCommand(Command, RunDir)
1206             return True
1207
1208         # build modules
1209         if BuildModule:
1210             BuildCommand = BuildCommand + [Target]
1211             LaunchCommand(BuildCommand, AutoGenObject.MakeFileDir)
1212             self.CreateAsBuiltInf()
1213             return True
1214
1215         # build library
1216         if Target == 'libraries':
1217             for Lib in AutoGenObject.LibraryBuildDirectoryList:
1218                 NewBuildCommand = BuildCommand + ['-f', os.path.normpath(os.path.join(Lib, makefile)), 'pbuild']
1219                 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)
1220             return True
1221
1222         # build module
1223         if Target == 'modules':
1224             for Lib in AutoGenObject.LibraryBuildDirectoryList:
1225                 NewBuildCommand = BuildCommand + ['-f', os.path.normpath(os.path.join(Lib, makefile)), 'pbuild']
1226                 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)
1227             for Mod in AutoGenObject.ModuleBuildDirectoryList:
1228                 NewBuildCommand = BuildCommand + ['-f', os.path.normpath(os.path.join(Mod, makefile)), 'pbuild']
1229                 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)
1230             self.CreateAsBuiltInf()
1231             return True
1232
1233         # cleanlib
1234         if Target == 'cleanlib':
1235             for Lib in AutoGenObject.LibraryBuildDirectoryList:
1236                 LibMakefile = os.path.normpath(os.path.join(Lib, makefile))
1237                 if os.path.exists(LibMakefile):
1238                     NewBuildCommand = BuildCommand + ['-f', LibMakefile, 'cleanall']
1239                     LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)
1240             return True
1241
1242         # clean
1243         if Target == 'clean':
1244             for Mod in AutoGenObject.ModuleBuildDirectoryList:
1245                 ModMakefile = os.path.normpath(os.path.join(Mod, makefile))
1246                 if os.path.exists(ModMakefile):
1247                     NewBuildCommand = BuildCommand + ['-f', ModMakefile, 'cleanall']
1248                     LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)
1249             for Lib in AutoGenObject.LibraryBuildDirectoryList:
1250                 LibMakefile = os.path.normpath(os.path.join(Lib, makefile))
1251                 if os.path.exists(LibMakefile):
1252                     NewBuildCommand = BuildCommand + ['-f', LibMakefile, 'cleanall']
1253                     LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)
1254             return True
1255
1256         # cleanall
1257         if Target == 'cleanall':
1258             try:
1259                 #os.rmdir(AutoGenObject.BuildDir)
1260                 RemoveDirectory(AutoGenObject.BuildDir, True)
1261             except WindowsError as X:
1262                 EdkLogger.error("build", FILE_DELETE_FAILURE, ExtraData=str(X))
1263         return True
1264
1265     ## Build a module or platform
1266     #
1267     # Create autogen code and makefile for a module or platform, and the launch
1268     # "make" command to build it
1269     #
1270     #   @param  Target                      The target of build command
1271     #   @param  Platform                    The platform file
1272     #   @param  Module                      The module file
1273     #   @param  BuildTarget                 The name of build target, one of "DEBUG", "RELEASE"
1274     #   @param  ToolChain                   The name of toolchain to build
1275     #   @param  Arch                        The arch of the module/platform
1276     #   @param  CreateDepModuleCodeFile     Flag used to indicate creating code
1277     #                                       for dependent modules/Libraries
1278     #   @param  CreateDepModuleMakeFile     Flag used to indicate creating makefile
1279     #                                       for dependent modules/Libraries
1280     #
1281     def _Build(self, Target, AutoGenObject, CreateDepsCodeFile=True, CreateDepsMakeFile=True, BuildModule=False):
1282         if AutoGenObject is None:
1283             return False
1284
1285         # skip file generation for cleanxxx targets, run and fds target
1286         if Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1287             # for target which must generate AutoGen code and makefile
1288             if not self.SkipAutoGen or Target == 'genc':
1289                 self.Progress.Start("Generating code")
1290                 AutoGenObject.CreateCodeFile(CreateDepsCodeFile)
1291                 self.Progress.Stop("done!")
1292             if Target == "genc":
1293                 return True
1294
1295             if not self.SkipAutoGen or Target == 'genmake':
1296                 self.Progress.Start("Generating makefile")
1297                 AutoGenObject.CreateMakeFile(CreateDepsMakeFile)
1298                 #AutoGenObject.CreateAsBuiltInf()
1299                 self.Progress.Stop("done!")
1300             if Target == "genmake":
1301                 return True
1302         else:
1303             # always recreate top/platform makefile when clean, just in case of inconsistency
1304             AutoGenObject.CreateCodeFile(False)
1305             AutoGenObject.CreateMakeFile(False)
1306
1307         if EdkLogger.GetLevel() == EdkLogger.QUIET:
1308             EdkLogger.quiet("Building ... %s" % repr(AutoGenObject))
1309
1310         BuildCommand = AutoGenObject.BuildCommand
1311         if BuildCommand is None or len(BuildCommand) == 0:
1312             EdkLogger.error("build", OPTION_MISSING,
1313                             "No build command found for this module. "
1314                             "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %
1315                                 (AutoGenObject.BuildTarget, AutoGenObject.ToolChain, AutoGenObject.Arch),
1316                             ExtraData=str(AutoGenObject))
1317
1318         # build modules
1319         if BuildModule:
1320             if Target != 'fds':
1321                 BuildCommand = BuildCommand + [Target]
1322             AutoGenObject.BuildTime = LaunchCommand(BuildCommand, AutoGenObject.MakeFileDir)
1323             self.CreateAsBuiltInf()
1324             return True
1325
1326         # genfds
1327         if Target == 'fds':
1328             if GenFdsApi(AutoGenObject.GenFdsCommandDict, self.Db):
1329                 EdkLogger.error("build", COMMAND_FAILURE)
1330             return True
1331
1332         # run
1333         if Target == 'run':
1334             RunDir = os.path.normpath(os.path.join(AutoGenObject.BuildDir, GlobalData.gGlobalDefines['ARCH']))
1335             Command = '.\SecMain'
1336             os.chdir(RunDir)
1337             LaunchCommand(Command, RunDir)
1338             return True
1339
1340         # build library
1341         if Target == 'libraries':
1342             pass
1343
1344         # not build modules
1345
1346
1347         # cleanall
1348         if Target == 'cleanall':
1349             try:
1350                 #os.rmdir(AutoGenObject.BuildDir)
1351                 RemoveDirectory(AutoGenObject.BuildDir, True)
1352             except WindowsError as X:
1353                 EdkLogger.error("build", FILE_DELETE_FAILURE, ExtraData=str(X))
1354         return True
1355
1356     ## Rebase module image and Get function address for the input module list.
1357     #
1358     def _RebaseModule (self, MapBuffer, BaseAddress, ModuleList, AddrIsOffset = True, ModeIsSmm = False):
1359         if ModeIsSmm:
1360             AddrIsOffset = False
1361         for InfFile in ModuleList:
1362             sys.stdout.write (".")
1363             sys.stdout.flush()
1364             ModuleInfo = ModuleList[InfFile]
1365             ModuleName = ModuleInfo.BaseName
1366             ModuleOutputImage = ModuleInfo.Image.FileName
1367             ModuleDebugImage  = os.path.join(ModuleInfo.DebugDir, ModuleInfo.BaseName + '.efi')
1368             ## for SMM module in SMRAM, the SMRAM will be allocated from base to top.
1369             if not ModeIsSmm:
1370                 BaseAddress = BaseAddress - ModuleInfo.Image.Size
1371                 #
1372                 # Update Image to new BaseAddress by GenFw tool
1373                 #
1374                 LaunchCommand(["GenFw", "--rebase", str(BaseAddress), "-r", ModuleOutputImage], ModuleInfo.OutputDir)
1375                 LaunchCommand(["GenFw", "--rebase", str(BaseAddress), "-r", ModuleDebugImage], ModuleInfo.DebugDir)
1376             else:
1377                 #
1378                 # Set new address to the section header only for SMM driver.
1379                 #
1380                 LaunchCommand(["GenFw", "--address", str(BaseAddress), "-r", ModuleOutputImage], ModuleInfo.OutputDir)
1381                 LaunchCommand(["GenFw", "--address", str(BaseAddress), "-r", ModuleDebugImage], ModuleInfo.DebugDir)
1382             #
1383             # Collect funtion address from Map file
1384             #
1385             ImageMapTable = ModuleOutputImage.replace('.efi', '.map')
1386             FunctionList = []
1387             if os.path.exists(ImageMapTable):
1388                 OrigImageBaseAddress = 0
1389                 ImageMap = open(ImageMapTable, 'r')
1390                 for LinStr in ImageMap:
1391                     if len (LinStr.strip()) == 0:
1392                         continue
1393                     #
1394                     # Get the preferred address set on link time.
1395                     #
1396                     if LinStr.find ('Preferred load address is') != -1:
1397                         StrList = LinStr.split()
1398                         OrigImageBaseAddress = int (StrList[len(StrList) - 1], 16)
1399
1400                     StrList = LinStr.split()
1401                     if len (StrList) > 4:
1402                         if StrList[3] == 'f' or StrList[3] == 'F':
1403                             Name = StrList[1]
1404                             RelativeAddress = int (StrList[2], 16) - OrigImageBaseAddress
1405                             FunctionList.append ((Name, RelativeAddress))
1406
1407                 ImageMap.close()
1408             #
1409             # Add general information.
1410             #
1411             if ModeIsSmm:
1412                 MapBuffer.write('\n\n%s (Fixed SMRAM Offset,   BaseAddress=0x%010X,  EntryPoint=0x%010X)\n' % (ModuleName, BaseAddress, BaseAddress + ModuleInfo.Image.EntryPoint))
1413             elif AddrIsOffset:
1414                 MapBuffer.write('\n\n%s (Fixed Memory Offset,  BaseAddress=-0x%010X, EntryPoint=-0x%010X)\n' % (ModuleName, 0 - BaseAddress, 0 - (BaseAddress + ModuleInfo.Image.EntryPoint)))
1415             else:
1416                 MapBuffer.write('\n\n%s (Fixed Memory Address, BaseAddress=0x%010X,  EntryPoint=0x%010X)\n' % (ModuleName, BaseAddress, BaseAddress + ModuleInfo.Image.EntryPoint))
1417             #
1418             # Add guid and general seciton section.
1419             #
1420             TextSectionAddress = 0
1421             DataSectionAddress = 0
1422             for SectionHeader in ModuleInfo.Image.SectionHeaderList:
1423                 if SectionHeader[0] == '.text':
1424                     TextSectionAddress = SectionHeader[1]
1425                 elif SectionHeader[0] in ['.data', '.sdata']:
1426                     DataSectionAddress = SectionHeader[1]
1427             if AddrIsOffset:
1428                 MapBuffer.write('(GUID=%s, .textbaseaddress=-0x%010X, .databaseaddress=-0x%010X)\n' % (ModuleInfo.Guid, 0 - (BaseAddress + TextSectionAddress), 0 - (BaseAddress + DataSectionAddress)))
1429             else:
1430                 MapBuffer.write('(GUID=%s, .textbaseaddress=0x%010X, .databaseaddress=0x%010X)\n' % (ModuleInfo.Guid, BaseAddress + TextSectionAddress, BaseAddress + DataSectionAddress))
1431             #
1432             # Add debug image full path.
1433             #
1434             MapBuffer.write('(IMAGE=%s)\n\n' % (ModuleDebugImage))
1435             #
1436             # Add funtion address
1437             #
1438             for Function in FunctionList:
1439                 if AddrIsOffset:
1440                     MapBuffer.write('  -0x%010X    %s\n' % (0 - (BaseAddress + Function[1]), Function[0]))
1441                 else:
1442                     MapBuffer.write('  0x%010X    %s\n' % (BaseAddress + Function[1], Function[0]))
1443             ImageMap.close()
1444
1445             #
1446             # for SMM module in SMRAM, the SMRAM will be allocated from base to top.
1447             #
1448             if ModeIsSmm:
1449                 BaseAddress = BaseAddress + ModuleInfo.Image.Size
1450
1451     ## Collect MAP information of all FVs
1452     #
1453     def _CollectFvMapBuffer (self, MapBuffer, Wa, ModuleList):
1454         if self.Fdf:
1455             # First get the XIP base address for FV map file.
1456             GuidPattern = re.compile("[-a-fA-F0-9]+")
1457             GuidName = re.compile("\(GUID=[-a-fA-F0-9]+")
1458             for FvName in Wa.FdfProfile.FvDict:
1459                 FvMapBuffer = os.path.join(Wa.FvDir, FvName + '.Fv.map')
1460                 if not os.path.exists(FvMapBuffer):
1461                     continue
1462                 FvMap = open(FvMapBuffer, 'r')
1463                 #skip FV size information
1464                 FvMap.readline()
1465                 FvMap.readline()
1466                 FvMap.readline()
1467                 FvMap.readline()
1468                 for Line in FvMap:
1469                     MatchGuid = GuidPattern.match(Line)
1470                     if MatchGuid is not None:
1471                         #
1472                         # Replace GUID with module name
1473                         #
1474                         GuidString = MatchGuid.group()
1475                         if GuidString.upper() in ModuleList:
1476                             Line = Line.replace(GuidString, ModuleList[GuidString.upper()].Name)
1477                     MapBuffer.write(Line)
1478                     #
1479                     # Add the debug image full path.
1480                     #
1481                     MatchGuid = GuidName.match(Line)
1482                     if MatchGuid is not None:
1483                         GuidString = MatchGuid.group().split("=")[1]
1484                         if GuidString.upper() in ModuleList:
1485                             MapBuffer.write('(IMAGE=%s)\n' % (os.path.join(ModuleList[GuidString.upper()].DebugDir, ModuleList[GuidString.upper()].Name + '.efi')))
1486
1487                 FvMap.close()
1488
1489     ## Collect MAP information of all modules
1490     #
1491     def _CollectModuleMapBuffer (self, MapBuffer, ModuleList):
1492         sys.stdout.write ("Generate Load Module At Fix Address Map")
1493         sys.stdout.flush()
1494         PatchEfiImageList = []
1495         PeiModuleList  = {}
1496         BtModuleList   = {}
1497         RtModuleList   = {}
1498         SmmModuleList  = {}
1499         PeiSize = 0
1500         BtSize  = 0
1501         RtSize  = 0
1502         # reserve 4K size in SMRAM to make SMM module address not from 0.
1503         SmmSize = 0x1000
1504         for ModuleGuid in ModuleList:
1505             Module = ModuleList[ModuleGuid]
1506             GlobalData.gProcessingFile = "%s [%s, %s, %s]" % (Module.MetaFile, Module.Arch, Module.ToolChain, Module.BuildTarget)
1507
1508             OutputImageFile = ''
1509             for ResultFile in Module.CodaTargetList:
1510                 if str(ResultFile.Target).endswith('.efi'):
1511                     #
1512                     # module list for PEI, DXE, RUNTIME and SMM
1513                     #
1514                     OutputImageFile = os.path.join(Module.OutputDir, Module.Name + '.efi')
1515                     ImageClass = PeImageClass (OutputImageFile)
1516                     if not ImageClass.IsValid:
1517                         EdkLogger.error("build", FILE_PARSE_FAILURE, ExtraData=ImageClass.ErrorInfo)
1518                     ImageInfo = PeImageInfo(Module.Name, Module.Guid, Module.Arch, Module.OutputDir, Module.DebugDir, ImageClass)
1519                     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]:
1520                         PeiModuleList[Module.MetaFile] = ImageInfo
1521                         PeiSize += ImageInfo.Image.Size
1522                     elif Module.ModuleType in [EDK_COMPONENT_TYPE_BS_DRIVER, SUP_MODULE_DXE_DRIVER, SUP_MODULE_UEFI_DRIVER]:
1523                         BtModuleList[Module.MetaFile] = ImageInfo
1524                         BtSize += ImageInfo.Image.Size
1525                     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]:
1526                         RtModuleList[Module.MetaFile] = ImageInfo
1527                         RtSize += ImageInfo.Image.Size
1528                     elif Module.ModuleType in [SUP_MODULE_SMM_CORE, SUP_MODULE_DXE_SMM_DRIVER, SUP_MODULE_MM_STANDALONE, SUP_MODULE_MM_CORE_STANDALONE]:
1529                         SmmModuleList[Module.MetaFile] = ImageInfo
1530                         SmmSize += ImageInfo.Image.Size
1531                         if Module.ModuleType == SUP_MODULE_DXE_SMM_DRIVER:
1532                             PiSpecVersion = Module.Module.Specification.get('PI_SPECIFICATION_VERSION', '0x00000000')
1533                             # for PI specification < PI1.1, DXE_SMM_DRIVER also runs as BOOT time driver.
1534                             if int(PiSpecVersion, 16) < 0x0001000A:
1535                                 BtModuleList[Module.MetaFile] = ImageInfo
1536                                 BtSize += ImageInfo.Image.Size
1537                     break
1538             #
1539             # EFI image is final target.
1540             # Check EFI image contains patchable FixAddress related PCDs.
1541             #
1542             if OutputImageFile != '':
1543                 ModuleIsPatch = False
1544                 for Pcd in Module.ModulePcdList:
1545                     if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE and Pcd.TokenCName in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SET:
1546                         ModuleIsPatch = True
1547                         break
1548                 if not ModuleIsPatch:
1549                     for Pcd in Module.LibraryPcdList:
1550                         if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE and Pcd.TokenCName in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SET:
1551                             ModuleIsPatch = True
1552                             break
1553
1554                 if not ModuleIsPatch:
1555                     continue
1556                 #
1557                 # Module includes the patchable load fix address PCDs.
1558                 # It will be fixed up later.
1559                 #
1560                 PatchEfiImageList.append (OutputImageFile)
1561
1562         #
1563         # Get Top Memory address
1564         #
1565         ReservedRuntimeMemorySize = 0
1566         TopMemoryAddress = 0
1567         if self.LoadFixAddress == 0xFFFFFFFFFFFFFFFF:
1568             TopMemoryAddress = 0
1569         else:
1570             TopMemoryAddress = self.LoadFixAddress
1571             if TopMemoryAddress < RtSize + BtSize + PeiSize:
1572                 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS is too low to load driver")
1573
1574         #
1575         # Patch FixAddress related PCDs into EFI image
1576         #
1577         for EfiImage in PatchEfiImageList:
1578             EfiImageMap = EfiImage.replace('.efi', '.map')
1579             if not os.path.exists(EfiImageMap):
1580                 continue
1581             #
1582             # Get PCD offset in EFI image by GenPatchPcdTable function
1583             #
1584             PcdTable = parsePcdInfoFromMapFile(EfiImageMap, EfiImage)
1585             #
1586             # Patch real PCD value by PatchPcdValue tool
1587             #
1588             for PcdInfo in PcdTable:
1589                 ReturnValue = 0
1590                 if PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE:
1591                     ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE_DATA_TYPE, str (PeiSize // 0x1000))
1592                 elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE:
1593                     ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE_DATA_TYPE, str (BtSize // 0x1000))
1594                 elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE:
1595                     ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE_DATA_TYPE, str (RtSize // 0x1000))
1596                 elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE and len (SmmModuleList) > 0:
1597                     ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE_DATA_TYPE, str (SmmSize // 0x1000))
1598                 if ReturnValue != 0:
1599                     EdkLogger.error("build", PARAMETER_INVALID, "Patch PCD value failed", ExtraData=ErrorInfo)
1600
1601         MapBuffer.write('PEI_CODE_PAGE_NUMBER      = 0x%x\n' % (PeiSize // 0x1000))
1602         MapBuffer.write('BOOT_CODE_PAGE_NUMBER     = 0x%x\n' % (BtSize // 0x1000))
1603         MapBuffer.write('RUNTIME_CODE_PAGE_NUMBER  = 0x%x\n' % (RtSize // 0x1000))
1604         if len (SmmModuleList) > 0:
1605             MapBuffer.write('SMM_CODE_PAGE_NUMBER      = 0x%x\n' % (SmmSize // 0x1000))
1606
1607         PeiBaseAddr = TopMemoryAddress - RtSize - BtSize
1608         BtBaseAddr  = TopMemoryAddress - RtSize
1609         RtBaseAddr  = TopMemoryAddress - ReservedRuntimeMemorySize
1610
1611         self._RebaseModule (MapBuffer, PeiBaseAddr, PeiModuleList, TopMemoryAddress == 0)
1612         self._RebaseModule (MapBuffer, BtBaseAddr, BtModuleList, TopMemoryAddress == 0)
1613         self._RebaseModule (MapBuffer, RtBaseAddr, RtModuleList, TopMemoryAddress == 0)
1614         self._RebaseModule (MapBuffer, 0x1000, SmmModuleList, AddrIsOffset=False, ModeIsSmm=True)
1615         MapBuffer.write('\n\n')
1616         sys.stdout.write ("\n")
1617         sys.stdout.flush()
1618
1619     ## Save platform Map file
1620     #
1621     def _SaveMapFile (self, MapBuffer, Wa):
1622         #
1623         # Map file path is got.
1624         #
1625         MapFilePath = os.path.join(Wa.BuildDir, Wa.Name + '.map')
1626         #
1627         # Save address map into MAP file.
1628         #
1629         SaveFileOnChange(MapFilePath, MapBuffer.getvalue(), False)
1630         MapBuffer.close()
1631         if self.LoadFixAddress != 0:
1632             sys.stdout.write ("\nLoad Module At Fix Address Map file can be found at %s\n" % (MapFilePath))
1633         sys.stdout.flush()
1634
1635     ## Build active platform for different build targets and different tool chains
1636     #
1637     def _BuildPlatform(self):
1638         SaveFileOnChange(self.PlatformBuildPath, '# DO NOT EDIT \n# FILE auto-generated\n', False)
1639         for BuildTarget in self.BuildTargetList:
1640             GlobalData.gGlobalDefines['TARGET'] = BuildTarget
1641             index = 0
1642             for ToolChain in self.ToolChainList:
1643                 GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain
1644                 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain
1645                 GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[index]
1646                 index += 1
1647                 Wa = WorkspaceAutoGen(
1648                         self.WorkspaceDir,
1649                         self.PlatformFile,
1650                         BuildTarget,
1651                         ToolChain,
1652                         self.ArchList,
1653                         self.BuildDatabase,
1654                         self.TargetTxt,
1655                         self.ToolDef,
1656                         self.Fdf,
1657                         self.FdList,
1658                         self.FvList,
1659                         self.CapList,
1660                         self.SkuId,
1661                         self.UniFlag,
1662                         self.Progress
1663                         )
1664                 self.Fdf = Wa.FdfFile
1665                 self.LoadFixAddress = Wa.Platform.LoadFixAddress
1666                 self.BuildReport.AddPlatformReport(Wa)
1667                 self.Progress.Stop("done!")
1668
1669                 # Add ffs build to makefile
1670                 CmdListDict = {}
1671                 if GlobalData.gEnableGenfdsMultiThread and self.Fdf:
1672                     CmdListDict = self._GenFfsCmd()
1673
1674                 for Arch in Wa.ArchList:
1675                     GlobalData.gGlobalDefines['ARCH'] = Arch
1676                     Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)
1677                     for Module in Pa.Platform.Modules:
1678                         # Get ModuleAutoGen object to generate C code file and makefile
1679                         Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)
1680                         if Ma is None:
1681                             continue
1682                         self.BuildModules.append(Ma)
1683                     self._BuildPa(self.Target, Pa, FfsCommand=CmdListDict)
1684
1685                 # Create MAP file when Load Fix Address is enabled.
1686                 if self.Target in ["", "all", "fds"]:
1687                     for Arch in Wa.ArchList:
1688                         GlobalData.gGlobalDefines['ARCH'] = Arch
1689                         #
1690                         # Check whether the set fix address is above 4G for 32bit image.
1691                         #
1692                         if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:
1693                             EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS can't be set to larger than or equal to 4G for the platform with IA32 or ARM arch modules")
1694                     #
1695                     # Get Module List
1696                     #
1697                     ModuleList = {}
1698                     for Pa in Wa.AutoGenObjectList:
1699                         for Ma in Pa.ModuleAutoGenList:
1700                             if Ma is None:
1701                                 continue
1702                             if not Ma.IsLibrary:
1703                                 ModuleList[Ma.Guid.upper()] = Ma
1704
1705                     MapBuffer = BytesIO('')
1706                     if self.LoadFixAddress != 0:
1707                         #
1708                         # Rebase module to the preferred memory address before GenFds
1709                         #
1710                         self._CollectModuleMapBuffer(MapBuffer, ModuleList)
1711                     if self.Fdf:
1712                         #
1713                         # create FDS again for the updated EFI image
1714                         #
1715                         self._Build("fds", Wa)
1716                         #
1717                         # Create MAP file for all platform FVs after GenFds.
1718                         #
1719                         self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)
1720                     #
1721                     # Save MAP buffer into MAP file.
1722                     #
1723                     self._SaveMapFile (MapBuffer, Wa)
1724
1725     ## Build active module for different build targets, different tool chains and different archs
1726     #
1727     def _BuildModule(self):
1728         for BuildTarget in self.BuildTargetList:
1729             GlobalData.gGlobalDefines['TARGET'] = BuildTarget
1730             index = 0
1731             for ToolChain in self.ToolChainList:
1732                 WorkspaceAutoGenTime = time.time()
1733                 GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain
1734                 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain
1735                 GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[index]
1736                 index += 1
1737                 #
1738                 # module build needs platform build information, so get platform
1739                 # AutoGen first
1740                 #
1741                 Wa = WorkspaceAutoGen(
1742                         self.WorkspaceDir,
1743                         self.PlatformFile,
1744                         BuildTarget,
1745                         ToolChain,
1746                         self.ArchList,
1747                         self.BuildDatabase,
1748                         self.TargetTxt,
1749                         self.ToolDef,
1750                         self.Fdf,
1751                         self.FdList,
1752                         self.FvList,
1753                         self.CapList,
1754                         self.SkuId,
1755                         self.UniFlag,
1756                         self.Progress,
1757                         self.ModuleFile
1758                         )
1759                 self.Fdf = Wa.FdfFile
1760                 self.LoadFixAddress = Wa.Platform.LoadFixAddress
1761                 Wa.CreateMakeFile(False)
1762                 # Add ffs build to makefile
1763                 CmdListDict = None
1764                 if GlobalData.gEnableGenfdsMultiThread and self.Fdf:
1765                     CmdListDict = self._GenFfsCmd()
1766                 self.Progress.Stop("done!")
1767                 MaList = []
1768                 ExitFlag = threading.Event()
1769                 ExitFlag.clear()
1770                 self.AutoGenTime += int(round((time.time() - WorkspaceAutoGenTime)))
1771                 for Arch in Wa.ArchList:
1772                     AutoGenStart = time.time()
1773                     GlobalData.gGlobalDefines['ARCH'] = Arch
1774                     Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)
1775                     for Module in Pa.Platform.Modules:
1776                         if self.ModuleFile.Dir == Module.Dir and self.ModuleFile.Name == Module.Name:
1777                             Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)
1778                             if Ma is None: continue
1779                             MaList.append(Ma)
1780                             if Ma.CanSkipbyHash():
1781                                 self.HashSkipModules.append(Ma)
1782                                 continue
1783                             # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'
1784                             if self.Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1785                                 # for target which must generate AutoGen code and makefile
1786                                 if not self.SkipAutoGen or self.Target == 'genc':
1787                                     self.Progress.Start("Generating code")
1788                                     Ma.CreateCodeFile(True)
1789                                     self.Progress.Stop("done!")
1790                                 if self.Target == "genc":
1791                                     return True
1792                                 if not self.SkipAutoGen or self.Target == 'genmake':
1793                                     self.Progress.Start("Generating makefile")
1794                                     if CmdListDict and self.Fdf and (Module.File, Arch) in CmdListDict:
1795                                         Ma.CreateMakeFile(True, CmdListDict[Module.File, Arch])
1796                                         del CmdListDict[Module.File, Arch]
1797                                     else:
1798                                         Ma.CreateMakeFile(True)
1799                                     self.Progress.Stop("done!")
1800                                 if self.Target == "genmake":
1801                                     return True
1802                             self.BuildModules.append(Ma)
1803                     self.AutoGenTime += int(round((time.time() - AutoGenStart)))
1804                     MakeStart = time.time()
1805                     for Ma in self.BuildModules:
1806                         if not Ma.IsBinaryModule:
1807                             Bt = BuildTask.New(ModuleMakeUnit(Ma, self.Target))
1808                         # Break build if any build thread has error
1809                         if BuildTask.HasError():
1810                             # we need a full version of makefile for platform
1811                             ExitFlag.set()
1812                             BuildTask.WaitForComplete()
1813                             Pa.CreateMakeFile(False)
1814                             EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)
1815                         # Start task scheduler
1816                         if not BuildTask.IsOnGoing():
1817                             BuildTask.StartScheduler(self.ThreadNumber, ExitFlag)
1818
1819                     # in case there's an interruption. we need a full version of makefile for platform
1820                     Pa.CreateMakeFile(False)
1821                     if BuildTask.HasError():
1822                         EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)
1823                     self.MakeTime += int(round((time.time() - MakeStart)))
1824
1825                 MakeContiue = time.time()
1826                 ExitFlag.set()
1827                 BuildTask.WaitForComplete()
1828                 self.CreateAsBuiltInf()
1829                 self.MakeTime += int(round((time.time() - MakeContiue)))
1830                 if BuildTask.HasError():
1831                     EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)
1832
1833                 self.BuildReport.AddPlatformReport(Wa, MaList)
1834                 if MaList == []:
1835                     EdkLogger.error(
1836                                 'build',
1837                                 BUILD_ERROR,
1838                                 "Module for [%s] is not a component of active platform."\
1839                                 " Please make sure that the ARCH and inf file path are"\
1840                                 " given in the same as in [%s]" % \
1841                                     (', '.join(Wa.ArchList), self.PlatformFile),
1842                                 ExtraData=self.ModuleFile
1843                                 )
1844                 # Create MAP file when Load Fix Address is enabled.
1845                 if self.Target == "fds" and self.Fdf:
1846                     for Arch in Wa.ArchList:
1847                         #
1848                         # Check whether the set fix address is above 4G for 32bit image.
1849                         #
1850                         if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:
1851                             EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS can't be set to larger than or equal to 4G for the platorm with IA32 or ARM arch modules")
1852                     #
1853                     # Get Module List
1854                     #
1855                     ModuleList = {}
1856                     for Pa in Wa.AutoGenObjectList:
1857                         for Ma in Pa.ModuleAutoGenList:
1858                             if Ma is None:
1859                                 continue
1860                             if not Ma.IsLibrary:
1861                                 ModuleList[Ma.Guid.upper()] = Ma
1862
1863                     MapBuffer = BytesIO('')
1864                     if self.LoadFixAddress != 0:
1865                         #
1866                         # Rebase module to the preferred memory address before GenFds
1867                         #
1868                         self._CollectModuleMapBuffer(MapBuffer, ModuleList)
1869                     #
1870                     # create FDS again for the updated EFI image
1871                     #
1872                     GenFdsStart = time.time()
1873                     self._Build("fds", Wa)
1874                     self.GenFdsTime += int(round((time.time() - GenFdsStart)))
1875                     #
1876                     # Create MAP file for all platform FVs after GenFds.
1877                     #
1878                     self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)
1879                     #
1880                     # Save MAP buffer into MAP file.
1881                     #
1882                     self._SaveMapFile (MapBuffer, Wa)
1883
1884     def _GenFfsCmd(self):
1885         # convert dictionary of Cmd:(Inf,Arch)
1886         # to a new dictionary of (Inf,Arch):Cmd,Cmd,Cmd...
1887         CmdSetDict = defaultdict(set)
1888         GenFfsDict = GenFds.GenFfsMakefile('', GlobalData.gFdfParser, self, self.ArchList, GlobalData)
1889         for Cmd in GenFfsDict:
1890             tmpInf, tmpArch = GenFfsDict[Cmd]
1891             CmdSetDict[tmpInf, tmpArch].add(Cmd)
1892         return CmdSetDict
1893
1894     ## Build a platform in multi-thread mode
1895     #
1896     def _MultiThreadBuildPlatform(self):
1897         SaveFileOnChange(self.PlatformBuildPath, '# DO NOT EDIT \n# FILE auto-generated\n', False)
1898         for BuildTarget in self.BuildTargetList:
1899             GlobalData.gGlobalDefines['TARGET'] = BuildTarget
1900             index = 0
1901             for ToolChain in self.ToolChainList:
1902                 WorkspaceAutoGenTime = time.time()
1903                 GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain
1904                 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain
1905                 GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[index]
1906                 index += 1
1907                 Wa = WorkspaceAutoGen(
1908                         self.WorkspaceDir,
1909                         self.PlatformFile,
1910                         BuildTarget,
1911                         ToolChain,
1912                         self.ArchList,
1913                         self.BuildDatabase,
1914                         self.TargetTxt,
1915                         self.ToolDef,
1916                         self.Fdf,
1917                         self.FdList,
1918                         self.FvList,
1919                         self.CapList,
1920                         self.SkuId,
1921                         self.UniFlag,
1922                         self.Progress
1923                         )
1924                 self.Fdf = Wa.FdfFile
1925                 self.LoadFixAddress = Wa.Platform.LoadFixAddress
1926                 self.BuildReport.AddPlatformReport(Wa)
1927                 Wa.CreateMakeFile(False)
1928
1929                 # Add ffs build to makefile
1930                 CmdListDict = None
1931                 if GlobalData.gEnableGenfdsMultiThread and self.Fdf:
1932                     CmdListDict = self._GenFfsCmd()
1933
1934                 # multi-thread exit flag
1935                 ExitFlag = threading.Event()
1936                 ExitFlag.clear()
1937                 self.AutoGenTime += int(round((time.time() - WorkspaceAutoGenTime)))
1938                 for Arch in Wa.ArchList:
1939                     AutoGenStart = time.time()
1940                     GlobalData.gGlobalDefines['ARCH'] = Arch
1941                     Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)
1942                     if Pa is None:
1943                         continue
1944                     ModuleList = []
1945                     for Inf in Pa.Platform.Modules:
1946                         ModuleList.append(Inf)
1947                     # Add the INF only list in FDF
1948                     if GlobalData.gFdfParser is not None:
1949                         for InfName in GlobalData.gFdfParser.Profile.InfList:
1950                             Inf = PathClass(NormPath(InfName), self.WorkspaceDir, Arch)
1951                             if Inf in Pa.Platform.Modules:
1952                                 continue
1953                             ModuleList.append(Inf)
1954                     for Module in ModuleList:
1955                         # Get ModuleAutoGen object to generate C code file and makefile
1956                         Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)
1957
1958                         if Ma is None:
1959                             continue
1960                         if Ma.CanSkipbyHash():
1961                             self.HashSkipModules.append(Ma)
1962                             continue
1963
1964                         # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'
1965                         if self.Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1966                             # for target which must generate AutoGen code and makefile
1967                             if not self.SkipAutoGen or self.Target == 'genc':
1968                                 Ma.CreateCodeFile(True)
1969                             if self.Target == "genc":
1970                                 continue
1971
1972                             if not self.SkipAutoGen or self.Target == 'genmake':
1973                                 if CmdListDict and self.Fdf and (Module.File, Arch) in CmdListDict:
1974                                     Ma.CreateMakeFile(True, CmdListDict[Module.File, Arch])
1975                                     del CmdListDict[Module.File, Arch]
1976                                 else:
1977                                     Ma.CreateMakeFile(True)
1978                             if self.Target == "genmake":
1979                                 continue
1980                         self.BuildModules.append(Ma)
1981                     self.Progress.Stop("done!")
1982                     self.AutoGenTime += int(round((time.time() - AutoGenStart)))
1983                     MakeStart = time.time()
1984                     for Ma in self.BuildModules:
1985                         # Generate build task for the module
1986                         if not Ma.IsBinaryModule:
1987                             Bt = BuildTask.New(ModuleMakeUnit(Ma, self.Target))
1988                         # Break build if any build thread has error
1989                         if BuildTask.HasError():
1990                             # we need a full version of makefile for platform
1991                             ExitFlag.set()
1992                             BuildTask.WaitForComplete()
1993                             Pa.CreateMakeFile(False)
1994                             EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)
1995                         # Start task scheduler
1996                         if not BuildTask.IsOnGoing():
1997                             BuildTask.StartScheduler(self.ThreadNumber, ExitFlag)
1998
1999                     # in case there's an interruption. we need a full version of makefile for platform
2000                     Pa.CreateMakeFile(False)
2001                     if BuildTask.HasError():
2002                         EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)
2003                     self.MakeTime += int(round((time.time() - MakeStart)))
2004
2005                 MakeContiue = time.time()
2006
2007                 #
2008                 #
2009                 # All modules have been put in build tasks queue. Tell task scheduler
2010                 # to exit if all tasks are completed
2011                 #
2012                 ExitFlag.set()
2013                 BuildTask.WaitForComplete()
2014                 self.CreateAsBuiltInf()
2015                 self.MakeTime += int(round((time.time() - MakeContiue)))
2016                 #
2017                 # Check for build error, and raise exception if one
2018                 # has been signaled.
2019                 #
2020                 if BuildTask.HasError():
2021                     EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)
2022
2023                 # Create MAP file when Load Fix Address is enabled.
2024                 if self.Target in ["", "all", "fds"]:
2025                     for Arch in Wa.ArchList:
2026                         #
2027                         # Check whether the set fix address is above 4G for 32bit image.
2028                         #
2029                         if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:
2030                             EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS can't be set to larger than or equal to 4G for the platorm with IA32 or ARM arch modules")
2031                     #
2032                     # Get Module List
2033                     #
2034                     ModuleList = {}
2035                     for Pa in Wa.AutoGenObjectList:
2036                         for Ma in Pa.ModuleAutoGenList:
2037                             if Ma is None:
2038                                 continue
2039                             if not Ma.IsLibrary:
2040                                 ModuleList[Ma.Guid.upper()] = Ma
2041                     #
2042                     # Rebase module to the preferred memory address before GenFds
2043                     #
2044                     MapBuffer = BytesIO('')
2045                     if self.LoadFixAddress != 0:
2046                         self._CollectModuleMapBuffer(MapBuffer, ModuleList)
2047
2048                     if self.Fdf:
2049                         #
2050                         # Generate FD image if there's a FDF file found
2051                         #
2052                         GenFdsStart = time.time()
2053                         if GenFdsApi(Wa.GenFdsCommandDict, self.Db):
2054                             EdkLogger.error("build", COMMAND_FAILURE)
2055
2056                         #
2057                         # Create MAP file for all platform FVs after GenFds.
2058                         #
2059                         self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)
2060                         self.GenFdsTime += int(round((time.time() - GenFdsStart)))
2061                     #
2062                     # Save MAP buffer into MAP file.
2063                     #
2064                     self._SaveMapFile(MapBuffer, Wa)
2065
2066     ## Generate GuidedSectionTools.txt in the FV directories.
2067     #
2068     def CreateGuidedSectionToolsFile(self):
2069         for BuildTarget in self.BuildTargetList:
2070             for ToolChain in self.ToolChainList:
2071                 Wa = WorkspaceAutoGen(
2072                         self.WorkspaceDir,
2073                         self.PlatformFile,
2074                         BuildTarget,
2075                         ToolChain,
2076                         self.ArchList,
2077                         self.BuildDatabase,
2078                         self.TargetTxt,
2079                         self.ToolDef,
2080                         self.Fdf,
2081                         self.FdList,
2082                         self.FvList,
2083                         self.CapList,
2084                         self.SkuId,
2085                         self.UniFlag
2086                         )
2087                 FvDir = Wa.FvDir
2088                 if not os.path.exists(FvDir):
2089                     continue
2090
2091                 for Arch in self.ArchList:
2092                     # Build up the list of supported architectures for this build
2093                     prefix = '%s_%s_%s_' % (BuildTarget, ToolChain, Arch)
2094
2095                     # Look through the tool definitions for GUIDed tools
2096                     guidAttribs = []
2097                     for (attrib, value) in self.ToolDef.ToolsDefTxtDictionary.items():
2098                         if attrib.upper().endswith('_GUID'):
2099                             split = attrib.split('_')
2100                             thisPrefix = '_'.join(split[0:3]) + '_'
2101                             if thisPrefix == prefix:
2102                                 guid = self.ToolDef.ToolsDefTxtDictionary[attrib]
2103                                 guid = guid.lower()
2104                                 toolName = split[3]
2105                                 path = '_'.join(split[0:4]) + '_PATH'
2106                                 path = self.ToolDef.ToolsDefTxtDictionary[path]
2107                                 path = self.GetFullPathOfTool(path)
2108                                 guidAttribs.append((guid, toolName, path))
2109
2110                     # Write out GuidedSecTools.txt
2111                     toolsFile = os.path.join(FvDir, 'GuidedSectionTools.txt')
2112                     toolsFile = open(toolsFile, 'wt')
2113                     for guidedSectionTool in guidAttribs:
2114                         print(' '.join(guidedSectionTool), file=toolsFile)
2115                     toolsFile.close()
2116
2117     ## Returns the full path of the tool.
2118     #
2119     def GetFullPathOfTool (self, tool):
2120         if os.path.exists(tool):
2121             return os.path.realpath(tool)
2122         else:
2123             # We need to search for the tool using the
2124             # PATH environment variable.
2125             for dirInPath in os.environ['PATH'].split(os.pathsep):
2126                 foundPath = os.path.join(dirInPath, tool)
2127                 if os.path.exists(foundPath):
2128                     return os.path.realpath(foundPath)
2129
2130         # If the tool was not found in the path then we just return
2131         # the input tool.
2132         return tool
2133
2134     ## Launch the module or platform build
2135     #
2136     def Launch(self):
2137         if not self.ModuleFile:
2138             if not self.SpawnMode or self.Target not in ["", "all"]:
2139                 self.SpawnMode = False
2140                 self._BuildPlatform()
2141             else:
2142                 self._MultiThreadBuildPlatform()
2143             self.CreateGuidedSectionToolsFile()
2144         else:
2145             self.SpawnMode = False
2146             self._BuildModule()
2147
2148         if self.Target == 'cleanall':
2149             RemoveDirectory(os.path.dirname(GlobalData.gDatabasePath), True)
2150
2151     def CreateAsBuiltInf(self):
2152         for Module in self.BuildModules:
2153             Module.CreateAsBuiltInf()
2154         for Module in self.HashSkipModules:
2155             Module.CreateAsBuiltInf(True)
2156         self.BuildModules = []
2157         self.HashSkipModules = []
2158     ## Do some clean-up works when error occurred
2159     def Relinquish(self):
2160         OldLogLevel = EdkLogger.GetLevel()
2161         EdkLogger.SetLevel(EdkLogger.ERROR)
2162         Utils.Progressor.Abort()
2163         if self.SpawnMode == True:
2164             BuildTask.Abort()
2165         EdkLogger.SetLevel(OldLogLevel)
2166
2167 def ParseDefines(DefineList=[]):
2168     DefineDict = {}
2169     if DefineList is not None:
2170         for Define in DefineList:
2171             DefineTokenList = Define.split("=", 1)
2172             if not GlobalData.gMacroNamePattern.match(DefineTokenList[0]):
2173                 EdkLogger.error('build', FORMAT_INVALID,
2174                                 "The macro name must be in the pattern [A-Z][A-Z0-9_]*",
2175                                 ExtraData=DefineTokenList[0])
2176
2177             if len(DefineTokenList) == 1:
2178                 DefineDict[DefineTokenList[0]] = "TRUE"
2179             else:
2180                 DefineDict[DefineTokenList[0]] = DefineTokenList[1].strip()
2181     return DefineDict
2182
2183 gParamCheck = []
2184 def SingleCheckCallback(option, opt_str, value, parser):
2185     if option not in gParamCheck:
2186         setattr(parser.values, option.dest, value)
2187         gParamCheck.append(option)
2188     else:
2189         parser.error("Option %s only allows one instance in command line!" % option)
2190
2191 def LogBuildTime(Time):
2192     if Time:
2193         TimeDurStr = ''
2194         TimeDur = time.gmtime(Time)
2195         if TimeDur.tm_yday > 1:
2196             TimeDurStr = time.strftime("%H:%M:%S", TimeDur) + ", %d day(s)" % (TimeDur.tm_yday - 1)
2197         else:
2198             TimeDurStr = time.strftime("%H:%M:%S", TimeDur)
2199         return TimeDurStr
2200     else:
2201         return None
2202
2203 ## Parse command line options
2204 #
2205 # Using standard Python module optparse to parse command line option of this tool.
2206 #
2207 #   @retval Opt   A optparse.Values object containing the parsed options
2208 #   @retval Args  Target of build command
2209 #
2210 def MyOptionParser():
2211     Parser = OptionParser(description=__copyright__, version=__version__, prog="build.exe", usage="%prog [options] [all|fds|genc|genmake|clean|cleanall|cleanlib|modules|libraries|run]")
2212     Parser.add_option("-a", "--arch", action="append", type="choice", choices=['IA32', 'X64', 'EBC', 'ARM', 'AARCH64'], dest="TargetArch",
2213         help="ARCHS is one of list: IA32, X64, ARM, AARCH64 or EBC, which overrides target.txt's TARGET_ARCH definition. To specify more archs, please repeat this option.")
2214     Parser.add_option("-p", "--platform", action="callback", type="string", dest="PlatformFile", callback=SingleCheckCallback,
2215         help="Build the platform specified by the DSC file name argument, overriding target.txt's ACTIVE_PLATFORM definition.")
2216     Parser.add_option("-m", "--module", action="callback", type="string", dest="ModuleFile", callback=SingleCheckCallback,
2217         help="Build the module specified by the INF file name argument.")
2218     Parser.add_option("-b", "--buildtarget", type="string", dest="BuildTarget", help="Using the TARGET to build the platform, overriding target.txt's TARGET definition.",
2219                       action="append")
2220     Parser.add_option("-t", "--tagname", action="append", type="string", dest="ToolChain",
2221         help="Using the Tool Chain Tagname to build the platform, overriding target.txt's TOOL_CHAIN_TAG definition.")
2222     Parser.add_option("-x", "--sku-id", action="callback", type="string", dest="SkuId", callback=SingleCheckCallback,
2223         help="Using this name of SKU ID to build the platform, overriding SKUID_IDENTIFIER in DSC file.")
2224
2225     Parser.add_option("-n", action="callback", type="int", dest="ThreadNumber", callback=SingleCheckCallback,
2226         help="Build the platform using multi-threaded compiler. The value overrides target.txt's MAX_CONCURRENT_THREAD_NUMBER. When value is set to 0, tool automatically detect number of "\
2227              "processor threads, set value to 1 means disable multi-thread build, and set value to more than 1 means user specify the threads number to build.")
2228
2229     Parser.add_option("-f", "--fdf", action="callback", type="string", dest="FdfFile", callback=SingleCheckCallback,
2230         help="The name of the FDF file to use, which overrides the setting in the DSC file.")
2231     Parser.add_option("-r", "--rom-image", action="append", type="string", dest="RomImage", default=[],
2232         help="The name of FD to be generated. The name must be from [FD] section in FDF file.")
2233     Parser.add_option("-i", "--fv-image", action="append", type="string", dest="FvImage", default=[],
2234         help="The name of FV to be generated. The name must be from [FV] section in FDF file.")
2235     Parser.add_option("-C", "--capsule-image", action="append", type="string", dest="CapName", default=[],
2236         help="The name of Capsule to be generated. The name must be from [Capsule] section in FDF file.")
2237     Parser.add_option("-u", "--skip-autogen", action="store_true", dest="SkipAutoGen", help="Skip AutoGen step.")
2238     Parser.add_option("-e", "--re-parse", action="store_true", dest="Reparse", help="Re-parse all meta-data files.")
2239
2240     Parser.add_option("-c", "--case-insensitive", action="store_true", dest="CaseInsensitive", default=False, help="Don't check case of file name.")
2241
2242     Parser.add_option("-w", "--warning-as-error", action="store_true", dest="WarningAsError", help="Treat warning in tools as error.")
2243     Parser.add_option("-j", "--log", action="store", dest="LogFile", help="Put log in specified file as well as on console.")
2244
2245     Parser.add_option("-s", "--silent", action="store_true", type=None, dest="SilentMode",
2246         help="Make use of silent mode of (n)make.")
2247     Parser.add_option("-q", "--quiet", action="store_true", type=None, help="Disable all messages except FATAL ERRORS.")
2248     Parser.add_option("-v", "--verbose", action="store_true", type=None, help="Turn on verbose output with informational messages printed, "\
2249                                                                                "including library instances selected, final dependency expression, "\
2250                                                                                "and warning messages, etc.")
2251     Parser.add_option("-d", "--debug", action="store", type="int", help="Enable debug messages at specified level.")
2252     Parser.add_option("-D", "--define", action="append", type="string", dest="Macros", help="Macro: \"Name [= Value]\".")
2253
2254     Parser.add_option("-y", "--report-file", action="store", dest="ReportFile", help="Create/overwrite the report to the specified filename.")
2255     Parser.add_option("-Y", "--report-type", action="append", type="choice", choices=['PCD', 'LIBRARY', 'FLASH', 'DEPEX', 'BUILD_FLAGS', 'FIXED_ADDRESS', 'HASH', 'EXECUTION_ORDER'], dest="ReportType", default=[],
2256         help="Flags that control the type of build report to generate.  Must be one of: [PCD, LIBRARY, FLASH, DEPEX, BUILD_FLAGS, FIXED_ADDRESS, HASH, EXECUTION_ORDER].  "\
2257              "To specify more than one flag, repeat this option on the command line and the default flag set is [PCD, LIBRARY, FLASH, DEPEX, HASH, BUILD_FLAGS, FIXED_ADDRESS]")
2258     Parser.add_option("-F", "--flag", action="store", type="string", dest="Flag",
2259         help="Specify the specific option to parse EDK UNI file. Must be one of: [-c, -s]. -c is for EDK framework UNI file, and -s is for EDK UEFI UNI file. "\
2260              "This option can also be specified by setting *_*_*_BUILD_FLAGS in [BuildOptions] section of platform DSC. If they are both specified, this value "\
2261              "will override the setting in [BuildOptions] section of platform DSC.")
2262     Parser.add_option("-N", "--no-cache", action="store_true", dest="DisableCache", default=False, help="Disable build cache mechanism")
2263     Parser.add_option("--conf", action="store", type="string", dest="ConfDirectory", help="Specify the customized Conf directory.")
2264     Parser.add_option("--check-usage", action="store_true", dest="CheckUsage", default=False, help="Check usage content of entries listed in INF file.")
2265     Parser.add_option("--ignore-sources", action="store_true", dest="IgnoreSources", default=False, help="Focus to a binary build and ignore all source files")
2266     Parser.add_option("--pcd", action="append", dest="OptionPcd", help="Set PCD value by command line. Format: \"PcdName=Value\" ")
2267     Parser.add_option("-l", "--cmd-len", action="store", type="int", dest="CommandLength", help="Specify the maximum line length of build command. Default is 4096.")
2268     Parser.add_option("--hash", action="store_true", dest="UseHashCache", default=False, help="Enable hash-based caching during build process.")
2269     Parser.add_option("--binary-destination", action="store", type="string", dest="BinCacheDest", help="Generate a cache of binary files in the specified directory.")
2270     Parser.add_option("--binary-source", action="store", type="string", dest="BinCacheSource", help="Consume a cache of binary files from the specified directory.")
2271     Parser.add_option("--genfds-multi-thread", action="store_true", dest="GenfdsMultiThread", default=False, help="Enable GenFds multi thread to generate ffs file.")
2272     (Opt, Args) = Parser.parse_args()
2273     return (Opt, Args)
2274
2275 ## Tool entrance method
2276 #
2277 # This method mainly dispatch specific methods per the command line options.
2278 # If no error found, return zero value so the caller of this tool can know
2279 # if it's executed successfully or not.
2280 #
2281 #   @retval 0     Tool was successful
2282 #   @retval 1     Tool failed
2283 #
2284 def Main():
2285     StartTime = time.time()
2286
2287     # Initialize log system
2288     EdkLogger.Initialize()
2289     GlobalData.gCommand = sys.argv[1:]
2290     #
2291     # Parse the options and args
2292     #
2293     (Option, Target) = MyOptionParser()
2294     GlobalData.gOptions = Option
2295     GlobalData.gCaseInsensitive = Option.CaseInsensitive
2296
2297     # Set log level
2298     if Option.verbose is not None:
2299         EdkLogger.SetLevel(EdkLogger.VERBOSE)
2300     elif Option.quiet is not None:
2301         EdkLogger.SetLevel(EdkLogger.QUIET)
2302     elif Option.debug is not None:
2303         EdkLogger.SetLevel(Option.debug + 1)
2304     else:
2305         EdkLogger.SetLevel(EdkLogger.INFO)
2306
2307     if Option.LogFile is not None:
2308         EdkLogger.SetLogFile(Option.LogFile)
2309
2310     if Option.WarningAsError == True:
2311         EdkLogger.SetWarningAsError()
2312
2313     if platform.platform().find("Windows") >= 0:
2314         GlobalData.gIsWindows = True
2315     else:
2316         GlobalData.gIsWindows = False
2317
2318     EdkLogger.quiet("Build environment: %s" % platform.platform())
2319     EdkLogger.quiet(time.strftime("Build start time: %H:%M:%S, %b.%d %Y\n", time.localtime()));
2320     ReturnCode = 0
2321     MyBuild = None
2322     BuildError = True
2323     try:
2324         if len(Target) == 0:
2325             Target = "all"
2326         elif len(Target) >= 2:
2327             EdkLogger.error("build", OPTION_NOT_SUPPORTED, "More than one targets are not supported.",
2328                             ExtraData="Please select one of: %s" % (' '.join(gSupportedTarget)))
2329         else:
2330             Target = Target[0].lower()
2331
2332         if Target not in gSupportedTarget:
2333             EdkLogger.error("build", OPTION_NOT_SUPPORTED, "Not supported target [%s]." % Target,
2334                             ExtraData="Please select one of: %s" % (' '.join(gSupportedTarget)))
2335
2336         #
2337         # Check environment variable: EDK_TOOLS_PATH, WORKSPACE, PATH
2338         #
2339         CheckEnvVariable()
2340         GlobalData.gCommandLineDefines.update(ParseDefines(Option.Macros))
2341
2342         Workspace = os.getenv("WORKSPACE")
2343         #
2344         # Get files real name in workspace dir
2345         #
2346         GlobalData.gAllFiles = Utils.DirCache(Workspace)
2347
2348         WorkingDirectory = os.getcwd()
2349         if not Option.ModuleFile:
2350             FileList = glob.glob(os.path.normpath(os.path.join(WorkingDirectory, '*.inf')))
2351             FileNum = len(FileList)
2352             if FileNum >= 2:
2353                 EdkLogger.error("build", OPTION_NOT_SUPPORTED, "There are %d INF files in %s." % (FileNum, WorkingDirectory),
2354                                 ExtraData="Please use '-m <INF_FILE_PATH>' switch to choose one.")
2355             elif FileNum == 1:
2356                 Option.ModuleFile = NormFile(FileList[0], Workspace)
2357
2358         if Option.ModuleFile:
2359             if os.path.isabs (Option.ModuleFile):
2360                 if os.path.normcase (os.path.normpath(Option.ModuleFile)).find (Workspace) == 0:
2361                     Option.ModuleFile = NormFile(os.path.normpath(Option.ModuleFile), Workspace)
2362             Option.ModuleFile = PathClass(Option.ModuleFile, Workspace)
2363             ErrorCode, ErrorInfo = Option.ModuleFile.Validate(".inf", False)
2364             if ErrorCode != 0:
2365                 EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)
2366
2367         if Option.PlatformFile is not None:
2368             if os.path.isabs (Option.PlatformFile):
2369                 if os.path.normcase (os.path.normpath(Option.PlatformFile)).find (Workspace) == 0:
2370                     Option.PlatformFile = NormFile(os.path.normpath(Option.PlatformFile), Workspace)
2371             Option.PlatformFile = PathClass(Option.PlatformFile, Workspace)
2372
2373         if Option.FdfFile is not None:
2374             if os.path.isabs (Option.FdfFile):
2375                 if os.path.normcase (os.path.normpath(Option.FdfFile)).find (Workspace) == 0:
2376                     Option.FdfFile = NormFile(os.path.normpath(Option.FdfFile), Workspace)
2377             Option.FdfFile = PathClass(Option.FdfFile, Workspace)
2378             ErrorCode, ErrorInfo = Option.FdfFile.Validate(".fdf", False)
2379             if ErrorCode != 0:
2380                 EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)
2381
2382         if Option.Flag is not None and Option.Flag not in ['-c', '-s']:
2383             EdkLogger.error("build", OPTION_VALUE_INVALID, "UNI flag must be one of -c or -s")
2384
2385         MyBuild = Build(Target, Workspace, Option)
2386         GlobalData.gCommandLineDefines['ARCH'] = ' '.join(MyBuild.ArchList)
2387         if not (MyBuild.LaunchPrebuildFlag and os.path.exists(MyBuild.PlatformBuildPath)):
2388             MyBuild.Launch()
2389
2390         #
2391         # All job done, no error found and no exception raised
2392         #
2393         BuildError = False
2394     except FatalError as X:
2395         if MyBuild is not None:
2396             # for multi-thread build exits safely
2397             MyBuild.Relinquish()
2398         if Option is not None and Option.debug is not None:
2399             EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())
2400         ReturnCode = X.args[0]
2401     except Warning as X:
2402         # error from Fdf parser
2403         if MyBuild is not None:
2404             # for multi-thread build exits safely
2405             MyBuild.Relinquish()
2406         if Option is not None and Option.debug is not None:
2407             EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())
2408         else:
2409             EdkLogger.error(X.ToolName, FORMAT_INVALID, File=X.FileName, Line=X.LineNumber, ExtraData=X.Message, RaiseError=False)
2410         ReturnCode = FORMAT_INVALID
2411     except KeyboardInterrupt:
2412         ReturnCode = ABORT_ERROR
2413         if Option is not None and Option.debug is not None:
2414             EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())
2415     except:
2416         if MyBuild is not None:
2417             # for multi-thread build exits safely
2418             MyBuild.Relinquish()
2419
2420         # try to get the meta-file from the object causing exception
2421         Tb = sys.exc_info()[-1]
2422         MetaFile = GlobalData.gProcessingFile
2423         while Tb is not None:
2424             if 'self' in Tb.tb_frame.f_locals and hasattr(Tb.tb_frame.f_locals['self'], 'MetaFile'):
2425                 MetaFile = Tb.tb_frame.f_locals['self'].MetaFile
2426             Tb = Tb.tb_next
2427         EdkLogger.error(
2428                     "\nbuild",
2429                     CODE_ERROR,
2430                     "Unknown fatal error when processing [%s]" % MetaFile,
2431                     ExtraData="\n(Please send email to edk2-devel@lists.01.org for help, attaching following call stack trace!)\n",
2432                     RaiseError=False
2433                     )
2434         EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())
2435         ReturnCode = CODE_ERROR
2436     finally:
2437         Utils.Progressor.Abort()
2438         Utils.ClearDuplicatedInf()
2439
2440     if ReturnCode == 0:
2441         try:
2442             MyBuild.LaunchPostbuild()
2443             Conclusion = "Done"
2444         except:
2445             Conclusion = "Failed"
2446     elif ReturnCode == ABORT_ERROR:
2447         Conclusion = "Aborted"
2448     else:
2449         Conclusion = "Failed"
2450     FinishTime = time.time()
2451     BuildDuration = time.gmtime(int(round(FinishTime - StartTime)))
2452     BuildDurationStr = ""
2453     if BuildDuration.tm_yday > 1:
2454         BuildDurationStr = time.strftime("%H:%M:%S", BuildDuration) + ", %d day(s)" % (BuildDuration.tm_yday - 1)
2455     else:
2456         BuildDurationStr = time.strftime("%H:%M:%S", BuildDuration)
2457     if MyBuild is not None:
2458         if not BuildError:
2459             MyBuild.BuildReport.GenerateReport(BuildDurationStr, LogBuildTime(MyBuild.AutoGenTime), LogBuildTime(MyBuild.MakeTime), LogBuildTime(MyBuild.GenFdsTime))
2460
2461     EdkLogger.SetLevel(EdkLogger.QUIET)
2462     EdkLogger.quiet("\n- %s -" % Conclusion)
2463     EdkLogger.quiet(time.strftime("Build end time: %H:%M:%S, %b.%d %Y", time.localtime()))
2464     EdkLogger.quiet("Build total time: %s\n" % BuildDurationStr)
2465     return ReturnCode
2466
2467 if __name__ == '__main__':
2468     r = Main()
2469     ## 0-127 is a safe return range, and 1 is a standard default error
2470     if r < 0 or r > 127: r = 1
2471     sys.exit(r)
2472