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         if "PYTHON_COMMAND" in os.environ:
 800             EdkLogger.quiet("%-16s = %s" % ("PYTHON_COMMAND", os.environ["PYTHON_COMMAND"]))
 801         self.InitPreBuild()
 802         self.InitPostBuild()
 803         if self.Prebuild:
 804             EdkLogger.quiet("%-16s = %s" % ("PREBUILD", self.Prebuild))
 805         if self.Postbuild:
 806             EdkLogger.quiet("%-16s = %s" % ("POSTBUILD", self.Postbuild))
 807         if self.Prebuild:
 808             self.LaunchPrebuild()
 809             self.TargetTxt = TargetTxtClassObject()
 810             self.ToolDef   = ToolDefClassObject()
 811         if not (self.LaunchPrebuildFlag and os.path.exists(self.PlatformBuildPath)):
 812             self.InitBuild()
 813
 814         EdkLogger.info("")
 815         os.chdir(self.WorkspaceDir)
 816
 817     ## Load configuration
 818     #
 819     #   This method will parse target.txt and get the build configurations.
 820     #
 821     def LoadConfiguration(self):
 822         #
 823         # Check target.txt and tools_def.txt and Init them
 824         #
 825         BuildConfigurationFile = os.path.normpath(os.path.join(GlobalData.gConfDirectory, gBuildConfiguration))
 826         if os.path.isfile(BuildConfigurationFile) == True:
 827             StatusCode = self.TargetTxt.LoadTargetTxtFile(BuildConfigurationFile)
 828
 829             ToolDefinitionFile = self.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_TOOL_CHAIN_CONF]
 830             if ToolDefinitionFile == '':
 831                 ToolDefinitionFile = gToolsDefinition
 832                 ToolDefinitionFile = os.path.normpath(mws.join(self.WorkspaceDir, 'Conf', ToolDefinitionFile))
 833             if os.path.isfile(ToolDefinitionFile) == True:
 834                 StatusCode = self.ToolDef.LoadToolDefFile(ToolDefinitionFile)
 835             else:
 836                 EdkLogger.error("build", FILE_NOT_FOUND, ExtraData=ToolDefinitionFile)
 837         else:
 838             EdkLogger.error("build", FILE_NOT_FOUND, ExtraData=BuildConfigurationFile)
 839
 840         # if no ARCH given in command line, get it from target.txt
 841         if not self.ArchList:
 842             self.ArchList = self.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_TARGET_ARCH]
 843         self.ArchList = tuple(self.ArchList)
 844
 845         # if no build target given in command line, get it from target.txt
 846         if not self.BuildTargetList:
 847             self.BuildTargetList = self.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_TARGET]
 848
 849         # if no tool chain given in command line, get it from target.txt
 850         if not self.ToolChainList:
 851             self.ToolChainList = self.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_TOOL_CHAIN_TAG]
 852             if self.ToolChainList is None or len(self.ToolChainList) == 0:
 853                 EdkLogger.error("build", RESOURCE_NOT_AVAILABLE, ExtraData="No toolchain given. Don't know how to build.\n")
 854
 855         # check if the tool chains are defined or not
 856         NewToolChainList = []
 857         for ToolChain in self.ToolChainList:
 858             if ToolChain not in self.ToolDef.ToolsDefTxtDatabase[TAB_TOD_DEFINES_TOOL_CHAIN_TAG]:
 859                 EdkLogger.warn("build", "Tool chain [%s] is not defined" % ToolChain)
 860             else:
 861                 NewToolChainList.append(ToolChain)
 862         # if no tool chain available, break the build
 863         if len(NewToolChainList) == 0:
 864             EdkLogger.error("build", RESOURCE_NOT_AVAILABLE,
 865                             ExtraData="[%s] not defined. No toolchain available for build!\n" % ", ".join(self.ToolChainList))
 866         else:
 867             self.ToolChainList = NewToolChainList
 868
 869         ToolChainFamily = []
 870         ToolDefinition = self.ToolDef.ToolsDefTxtDatabase
 871         for Tool in self.ToolChainList:
 872             if TAB_TOD_DEFINES_FAMILY not in ToolDefinition or Tool not in ToolDefinition[TAB_TOD_DEFINES_FAMILY] \
 873                or not ToolDefinition[TAB_TOD_DEFINES_FAMILY][Tool]:
 874                 EdkLogger.warn("build", "No tool chain family found in configuration for %s. Default to MSFT." % Tool)
 875                 ToolChainFamily.append(TAB_COMPILER_MSFT)
 876             else:
 877                 ToolChainFamily.append(ToolDefinition[TAB_TOD_DEFINES_FAMILY][Tool])
 878         self.ToolChainFamily = ToolChainFamily
 879
 880         if self.ThreadNumber is None:
 881             self.ThreadNumber = self.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_MAX_CONCURRENT_THREAD_NUMBER]
 882             if self.ThreadNumber == '':
 883                 self.ThreadNumber = 0
 884             else:
 885                 self.ThreadNumber = int(self.ThreadNumber, 0)
 886
 887         if self.ThreadNumber == 0:
 888             try:
 889                 self.ThreadNumber = multiprocessing.cpu_count()
 890             except (ImportError, NotImplementedError):
 891                 self.ThreadNumber = 1
 892
 893         if not self.PlatformFile:
 894             PlatformFile = self.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_ACTIVE_PLATFORM]
 895             if not PlatformFile:
 896                 # Try to find one in current directory
 897                 WorkingDirectory = os.getcwd()
 898                 FileList = glob.glob(os.path.normpath(os.path.join(WorkingDirectory, '*.dsc')))
 899                 FileNum = len(FileList)
 900                 if FileNum >= 2:
 901                     EdkLogger.error("build", OPTION_MISSING,
 902                                     ExtraData="There are %d DSC files in %s. Use '-p' to specify one.\n" % (FileNum, WorkingDirectory))
 903                 elif FileNum == 1:
 904                     PlatformFile = FileList[0]
 905                 else:
 906                     EdkLogger.error("build", RESOURCE_NOT_AVAILABLE,
 907                                     ExtraData="No active platform specified in target.txt or command line! Nothing can be built.\n")
 908
 909             self.PlatformFile = PathClass(NormFile(PlatformFile, self.WorkspaceDir), self.WorkspaceDir)
 910
 911     ## Initialize build configuration
 912     #
 913     #   This method will parse DSC file and merge the configurations from
 914     #   command line and target.txt, then get the final build configurations.
 915     #
 916     def InitBuild(self):
 917         # parse target.txt, tools_def.txt, and platform file
 918         self.LoadConfiguration()
 919
 920         # Allow case-insensitive for those from command line or configuration file
 921         ErrorCode, ErrorInfo = self.PlatformFile.Validate(".dsc", False)
 922         if ErrorCode != 0:
 923             EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)
 924
 925
 926     def InitPreBuild(self):
 927         self.LoadConfiguration()
 928         ErrorCode, ErrorInfo = self.PlatformFile.Validate(".dsc", False)
 929         if ErrorCode != 0:
 930             EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)
 931         if self.BuildTargetList:
 932             GlobalData.gGlobalDefines['TARGET'] = self.BuildTargetList[0]
 933         if self.ArchList:
 934             GlobalData.gGlobalDefines['ARCH'] = self.ArchList[0]
 935         if self.ToolChainList:
 936             GlobalData.gGlobalDefines['TOOLCHAIN'] = self.ToolChainList[0]
 937             GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = self.ToolChainList[0]
 938         if self.ToolChainFamily:
 939             GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[0]
 940         if 'PREBUILD' in GlobalData.gCommandLineDefines:
 941             self.Prebuild   = GlobalData.gCommandLineDefines.get('PREBUILD')
 942         else:
 943             self.Db_Flag = True
 944             Platform = self.Db.MapPlatform(str(self.PlatformFile))
 945             self.Prebuild = str(Platform.Prebuild)
 946         if self.Prebuild:
 947             PrebuildList = []
 948             #
 949             # Evaluate all arguments and convert arguments that are WORKSPACE
 950             # relative paths to absolute paths.  Filter arguments that look like
 951             # flags or do not follow the file/dir naming rules to avoid false
 952             # positives on this conversion.
 953             #
 954             for Arg in self.Prebuild.split():
 955                 #
 956                 # Do not modify Arg if it looks like a flag or an absolute file path
 957                 #
 958                 if Arg.startswith('-')  or os.path.isabs(Arg):
 959                     PrebuildList.append(Arg)
 960                     continue
 961                 #
 962                 # Do not modify Arg if it does not look like a Workspace relative
 963                 # path that starts with a valid package directory name
 964                 #
 965                 if not Arg[0].isalpha() or os.path.dirname(Arg) == '':
 966                     PrebuildList.append(Arg)
 967                     continue
 968                 #
 969                 # If Arg looks like a WORKSPACE relative path, then convert to an
 970                 # absolute path and check to see if the file exists.
 971                 #
 972                 Temp = mws.join(self.WorkspaceDir, Arg)
 973                 if os.path.isfile(Temp):
 974                     Arg = Temp
 975                 PrebuildList.append(Arg)
 976             self.Prebuild       = ' '.join(PrebuildList)
 977             self.Prebuild += self.PassCommandOption(self.BuildTargetList, self.ArchList, self.ToolChainList, self.PlatformFile, self.Target)
 978
 979     def InitPostBuild(self):
 980         if 'POSTBUILD' in GlobalData.gCommandLineDefines:
 981             self.Postbuild = GlobalData.gCommandLineDefines.get('POSTBUILD')
 982         else:
 983             Platform = self.Db.MapPlatform(str(self.PlatformFile))
 984             self.Postbuild = str(Platform.Postbuild)
 985         if self.Postbuild:
 986             PostbuildList = []
 987             #
 988             # Evaluate all arguments and convert arguments that are WORKSPACE
 989             # relative paths to absolute paths.  Filter arguments that look like
 990             # flags or do not follow the file/dir naming rules to avoid false
 991             # positives on this conversion.
 992             #
 993             for Arg in self.Postbuild.split():
 994                 #
 995                 # Do not modify Arg if it looks like a flag or an absolute file path
 996                 #
 997                 if Arg.startswith('-')  or os.path.isabs(Arg):
 998                     PostbuildList.append(Arg)
 999                     continue
1000                 #
1001                 # Do not modify Arg if it does not look like a Workspace relative
1002                 # path that starts with a valid package directory name
1003                 #
1004                 if not Arg[0].isalpha() or os.path.dirname(Arg) == '':
1005                     PostbuildList.append(Arg)
1006                     continue
1007                 #
1008                 # If Arg looks like a WORKSPACE relative path, then convert to an
1009                 # absolute path and check to see if the file exists.
1010                 #
1011                 Temp = mws.join(self.WorkspaceDir, Arg)
1012                 if os.path.isfile(Temp):
1013                     Arg = Temp
1014                 PostbuildList.append(Arg)
1015             self.Postbuild       = ' '.join(PostbuildList)
1016             self.Postbuild += self.PassCommandOption(self.BuildTargetList, self.ArchList, self.ToolChainList, self.PlatformFile, self.Target)
1017
1018     def PassCommandOption(self, BuildTarget, TargetArch, ToolChain, PlatformFile, Target):
1019         BuildStr = ''
1020         if GlobalData.gCommand and isinstance(GlobalData.gCommand, list):
1021             BuildStr += ' ' + ' '.join(GlobalData.gCommand)
1022         TargetFlag = False
1023         ArchFlag = False
1024         ToolChainFlag = False
1025         PlatformFileFlag = False
1026
1027         if GlobalData.gOptions and not GlobalData.gOptions.BuildTarget:
1028             TargetFlag = True
1029         if GlobalData.gOptions and not GlobalData.gOptions.TargetArch:
1030             ArchFlag = True
1031         if GlobalData.gOptions and not GlobalData.gOptions.ToolChain:
1032             ToolChainFlag = True
1033         if GlobalData.gOptions and not GlobalData.gOptions.PlatformFile:
1034             PlatformFileFlag = True
1035
1036         if TargetFlag and BuildTarget:
1037             if isinstance(BuildTarget, list) or isinstance(BuildTarget, tuple):
1038                 BuildStr += ' -b ' + ' -b '.join(BuildTarget)
1039             elif isinstance(BuildTarget, str):
1040                 BuildStr += ' -b ' + BuildTarget
1041         if ArchFlag and TargetArch:
1042             if isinstance(TargetArch, list) or isinstance(TargetArch, tuple):
1043                 BuildStr += ' -a ' + ' -a '.join(TargetArch)
1044             elif isinstance(TargetArch, str):
1045                 BuildStr += ' -a ' + TargetArch
1046         if ToolChainFlag and ToolChain:
1047             if isinstance(ToolChain, list) or isinstance(ToolChain, tuple):
1048                 BuildStr += ' -t ' + ' -t '.join(ToolChain)
1049             elif isinstance(ToolChain, str):
1050                 BuildStr += ' -t ' + ToolChain
1051         if PlatformFileFlag and PlatformFile:
1052             if isinstance(PlatformFile, list) or isinstance(PlatformFile, tuple):
1053                 BuildStr += ' -p ' + ' -p '.join(PlatformFile)
1054             elif isinstance(PlatformFile, str):
1055                 BuildStr += ' -p' + PlatformFile
1056         BuildStr += ' --conf=' + GlobalData.gConfDirectory
1057         if Target:
1058             BuildStr += ' ' + Target
1059
1060         return BuildStr
1061
1062     def LaunchPrebuild(self):
1063         if self.Prebuild:
1064             EdkLogger.info("\n- Prebuild Start -\n")
1065             self.LaunchPrebuildFlag = True
1066             #
1067             # The purpose of .PrebuildEnv file is capture environment variable settings set by the prebuild script
1068             # and preserve them for the rest of the main build step, because the child process environment will
1069             # evaporate as soon as it exits, we cannot get it in build step.
1070             #
1071             PrebuildEnvFile = os.path.join(GlobalData.gConfDirectory, '.cache', '.PrebuildEnv')
1072             if os.path.isfile(PrebuildEnvFile):
1073                 os.remove(PrebuildEnvFile)
1074             if os.path.isfile(self.PlatformBuildPath):
1075                 os.remove(self.PlatformBuildPath)
1076             if sys.platform == "win32":
1077                 args = ' && '.join((self.Prebuild, 'set > ' + PrebuildEnvFile))
1078                 Process = Popen(args, stdout=PIPE, stderr=PIPE, shell=True)
1079             else:
1080                 args = ' && '.join((self.Prebuild, 'env > ' + PrebuildEnvFile))
1081                 Process = Popen(args, stdout=PIPE, stderr=PIPE, shell=True)
1082
1083             # launch two threads to read the STDOUT and STDERR
1084             EndOfProcedure = Event()
1085             EndOfProcedure.clear()
1086             if Process.stdout:
1087                 StdOutThread = Thread(target=ReadMessage, args=(Process.stdout, EdkLogger.info, EndOfProcedure))
1088                 StdOutThread.setName("STDOUT-Redirector")
1089                 StdOutThread.setDaemon(False)
1090                 StdOutThread.start()
1091
1092             if Process.stderr:
1093                 StdErrThread = Thread(target=ReadMessage, args=(Process.stderr, EdkLogger.quiet, EndOfProcedure))
1094                 StdErrThread.setName("STDERR-Redirector")
1095                 StdErrThread.setDaemon(False)
1096                 StdErrThread.start()
1097             # waiting for program exit
1098             Process.wait()
1099
1100             if Process.stdout:
1101                 StdOutThread.join()
1102             if Process.stderr:
1103                 StdErrThread.join()
1104             if Process.returncode != 0 :
1105                 EdkLogger.error("Prebuild", PREBUILD_ERROR, 'Prebuild process is not success!')
1106
1107             if os.path.exists(PrebuildEnvFile):
1108                 f = open(PrebuildEnvFile)
1109                 envs = f.readlines()
1110                 f.close()
1111                 envs = [l.split("=", 1) for l in envs ]
1112                 envs = [[I.strip() for I in item] for item in envs if len(item) == 2]
1113                 os.environ.update(dict(envs))
1114             EdkLogger.info("\n- Prebuild Done -\n")
1115
1116     def LaunchPostbuild(self):
1117         if self.Postbuild:
1118             EdkLogger.info("\n- Postbuild Start -\n")
1119             if sys.platform == "win32":
1120                 Process = Popen(self.Postbuild, stdout=PIPE, stderr=PIPE, shell=True)
1121             else:
1122                 Process = Popen(self.Postbuild, stdout=PIPE, stderr=PIPE, shell=True)
1123             # launch two threads to read the STDOUT and STDERR
1124             EndOfProcedure = Event()
1125             EndOfProcedure.clear()
1126             if Process.stdout:
1127                 StdOutThread = Thread(target=ReadMessage, args=(Process.stdout, EdkLogger.info, EndOfProcedure))
1128                 StdOutThread.setName("STDOUT-Redirector")
1129                 StdOutThread.setDaemon(False)
1130                 StdOutThread.start()
1131
1132             if Process.stderr:
1133                 StdErrThread = Thread(target=ReadMessage, args=(Process.stderr, EdkLogger.quiet, EndOfProcedure))
1134                 StdErrThread.setName("STDERR-Redirector")
1135                 StdErrThread.setDaemon(False)
1136                 StdErrThread.start()
1137             # waiting for program exit
1138             Process.wait()
1139
1140             if Process.stdout:
1141                 StdOutThread.join()
1142             if Process.stderr:
1143                 StdErrThread.join()
1144             if Process.returncode != 0 :
1145                 EdkLogger.error("Postbuild", POSTBUILD_ERROR, 'Postbuild process is not success!')
1146             EdkLogger.info("\n- Postbuild Done -\n")
1147     ## Build a module or platform
1148     #
1149     # Create autogen code and makefile for a module or platform, and the launch
1150     # "make" command to build it
1151     #
1152     #   @param  Target                      The target of build command
1153     #   @param  Platform                    The platform file
1154     #   @param  Module                      The module file
1155     #   @param  BuildTarget                 The name of build target, one of "DEBUG", "RELEASE"
1156     #   @param  ToolChain                   The name of toolchain to build
1157     #   @param  Arch                        The arch of the module/platform
1158     #   @param  CreateDepModuleCodeFile     Flag used to indicate creating code
1159     #                                       for dependent modules/Libraries
1160     #   @param  CreateDepModuleMakeFile     Flag used to indicate creating makefile
1161     #                                       for dependent modules/Libraries
1162     #
1163     def _BuildPa(self, Target, AutoGenObject, CreateDepsCodeFile=True, CreateDepsMakeFile=True, BuildModule=False, FfsCommand={}):
1164         if AutoGenObject is None:
1165             return False
1166
1167         # skip file generation for cleanxxx targets, run and fds target
1168         if Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1169             # for target which must generate AutoGen code and makefile
1170             if not self.SkipAutoGen or Target == 'genc':
1171                 self.Progress.Start("Generating code")
1172                 AutoGenObject.CreateCodeFile(CreateDepsCodeFile)
1173                 self.Progress.Stop("done!")
1174             if Target == "genc":
1175                 return True
1176
1177             if not self.SkipAutoGen or Target == 'genmake':
1178                 self.Progress.Start("Generating makefile")
1179                 AutoGenObject.CreateMakeFile(CreateDepsMakeFile, FfsCommand)
1180                 self.Progress.Stop("done!")
1181             if Target == "genmake":
1182                 return True
1183         else:
1184             # always recreate top/platform makefile when clean, just in case of inconsistency
1185             AutoGenObject.CreateCodeFile(False)
1186             AutoGenObject.CreateMakeFile(False)
1187
1188         if EdkLogger.GetLevel() == EdkLogger.QUIET:
1189             EdkLogger.quiet("Building ... %s" % repr(AutoGenObject))
1190
1191         BuildCommand = AutoGenObject.BuildCommand
1192         if BuildCommand is None or len(BuildCommand) == 0:
1193             EdkLogger.error("build", OPTION_MISSING,
1194                             "No build command found for this module. "
1195                             "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %
1196                                 (AutoGenObject.BuildTarget, AutoGenObject.ToolChain, AutoGenObject.Arch),
1197                             ExtraData=str(AutoGenObject))
1198
1199         makefile = GenMake.BuildFile(AutoGenObject)._FILE_NAME_[GenMake.gMakeType]
1200
1201         # run
1202         if Target == 'run':
1203             RunDir = os.path.normpath(os.path.join(AutoGenObject.BuildDir, GlobalData.gGlobalDefines['ARCH']))
1204             Command = '.\SecMain'
1205             os.chdir(RunDir)
1206             LaunchCommand(Command, RunDir)
1207             return True
1208
1209         # build modules
1210         if BuildModule:
1211             BuildCommand = BuildCommand + [Target]
1212             LaunchCommand(BuildCommand, AutoGenObject.MakeFileDir)
1213             self.CreateAsBuiltInf()
1214             return True
1215
1216         # build library
1217         if Target == 'libraries':
1218             for Lib in AutoGenObject.LibraryBuildDirectoryList:
1219                 NewBuildCommand = BuildCommand + ['-f', os.path.normpath(os.path.join(Lib, makefile)), 'pbuild']
1220                 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)
1221             return True
1222
1223         # build module
1224         if Target == 'modules':
1225             for Lib in AutoGenObject.LibraryBuildDirectoryList:
1226                 NewBuildCommand = BuildCommand + ['-f', os.path.normpath(os.path.join(Lib, makefile)), 'pbuild']
1227                 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)
1228             for Mod in AutoGenObject.ModuleBuildDirectoryList:
1229                 NewBuildCommand = BuildCommand + ['-f', os.path.normpath(os.path.join(Mod, makefile)), 'pbuild']
1230                 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)
1231             self.CreateAsBuiltInf()
1232             return True
1233
1234         # cleanlib
1235         if Target == 'cleanlib':
1236             for Lib in AutoGenObject.LibraryBuildDirectoryList:
1237                 LibMakefile = os.path.normpath(os.path.join(Lib, makefile))
1238                 if os.path.exists(LibMakefile):
1239                     NewBuildCommand = BuildCommand + ['-f', LibMakefile, 'cleanall']
1240                     LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)
1241             return True
1242
1243         # clean
1244         if Target == 'clean':
1245             for Mod in AutoGenObject.ModuleBuildDirectoryList:
1246                 ModMakefile = os.path.normpath(os.path.join(Mod, makefile))
1247                 if os.path.exists(ModMakefile):
1248                     NewBuildCommand = BuildCommand + ['-f', ModMakefile, 'cleanall']
1249                     LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)
1250             for Lib in AutoGenObject.LibraryBuildDirectoryList:
1251                 LibMakefile = os.path.normpath(os.path.join(Lib, makefile))
1252                 if os.path.exists(LibMakefile):
1253                     NewBuildCommand = BuildCommand + ['-f', LibMakefile, 'cleanall']
1254                     LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)
1255             return True
1256
1257         # cleanall
1258         if Target == 'cleanall':
1259             try:
1260                 #os.rmdir(AutoGenObject.BuildDir)
1261                 RemoveDirectory(AutoGenObject.BuildDir, True)
1262             except WindowsError as X:
1263                 EdkLogger.error("build", FILE_DELETE_FAILURE, ExtraData=str(X))
1264         return True
1265
1266     ## Build a module or platform
1267     #
1268     # Create autogen code and makefile for a module or platform, and the launch
1269     # "make" command to build it
1270     #
1271     #   @param  Target                      The target of build command
1272     #   @param  Platform                    The platform file
1273     #   @param  Module                      The module file
1274     #   @param  BuildTarget                 The name of build target, one of "DEBUG", "RELEASE"
1275     #   @param  ToolChain                   The name of toolchain to build
1276     #   @param  Arch                        The arch of the module/platform
1277     #   @param  CreateDepModuleCodeFile     Flag used to indicate creating code
1278     #                                       for dependent modules/Libraries
1279     #   @param  CreateDepModuleMakeFile     Flag used to indicate creating makefile
1280     #                                       for dependent modules/Libraries
1281     #
1282     def _Build(self, Target, AutoGenObject, CreateDepsCodeFile=True, CreateDepsMakeFile=True, BuildModule=False):
1283         if AutoGenObject is None:
1284             return False
1285
1286         # skip file generation for cleanxxx targets, run and fds target
1287         if Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1288             # for target which must generate AutoGen code and makefile
1289             if not self.SkipAutoGen or Target == 'genc':
1290                 self.Progress.Start("Generating code")
1291                 AutoGenObject.CreateCodeFile(CreateDepsCodeFile)
1292                 self.Progress.Stop("done!")
1293             if Target == "genc":
1294                 return True
1295
1296             if not self.SkipAutoGen or Target == 'genmake':
1297                 self.Progress.Start("Generating makefile")
1298                 AutoGenObject.CreateMakeFile(CreateDepsMakeFile)
1299                 #AutoGenObject.CreateAsBuiltInf()
1300                 self.Progress.Stop("done!")
1301             if Target == "genmake":
1302                 return True
1303         else:
1304             # always recreate top/platform makefile when clean, just in case of inconsistency
1305             AutoGenObject.CreateCodeFile(False)
1306             AutoGenObject.CreateMakeFile(False)
1307
1308         if EdkLogger.GetLevel() == EdkLogger.QUIET:
1309             EdkLogger.quiet("Building ... %s" % repr(AutoGenObject))
1310
1311         BuildCommand = AutoGenObject.BuildCommand
1312         if BuildCommand is None or len(BuildCommand) == 0:
1313             EdkLogger.error("build", OPTION_MISSING,
1314                             "No build command found for this module. "
1315                             "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %
1316                                 (AutoGenObject.BuildTarget, AutoGenObject.ToolChain, AutoGenObject.Arch),
1317                             ExtraData=str(AutoGenObject))
1318
1319         # build modules
1320         if BuildModule:
1321             if Target != 'fds':
1322                 BuildCommand = BuildCommand + [Target]
1323             AutoGenObject.BuildTime = LaunchCommand(BuildCommand, AutoGenObject.MakeFileDir)
1324             self.CreateAsBuiltInf()
1325             return True
1326
1327         # genfds
1328         if Target == 'fds':
1329             if GenFdsApi(AutoGenObject.GenFdsCommandDict, self.Db):
1330                 EdkLogger.error("build", COMMAND_FAILURE)
1331             return True
1332
1333         # run
1334         if Target == 'run':
1335             RunDir = os.path.normpath(os.path.join(AutoGenObject.BuildDir, GlobalData.gGlobalDefines['ARCH']))
1336             Command = '.\SecMain'
1337             os.chdir(RunDir)
1338             LaunchCommand(Command, RunDir)
1339             return True
1340
1341         # build library
1342         if Target == 'libraries':
1343             pass
1344
1345         # not build modules
1346
1347
1348         # cleanall
1349         if Target == 'cleanall':
1350             try:
1351                 #os.rmdir(AutoGenObject.BuildDir)
1352                 RemoveDirectory(AutoGenObject.BuildDir, True)
1353             except WindowsError as X:
1354                 EdkLogger.error("build", FILE_DELETE_FAILURE, ExtraData=str(X))
1355         return True
1356
1357     ## Rebase module image and Get function address for the input module list.
1358     #
1359     def _RebaseModule (self, MapBuffer, BaseAddress, ModuleList, AddrIsOffset = True, ModeIsSmm = False):
1360         if ModeIsSmm:
1361             AddrIsOffset = False
1362         for InfFile in ModuleList:
1363             sys.stdout.write (".")
1364             sys.stdout.flush()
1365             ModuleInfo = ModuleList[InfFile]
1366             ModuleName = ModuleInfo.BaseName
1367             ModuleOutputImage = ModuleInfo.Image.FileName
1368             ModuleDebugImage  = os.path.join(ModuleInfo.DebugDir, ModuleInfo.BaseName + '.efi')
1369             ## for SMM module in SMRAM, the SMRAM will be allocated from base to top.
1370             if not ModeIsSmm:
1371                 BaseAddress = BaseAddress - ModuleInfo.Image.Size
1372                 #
1373                 # Update Image to new BaseAddress by GenFw tool
1374                 #
1375                 LaunchCommand(["GenFw", "--rebase", str(BaseAddress), "-r", ModuleOutputImage], ModuleInfo.OutputDir)
1376                 LaunchCommand(["GenFw", "--rebase", str(BaseAddress), "-r", ModuleDebugImage], ModuleInfo.DebugDir)
1377             else:
1378                 #
1379                 # Set new address to the section header only for SMM driver.
1380                 #
1381                 LaunchCommand(["GenFw", "--address", str(BaseAddress), "-r", ModuleOutputImage], ModuleInfo.OutputDir)
1382                 LaunchCommand(["GenFw", "--address", str(BaseAddress), "-r", ModuleDebugImage], ModuleInfo.DebugDir)
1383             #
1384             # Collect funtion address from Map file
1385             #
1386             ImageMapTable = ModuleOutputImage.replace('.efi', '.map')
1387             FunctionList = []
1388             if os.path.exists(ImageMapTable):
1389                 OrigImageBaseAddress = 0
1390                 ImageMap = open(ImageMapTable, 'r')
1391                 for LinStr in ImageMap:
1392                     if len (LinStr.strip()) == 0:
1393                         continue
1394                     #
1395                     # Get the preferred address set on link time.
1396                     #
1397                     if LinStr.find ('Preferred load address is') != -1:
1398                         StrList = LinStr.split()
1399                         OrigImageBaseAddress = int (StrList[len(StrList) - 1], 16)
1400
1401                     StrList = LinStr.split()
1402                     if len (StrList) > 4:
1403                         if StrList[3] == 'f' or StrList[3] == 'F':
1404                             Name = StrList[1]
1405                             RelativeAddress = int (StrList[2], 16) - OrigImageBaseAddress
1406                             FunctionList.append ((Name, RelativeAddress))
1407
1408                 ImageMap.close()
1409             #
1410             # Add general information.
1411             #
1412             if ModeIsSmm:
1413                 MapBuffer.write('\n\n%s (Fixed SMRAM Offset,   BaseAddress=0x%010X,  EntryPoint=0x%010X)\n' % (ModuleName, BaseAddress, BaseAddress + ModuleInfo.Image.EntryPoint))
1414             elif AddrIsOffset:
1415                 MapBuffer.write('\n\n%s (Fixed Memory Offset,  BaseAddress=-0x%010X, EntryPoint=-0x%010X)\n' % (ModuleName, 0 - BaseAddress, 0 - (BaseAddress + ModuleInfo.Image.EntryPoint)))
1416             else:
1417                 MapBuffer.write('\n\n%s (Fixed Memory Address, BaseAddress=0x%010X,  EntryPoint=0x%010X)\n' % (ModuleName, BaseAddress, BaseAddress + ModuleInfo.Image.EntryPoint))
1418             #
1419             # Add guid and general seciton section.
1420             #
1421             TextSectionAddress = 0
1422             DataSectionAddress = 0
1423             for SectionHeader in ModuleInfo.Image.SectionHeaderList:
1424                 if SectionHeader[0] == '.text':
1425                     TextSectionAddress = SectionHeader[1]
1426                 elif SectionHeader[0] in ['.data', '.sdata']:
1427                     DataSectionAddress = SectionHeader[1]
1428             if AddrIsOffset:
1429                 MapBuffer.write('(GUID=%s, .textbaseaddress=-0x%010X, .databaseaddress=-0x%010X)\n' % (ModuleInfo.Guid, 0 - (BaseAddress + TextSectionAddress), 0 - (BaseAddress + DataSectionAddress)))
1430             else:
1431                 MapBuffer.write('(GUID=%s, .textbaseaddress=0x%010X, .databaseaddress=0x%010X)\n' % (ModuleInfo.Guid, BaseAddress + TextSectionAddress, BaseAddress + DataSectionAddress))
1432             #
1433             # Add debug image full path.
1434             #
1435             MapBuffer.write('(IMAGE=%s)\n\n' % (ModuleDebugImage))
1436             #
1437             # Add funtion address
1438             #
1439             for Function in FunctionList:
1440                 if AddrIsOffset:
1441                     MapBuffer.write('  -0x%010X    %s\n' % (0 - (BaseAddress + Function[1]), Function[0]))
1442                 else:
1443                     MapBuffer.write('  0x%010X    %s\n' % (BaseAddress + Function[1], Function[0]))
1444             ImageMap.close()
1445
1446             #
1447             # for SMM module in SMRAM, the SMRAM will be allocated from base to top.
1448             #
1449             if ModeIsSmm:
1450                 BaseAddress = BaseAddress + ModuleInfo.Image.Size
1451
1452     ## Collect MAP information of all FVs
1453     #
1454     def _CollectFvMapBuffer (self, MapBuffer, Wa, ModuleList):
1455         if self.Fdf:
1456             # First get the XIP base address for FV map file.
1457             GuidPattern = re.compile("[-a-fA-F0-9]+")
1458             GuidName = re.compile("\(GUID=[-a-fA-F0-9]+")
1459             for FvName in Wa.FdfProfile.FvDict:
1460                 FvMapBuffer = os.path.join(Wa.FvDir, FvName + '.Fv.map')
1461                 if not os.path.exists(FvMapBuffer):
1462                     continue
1463                 FvMap = open(FvMapBuffer, 'r')
1464                 #skip FV size information
1465                 FvMap.readline()
1466                 FvMap.readline()
1467                 FvMap.readline()
1468                 FvMap.readline()
1469                 for Line in FvMap:
1470                     MatchGuid = GuidPattern.match(Line)
1471                     if MatchGuid is not None:
1472                         #
1473                         # Replace GUID with module name
1474                         #
1475                         GuidString = MatchGuid.group()
1476                         if GuidString.upper() in ModuleList:
1477                             Line = Line.replace(GuidString, ModuleList[GuidString.upper()].Name)
1478                     MapBuffer.write(Line)
1479                     #
1480                     # Add the debug image full path.
1481                     #
1482                     MatchGuid = GuidName.match(Line)
1483                     if MatchGuid is not None:
1484                         GuidString = MatchGuid.group().split("=")[1]
1485                         if GuidString.upper() in ModuleList:
1486                             MapBuffer.write('(IMAGE=%s)\n' % (os.path.join(ModuleList[GuidString.upper()].DebugDir, ModuleList[GuidString.upper()].Name + '.efi')))
1487
1488                 FvMap.close()
1489
1490     ## Collect MAP information of all modules
1491     #
1492     def _CollectModuleMapBuffer (self, MapBuffer, ModuleList):
1493         sys.stdout.write ("Generate Load Module At Fix Address Map")
1494         sys.stdout.flush()
1495         PatchEfiImageList = []
1496         PeiModuleList  = {}
1497         BtModuleList   = {}
1498         RtModuleList   = {}
1499         SmmModuleList  = {}
1500         PeiSize = 0
1501         BtSize  = 0
1502         RtSize  = 0
1503         # reserve 4K size in SMRAM to make SMM module address not from 0.
1504         SmmSize = 0x1000
1505         for ModuleGuid in ModuleList:
1506             Module = ModuleList[ModuleGuid]
1507             GlobalData.gProcessingFile = "%s [%s, %s, %s]" % (Module.MetaFile, Module.Arch, Module.ToolChain, Module.BuildTarget)
1508
1509             OutputImageFile = ''
1510             for ResultFile in Module.CodaTargetList:
1511                 if str(ResultFile.Target).endswith('.efi'):
1512                     #
1513                     # module list for PEI, DXE, RUNTIME and SMM
1514                     #
1515                     OutputImageFile = os.path.join(Module.OutputDir, Module.Name + '.efi')
1516                     ImageClass = PeImageClass (OutputImageFile)
1517                     if not ImageClass.IsValid:
1518                         EdkLogger.error("build", FILE_PARSE_FAILURE, ExtraData=ImageClass.ErrorInfo)
1519                     ImageInfo = PeImageInfo(Module.Name, Module.Guid, Module.Arch, Module.OutputDir, Module.DebugDir, ImageClass)
1520                     if Module.ModuleType in [SUP_MODULE_PEI_CORE, SUP_MODULE_PEIM, EDK_COMPONENT_TYPE_COMBINED_PEIM_DRIVER, EDK_COMPONENT_TYPE_PIC_PEIM, EDK_COMPONENT_TYPE_RELOCATABLE_PEIM, SUP_MODULE_DXE_CORE]:
1521                         PeiModuleList[Module.MetaFile] = ImageInfo
1522                         PeiSize += ImageInfo.Image.Size
1523                     elif Module.ModuleType in [EDK_COMPONENT_TYPE_BS_DRIVER, SUP_MODULE_DXE_DRIVER, SUP_MODULE_UEFI_DRIVER]:
1524                         BtModuleList[Module.MetaFile] = ImageInfo
1525                         BtSize += ImageInfo.Image.Size
1526                     elif Module.ModuleType in [SUP_MODULE_DXE_RUNTIME_DRIVER, EDK_COMPONENT_TYPE_RT_DRIVER, SUP_MODULE_DXE_SAL_DRIVER, EDK_COMPONENT_TYPE_SAL_RT_DRIVER]:
1527                         RtModuleList[Module.MetaFile] = ImageInfo
1528                         RtSize += ImageInfo.Image.Size
1529                     elif Module.ModuleType in [SUP_MODULE_SMM_CORE, SUP_MODULE_DXE_SMM_DRIVER, SUP_MODULE_MM_STANDALONE, SUP_MODULE_MM_CORE_STANDALONE]:
1530                         SmmModuleList[Module.MetaFile] = ImageInfo
1531                         SmmSize += ImageInfo.Image.Size
1532                         if Module.ModuleType == SUP_MODULE_DXE_SMM_DRIVER:
1533                             PiSpecVersion = Module.Module.Specification.get('PI_SPECIFICATION_VERSION', '0x00000000')
1534                             # for PI specification < PI1.1, DXE_SMM_DRIVER also runs as BOOT time driver.
1535                             if int(PiSpecVersion, 16) < 0x0001000A:
1536                                 BtModuleList[Module.MetaFile] = ImageInfo
1537                                 BtSize += ImageInfo.Image.Size
1538                     break
1539             #
1540             # EFI image is final target.
1541             # Check EFI image contains patchable FixAddress related PCDs.
1542             #
1543             if OutputImageFile != '':
1544                 ModuleIsPatch = False
1545                 for Pcd in Module.ModulePcdList:
1546                     if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE and Pcd.TokenCName in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SET:
1547                         ModuleIsPatch = True
1548                         break
1549                 if not ModuleIsPatch:
1550                     for Pcd in Module.LibraryPcdList:
1551                         if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE and Pcd.TokenCName in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SET:
1552                             ModuleIsPatch = True
1553                             break
1554
1555                 if not ModuleIsPatch:
1556                     continue
1557                 #
1558                 # Module includes the patchable load fix address PCDs.
1559                 # It will be fixed up later.
1560                 #
1561                 PatchEfiImageList.append (OutputImageFile)
1562
1563         #
1564         # Get Top Memory address
1565         #
1566         ReservedRuntimeMemorySize = 0
1567         TopMemoryAddress = 0
1568         if self.LoadFixAddress == 0xFFFFFFFFFFFFFFFF:
1569             TopMemoryAddress = 0
1570         else:
1571             TopMemoryAddress = self.LoadFixAddress
1572             if TopMemoryAddress < RtSize + BtSize + PeiSize:
1573                 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS is too low to load driver")
1574
1575         #
1576         # Patch FixAddress related PCDs into EFI image
1577         #
1578         for EfiImage in PatchEfiImageList:
1579             EfiImageMap = EfiImage.replace('.efi', '.map')
1580             if not os.path.exists(EfiImageMap):
1581                 continue
1582             #
1583             # Get PCD offset in EFI image by GenPatchPcdTable function
1584             #
1585             PcdTable = parsePcdInfoFromMapFile(EfiImageMap, EfiImage)
1586             #
1587             # Patch real PCD value by PatchPcdValue tool
1588             #
1589             for PcdInfo in PcdTable:
1590                 ReturnValue = 0
1591                 if PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE:
1592                     ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE_DATA_TYPE, str (PeiSize // 0x1000))
1593                 elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE:
1594                     ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE_DATA_TYPE, str (BtSize // 0x1000))
1595                 elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE:
1596                     ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE_DATA_TYPE, str (RtSize // 0x1000))
1597                 elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE and len (SmmModuleList) > 0:
1598                     ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE_DATA_TYPE, str (SmmSize // 0x1000))
1599                 if ReturnValue != 0:
1600                     EdkLogger.error("build", PARAMETER_INVALID, "Patch PCD value failed", ExtraData=ErrorInfo)
1601
1602         MapBuffer.write('PEI_CODE_PAGE_NUMBER      = 0x%x\n' % (PeiSize // 0x1000))
1603         MapBuffer.write('BOOT_CODE_PAGE_NUMBER     = 0x%x\n' % (BtSize // 0x1000))
1604         MapBuffer.write('RUNTIME_CODE_PAGE_NUMBER  = 0x%x\n' % (RtSize // 0x1000))
1605         if len (SmmModuleList) > 0:
1606             MapBuffer.write('SMM_CODE_PAGE_NUMBER      = 0x%x\n' % (SmmSize // 0x1000))
1607
1608         PeiBaseAddr = TopMemoryAddress - RtSize - BtSize
1609         BtBaseAddr  = TopMemoryAddress - RtSize
1610         RtBaseAddr  = TopMemoryAddress - ReservedRuntimeMemorySize
1611
1612         self._RebaseModule (MapBuffer, PeiBaseAddr, PeiModuleList, TopMemoryAddress == 0)
1613         self._RebaseModule (MapBuffer, BtBaseAddr, BtModuleList, TopMemoryAddress == 0)
1614         self._RebaseModule (MapBuffer, RtBaseAddr, RtModuleList, TopMemoryAddress == 0)
1615         self._RebaseModule (MapBuffer, 0x1000, SmmModuleList, AddrIsOffset=False, ModeIsSmm=True)
1616         MapBuffer.write('\n\n')
1617         sys.stdout.write ("\n")
1618         sys.stdout.flush()
1619
1620     ## Save platform Map file
1621     #
1622     def _SaveMapFile (self, MapBuffer, Wa):
1623         #
1624         # Map file path is got.
1625         #
1626         MapFilePath = os.path.join(Wa.BuildDir, Wa.Name + '.map')
1627         #
1628         # Save address map into MAP file.
1629         #
1630         SaveFileOnChange(MapFilePath, MapBuffer.getvalue(), False)
1631         MapBuffer.close()
1632         if self.LoadFixAddress != 0:
1633             sys.stdout.write ("\nLoad Module At Fix Address Map file can be found at %s\n" % (MapFilePath))
1634         sys.stdout.flush()
1635
1636     ## Build active platform for different build targets and different tool chains
1637     #
1638     def _BuildPlatform(self):
1639         SaveFileOnChange(self.PlatformBuildPath, '# DO NOT EDIT \n# FILE auto-generated\n', False)
1640         for BuildTarget in self.BuildTargetList:
1641             GlobalData.gGlobalDefines['TARGET'] = BuildTarget
1642             index = 0
1643             for ToolChain in self.ToolChainList:
1644                 GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain
1645                 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain
1646                 GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[index]
1647                 index += 1
1648                 Wa = WorkspaceAutoGen(
1649                         self.WorkspaceDir,
1650                         self.PlatformFile,
1651                         BuildTarget,
1652                         ToolChain,
1653                         self.ArchList,
1654                         self.BuildDatabase,
1655                         self.TargetTxt,
1656                         self.ToolDef,
1657                         self.Fdf,
1658                         self.FdList,
1659                         self.FvList,
1660                         self.CapList,
1661                         self.SkuId,
1662                         self.UniFlag,
1663                         self.Progress
1664                         )
1665                 self.Fdf = Wa.FdfFile
1666                 self.LoadFixAddress = Wa.Platform.LoadFixAddress
1667                 self.BuildReport.AddPlatformReport(Wa)
1668                 self.Progress.Stop("done!")
1669
1670                 # Add ffs build to makefile
1671                 CmdListDict = {}
1672                 if GlobalData.gEnableGenfdsMultiThread and self.Fdf:
1673                     CmdListDict = self._GenFfsCmd()
1674
1675                 for Arch in Wa.ArchList:
1676                     GlobalData.gGlobalDefines['ARCH'] = Arch
1677                     Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)
1678                     for Module in Pa.Platform.Modules:
1679                         # Get ModuleAutoGen object to generate C code file and makefile
1680                         Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)
1681                         if Ma is None:
1682                             continue
1683                         self.BuildModules.append(Ma)
1684                     self._BuildPa(self.Target, Pa, FfsCommand=CmdListDict)
1685
1686                 # Create MAP file when Load Fix Address is enabled.
1687                 if self.Target in ["", "all", "fds"]:
1688                     for Arch in Wa.ArchList:
1689                         GlobalData.gGlobalDefines['ARCH'] = Arch
1690                         #
1691                         # Check whether the set fix address is above 4G for 32bit image.
1692                         #
1693                         if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:
1694                             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")
1695                     #
1696                     # Get Module List
1697                     #
1698                     ModuleList = {}
1699                     for Pa in Wa.AutoGenObjectList:
1700                         for Ma in Pa.ModuleAutoGenList:
1701                             if Ma is None:
1702                                 continue
1703                             if not Ma.IsLibrary:
1704                                 ModuleList[Ma.Guid.upper()] = Ma
1705
1706                     MapBuffer = BytesIO('')
1707                     if self.LoadFixAddress != 0:
1708                         #
1709                         # Rebase module to the preferred memory address before GenFds
1710                         #
1711                         self._CollectModuleMapBuffer(MapBuffer, ModuleList)
1712                     if self.Fdf:
1713                         #
1714                         # create FDS again for the updated EFI image
1715                         #
1716                         self._Build("fds", Wa)
1717                         #
1718                         # Create MAP file for all platform FVs after GenFds.
1719                         #
1720                         self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)
1721                     #
1722                     # Save MAP buffer into MAP file.
1723                     #
1724                     self._SaveMapFile (MapBuffer, Wa)
1725
1726     ## Build active module for different build targets, different tool chains and different archs
1727     #
1728     def _BuildModule(self):
1729         for BuildTarget in self.BuildTargetList:
1730             GlobalData.gGlobalDefines['TARGET'] = BuildTarget
1731             index = 0
1732             for ToolChain in self.ToolChainList:
1733                 WorkspaceAutoGenTime = time.time()
1734                 GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain
1735                 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain
1736                 GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[index]
1737                 index += 1
1738                 #
1739                 # module build needs platform build information, so get platform
1740                 # AutoGen first
1741                 #
1742                 Wa = WorkspaceAutoGen(
1743                         self.WorkspaceDir,
1744                         self.PlatformFile,
1745                         BuildTarget,
1746                         ToolChain,
1747                         self.ArchList,
1748                         self.BuildDatabase,
1749                         self.TargetTxt,
1750                         self.ToolDef,
1751                         self.Fdf,
1752                         self.FdList,
1753                         self.FvList,
1754                         self.CapList,
1755                         self.SkuId,
1756                         self.UniFlag,
1757                         self.Progress,
1758                         self.ModuleFile
1759                         )
1760                 self.Fdf = Wa.FdfFile
1761                 self.LoadFixAddress = Wa.Platform.LoadFixAddress
1762                 Wa.CreateMakeFile(False)
1763                 # Add ffs build to makefile
1764                 CmdListDict = None
1765                 if GlobalData.gEnableGenfdsMultiThread and self.Fdf:
1766                     CmdListDict = self._GenFfsCmd()
1767                 self.Progress.Stop("done!")
1768                 MaList = []
1769                 ExitFlag = threading.Event()
1770                 ExitFlag.clear()
1771                 self.AutoGenTime += int(round((time.time() - WorkspaceAutoGenTime)))
1772                 for Arch in Wa.ArchList:
1773                     AutoGenStart = time.time()
1774                     GlobalData.gGlobalDefines['ARCH'] = Arch
1775                     Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)
1776                     for Module in Pa.Platform.Modules:
1777                         if self.ModuleFile.Dir == Module.Dir and self.ModuleFile.Name == Module.Name:
1778                             Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)
1779                             if Ma is None: continue
1780                             MaList.append(Ma)
1781                             if Ma.CanSkipbyHash():
1782                                 self.HashSkipModules.append(Ma)
1783                                 continue
1784                             # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'
1785                             if self.Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1786                                 # for target which must generate AutoGen code and makefile
1787                                 if not self.SkipAutoGen or self.Target == 'genc':
1788                                     self.Progress.Start("Generating code")
1789                                     Ma.CreateCodeFile(True)
1790                                     self.Progress.Stop("done!")
1791                                 if self.Target == "genc":
1792                                     return True
1793                                 if not self.SkipAutoGen or self.Target == 'genmake':
1794                                     self.Progress.Start("Generating makefile")
1795                                     if CmdListDict and self.Fdf and (Module.File, Arch) in CmdListDict:
1796                                         Ma.CreateMakeFile(True, CmdListDict[Module.File, Arch])
1797                                         del CmdListDict[Module.File, Arch]
1798                                     else:
1799                                         Ma.CreateMakeFile(True)
1800                                     self.Progress.Stop("done!")
1801                                 if self.Target == "genmake":
1802                                     return True
1803                             self.BuildModules.append(Ma)
1804                     self.AutoGenTime += int(round((time.time() - AutoGenStart)))
1805                     MakeStart = time.time()
1806                     for Ma in self.BuildModules:
1807                         if not Ma.IsBinaryModule:
1808                             Bt = BuildTask.New(ModuleMakeUnit(Ma, self.Target))
1809                         # Break build if any build thread has error
1810                         if BuildTask.HasError():
1811                             # we need a full version of makefile for platform
1812                             ExitFlag.set()
1813                             BuildTask.WaitForComplete()
1814                             Pa.CreateMakeFile(False)
1815                             EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)
1816                         # Start task scheduler
1817                         if not BuildTask.IsOnGoing():
1818                             BuildTask.StartScheduler(self.ThreadNumber, ExitFlag)
1819
1820                     # in case there's an interruption. we need a full version of makefile for platform
1821                     Pa.CreateMakeFile(False)
1822                     if BuildTask.HasError():
1823                         EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)
1824                     self.MakeTime += int(round((time.time() - MakeStart)))
1825
1826                 MakeContiue = time.time()
1827                 ExitFlag.set()
1828                 BuildTask.WaitForComplete()
1829                 self.CreateAsBuiltInf()
1830                 self.MakeTime += int(round((time.time() - MakeContiue)))
1831                 if BuildTask.HasError():
1832                     EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)
1833
1834                 self.BuildReport.AddPlatformReport(Wa, MaList)
1835                 if MaList == []:
1836                     EdkLogger.error(
1837                                 'build',
1838                                 BUILD_ERROR,
1839                                 "Module for [%s] is not a component of active platform."\
1840                                 " Please make sure that the ARCH and inf file path are"\
1841                                 " given in the same as in [%s]" % \
1842                                     (', '.join(Wa.ArchList), self.PlatformFile),
1843                                 ExtraData=self.ModuleFile
1844                                 )
1845                 # Create MAP file when Load Fix Address is enabled.
1846                 if self.Target == "fds" and self.Fdf:
1847                     for Arch in Wa.ArchList:
1848                         #
1849                         # Check whether the set fix address is above 4G for 32bit image.
1850                         #
1851                         if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:
1852                             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")
1853                     #
1854                     # Get Module List
1855                     #
1856                     ModuleList = {}
1857                     for Pa in Wa.AutoGenObjectList:
1858                         for Ma in Pa.ModuleAutoGenList:
1859                             if Ma is None:
1860                                 continue
1861                             if not Ma.IsLibrary:
1862                                 ModuleList[Ma.Guid.upper()] = Ma
1863
1864                     MapBuffer = BytesIO('')
1865                     if self.LoadFixAddress != 0:
1866                         #
1867                         # Rebase module to the preferred memory address before GenFds
1868                         #
1869                         self._CollectModuleMapBuffer(MapBuffer, ModuleList)
1870                     #
1871                     # create FDS again for the updated EFI image
1872                     #
1873                     GenFdsStart = time.time()
1874                     self._Build("fds", Wa)
1875                     self.GenFdsTime += int(round((time.time() - GenFdsStart)))
1876                     #
1877                     # Create MAP file for all platform FVs after GenFds.
1878                     #
1879                     self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)
1880                     #
1881                     # Save MAP buffer into MAP file.
1882                     #
1883                     self._SaveMapFile (MapBuffer, Wa)
1884
1885     def _GenFfsCmd(self):
1886         # convert dictionary of Cmd:(Inf,Arch)
1887         # to a new dictionary of (Inf,Arch):Cmd,Cmd,Cmd...
1888         CmdSetDict = defaultdict(set)
1889         GenFfsDict = GenFds.GenFfsMakefile('', GlobalData.gFdfParser, self, self.ArchList, GlobalData)
1890         for Cmd in GenFfsDict:
1891             tmpInf, tmpArch = GenFfsDict[Cmd]
1892             CmdSetDict[tmpInf, tmpArch].add(Cmd)
1893         return CmdSetDict
1894
1895     ## Build a platform in multi-thread mode
1896     #
1897     def _MultiThreadBuildPlatform(self):
1898         SaveFileOnChange(self.PlatformBuildPath, '# DO NOT EDIT \n# FILE auto-generated\n', False)
1899         for BuildTarget in self.BuildTargetList:
1900             GlobalData.gGlobalDefines['TARGET'] = BuildTarget
1901             index = 0
1902             for ToolChain in self.ToolChainList:
1903                 WorkspaceAutoGenTime = time.time()
1904                 GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain
1905                 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain
1906                 GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[index]
1907                 index += 1
1908                 Wa = WorkspaceAutoGen(
1909                         self.WorkspaceDir,
1910                         self.PlatformFile,
1911                         BuildTarget,
1912                         ToolChain,
1913                         self.ArchList,
1914                         self.BuildDatabase,
1915                         self.TargetTxt,
1916                         self.ToolDef,
1917                         self.Fdf,
1918                         self.FdList,
1919                         self.FvList,
1920                         self.CapList,
1921                         self.SkuId,
1922                         self.UniFlag,
1923                         self.Progress
1924                         )
1925                 self.Fdf = Wa.FdfFile
1926                 self.LoadFixAddress = Wa.Platform.LoadFixAddress
1927                 self.BuildReport.AddPlatformReport(Wa)
1928                 Wa.CreateMakeFile(False)
1929
1930                 # Add ffs build to makefile
1931                 CmdListDict = None
1932                 if GlobalData.gEnableGenfdsMultiThread and self.Fdf:
1933                     CmdListDict = self._GenFfsCmd()
1934
1935                 # multi-thread exit flag
1936                 ExitFlag = threading.Event()
1937                 ExitFlag.clear()
1938                 self.AutoGenTime += int(round((time.time() - WorkspaceAutoGenTime)))
1939                 for Arch in Wa.ArchList:
1940                     AutoGenStart = time.time()
1941                     GlobalData.gGlobalDefines['ARCH'] = Arch
1942                     Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)
1943                     if Pa is None:
1944                         continue
1945                     ModuleList = []
1946                     for Inf in Pa.Platform.Modules:
1947                         ModuleList.append(Inf)
1948                     # Add the INF only list in FDF
1949                     if GlobalData.gFdfParser is not None:
1950                         for InfName in GlobalData.gFdfParser.Profile.InfList:
1951                             Inf = PathClass(NormPath(InfName), self.WorkspaceDir, Arch)
1952                             if Inf in Pa.Platform.Modules:
1953                                 continue
1954                             ModuleList.append(Inf)
1955                     for Module in ModuleList:
1956                         # Get ModuleAutoGen object to generate C code file and makefile
1957                         Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)
1958
1959                         if Ma is None:
1960                             continue
1961                         if Ma.CanSkipbyHash():
1962                             self.HashSkipModules.append(Ma)
1963                             continue
1964
1965                         # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'
1966                         if self.Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1967                             # for target which must generate AutoGen code and makefile
1968                             if not self.SkipAutoGen or self.Target == 'genc':
1969                                 Ma.CreateCodeFile(True)
1970                             if self.Target == "genc":
1971                                 continue
1972
1973                             if not self.SkipAutoGen or self.Target == 'genmake':
1974                                 if CmdListDict and self.Fdf and (Module.File, Arch) in CmdListDict:
1975                                     Ma.CreateMakeFile(True, CmdListDict[Module.File, Arch])
1976                                     del CmdListDict[Module.File, Arch]
1977                                 else:
1978                                     Ma.CreateMakeFile(True)
1979                             if self.Target == "genmake":
1980                                 continue
1981                         self.BuildModules.append(Ma)
1982                     self.Progress.Stop("done!")
1983                     self.AutoGenTime += int(round((time.time() - AutoGenStart)))
1984                     MakeStart = time.time()
1985                     for Ma in self.BuildModules:
1986                         # Generate build task for the module
1987                         if not Ma.IsBinaryModule:
1988                             Bt = BuildTask.New(ModuleMakeUnit(Ma, self.Target))
1989                         # Break build if any build thread has error
1990                         if BuildTask.HasError():
1991                             # we need a full version of makefile for platform
1992                             ExitFlag.set()
1993                             BuildTask.WaitForComplete()
1994                             Pa.CreateMakeFile(False)
1995                             EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)
1996                         # Start task scheduler
1997                         if not BuildTask.IsOnGoing():
1998                             BuildTask.StartScheduler(self.ThreadNumber, ExitFlag)
1999
2000                     # in case there's an interruption. we need a full version of makefile for platform
2001                     Pa.CreateMakeFile(False)
2002                     if BuildTask.HasError():
2003                         EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)
2004                     self.MakeTime += int(round((time.time() - MakeStart)))
2005
2006                 MakeContiue = time.time()
2007
2008                 #
2009                 #
2010                 # All modules have been put in build tasks queue. Tell task scheduler
2011                 # to exit if all tasks are completed
2012                 #
2013                 ExitFlag.set()
2014                 BuildTask.WaitForComplete()
2015                 self.CreateAsBuiltInf()
2016                 self.MakeTime += int(round((time.time() - MakeContiue)))
2017                 #
2018                 # Check for build error, and raise exception if one
2019                 # has been signaled.
2020                 #
2021                 if BuildTask.HasError():
2022                     EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)
2023
2024                 # Create MAP file when Load Fix Address is enabled.
2025                 if self.Target in ["", "all", "fds"]:
2026                     for Arch in Wa.ArchList:
2027                         #
2028                         # Check whether the set fix address is above 4G for 32bit image.
2029                         #
2030                         if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:
2031                             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")
2032                     #
2033                     # Get Module List
2034                     #
2035                     ModuleList = {}
2036                     for Pa in Wa.AutoGenObjectList:
2037                         for Ma in Pa.ModuleAutoGenList:
2038                             if Ma is None:
2039                                 continue
2040                             if not Ma.IsLibrary:
2041                                 ModuleList[Ma.Guid.upper()] = Ma
2042                     #
2043                     # Rebase module to the preferred memory address before GenFds
2044                     #
2045                     MapBuffer = BytesIO('')
2046                     if self.LoadFixAddress != 0:
2047                         self._CollectModuleMapBuffer(MapBuffer, ModuleList)
2048
2049                     if self.Fdf:
2050                         #
2051                         # Generate FD image if there's a FDF file found
2052                         #
2053                         GenFdsStart = time.time()
2054                         if GenFdsApi(Wa.GenFdsCommandDict, self.Db):
2055                             EdkLogger.error("build", COMMAND_FAILURE)
2056
2057                         #
2058                         # Create MAP file for all platform FVs after GenFds.
2059                         #
2060                         self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)
2061                         self.GenFdsTime += int(round((time.time() - GenFdsStart)))
2062                     #
2063                     # Save MAP buffer into MAP file.
2064                     #
2065                     self._SaveMapFile(MapBuffer, Wa)
2066
2067     ## Generate GuidedSectionTools.txt in the FV directories.
2068     #
2069     def CreateGuidedSectionToolsFile(self):
2070         for BuildTarget in self.BuildTargetList:
2071             for ToolChain in self.ToolChainList:
2072                 Wa = WorkspaceAutoGen(
2073                         self.WorkspaceDir,
2074                         self.PlatformFile,
2075                         BuildTarget,
2076                         ToolChain,
2077                         self.ArchList,
2078                         self.BuildDatabase,
2079                         self.TargetTxt,
2080                         self.ToolDef,
2081                         self.Fdf,
2082                         self.FdList,
2083                         self.FvList,
2084                         self.CapList,
2085                         self.SkuId,
2086                         self.UniFlag
2087                         )
2088                 FvDir = Wa.FvDir
2089                 if not os.path.exists(FvDir):
2090                     continue
2091
2092                 for Arch in self.ArchList:
2093                     # Build up the list of supported architectures for this build
2094                     prefix = '%s_%s_%s_' % (BuildTarget, ToolChain, Arch)
2095
2096                     # Look through the tool definitions for GUIDed tools
2097                     guidAttribs = []
2098                     for (attrib, value) in self.ToolDef.ToolsDefTxtDictionary.items():
2099                         if attrib.upper().endswith('_GUID'):
2100                             split = attrib.split('_')
2101                             thisPrefix = '_'.join(split[0:3]) + '_'
2102                             if thisPrefix == prefix:
2103                                 guid = self.ToolDef.ToolsDefTxtDictionary[attrib]
2104                                 guid = guid.lower()
2105                                 toolName = split[3]
2106                                 path = '_'.join(split[0:4]) + '_PATH'
2107                                 path = self.ToolDef.ToolsDefTxtDictionary[path]
2108                                 path = self.GetFullPathOfTool(path)
2109                                 guidAttribs.append((guid, toolName, path))
2110
2111                     # Write out GuidedSecTools.txt
2112                     toolsFile = os.path.join(FvDir, 'GuidedSectionTools.txt')
2113                     toolsFile = open(toolsFile, 'wt')
2114                     for guidedSectionTool in guidAttribs:
2115                         print(' '.join(guidedSectionTool), file=toolsFile)
2116                     toolsFile.close()
2117
2118     ## Returns the full path of the tool.
2119     #
2120     def GetFullPathOfTool (self, tool):
2121         if os.path.exists(tool):
2122             return os.path.realpath(tool)
2123         else:
2124             # We need to search for the tool using the
2125             # PATH environment variable.
2126             for dirInPath in os.environ['PATH'].split(os.pathsep):
2127                 foundPath = os.path.join(dirInPath, tool)
2128                 if os.path.exists(foundPath):
2129                     return os.path.realpath(foundPath)
2130
2131         # If the tool was not found in the path then we just return
2132         # the input tool.
2133         return tool
2134
2135     ## Launch the module or platform build
2136     #
2137     def Launch(self):
2138         if not self.ModuleFile:
2139             if not self.SpawnMode or self.Target not in ["", "all"]:
2140                 self.SpawnMode = False
2141                 self._BuildPlatform()
2142             else:
2143                 self._MultiThreadBuildPlatform()
2144             self.CreateGuidedSectionToolsFile()
2145         else:
2146             self.SpawnMode = False
2147             self._BuildModule()
2148
2149         if self.Target == 'cleanall':
2150             RemoveDirectory(os.path.dirname(GlobalData.gDatabasePath), True)
2151
2152     def CreateAsBuiltInf(self):
2153         for Module in self.BuildModules:
2154             Module.CreateAsBuiltInf()
2155         for Module in self.HashSkipModules:
2156             Module.CreateAsBuiltInf(True)
2157         self.BuildModules = []
2158         self.HashSkipModules = []
2159     ## Do some clean-up works when error occurred
2160     def Relinquish(self):
2161         OldLogLevel = EdkLogger.GetLevel()
2162         EdkLogger.SetLevel(EdkLogger.ERROR)
2163         Utils.Progressor.Abort()
2164         if self.SpawnMode == True:
2165             BuildTask.Abort()
2166         EdkLogger.SetLevel(OldLogLevel)
2167
2168 def ParseDefines(DefineList=[]):
2169     DefineDict = {}
2170     if DefineList is not None:
2171         for Define in DefineList:
2172             DefineTokenList = Define.split("=", 1)
2173             if not GlobalData.gMacroNamePattern.match(DefineTokenList[0]):
2174                 EdkLogger.error('build', FORMAT_INVALID,
2175                                 "The macro name must be in the pattern [A-Z][A-Z0-9_]*",
2176                                 ExtraData=DefineTokenList[0])
2177
2178             if len(DefineTokenList) == 1:
2179                 DefineDict[DefineTokenList[0]] = "TRUE"
2180             else:
2181                 DefineDict[DefineTokenList[0]] = DefineTokenList[1].strip()
2182     return DefineDict
2183
2184 gParamCheck = []
2185 def SingleCheckCallback(option, opt_str, value, parser):
2186     if option not in gParamCheck:
2187         setattr(parser.values, option.dest, value)
2188         gParamCheck.append(option)
2189     else:
2190         parser.error("Option %s only allows one instance in command line!" % option)
2191
2192 def LogBuildTime(Time):
2193     if Time:
2194         TimeDurStr = ''
2195         TimeDur = time.gmtime(Time)
2196         if TimeDur.tm_yday > 1:
2197             TimeDurStr = time.strftime("%H:%M:%S", TimeDur) + ", %d day(s)" % (TimeDur.tm_yday - 1)
2198         else:
2199             TimeDurStr = time.strftime("%H:%M:%S", TimeDur)
2200         return TimeDurStr
2201     else:
2202         return None
2203
2204 ## Parse command line options
2205 #
2206 # Using standard Python module optparse to parse command line option of this tool.
2207 #
2208 #   @retval Opt   A optparse.Values object containing the parsed options
2209 #   @retval Args  Target of build command
2210 #
2211 def MyOptionParser():
2212     Parser = OptionParser(description=__copyright__, version=__version__, prog="build.exe", usage="%prog [options] [all|fds|genc|genmake|clean|cleanall|cleanlib|modules|libraries|run]")
2213     Parser.add_option("-a", "--arch", action="append", type="choice", choices=['IA32', 'X64', 'EBC', 'ARM', 'AARCH64'], dest="TargetArch",
2214         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.")
2215     Parser.add_option("-p", "--platform", action="callback", type="string", dest="PlatformFile", callback=SingleCheckCallback,
2216         help="Build the platform specified by the DSC file name argument, overriding target.txt's ACTIVE_PLATFORM definition.")
2217     Parser.add_option("-m", "--module", action="callback", type="string", dest="ModuleFile", callback=SingleCheckCallback,
2218         help="Build the module specified by the INF file name argument.")
2219     Parser.add_option("-b", "--buildtarget", type="string", dest="BuildTarget", help="Using the TARGET to build the platform, overriding target.txt's TARGET definition.",
2220                       action="append")
2221     Parser.add_option("-t", "--tagname", action="append", type="string", dest="ToolChain",
2222         help="Using the Tool Chain Tagname to build the platform, overriding target.txt's TOOL_CHAIN_TAG definition.")
2223     Parser.add_option("-x", "--sku-id", action="callback", type="string", dest="SkuId", callback=SingleCheckCallback,
2224         help="Using this name of SKU ID to build the platform, overriding SKUID_IDENTIFIER in DSC file.")
2225
2226     Parser.add_option("-n", action="callback", type="int", dest="ThreadNumber", callback=SingleCheckCallback,
2227         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 "\
2228              "processor threads, set value to 1 means disable multi-thread build, and set value to more than 1 means user specify the threads number to build.")
2229
2230     Parser.add_option("-f", "--fdf", action="callback", type="string", dest="FdfFile", callback=SingleCheckCallback,
2231         help="The name of the FDF file to use, which overrides the setting in the DSC file.")
2232     Parser.add_option("-r", "--rom-image", action="append", type="string", dest="RomImage", default=[],
2233         help="The name of FD to be generated. The name must be from [FD] section in FDF file.")
2234     Parser.add_option("-i", "--fv-image", action="append", type="string", dest="FvImage", default=[],
2235         help="The name of FV to be generated. The name must be from [FV] section in FDF file.")
2236     Parser.add_option("-C", "--capsule-image", action="append", type="string", dest="CapName", default=[],
2237         help="The name of Capsule to be generated. The name must be from [Capsule] section in FDF file.")
2238     Parser.add_option("-u", "--skip-autogen", action="store_true", dest="SkipAutoGen", help="Skip AutoGen step.")
2239     Parser.add_option("-e", "--re-parse", action="store_true", dest="Reparse", help="Re-parse all meta-data files.")
2240
2241     Parser.add_option("-c", "--case-insensitive", action="store_true", dest="CaseInsensitive", default=False, help="Don't check case of file name.")
2242
2243     Parser.add_option("-w", "--warning-as-error", action="store_true", dest="WarningAsError", help="Treat warning in tools as error.")
2244     Parser.add_option("-j", "--log", action="store", dest="LogFile", help="Put log in specified file as well as on console.")
2245
2246     Parser.add_option("-s", "--silent", action="store_true", type=None, dest="SilentMode",
2247         help="Make use of silent mode of (n)make.")
2248     Parser.add_option("-q", "--quiet", action="store_true", type=None, help="Disable all messages except FATAL ERRORS.")
2249     Parser.add_option("-v", "--verbose", action="store_true", type=None, help="Turn on verbose output with informational messages printed, "\
2250                                                                                "including library instances selected, final dependency expression, "\
2251                                                                                "and warning messages, etc.")
2252     Parser.add_option("-d", "--debug", action="store", type="int", help="Enable debug messages at specified level.")
2253     Parser.add_option("-D", "--define", action="append", type="string", dest="Macros", help="Macro: \"Name [= Value]\".")
2254
2255     Parser.add_option("-y", "--report-file", action="store", dest="ReportFile", help="Create/overwrite the report to the specified filename.")
2256     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=[],
2257         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].  "\
2258              "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]")
2259     Parser.add_option("-F", "--flag", action="store", type="string", dest="Flag",
2260         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. "\
2261              "This option can also be specified by setting *_*_*_BUILD_FLAGS in [BuildOptions] section of platform DSC. If they are both specified, this value "\
2262              "will override the setting in [BuildOptions] section of platform DSC.")
2263     Parser.add_option("-N", "--no-cache", action="store_true", dest="DisableCache", default=False, help="Disable build cache mechanism")
2264     Parser.add_option("--conf", action="store", type="string", dest="ConfDirectory", help="Specify the customized Conf directory.")
2265     Parser.add_option("--check-usage", action="store_true", dest="CheckUsage", default=False, help="Check usage content of entries listed in INF file.")
2266     Parser.add_option("--ignore-sources", action="store_true", dest="IgnoreSources", default=False, help="Focus to a binary build and ignore all source files")
2267     Parser.add_option("--pcd", action="append", dest="OptionPcd", help="Set PCD value by command line. Format: \"PcdName=Value\" ")
2268     Parser.add_option("-l", "--cmd-len", action="store", type="int", dest="CommandLength", help="Specify the maximum line length of build command. Default is 4096.")
2269     Parser.add_option("--hash", action="store_true", dest="UseHashCache", default=False, help="Enable hash-based caching during build process.")
2270     Parser.add_option("--binary-destination", action="store", type="string", dest="BinCacheDest", help="Generate a cache of binary files in the specified directory.")
2271     Parser.add_option("--binary-source", action="store", type="string", dest="BinCacheSource", help="Consume a cache of binary files from the specified directory.")
2272     Parser.add_option("--genfds-multi-thread", action="store_true", dest="GenfdsMultiThread", default=False, help="Enable GenFds multi thread to generate ffs file.")
2273     (Opt, Args) = Parser.parse_args()
2274     return (Opt, Args)
2275
2276 ## Tool entrance method
2277 #
2278 # This method mainly dispatch specific methods per the command line options.
2279 # If no error found, return zero value so the caller of this tool can know
2280 # if it's executed successfully or not.
2281 #
2282 #   @retval 0     Tool was successful
2283 #   @retval 1     Tool failed
2284 #
2285 def Main():
2286     StartTime = time.time()
2287
2288     # Initialize log system
2289     EdkLogger.Initialize()
2290     GlobalData.gCommand = sys.argv[1:]
2291     #
2292     # Parse the options and args
2293     #
2294     (Option, Target) = MyOptionParser()
2295     GlobalData.gOptions = Option
2296     GlobalData.gCaseInsensitive = Option.CaseInsensitive
2297
2298     # Set log level
2299     if Option.verbose is not None:
2300         EdkLogger.SetLevel(EdkLogger.VERBOSE)
2301     elif Option.quiet is not None:
2302         EdkLogger.SetLevel(EdkLogger.QUIET)
2303     elif Option.debug is not None:
2304         EdkLogger.SetLevel(Option.debug + 1)
2305     else:
2306         EdkLogger.SetLevel(EdkLogger.INFO)
2307
2308     if Option.LogFile is not None:
2309         EdkLogger.SetLogFile(Option.LogFile)
2310
2311     if Option.WarningAsError == True:
2312         EdkLogger.SetWarningAsError()
2313
2314     if platform.platform().find("Windows") >= 0:
2315         GlobalData.gIsWindows = True
2316     else:
2317         GlobalData.gIsWindows = False
2318
2319     EdkLogger.quiet("Build environment: %s" % platform.platform())
2320     EdkLogger.quiet(time.strftime("Build start time: %H:%M:%S, %b.%d %Y\n", time.localtime()));
2321     ReturnCode = 0
2322     MyBuild = None
2323     BuildError = True
2324     try:
2325         if len(Target) == 0:
2326             Target = "all"
2327         elif len(Target) >= 2:
2328             EdkLogger.error("build", OPTION_NOT_SUPPORTED, "More than one targets are not supported.",
2329                             ExtraData="Please select one of: %s" % (' '.join(gSupportedTarget)))
2330         else:
2331             Target = Target[0].lower()
2332
2333         if Target not in gSupportedTarget:
2334             EdkLogger.error("build", OPTION_NOT_SUPPORTED, "Not supported target [%s]." % Target,
2335                             ExtraData="Please select one of: %s" % (' '.join(gSupportedTarget)))
2336
2337         #
2338         # Check environment variable: EDK_TOOLS_PATH, WORKSPACE, PATH
2339         #
2340         CheckEnvVariable()
2341         GlobalData.gCommandLineDefines.update(ParseDefines(Option.Macros))
2342
2343         Workspace = os.getenv("WORKSPACE")
2344         #
2345         # Get files real name in workspace dir
2346         #
2347         GlobalData.gAllFiles = Utils.DirCache(Workspace)
2348
2349         WorkingDirectory = os.getcwd()
2350         if not Option.ModuleFile:
2351             FileList = glob.glob(os.path.normpath(os.path.join(WorkingDirectory, '*.inf')))
2352             FileNum = len(FileList)
2353             if FileNum >= 2:
2354                 EdkLogger.error("build", OPTION_NOT_SUPPORTED, "There are %d INF files in %s." % (FileNum, WorkingDirectory),
2355                                 ExtraData="Please use '-m <INF_FILE_PATH>' switch to choose one.")
2356             elif FileNum == 1:
2357                 Option.ModuleFile = NormFile(FileList[0], Workspace)
2358
2359         if Option.ModuleFile:
2360             if os.path.isabs (Option.ModuleFile):
2361                 if os.path.normcase (os.path.normpath(Option.ModuleFile)).find (Workspace) == 0:
2362                     Option.ModuleFile = NormFile(os.path.normpath(Option.ModuleFile), Workspace)
2363             Option.ModuleFile = PathClass(Option.ModuleFile, Workspace)
2364             ErrorCode, ErrorInfo = Option.ModuleFile.Validate(".inf", False)
2365             if ErrorCode != 0:
2366                 EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)
2367
2368         if Option.PlatformFile is not None:
2369             if os.path.isabs (Option.PlatformFile):
2370                 if os.path.normcase (os.path.normpath(Option.PlatformFile)).find (Workspace) == 0:
2371                     Option.PlatformFile = NormFile(os.path.normpath(Option.PlatformFile), Workspace)
2372             Option.PlatformFile = PathClass(Option.PlatformFile, Workspace)
2373
2374         if Option.FdfFile is not None:
2375             if os.path.isabs (Option.FdfFile):
2376                 if os.path.normcase (os.path.normpath(Option.FdfFile)).find (Workspace) == 0:
2377                     Option.FdfFile = NormFile(os.path.normpath(Option.FdfFile), Workspace)
2378             Option.FdfFile = PathClass(Option.FdfFile, Workspace)
2379             ErrorCode, ErrorInfo = Option.FdfFile.Validate(".fdf", False)
2380             if ErrorCode != 0:
2381                 EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)
2382
2383         if Option.Flag is not None and Option.Flag not in ['-c', '-s']:
2384             EdkLogger.error("build", OPTION_VALUE_INVALID, "UNI flag must be one of -c or -s")
2385
2386         MyBuild = Build(Target, Workspace, Option)
2387         GlobalData.gCommandLineDefines['ARCH'] = ' '.join(MyBuild.ArchList)
2388         if not (MyBuild.LaunchPrebuildFlag and os.path.exists(MyBuild.PlatformBuildPath)):
2389             MyBuild.Launch()
2390
2391         #
2392         # All job done, no error found and no exception raised
2393         #
2394         BuildError = False
2395     except FatalError as X:
2396         if MyBuild is not None:
2397             # for multi-thread build exits safely
2398             MyBuild.Relinquish()
2399         if Option is not None and Option.debug is not None:
2400             EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())
2401         ReturnCode = X.args[0]
2402     except Warning as X:
2403         # error from Fdf parser
2404         if MyBuild is not None:
2405             # for multi-thread build exits safely
2406             MyBuild.Relinquish()
2407         if Option is not None and Option.debug is not None:
2408             EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())
2409         else:
2410             EdkLogger.error(X.ToolName, FORMAT_INVALID, File=X.FileName, Line=X.LineNumber, ExtraData=X.Message, RaiseError=False)
2411         ReturnCode = FORMAT_INVALID
2412     except KeyboardInterrupt:
2413         ReturnCode = ABORT_ERROR
2414         if Option is not None and Option.debug is not None:
2415             EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())
2416     except:
2417         if MyBuild is not None:
2418             # for multi-thread build exits safely
2419             MyBuild.Relinquish()
2420
2421         # try to get the meta-file from the object causing exception
2422         Tb = sys.exc_info()[-1]
2423         MetaFile = GlobalData.gProcessingFile
2424         while Tb is not None:
2425             if 'self' in Tb.tb_frame.f_locals and hasattr(Tb.tb_frame.f_locals['self'], 'MetaFile'):
2426                 MetaFile = Tb.tb_frame.f_locals['self'].MetaFile
2427             Tb = Tb.tb_next
2428         EdkLogger.error(
2429                     "\nbuild",
2430                     CODE_ERROR,
2431                     "Unknown fatal error when processing [%s]" % MetaFile,
2432                     ExtraData="\n(Please send email to edk2-devel@lists.01.org for help, attaching following call stack trace!)\n",
2433                     RaiseError=False
2434                     )
2435         EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())
2436         ReturnCode = CODE_ERROR
2437     finally:
2438         Utils.Progressor.Abort()
2439         Utils.ClearDuplicatedInf()
2440
2441     if ReturnCode == 0:
2442         try:
2443             MyBuild.LaunchPostbuild()
2444             Conclusion = "Done"
2445         except:
2446             Conclusion = "Failed"
2447     elif ReturnCode == ABORT_ERROR:
2448         Conclusion = "Aborted"
2449     else:
2450         Conclusion = "Failed"
2451     FinishTime = time.time()
2452     BuildDuration = time.gmtime(int(round(FinishTime - StartTime)))
2453     BuildDurationStr = ""
2454     if BuildDuration.tm_yday > 1:
2455         BuildDurationStr = time.strftime("%H:%M:%S", BuildDuration) + ", %d day(s)" % (BuildDuration.tm_yday - 1)
2456     else:
2457         BuildDurationStr = time.strftime("%H:%M:%S", BuildDuration)
2458     if MyBuild is not None:
2459         if not BuildError:
2460             MyBuild.BuildReport.GenerateReport(BuildDurationStr, LogBuildTime(MyBuild.AutoGenTime), LogBuildTime(MyBuild.MakeTime), LogBuildTime(MyBuild.GenFdsTime))
2461
2462     EdkLogger.SetLevel(EdkLogger.QUIET)
2463     EdkLogger.quiet("\n- %s -" % Conclusion)
2464     EdkLogger.quiet(time.strftime("Build end time: %H:%M:%S, %b.%d %Y", time.localtime()))
2465     EdkLogger.quiet("Build total time: %s\n" % BuildDurationStr)
2466     return ReturnCode
2467
2468 if __name__ == '__main__':
2469     r = Main()
2470     ## 0-127 is a safe return range, and 1 is a standard default error
2471     if r < 0 or r > 127: r = 1
2472     sys.exit(r)
2473