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