BaseTools/Source/Python/build/build.py

   1 ## @file
   2 # build a platform or a module
   3 #
   4 #  Copyright (c) 2014, Hewlett-Packard Development Company, L.P.<BR>
   5 #  Copyright (c) 2007 - 2019, Intel Corporation. All rights reserved.<BR>
   6 #  Copyright (c) 2018, Hewlett Packard Enterprise Development, L.P.<BR>
   7 #
   8 #  This program and the accompanying materials
   9 #  are licensed and made available under the terms and conditions of the BSD License
  10 #  which accompanies this distribution.  The full text of the license may be found at
  11 #  http://opensource.org/licenses/bsd-license.php
  12 #
  13 #  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  14 #  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  15 #
  16
  17 ##
  18 # Import Modules
  19 #
  20 from __future__ import print_function
  21 import Common.LongFilePathOs as os
  22 import re
  23 from io import BytesIO
  24 import sys
  25 import glob
  26 import time
  27 import platform
  28 import traceback
  29 import encodings.ascii
  30 import multiprocessing
  31
  32 from struct import *
  33 from threading import *
  34 import threading
  35 from optparse import OptionParser
  36 from subprocess import *
  37 from Common import Misc as Utils
  38
  39 from Common.LongFilePathSupport import OpenLongFilePath as open
  40 from Common.TargetTxtClassObject import TargetTxtClassObject
  41 from Common.ToolDefClassObject import ToolDefClassObject
  42 from Common.DataType import *
  43 from Common.BuildVersion import gBUILD_VERSION
  44 from AutoGen.AutoGen import *
  45 from Common.BuildToolError import *
  46 from Workspace.WorkspaceDatabase import WorkspaceDatabase
  47 from Common.MultipleWorkspace import MultipleWorkspace as mws
  48
  49 from BuildReport import BuildReport
  50 from GenPatchPcdTable.GenPatchPcdTable import *
  51 from PatchPcdValue.PatchPcdValue import *
  52
  53 import Common.EdkLogger
  54 import Common.GlobalData as GlobalData
  55 from GenFds.GenFds import GenFds, GenFdsApi
  56
  57 from collections import OrderedDict, defaultdict
  58
  59 # Version and Copyright
  60 VersionNumber = "0.60" + ' ' + gBUILD_VERSION
  61 __version__ = "%prog Version " + VersionNumber
  62 __copyright__ = "Copyright (c) 2007 - 2018, Intel Corporation  All rights reserved."
  63
  64 ## standard targets of build command
  65 gSupportedTarget = ['all', 'genc', 'genmake', 'modules', 'libraries', 'fds', 'clean', 'cleanall', 'cleanlib', 'run']
  66
  67 ## build configuration file
  68 gBuildConfiguration = "target.txt"
  69 gToolsDefinition = "tools_def.txt"
  70
  71 TemporaryTablePattern = re.compile(r'^_\d+_\d+_[a-fA-F0-9]+$')
  72 TmpTableDict = {}
  73
  74 ## Check environment PATH variable to make sure the specified tool is found
  75 #
  76 #   If the tool is found in the PATH, then True is returned
  77 #   Otherwise, False is returned
  78 #
  79 def IsToolInPath(tool):
  80     if 'PATHEXT' in os.environ:
  81         extns = os.environ['PATHEXT'].split(os.path.pathsep)
  82     else:
  83         extns = ('',)
  84     for pathDir in os.environ['PATH'].split(os.path.pathsep):
  85         for ext in extns:
  86             if os.path.exists(os.path.join(pathDir, tool + ext)):
  87                 return True
  88     return False
  89
  90 ## Check environment variables
  91 #
  92 #  Check environment variables that must be set for build. Currently they are
  93 #
  94 #   WORKSPACE           The directory all packages/platforms start from
  95 #   EDK_TOOLS_PATH      The directory contains all tools needed by the build
  96 #   PATH                $(EDK_TOOLS_PATH)/Bin/<sys> must be set in PATH
  97 #
  98 #   If any of above environment variable is not set or has error, the build
  99 #   will be broken.
 100 #
 101 def CheckEnvVariable():
 102     # check WORKSPACE
 103     if "WORKSPACE" not in os.environ:
 104         EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "Environment variable not found",
 105                         ExtraData="WORKSPACE")
 106
 107     WorkspaceDir = os.path.normcase(os.path.normpath(os.environ["WORKSPACE"]))
 108     if not os.path.exists(WorkspaceDir):
 109         EdkLogger.error("build", FILE_NOT_FOUND, "WORKSPACE doesn't exist", ExtraData=WorkspaceDir)
 110     elif ' ' in WorkspaceDir:
 111         EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in WORKSPACE path",
 112                         ExtraData=WorkspaceDir)
 113     os.environ["WORKSPACE"] = WorkspaceDir
 114
 115     # set multiple workspace
 116     PackagesPath = os.getenv("PACKAGES_PATH")
 117     mws.setWs(WorkspaceDir, PackagesPath)
 118     if mws.PACKAGES_PATH:
 119         for Path in mws.PACKAGES_PATH:
 120             if not os.path.exists(Path):
 121                 EdkLogger.error("build", FILE_NOT_FOUND, "One Path in PACKAGES_PATH doesn't exist", ExtraData=Path)
 122             elif ' ' in Path:
 123                 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in PACKAGES_PATH", ExtraData=Path)
 124
 125
 126     os.environ["EDK_TOOLS_PATH"] = os.path.normcase(os.environ["EDK_TOOLS_PATH"])
 127
 128     # check EDK_TOOLS_PATH
 129     if "EDK_TOOLS_PATH" not in os.environ:
 130         EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "Environment variable not found",
 131                         ExtraData="EDK_TOOLS_PATH")
 132
 133     # check PATH
 134     if "PATH" not in os.environ:
 135         EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "Environment variable not found",
 136                         ExtraData="PATH")
 137
 138     GlobalData.gWorkspace = WorkspaceDir
 139
 140     GlobalData.gGlobalDefines["WORKSPACE"]  = WorkspaceDir
 141     GlobalData.gGlobalDefines["EDK_TOOLS_PATH"] = os.environ["EDK_TOOLS_PATH"]
 142
 143 ## Get normalized file path
 144 #
 145 # Convert the path to be local format, and remove the WORKSPACE path at the
 146 # beginning if the file path is given in full path.
 147 #
 148 # @param  FilePath      File path to be normalized
 149 # @param  Workspace     Workspace path which the FilePath will be checked against
 150 #
 151 # @retval string        The normalized file path
 152 #
 153 def NormFile(FilePath, Workspace):
 154     # check if the path is absolute or relative
 155     if os.path.isabs(FilePath):
 156         FileFullPath = os.path.normpath(FilePath)
 157     else:
 158         FileFullPath = os.path.normpath(mws.join(Workspace, FilePath))
 159         Workspace = mws.getWs(Workspace, FilePath)
 160
 161     # check if the file path exists or not
 162     if not os.path.isfile(FileFullPath):
 163         EdkLogger.error("build", FILE_NOT_FOUND, ExtraData="\t%s (Please give file in absolute path or relative to WORKSPACE)" % FileFullPath)
 164
 165     # remove workspace directory from the beginning part of the file path
 166     if Workspace[-1] in ["\\", "/"]:
 167         return FileFullPath[len(Workspace):]
 168     else:
 169         return FileFullPath[(len(Workspace) + 1):]
 170
 171 ## Get the output of an external program
 172 #
 173 # This is the entrance method of thread reading output of an external program and
 174 # putting them in STDOUT/STDERR of current program.
 175 #
 176 # @param  From      The stream message read from
 177 # @param  To        The stream message put on
 178 # @param  ExitFlag  The flag used to indicate stopping reading
 179 #
 180 def ReadMessage(From, To, ExitFlag):
 181     while True:
 182         # read one line a time
 183         Line = From.readline()
 184         # empty string means "end"
 185         if Line is not None and Line != "":
 186             To(Line.rstrip())
 187         else:
 188             break
 189         if ExitFlag.isSet():
 190             break
 191
 192 ## Launch an external program
 193 #
 194 # This method will call subprocess.Popen to execute an external program with
 195 # given options in specified directory. Because of the dead-lock issue during
 196 # redirecting output of the external program, threads are used to to do the
 197 # redirection work.
 198 #
 199 # @param  Command               A list or string containing the call of the program
 200 # @param  WorkingDir            The directory in which the program will be running
 201 #
 202 def LaunchCommand(Command, WorkingDir):
 203     BeginTime = time.time()
 204     # if working directory doesn't exist, Popen() will raise an exception
 205     if not os.path.isdir(WorkingDir):
 206         EdkLogger.error("build", FILE_NOT_FOUND, ExtraData=WorkingDir)
 207
 208     # Command is used as the first Argument in following Popen().
 209     # It could be a string or sequence. We find that if command is a string in following Popen(),
 210     # ubuntu may fail with an error message that the command is not found.
 211     # So here we may need convert command from string to list instance.
 212     if platform.system() != 'Windows':
 213         if not isinstance(Command, list):
 214             Command = Command.split()
 215         Command = ' '.join(Command)
 216
 217     Proc = None
 218     EndOfProcedure = None
 219     try:
 220         # launch the command
 221         Proc = Popen(Command, stdout=PIPE, stderr=PIPE, env=os.environ, cwd=WorkingDir, bufsize=-1, shell=True)
 222
 223         # launch two threads to read the STDOUT and STDERR
 224         EndOfProcedure = Event()
 225         EndOfProcedure.clear()
 226         if Proc.stdout:
 227             StdOutThread = Thread(target=ReadMessage, args=(Proc.stdout, EdkLogger.info, EndOfProcedure))
 228             StdOutThread.setName("STDOUT-Redirector")
 229             StdOutThread.setDaemon(False)
 230             StdOutThread.start()
 231
 232         if Proc.stderr:
 233             StdErrThread = Thread(target=ReadMessage, args=(Proc.stderr, EdkLogger.quiet, EndOfProcedure))
 234             StdErrThread.setName("STDERR-Redirector")
 235             StdErrThread.setDaemon(False)
 236             StdErrThread.start()
 237
 238         # waiting for program exit
 239         Proc.wait()
 240     except: # in case of aborting
 241         # terminate the threads redirecting the program output
 242         EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())
 243         if EndOfProcedure is not None:
 244             EndOfProcedure.set()
 245         if Proc is None:
 246             if not isinstance(Command, type("")):
 247                 Command = " ".join(Command)
 248             EdkLogger.error("build", COMMAND_FAILURE, "Failed to start command", ExtraData="%s [%s]" % (Command, WorkingDir))
 249
 250     if Proc.stdout:
 251         StdOutThread.join()
 252     if Proc.stderr:
 253         StdErrThread.join()
 254
 255     # check the return code of the program
 256     if Proc.returncode != 0:
 257         if not isinstance(Command, type("")):
 258             Command = " ".join(Command)
 259         # print out the Response file and its content when make failure
 260         RespFile = os.path.join(WorkingDir, 'OUTPUT', 'respfilelist.txt')
 261         if os.path.isfile(RespFile):
 262             f = open(RespFile)
 263             RespContent = f.read()
 264             f.close()
 265             EdkLogger.info(RespContent)
 266
 267         EdkLogger.error("build", COMMAND_FAILURE, ExtraData="%s [%s]" % (Command, WorkingDir))
 268     return "%dms" % (int(round((time.time() - BeginTime) * 1000)))
 269
 270 ## The smallest unit that can be built in multi-thread build mode
 271 #
 272 # This is the base class of build unit. The "Obj" parameter must provide
 273 # __str__(), __eq__() and __hash__() methods. Otherwise there could be build units
 274 # missing build.
 275 #
 276 # Currently the "Obj" should be only ModuleAutoGen or PlatformAutoGen objects.
 277 #
 278 class BuildUnit:
 279     ## The constructor
 280     #
 281     #   @param  self        The object pointer
 282     #   @param  Obj         The object the build is working on
 283     #   @param  Target      The build target name, one of gSupportedTarget
 284     #   @param  Dependency  The BuildUnit(s) which must be completed in advance
 285     #   @param  WorkingDir  The directory build command starts in
 286     #
 287     def __init__(self, Obj, BuildCommand, Target, Dependency, WorkingDir="."):
 288         self.BuildObject = Obj
 289         self.Dependency = Dependency
 290         self.WorkingDir = WorkingDir
 291         self.Target = Target
 292         self.BuildCommand = BuildCommand
 293         if not BuildCommand:
 294             EdkLogger.error("build", OPTION_MISSING,
 295                             "No build command found for this module. "
 296                             "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %
 297                                 (Obj.BuildTarget, Obj.ToolChain, Obj.Arch),
 298                             ExtraData=str(Obj))
 299
 300
 301     ## str() method
 302     #
 303     #   It just returns the string representation of self.BuildObject
 304     #
 305     #   @param  self        The object pointer
 306     #
 307     def __str__(self):
 308         return str(self.BuildObject)
 309
 310     ## "==" operator method
 311     #
 312     #   It just compares self.BuildObject with "Other". So self.BuildObject must
 313     #   provide its own __eq__() method.
 314     #
 315     #   @param  self        The object pointer
 316     #   @param  Other       The other BuildUnit object compared to
 317     #
 318     def __eq__(self, Other):
 319         return Other and self.BuildObject == Other.BuildObject \
 320                 and Other.BuildObject \
 321                 and self.BuildObject.Arch == Other.BuildObject.Arch
 322
 323     ## hash() method
 324     #
 325     #   It just returns the hash value of self.BuildObject which must be hashable.
 326     #
 327     #   @param  self        The object pointer
 328     #
 329     def __hash__(self):
 330         return hash(self.BuildObject) + hash(self.BuildObject.Arch)
 331
 332     def __repr__(self):
 333         return repr(self.BuildObject)
 334
 335 ## The smallest module unit that can be built by nmake/make command in multi-thread build mode
 336 #
 337 # This class is for module build by nmake/make build system. The "Obj" parameter
 338 # must provide __str__(), __eq__() and __hash__() methods. Otherwise there could
 339 # be make units missing build.
 340 #
 341 # Currently the "Obj" should be only ModuleAutoGen object.
 342 #
 343 class ModuleMakeUnit(BuildUnit):
 344     ## The constructor
 345     #
 346     #   @param  self        The object pointer
 347     #   @param  Obj         The ModuleAutoGen object the build is working on
 348     #   @param  Target      The build target name, one of gSupportedTarget
 349     #
 350     def __init__(self, Obj, Target):
 351         Dependency = [ModuleMakeUnit(La, Target) for La in Obj.LibraryAutoGenList]
 352         BuildUnit.__init__(self, Obj, Obj.BuildCommand, Target, Dependency, Obj.MakeFileDir)
 353         if Target in [None, "", "all"]:
 354             self.Target = "tbuild"
 355
 356 ## The smallest platform unit that can be built by nmake/make command in multi-thread build mode
 357 #
 358 # This class is for platform build by nmake/make build system. The "Obj" parameter
 359 # must provide __str__(), __eq__() and __hash__() methods. Otherwise there could
 360 # be make units missing build.
 361 #
 362 # Currently the "Obj" should be only PlatformAutoGen object.
 363 #
 364 class PlatformMakeUnit(BuildUnit):
 365     ## The constructor
 366     #
 367     #   @param  self        The object pointer
 368     #   @param  Obj         The PlatformAutoGen object the build is working on
 369     #   @param  Target      The build target name, one of gSupportedTarget
 370     #
 371     def __init__(self, Obj, Target):
 372         Dependency = [ModuleMakeUnit(Lib, Target) for Lib in self.BuildObject.LibraryAutoGenList]
 373         Dependency.extend([ModuleMakeUnit(Mod, Target) for Mod in self.BuildObject.ModuleAutoGenList])
 374         BuildUnit.__init__(self, Obj, Obj.BuildCommand, Target, Dependency, Obj.MakeFileDir)
 375
 376 ## The class representing the task of a module build or platform build
 377 #
 378 # This class manages the build tasks in multi-thread build mode. Its jobs include
 379 # scheduling thread running, catching thread error, monitor the thread status, etc.
 380 #
 381 class BuildTask:
 382     # queue for tasks waiting for schedule
 383     _PendingQueue = OrderedDict()
 384     _PendingQueueLock = threading.Lock()
 385
 386     # queue for tasks ready for running
 387     _ReadyQueue = OrderedDict()
 388     _ReadyQueueLock = threading.Lock()
 389
 390     # queue for run tasks
 391     _RunningQueue = OrderedDict()
 392     _RunningQueueLock = threading.Lock()
 393
 394     # queue containing all build tasks, in case duplicate build
 395     _TaskQueue = OrderedDict()
 396
 397     # flag indicating error occurs in a running thread
 398     _ErrorFlag = threading.Event()
 399     _ErrorFlag.clear()
 400     _ErrorMessage = ""
 401
 402     # BoundedSemaphore object used to control the number of running threads
 403     _Thread = None
 404
 405     # flag indicating if the scheduler is started or not
 406     _SchedulerStopped = threading.Event()
 407     _SchedulerStopped.set()
 408
 409     ## Start the task scheduler thread
 410     #
 411     #   @param  MaxThreadNumber     The maximum thread number
 412     #   @param  ExitFlag            Flag used to end the scheduler
 413     #
 414     @staticmethod
 415     def StartScheduler(MaxThreadNumber, ExitFlag):
 416         SchedulerThread = Thread(target=BuildTask.Scheduler, args=(MaxThreadNumber, ExitFlag))
 417         SchedulerThread.setName("Build-Task-Scheduler")
 418         SchedulerThread.setDaemon(False)
 419         SchedulerThread.start()
 420         # wait for the scheduler to be started, especially useful in Linux
 421         while not BuildTask.IsOnGoing():
 422             time.sleep(0.01)
 423
 424     ## Scheduler method
 425     #
 426     #   @param  MaxThreadNumber     The maximum thread number
 427     #   @param  ExitFlag            Flag used to end the scheduler
 428     #
 429     @staticmethod
 430     def Scheduler(MaxThreadNumber, ExitFlag):
 431         BuildTask._SchedulerStopped.clear()
 432         try:
 433             # use BoundedSemaphore to control the maximum running threads
 434             BuildTask._Thread = BoundedSemaphore(MaxThreadNumber)
 435             #
 436             # scheduling loop, which will exits when no pending/ready task and
 437             # indicated to do so, or there's error in running thread
 438             #
 439             while (len(BuildTask._PendingQueue) > 0 or len(BuildTask._ReadyQueue) > 0 \
 440                    or not ExitFlag.isSet()) and not BuildTask._ErrorFlag.isSet():
 441                 EdkLogger.debug(EdkLogger.DEBUG_8, "Pending Queue (%d), Ready Queue (%d)"
 442                                 % (len(BuildTask._PendingQueue), len(BuildTask._ReadyQueue)))
 443
 444                 # get all pending tasks
 445                 BuildTask._PendingQueueLock.acquire()
 446                 BuildObjectList = BuildTask._PendingQueue.keys()
 447                 #
 448                 # check if their dependency is resolved, and if true, move them
 449                 # into ready queue
 450                 #
 451                 for BuildObject in BuildObjectList:
 452                     Bt = BuildTask._PendingQueue[BuildObject]
 453                     if Bt.IsReady():
 454                         BuildTask._ReadyQueue[BuildObject] = BuildTask._PendingQueue.pop(BuildObject)
 455                 BuildTask._PendingQueueLock.release()
 456
 457                 # launch build thread until the maximum number of threads is reached
 458                 while not BuildTask._ErrorFlag.isSet():
 459                     # empty ready queue, do nothing further
 460                     if len(BuildTask._ReadyQueue) == 0:
 461                         break
 462
 463                     # wait for active thread(s) exit
 464                     BuildTask._Thread.acquire(True)
 465
 466                     # start a new build thread
 467                     Bo, Bt = BuildTask._ReadyQueue.popitem()
 468
 469                     # move into running queue
 470                     BuildTask._RunningQueueLock.acquire()
 471                     BuildTask._RunningQueue[Bo] = Bt
 472                     BuildTask._RunningQueueLock.release()
 473
 474                     Bt.Start()
 475                     # avoid tense loop
 476                     time.sleep(0.01)
 477
 478                 # avoid tense loop
 479                 time.sleep(0.01)
 480
 481             # wait for all running threads exit
 482             if BuildTask._ErrorFlag.isSet():
 483                 EdkLogger.quiet("\nWaiting for all build threads exit...")
 484             # while not BuildTask._ErrorFlag.isSet() and \
 485             while len(BuildTask._RunningQueue) > 0:
 486                 EdkLogger.verbose("Waiting for thread ending...(%d)" % len(BuildTask._RunningQueue))
 487                 EdkLogger.debug(EdkLogger.DEBUG_8, "Threads [%s]" % ", ".join(Th.getName() for Th in threading.enumerate()))
 488                 # avoid tense loop
 489                 time.sleep(0.1)
 490         except BaseException as X:
 491             #
 492             # TRICK: hide the output of threads left runing, so that the user can
 493             #        catch the error message easily
 494             #
 495             EdkLogger.SetLevel(EdkLogger.ERROR)
 496             BuildTask._ErrorFlag.set()
 497             BuildTask._ErrorMessage = "build thread scheduler error\n\t%s" % str(X)
 498
 499         BuildTask._PendingQueue.clear()
 500         BuildTask._ReadyQueue.clear()
 501         BuildTask._RunningQueue.clear()
 502         BuildTask._TaskQueue.clear()
 503         BuildTask._SchedulerStopped.set()
 504
 505     ## Wait for all running method exit
 506     #
 507     @staticmethod
 508     def WaitForComplete():
 509         BuildTask._SchedulerStopped.wait()
 510
 511     ## Check if the scheduler is running or not
 512     #
 513     @staticmethod
 514     def IsOnGoing():
 515         return not BuildTask._SchedulerStopped.isSet()
 516
 517     ## Abort the build
 518     @staticmethod
 519     def Abort():
 520         if BuildTask.IsOnGoing():
 521             BuildTask._ErrorFlag.set()
 522             BuildTask.WaitForComplete()
 523
 524     ## Check if there's error in running thread
 525     #
 526     #   Since the main thread cannot catch exceptions in other thread, we have to
 527     #   use threading.Event to communicate this formation to main thread.
 528     #
 529     @staticmethod
 530     def HasError():
 531         return BuildTask._ErrorFlag.isSet()
 532
 533     ## Get error message in running thread
 534     #
 535     #   Since the main thread cannot catch exceptions in other thread, we have to
 536     #   use a static variable to communicate this message to main thread.
 537     #
 538     @staticmethod
 539     def GetErrorMessage():
 540         return BuildTask._ErrorMessage
 541
 542     ## Factory method to create a BuildTask object
 543     #
 544     #   This method will check if a module is building or has been built. And if
 545     #   true, just return the associated BuildTask object in the _TaskQueue. If
 546     #   not, create and return a new BuildTask object. The new BuildTask object
 547     #   will be appended to the _PendingQueue for scheduling later.
 548     #
 549     #   @param  BuildItem       A BuildUnit object representing a build object
 550     #   @param  Dependency      The dependent build object of BuildItem
 551     #
 552     @staticmethod
 553     def New(BuildItem, Dependency=None):
 554         if BuildItem in BuildTask._TaskQueue:
 555             Bt = BuildTask._TaskQueue[BuildItem]
 556             return Bt
 557
 558         Bt = BuildTask()
 559         Bt._Init(BuildItem, Dependency)
 560         BuildTask._TaskQueue[BuildItem] = Bt
 561
 562         BuildTask._PendingQueueLock.acquire()
 563         BuildTask._PendingQueue[BuildItem] = Bt
 564         BuildTask._PendingQueueLock.release()
 565
 566         return Bt
 567
 568     ## The real constructor of BuildTask
 569     #
 570     #   @param  BuildItem       A BuildUnit object representing a build object
 571     #   @param  Dependency      The dependent build object of BuildItem
 572     #
 573     def _Init(self, BuildItem, Dependency=None):
 574         self.BuildItem = BuildItem
 575
 576         self.DependencyList = []
 577         if Dependency is None:
 578             Dependency = BuildItem.Dependency
 579         else:
 580             Dependency.extend(BuildItem.Dependency)
 581         self.AddDependency(Dependency)
 582         # flag indicating build completes, used to avoid unnecessary re-build
 583         self.CompleteFlag = False
 584
 585     ## Check if all dependent build tasks are completed or not
 586     #
 587     def IsReady(self):
 588         ReadyFlag = True
 589         for Dep in self.DependencyList:
 590             if Dep.CompleteFlag == True:
 591                 continue
 592             ReadyFlag = False
 593             break
 594
 595         return ReadyFlag
 596
 597     ## Add dependent build task
 598     #
 599     #   @param  Dependency      The list of dependent build objects
 600     #
 601     def AddDependency(self, Dependency):
 602         for Dep in Dependency:
 603             if not Dep.BuildObject.IsBinaryModule:
 604                 self.DependencyList.append(BuildTask.New(Dep))    # BuildTask list
 605
 606     ## The thread wrapper of LaunchCommand function
 607     #
 608     # @param  Command               A list or string contains the call of the command
 609     # @param  WorkingDir            The directory in which the program will be running
 610     #
 611     def _CommandThread(self, Command, WorkingDir):
 612         try:
 613             self.BuildItem.BuildObject.BuildTime = LaunchCommand(Command, WorkingDir)
 614             self.CompleteFlag = True
 615         except:
 616             #
 617             # TRICK: hide the output of threads left runing, so that the user can
 618             #        catch the error message easily
 619             #
 620             if not BuildTask._ErrorFlag.isSet():
 621                 GlobalData.gBuildingModule = "%s [%s, %s, %s]" % (str(self.BuildItem.BuildObject),
 622                                                                   self.BuildItem.BuildObject.Arch,
 623                                                                   self.BuildItem.BuildObject.ToolChain,
 624                                                                   self.BuildItem.BuildObject.BuildTarget
 625                                                                  )
 626             EdkLogger.SetLevel(EdkLogger.ERROR)
 627             BuildTask._ErrorFlag.set()
 628             BuildTask._ErrorMessage = "%s broken\n    %s [%s]" % \
 629                                       (threading.currentThread().getName(), Command, WorkingDir)
 630         # indicate there's a thread is available for another build task
 631         BuildTask._RunningQueueLock.acquire()
 632         BuildTask._RunningQueue.pop(self.BuildItem)
 633         BuildTask._RunningQueueLock.release()
 634         BuildTask._Thread.release()
 635
 636     ## Start build task thread
 637     #
 638     def Start(self):
 639         EdkLogger.quiet("Building ... %s" % repr(self.BuildItem))
 640         Command = self.BuildItem.BuildCommand + [self.BuildItem.Target]
 641         self.BuildTread = Thread(target=self._CommandThread, args=(Command, self.BuildItem.WorkingDir))
 642         self.BuildTread.setName("build thread")
 643         self.BuildTread.setDaemon(False)
 644         self.BuildTread.start()
 645
 646 ## The class contains the information related to EFI image
 647 #
 648 class PeImageInfo():
 649     ## Constructor
 650     #
 651     # Constructor will load all required image information.
 652     #
 653     #   @param  BaseName          The full file path of image.
 654     #   @param  Guid              The GUID for image.
 655     #   @param  Arch              Arch of this image.
 656     #   @param  OutputDir         The output directory for image.
 657     #   @param  DebugDir          The debug directory for image.
 658     #   @param  ImageClass        PeImage Information
 659     #
 660     def __init__(self, BaseName, Guid, Arch, OutputDir, DebugDir, ImageClass):
 661         self.BaseName         = BaseName
 662         self.Guid             = Guid
 663         self.Arch             = Arch
 664         self.OutputDir        = OutputDir
 665         self.DebugDir         = DebugDir
 666         self.Image            = ImageClass
 667         self.Image.Size       = (self.Image.Size / 0x1000 + 1) * 0x1000
 668
 669 ## The class implementing the EDK2 build process
 670 #
 671 #   The build process includes:
 672 #       1. Load configuration from target.txt and tools_def.txt in $(WORKSPACE)/Conf
 673 #       2. Parse DSC file of active platform
 674 #       3. Parse FDF file if any
 675 #       4. Establish build database, including parse all other files (module, package)
 676 #       5. Create AutoGen files (C code file, depex file, makefile) if necessary
 677 #       6. Call build command
 678 #
 679 class Build():
 680     ## Constructor
 681     #
 682     # Constructor will load all necessary configurations, parse platform, modules
 683     # and packages and the establish a database for AutoGen.
 684     #
 685     #   @param  Target              The build command target, one of gSupportedTarget
 686     #   @param  WorkspaceDir        The directory of workspace
 687     #   @param  BuildOptions        Build options passed from command line
 688     #
 689     def __init__(self, Target, WorkspaceDir, BuildOptions):
 690         self.WorkspaceDir   = WorkspaceDir
 691         self.Target         = Target
 692         self.PlatformFile   = BuildOptions.PlatformFile
 693         self.ModuleFile     = BuildOptions.ModuleFile
 694         self.ArchList       = BuildOptions.TargetArch
 695         self.ToolChainList  = BuildOptions.ToolChain
 696         self.BuildTargetList= BuildOptions.BuildTarget
 697         self.Fdf            = BuildOptions.FdfFile
 698         self.FdList         = BuildOptions.RomImage
 699         self.FvList         = BuildOptions.FvImage
 700         self.CapList        = BuildOptions.CapName
 701         self.SilentMode     = BuildOptions.SilentMode
 702         self.ThreadNumber   = BuildOptions.ThreadNumber
 703         self.SkipAutoGen    = BuildOptions.SkipAutoGen
 704         self.Reparse        = BuildOptions.Reparse
 705         self.SkuId          = BuildOptions.SkuId
 706         if self.SkuId:
 707             GlobalData.gSKUID_CMD = self.SkuId
 708         self.ConfDirectory = BuildOptions.ConfDirectory
 709         self.SpawnMode      = True
 710         self.BuildReport    = BuildReport(BuildOptions.ReportFile, BuildOptions.ReportType)
 711         self.TargetTxt      = TargetTxtClassObject()
 712         self.ToolDef        = ToolDefClassObject()
 713         self.AutoGenTime    = 0
 714         self.MakeTime       = 0
 715         self.GenFdsTime     = 0
 716         GlobalData.BuildOptionPcd     = BuildOptions.OptionPcd if BuildOptions.OptionPcd else []
 717         #Set global flag for build mode
 718         GlobalData.gIgnoreSource = BuildOptions.IgnoreSources
 719         GlobalData.gUseHashCache = BuildOptions.UseHashCache
 720         GlobalData.gBinCacheDest   = BuildOptions.BinCacheDest
 721         GlobalData.gBinCacheSource = BuildOptions.BinCacheSource
 722         GlobalData.gEnableGenfdsMultiThread = BuildOptions.GenfdsMultiThread
 723
 724         if GlobalData.gBinCacheDest and not GlobalData.gUseHashCache:
 725             EdkLogger.error("build", OPTION_NOT_SUPPORTED, ExtraData="--binary-destination must be used together with --hash.")
 726
 727         if GlobalData.gBinCacheSource and not GlobalData.gUseHashCache:
 728             EdkLogger.error("build", OPTION_NOT_SUPPORTED, ExtraData="--binary-source must be used together with --hash.")
 729
 730         if GlobalData.gBinCacheDest and GlobalData.gBinCacheSource:
 731             EdkLogger.error("build", OPTION_NOT_SUPPORTED, ExtraData="--binary-destination can not be used together with --binary-source.")
 732
 733         if GlobalData.gBinCacheSource:
 734             BinCacheSource = os.path.normpath(GlobalData.gBinCacheSource)
 735             if not os.path.isabs(BinCacheSource):
 736                 BinCacheSource = mws.join(self.WorkspaceDir, BinCacheSource)
 737             GlobalData.gBinCacheSource = BinCacheSource
 738         else:
 739             if GlobalData.gBinCacheSource is not None:
 740                 EdkLogger.error("build", OPTION_VALUE_INVALID, ExtraData="Invalid value of option --binary-source.")
 741
 742         if GlobalData.gBinCacheDest:
 743             BinCacheDest = os.path.normpath(GlobalData.gBinCacheDest)
 744             if not os.path.isabs(BinCacheDest):
 745                 BinCacheDest = mws.join(self.WorkspaceDir, BinCacheDest)
 746             GlobalData.gBinCacheDest = BinCacheDest
 747         else:
 748             if GlobalData.gBinCacheDest is not None:
 749                 EdkLogger.error("build", OPTION_VALUE_INVALID, ExtraData="Invalid value of option --binary-destination.")
 750
 751         if self.ConfDirectory:
 752             # Get alternate Conf location, if it is absolute, then just use the absolute directory name
 753             ConfDirectoryPath = os.path.normpath(self.ConfDirectory)
 754
 755             if not os.path.isabs(ConfDirectoryPath):
 756                 # Since alternate directory name is not absolute, the alternate directory is located within the WORKSPACE
 757                 # This also handles someone specifying the Conf directory in the workspace. Using --conf=Conf
 758                 ConfDirectoryPath = mws.join(self.WorkspaceDir, ConfDirectoryPath)
 759         else:
 760             if "CONF_PATH" in os.environ:
 761                 ConfDirectoryPath = os.path.normcase(os.path.normpath(os.environ["CONF_PATH"]))
 762             else:
 763                 # Get standard WORKSPACE/Conf use the absolute path to the WORKSPACE/Conf
 764                 ConfDirectoryPath = mws.join(self.WorkspaceDir, 'Conf')
 765         GlobalData.gConfDirectory = ConfDirectoryPath
 766         GlobalData.gDatabasePath = os.path.normpath(os.path.join(ConfDirectoryPath, GlobalData.gDatabasePath))
 767
 768         self.Db = WorkspaceDatabase()
 769         self.BuildDatabase = self.Db.BuildObject
 770         self.Platform = None
 771         self.ToolChainFamily = None
 772         self.LoadFixAddress = 0
 773         self.UniFlag        = BuildOptions.Flag
 774         self.BuildModules = []
 775         self.HashSkipModules = []
 776         self.Db_Flag = False
 777         self.LaunchPrebuildFlag = False
 778         self.PlatformBuildPath = os.path.join(GlobalData.gConfDirectory, '.cache', '.PlatformBuild')
 779         if BuildOptions.CommandLength:
 780             GlobalData.gCommandMaxLength = BuildOptions.CommandLength
 781
 782         # print dot character during doing some time-consuming work
 783         self.Progress = Utils.Progressor()
 784         # print current build environment and configuration
 785         EdkLogger.quiet("%-16s = %s" % ("WORKSPACE", os.environ["WORKSPACE"]))
 786         if "PACKAGES_PATH" in os.environ:
 787             # WORKSPACE env has been converted before. Print the same path style with WORKSPACE env.
 788             EdkLogger.quiet("%-16s = %s" % ("PACKAGES_PATH", os.path.normcase(os.path.normpath(os.environ["PACKAGES_PATH"]))))
 789         EdkLogger.quiet("%-16s = %s" % ("EDK_TOOLS_PATH", os.environ["EDK_TOOLS_PATH"]))
 790         if "EDK_TOOLS_BIN" in os.environ:
 791             # Print the same path style with WORKSPACE env.
 792             EdkLogger.quiet("%-16s = %s" % ("EDK_TOOLS_BIN", os.path.normcase(os.path.normpath(os.environ["EDK_TOOLS_BIN"]))))
 793         EdkLogger.quiet("%-16s = %s" % ("CONF_PATH", GlobalData.gConfDirectory))
 794         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 = [l.split("=", 1) for l in envs ]
1105                 envs = [[I.strip() for I in item] for item in envs if len(item) == 2]
1106                 os.environ.update(dict(envs))
1107             EdkLogger.info("\n- Prebuild Done -\n")
1108
1109     def LaunchPostbuild(self):
1110         if self.Postbuild:
1111             EdkLogger.info("\n- Postbuild Start -\n")
1112             if sys.platform == "win32":
1113                 Process = Popen(self.Postbuild, stdout=PIPE, stderr=PIPE, shell=True)
1114             else:
1115                 Process = Popen(self.Postbuild, stdout=PIPE, stderr=PIPE, shell=True)
1116             # launch two threads to read the STDOUT and STDERR
1117             EndOfProcedure = Event()
1118             EndOfProcedure.clear()
1119             if Process.stdout:
1120                 StdOutThread = Thread(target=ReadMessage, args=(Process.stdout, EdkLogger.info, EndOfProcedure))
1121                 StdOutThread.setName("STDOUT-Redirector")
1122                 StdOutThread.setDaemon(False)
1123                 StdOutThread.start()
1124
1125             if Process.stderr:
1126                 StdErrThread = Thread(target=ReadMessage, args=(Process.stderr, EdkLogger.quiet, EndOfProcedure))
1127                 StdErrThread.setName("STDERR-Redirector")
1128                 StdErrThread.setDaemon(False)
1129                 StdErrThread.start()
1130             # waiting for program exit
1131             Process.wait()
1132
1133             if Process.stdout:
1134                 StdOutThread.join()
1135             if Process.stderr:
1136                 StdErrThread.join()
1137             if Process.returncode != 0 :
1138                 EdkLogger.error("Postbuild", POSTBUILD_ERROR, 'Postbuild process is not success!')
1139             EdkLogger.info("\n- Postbuild Done -\n")
1140     ## Build a module or platform
1141     #
1142     # Create autogen code and makefile for a module or platform, and the launch
1143     # "make" command to build it
1144     #
1145     #   @param  Target                      The target of build command
1146     #   @param  Platform                    The platform file
1147     #   @param  Module                      The module file
1148     #   @param  BuildTarget                 The name of build target, one of "DEBUG", "RELEASE"
1149     #   @param  ToolChain                   The name of toolchain to build
1150     #   @param  Arch                        The arch of the module/platform
1151     #   @param  CreateDepModuleCodeFile     Flag used to indicate creating code
1152     #                                       for dependent modules/Libraries
1153     #   @param  CreateDepModuleMakeFile     Flag used to indicate creating makefile
1154     #                                       for dependent modules/Libraries
1155     #
1156     def _BuildPa(self, Target, AutoGenObject, CreateDepsCodeFile=True, CreateDepsMakeFile=True, BuildModule=False, FfsCommand={}):
1157         if AutoGenObject is None:
1158             return False
1159
1160         # skip file generation for cleanxxx targets, run and fds target
1161         if Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1162             # for target which must generate AutoGen code and makefile
1163             if not self.SkipAutoGen or Target == 'genc':
1164                 self.Progress.Start("Generating code")
1165                 AutoGenObject.CreateCodeFile(CreateDepsCodeFile)
1166                 self.Progress.Stop("done!")
1167             if Target == "genc":
1168                 return True
1169
1170             if not self.SkipAutoGen or Target == 'genmake':
1171                 self.Progress.Start("Generating makefile")
1172                 AutoGenObject.CreateMakeFile(CreateDepsMakeFile, FfsCommand)
1173                 self.Progress.Stop("done!")
1174             if Target == "genmake":
1175                 return True
1176         else:
1177             # always recreate top/platform makefile when clean, just in case of inconsistency
1178             AutoGenObject.CreateCodeFile(False)
1179             AutoGenObject.CreateMakeFile(False)
1180
1181         if EdkLogger.GetLevel() == EdkLogger.QUIET:
1182             EdkLogger.quiet("Building ... %s" % repr(AutoGenObject))
1183
1184         BuildCommand = AutoGenObject.BuildCommand
1185         if BuildCommand is None or len(BuildCommand) == 0:
1186             EdkLogger.error("build", OPTION_MISSING,
1187                             "No build command found for this module. "
1188                             "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %
1189                                 (AutoGenObject.BuildTarget, AutoGenObject.ToolChain, AutoGenObject.Arch),
1190                             ExtraData=str(AutoGenObject))
1191
1192         makefile = GenMake.BuildFile(AutoGenObject)._FILE_NAME_[GenMake.gMakeType]
1193
1194         # run
1195         if Target == 'run':
1196             RunDir = os.path.normpath(os.path.join(AutoGenObject.BuildDir, GlobalData.gGlobalDefines['ARCH']))
1197             Command = '.\SecMain'
1198             os.chdir(RunDir)
1199             LaunchCommand(Command, RunDir)
1200             return True
1201
1202         # build modules
1203         if BuildModule:
1204             BuildCommand = BuildCommand + [Target]
1205             LaunchCommand(BuildCommand, AutoGenObject.MakeFileDir)
1206             self.CreateAsBuiltInf()
1207             return True
1208
1209         # build library
1210         if Target == 'libraries':
1211             for Lib in AutoGenObject.LibraryBuildDirectoryList:
1212                 NewBuildCommand = BuildCommand + ['-f', os.path.normpath(os.path.join(Lib, makefile)), 'pbuild']
1213                 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)
1214             return True
1215
1216         # build module
1217         if Target == 'modules':
1218             for Lib in AutoGenObject.LibraryBuildDirectoryList:
1219                 NewBuildCommand = BuildCommand + ['-f', os.path.normpath(os.path.join(Lib, makefile)), 'pbuild']
1220                 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)
1221             for Mod in AutoGenObject.ModuleBuildDirectoryList:
1222                 NewBuildCommand = BuildCommand + ['-f', os.path.normpath(os.path.join(Mod, makefile)), 'pbuild']
1223                 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)
1224             self.CreateAsBuiltInf()
1225             return True
1226
1227         # cleanlib
1228         if Target == 'cleanlib':
1229             for Lib in AutoGenObject.LibraryBuildDirectoryList:
1230                 LibMakefile = os.path.normpath(os.path.join(Lib, makefile))
1231                 if os.path.exists(LibMakefile):
1232                     NewBuildCommand = BuildCommand + ['-f', LibMakefile, 'cleanall']
1233                     LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)
1234             return True
1235
1236         # clean
1237         if Target == 'clean':
1238             for Mod in AutoGenObject.ModuleBuildDirectoryList:
1239                 ModMakefile = os.path.normpath(os.path.join(Mod, makefile))
1240                 if os.path.exists(ModMakefile):
1241                     NewBuildCommand = BuildCommand + ['-f', ModMakefile, 'cleanall']
1242                     LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)
1243             for Lib in AutoGenObject.LibraryBuildDirectoryList:
1244                 LibMakefile = os.path.normpath(os.path.join(Lib, makefile))
1245                 if os.path.exists(LibMakefile):
1246                     NewBuildCommand = BuildCommand + ['-f', LibMakefile, 'cleanall']
1247                     LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)
1248             return True
1249
1250         # cleanall
1251         if Target == 'cleanall':
1252             try:
1253                 #os.rmdir(AutoGenObject.BuildDir)
1254                 RemoveDirectory(AutoGenObject.BuildDir, True)
1255             except WindowsError as X:
1256                 EdkLogger.error("build", FILE_DELETE_FAILURE, ExtraData=str(X))
1257         return True
1258
1259     ## Build a module or platform
1260     #
1261     # Create autogen code and makefile for a module or platform, and the launch
1262     # "make" command to build it
1263     #
1264     #   @param  Target                      The target of build command
1265     #   @param  Platform                    The platform file
1266     #   @param  Module                      The module file
1267     #   @param  BuildTarget                 The name of build target, one of "DEBUG", "RELEASE"
1268     #   @param  ToolChain                   The name of toolchain to build
1269     #   @param  Arch                        The arch of the module/platform
1270     #   @param  CreateDepModuleCodeFile     Flag used to indicate creating code
1271     #                                       for dependent modules/Libraries
1272     #   @param  CreateDepModuleMakeFile     Flag used to indicate creating makefile
1273     #                                       for dependent modules/Libraries
1274     #
1275     def _Build(self, Target, AutoGenObject, CreateDepsCodeFile=True, CreateDepsMakeFile=True, BuildModule=False):
1276         if AutoGenObject is None:
1277             return False
1278
1279         # skip file generation for cleanxxx targets, run and fds target
1280         if Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1281             # for target which must generate AutoGen code and makefile
1282             if not self.SkipAutoGen or Target == 'genc':
1283                 self.Progress.Start("Generating code")
1284                 AutoGenObject.CreateCodeFile(CreateDepsCodeFile)
1285                 self.Progress.Stop("done!")
1286             if Target == "genc":
1287                 return True
1288
1289             if not self.SkipAutoGen or Target == 'genmake':
1290                 self.Progress.Start("Generating makefile")
1291                 AutoGenObject.CreateMakeFile(CreateDepsMakeFile)
1292                 #AutoGenObject.CreateAsBuiltInf()
1293                 self.Progress.Stop("done!")
1294             if Target == "genmake":
1295                 return True
1296         else:
1297             # always recreate top/platform makefile when clean, just in case of inconsistency
1298             AutoGenObject.CreateCodeFile(False)
1299             AutoGenObject.CreateMakeFile(False)
1300
1301         if EdkLogger.GetLevel() == EdkLogger.QUIET:
1302             EdkLogger.quiet("Building ... %s" % repr(AutoGenObject))
1303
1304         BuildCommand = AutoGenObject.BuildCommand
1305         if BuildCommand is None or len(BuildCommand) == 0:
1306             EdkLogger.error("build", OPTION_MISSING,
1307                             "No build command found for this module. "
1308                             "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %
1309                                 (AutoGenObject.BuildTarget, AutoGenObject.ToolChain, AutoGenObject.Arch),
1310                             ExtraData=str(AutoGenObject))
1311
1312         # build modules
1313         if BuildModule:
1314             if Target != 'fds':
1315                 BuildCommand = BuildCommand + [Target]
1316             AutoGenObject.BuildTime = LaunchCommand(BuildCommand, AutoGenObject.MakeFileDir)
1317             self.CreateAsBuiltInf()
1318             return True
1319
1320         # genfds
1321         if Target == 'fds':
1322             if GenFdsApi(AutoGenObject.GenFdsCommandDict, self.Db):
1323                 EdkLogger.error("build", COMMAND_FAILURE)
1324             return True
1325
1326         # run
1327         if Target == 'run':
1328             RunDir = os.path.normpath(os.path.join(AutoGenObject.BuildDir, GlobalData.gGlobalDefines['ARCH']))
1329             Command = '.\SecMain'
1330             os.chdir(RunDir)
1331             LaunchCommand(Command, RunDir)
1332             return True
1333
1334         # build library
1335         if Target == 'libraries':
1336             pass
1337
1338         # not build modules
1339
1340
1341         # cleanall
1342         if Target == 'cleanall':
1343             try:
1344                 #os.rmdir(AutoGenObject.BuildDir)
1345                 RemoveDirectory(AutoGenObject.BuildDir, True)
1346             except WindowsError as X:
1347                 EdkLogger.error("build", FILE_DELETE_FAILURE, ExtraData=str(X))
1348         return True
1349
1350     ## Rebase module image and Get function address for the input module list.
1351     #
1352     def _RebaseModule (self, MapBuffer, BaseAddress, ModuleList, AddrIsOffset = True, ModeIsSmm = False):
1353         if ModeIsSmm:
1354             AddrIsOffset = False
1355         for InfFile in ModuleList:
1356             sys.stdout.write (".")
1357             sys.stdout.flush()
1358             ModuleInfo = ModuleList[InfFile]
1359             ModuleName = ModuleInfo.BaseName
1360             ModuleOutputImage = ModuleInfo.Image.FileName
1361             ModuleDebugImage  = os.path.join(ModuleInfo.DebugDir, ModuleInfo.BaseName + '.efi')
1362             ## for SMM module in SMRAM, the SMRAM will be allocated from base to top.
1363             if not ModeIsSmm:
1364                 BaseAddress = BaseAddress - ModuleInfo.Image.Size
1365                 #
1366                 # Update Image to new BaseAddress by GenFw tool
1367                 #
1368                 LaunchCommand(["GenFw", "--rebase", str(BaseAddress), "-r", ModuleOutputImage], ModuleInfo.OutputDir)
1369                 LaunchCommand(["GenFw", "--rebase", str(BaseAddress), "-r", ModuleDebugImage], ModuleInfo.DebugDir)
1370             else:
1371                 #
1372                 # Set new address to the section header only for SMM driver.
1373                 #
1374                 LaunchCommand(["GenFw", "--address", str(BaseAddress), "-r", ModuleOutputImage], ModuleInfo.OutputDir)
1375                 LaunchCommand(["GenFw", "--address", str(BaseAddress), "-r", ModuleDebugImage], ModuleInfo.DebugDir)
1376             #
1377             # Collect funtion address from Map file
1378             #
1379             ImageMapTable = ModuleOutputImage.replace('.efi', '.map')
1380             FunctionList = []
1381             if os.path.exists(ImageMapTable):
1382                 OrigImageBaseAddress = 0
1383                 ImageMap = open(ImageMapTable, 'r')
1384                 for LinStr in ImageMap:
1385                     if len (LinStr.strip()) == 0:
1386                         continue
1387                     #
1388                     # Get the preferred address set on link time.
1389                     #
1390                     if LinStr.find ('Preferred load address is') != -1:
1391                         StrList = LinStr.split()
1392                         OrigImageBaseAddress = int (StrList[len(StrList) - 1], 16)
1393
1394                     StrList = LinStr.split()
1395                     if len (StrList) > 4:
1396                         if StrList[3] == 'f' or StrList[3] == 'F':
1397                             Name = StrList[1]
1398                             RelativeAddress = int (StrList[2], 16) - OrigImageBaseAddress
1399                             FunctionList.append ((Name, RelativeAddress))
1400
1401                 ImageMap.close()
1402             #
1403             # Add general information.
1404             #
1405             if ModeIsSmm:
1406                 MapBuffer.write('\n\n%s (Fixed SMRAM Offset,   BaseAddress=0x%010X,  EntryPoint=0x%010X)\n' % (ModuleName, BaseAddress, BaseAddress + ModuleInfo.Image.EntryPoint))
1407             elif AddrIsOffset:
1408                 MapBuffer.write('\n\n%s (Fixed Memory Offset,  BaseAddress=-0x%010X, EntryPoint=-0x%010X)\n' % (ModuleName, 0 - BaseAddress, 0 - (BaseAddress + ModuleInfo.Image.EntryPoint)))
1409             else:
1410                 MapBuffer.write('\n\n%s (Fixed Memory Address, BaseAddress=0x%010X,  EntryPoint=0x%010X)\n' % (ModuleName, BaseAddress, BaseAddress + ModuleInfo.Image.EntryPoint))
1411             #
1412             # Add guid and general seciton section.
1413             #
1414             TextSectionAddress = 0
1415             DataSectionAddress = 0
1416             for SectionHeader in ModuleInfo.Image.SectionHeaderList:
1417                 if SectionHeader[0] == '.text':
1418                     TextSectionAddress = SectionHeader[1]
1419                 elif SectionHeader[0] in ['.data', '.sdata']:
1420                     DataSectionAddress = SectionHeader[1]
1421             if AddrIsOffset:
1422                 MapBuffer.write('(GUID=%s, .textbaseaddress=-0x%010X, .databaseaddress=-0x%010X)\n' % (ModuleInfo.Guid, 0 - (BaseAddress + TextSectionAddress), 0 - (BaseAddress + DataSectionAddress)))
1423             else:
1424                 MapBuffer.write('(GUID=%s, .textbaseaddress=0x%010X, .databaseaddress=0x%010X)\n' % (ModuleInfo.Guid, BaseAddress + TextSectionAddress, BaseAddress + DataSectionAddress))
1425             #
1426             # Add debug image full path.
1427             #
1428             MapBuffer.write('(IMAGE=%s)\n\n' % (ModuleDebugImage))
1429             #
1430             # Add funtion address
1431             #
1432             for Function in FunctionList:
1433                 if AddrIsOffset:
1434                     MapBuffer.write('  -0x%010X    %s\n' % (0 - (BaseAddress + Function[1]), Function[0]))
1435                 else:
1436                     MapBuffer.write('  0x%010X    %s\n' % (BaseAddress + Function[1], Function[0]))
1437             ImageMap.close()
1438
1439             #
1440             # for SMM module in SMRAM, the SMRAM will be allocated from base to top.
1441             #
1442             if ModeIsSmm:
1443                 BaseAddress = BaseAddress + ModuleInfo.Image.Size
1444
1445     ## Collect MAP information of all FVs
1446     #
1447     def _CollectFvMapBuffer (self, MapBuffer, Wa, ModuleList):
1448         if self.Fdf:
1449             # First get the XIP base address for FV map file.
1450             GuidPattern = re.compile("[-a-fA-F0-9]+")
1451             GuidName = re.compile("\(GUID=[-a-fA-F0-9]+")
1452             for FvName in Wa.FdfProfile.FvDict:
1453                 FvMapBuffer = os.path.join(Wa.FvDir, FvName + '.Fv.map')
1454                 if not os.path.exists(FvMapBuffer):
1455                     continue
1456                 FvMap = open(FvMapBuffer, 'r')
1457                 #skip FV size information
1458                 FvMap.readline()
1459                 FvMap.readline()
1460                 FvMap.readline()
1461                 FvMap.readline()
1462                 for Line in FvMap:
1463                     MatchGuid = GuidPattern.match(Line)
1464                     if MatchGuid is not None:
1465                         #
1466                         # Replace GUID with module name
1467                         #
1468                         GuidString = MatchGuid.group()
1469                         if GuidString.upper() in ModuleList:
1470                             Line = Line.replace(GuidString, ModuleList[GuidString.upper()].Name)
1471                     MapBuffer.write(Line)
1472                     #
1473                     # Add the debug image full path.
1474                     #
1475                     MatchGuid = GuidName.match(Line)
1476                     if MatchGuid is not None:
1477                         GuidString = MatchGuid.group().split("=")[1]
1478                         if GuidString.upper() in ModuleList:
1479                             MapBuffer.write('(IMAGE=%s)\n' % (os.path.join(ModuleList[GuidString.upper()].DebugDir, ModuleList[GuidString.upper()].Name + '.efi')))
1480
1481                 FvMap.close()
1482
1483     ## Collect MAP information of all modules
1484     #
1485     def _CollectModuleMapBuffer (self, MapBuffer, ModuleList):
1486         sys.stdout.write ("Generate Load Module At Fix Address Map")
1487         sys.stdout.flush()
1488         PatchEfiImageList = []
1489         PeiModuleList  = {}
1490         BtModuleList   = {}
1491         RtModuleList   = {}
1492         SmmModuleList  = {}
1493         PeiSize = 0
1494         BtSize  = 0
1495         RtSize  = 0
1496         # reserve 4K size in SMRAM to make SMM module address not from 0.
1497         SmmSize = 0x1000
1498         for ModuleGuid in ModuleList:
1499             Module = ModuleList[ModuleGuid]
1500             GlobalData.gProcessingFile = "%s [%s, %s, %s]" % (Module.MetaFile, Module.Arch, Module.ToolChain, Module.BuildTarget)
1501
1502             OutputImageFile = ''
1503             for ResultFile in Module.CodaTargetList:
1504                 if str(ResultFile.Target).endswith('.efi'):
1505                     #
1506                     # module list for PEI, DXE, RUNTIME and SMM
1507                     #
1508                     OutputImageFile = os.path.join(Module.OutputDir, Module.Name + '.efi')
1509                     ImageClass = PeImageClass (OutputImageFile)
1510                     if not ImageClass.IsValid:
1511                         EdkLogger.error("build", FILE_PARSE_FAILURE, ExtraData=ImageClass.ErrorInfo)
1512                     ImageInfo = PeImageInfo(Module.Name, Module.Guid, Module.Arch, Module.OutputDir, Module.DebugDir, ImageClass)
1513                     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]:
1514                         PeiModuleList[Module.MetaFile] = ImageInfo
1515                         PeiSize += ImageInfo.Image.Size
1516                     elif Module.ModuleType in [EDK_COMPONENT_TYPE_BS_DRIVER, SUP_MODULE_DXE_DRIVER, SUP_MODULE_UEFI_DRIVER]:
1517                         BtModuleList[Module.MetaFile] = ImageInfo
1518                         BtSize += ImageInfo.Image.Size
1519                     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]:
1520                         RtModuleList[Module.MetaFile] = ImageInfo
1521                         RtSize += ImageInfo.Image.Size
1522                     elif Module.ModuleType in [SUP_MODULE_SMM_CORE, SUP_MODULE_DXE_SMM_DRIVER, SUP_MODULE_MM_STANDALONE, SUP_MODULE_MM_CORE_STANDALONE]:
1523                         SmmModuleList[Module.MetaFile] = ImageInfo
1524                         SmmSize += ImageInfo.Image.Size
1525                         if Module.ModuleType == SUP_MODULE_DXE_SMM_DRIVER:
1526                             PiSpecVersion = Module.Module.Specification.get('PI_SPECIFICATION_VERSION', '0x00000000')
1527                             # for PI specification < PI1.1, DXE_SMM_DRIVER also runs as BOOT time driver.
1528                             if int(PiSpecVersion, 16) < 0x0001000A:
1529                                 BtModuleList[Module.MetaFile] = ImageInfo
1530                                 BtSize += ImageInfo.Image.Size
1531                     break
1532             #
1533             # EFI image is final target.
1534             # Check EFI image contains patchable FixAddress related PCDs.
1535             #
1536             if OutputImageFile != '':
1537                 ModuleIsPatch = False
1538                 for Pcd in Module.ModulePcdList:
1539                     if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE and Pcd.TokenCName in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SET:
1540                         ModuleIsPatch = True
1541                         break
1542                 if not ModuleIsPatch:
1543                     for Pcd in Module.LibraryPcdList:
1544                         if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE and Pcd.TokenCName in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SET:
1545                             ModuleIsPatch = True
1546                             break
1547
1548                 if not ModuleIsPatch:
1549                     continue
1550                 #
1551                 # Module includes the patchable load fix address PCDs.
1552                 # It will be fixed up later.
1553                 #
1554                 PatchEfiImageList.append (OutputImageFile)
1555
1556         #
1557         # Get Top Memory address
1558         #
1559         ReservedRuntimeMemorySize = 0
1560         TopMemoryAddress = 0
1561         if self.LoadFixAddress == 0xFFFFFFFFFFFFFFFF:
1562             TopMemoryAddress = 0
1563         else:
1564             TopMemoryAddress = self.LoadFixAddress
1565             if TopMemoryAddress < RtSize + BtSize + PeiSize:
1566                 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS is too low to load driver")
1567
1568         #
1569         # Patch FixAddress related PCDs into EFI image
1570         #
1571         for EfiImage in PatchEfiImageList:
1572             EfiImageMap = EfiImage.replace('.efi', '.map')
1573             if not os.path.exists(EfiImageMap):
1574                 continue
1575             #
1576             # Get PCD offset in EFI image by GenPatchPcdTable function
1577             #
1578             PcdTable = parsePcdInfoFromMapFile(EfiImageMap, EfiImage)
1579             #
1580             # Patch real PCD value by PatchPcdValue tool
1581             #
1582             for PcdInfo in PcdTable:
1583                 ReturnValue = 0
1584                 if PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE:
1585                     ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE_DATA_TYPE, str (PeiSize / 0x1000))
1586                 elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE:
1587                     ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE_DATA_TYPE, str (BtSize / 0x1000))
1588                 elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE:
1589                     ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE_DATA_TYPE, str (RtSize / 0x1000))
1590                 elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE and len (SmmModuleList) > 0:
1591                     ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE_DATA_TYPE, str (SmmSize / 0x1000))
1592                 if ReturnValue != 0:
1593                     EdkLogger.error("build", PARAMETER_INVALID, "Patch PCD value failed", ExtraData=ErrorInfo)
1594
1595         MapBuffer.write('PEI_CODE_PAGE_NUMBER      = 0x%x\n' % (PeiSize / 0x1000))
1596         MapBuffer.write('BOOT_CODE_PAGE_NUMBER     = 0x%x\n' % (BtSize / 0x1000))
1597         MapBuffer.write('RUNTIME_CODE_PAGE_NUMBER  = 0x%x\n' % (RtSize / 0x1000))
1598         if len (SmmModuleList) > 0:
1599             MapBuffer.write('SMM_CODE_PAGE_NUMBER      = 0x%x\n' % (SmmSize / 0x1000))
1600
1601         PeiBaseAddr = TopMemoryAddress - RtSize - BtSize
1602         BtBaseAddr  = TopMemoryAddress - RtSize
1603         RtBaseAddr  = TopMemoryAddress - ReservedRuntimeMemorySize
1604
1605         self._RebaseModule (MapBuffer, PeiBaseAddr, PeiModuleList, TopMemoryAddress == 0)
1606         self._RebaseModule (MapBuffer, BtBaseAddr, BtModuleList, TopMemoryAddress == 0)
1607         self._RebaseModule (MapBuffer, RtBaseAddr, RtModuleList, TopMemoryAddress == 0)
1608         self._RebaseModule (MapBuffer, 0x1000, SmmModuleList, AddrIsOffset=False, ModeIsSmm=True)
1609         MapBuffer.write('\n\n')
1610         sys.stdout.write ("\n")
1611         sys.stdout.flush()
1612
1613     ## Save platform Map file
1614     #
1615     def _SaveMapFile (self, MapBuffer, Wa):
1616         #
1617         # Map file path is got.
1618         #
1619         MapFilePath = os.path.join(Wa.BuildDir, Wa.Name + '.map')
1620         #
1621         # Save address map into MAP file.
1622         #
1623         SaveFileOnChange(MapFilePath, MapBuffer.getvalue(), False)
1624         MapBuffer.close()
1625         if self.LoadFixAddress != 0:
1626             sys.stdout.write ("\nLoad Module At Fix Address Map file can be found at %s\n" % (MapFilePath))
1627         sys.stdout.flush()
1628
1629     ## Build active platform for different build targets and different tool chains
1630     #
1631     def _BuildPlatform(self):
1632         SaveFileOnChange(self.PlatformBuildPath, '# DO NOT EDIT \n# FILE auto-generated\n', False)
1633         for BuildTarget in self.BuildTargetList:
1634             GlobalData.gGlobalDefines['TARGET'] = BuildTarget
1635             index = 0
1636             for ToolChain in self.ToolChainList:
1637                 GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain
1638                 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain
1639                 GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[index]
1640                 index += 1
1641                 Wa = WorkspaceAutoGen(
1642                         self.WorkspaceDir,
1643                         self.PlatformFile,
1644                         BuildTarget,
1645                         ToolChain,
1646                         self.ArchList,
1647                         self.BuildDatabase,
1648                         self.TargetTxt,
1649                         self.ToolDef,
1650                         self.Fdf,
1651                         self.FdList,
1652                         self.FvList,
1653                         self.CapList,
1654                         self.SkuId,
1655                         self.UniFlag,
1656                         self.Progress
1657                         )
1658                 self.Fdf = Wa.FdfFile
1659                 self.LoadFixAddress = Wa.Platform.LoadFixAddress
1660                 self.BuildReport.AddPlatformReport(Wa)
1661                 self.Progress.Stop("done!")
1662
1663                 # Add ffs build to makefile
1664                 CmdListDict = {}
1665                 if GlobalData.gEnableGenfdsMultiThread and self.Fdf:
1666                     CmdListDict = self._GenFfsCmd()
1667
1668                 for Arch in Wa.ArchList:
1669                     GlobalData.gGlobalDefines['ARCH'] = Arch
1670                     Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)
1671                     for Module in Pa.Platform.Modules:
1672                         # Get ModuleAutoGen object to generate C code file and makefile
1673                         Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)
1674                         if Ma is None:
1675                             continue
1676                         self.BuildModules.append(Ma)
1677                     self._BuildPa(self.Target, Pa, FfsCommand=CmdListDict)
1678
1679                 # Create MAP file when Load Fix Address is enabled.
1680                 if self.Target in ["", "all", "fds"]:
1681                     for Arch in Wa.ArchList:
1682                         GlobalData.gGlobalDefines['ARCH'] = Arch
1683                         #
1684                         # Check whether the set fix address is above 4G for 32bit image.
1685                         #
1686                         if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:
1687                             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")
1688                     #
1689                     # Get Module List
1690                     #
1691                     ModuleList = {}
1692                     for Pa in Wa.AutoGenObjectList:
1693                         for Ma in Pa.ModuleAutoGenList:
1694                             if Ma is None:
1695                                 continue
1696                             if not Ma.IsLibrary:
1697                                 ModuleList[Ma.Guid.upper()] = Ma
1698
1699                     MapBuffer = BytesIO('')
1700                     if self.LoadFixAddress != 0:
1701                         #
1702                         # Rebase module to the preferred memory address before GenFds
1703                         #
1704                         self._CollectModuleMapBuffer(MapBuffer, ModuleList)
1705                     if self.Fdf:
1706                         #
1707                         # create FDS again for the updated EFI image
1708                         #
1709                         self._Build("fds", Wa)
1710                         #
1711                         # Create MAP file for all platform FVs after GenFds.
1712                         #
1713                         self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)
1714                     #
1715                     # Save MAP buffer into MAP file.
1716                     #
1717                     self._SaveMapFile (MapBuffer, Wa)
1718
1719     ## Build active module for different build targets, different tool chains and different archs
1720     #
1721     def _BuildModule(self):
1722         for BuildTarget in self.BuildTargetList:
1723             GlobalData.gGlobalDefines['TARGET'] = BuildTarget
1724             index = 0
1725             for ToolChain in self.ToolChainList:
1726                 WorkspaceAutoGenTime = time.time()
1727                 GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain
1728                 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain
1729                 GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[index]
1730                 index += 1
1731                 #
1732                 # module build needs platform build information, so get platform
1733                 # AutoGen first
1734                 #
1735                 Wa = WorkspaceAutoGen(
1736                         self.WorkspaceDir,
1737                         self.PlatformFile,
1738                         BuildTarget,
1739                         ToolChain,
1740                         self.ArchList,
1741                         self.BuildDatabase,
1742                         self.TargetTxt,
1743                         self.ToolDef,
1744                         self.Fdf,
1745                         self.FdList,
1746                         self.FvList,
1747                         self.CapList,
1748                         self.SkuId,
1749                         self.UniFlag,
1750                         self.Progress,
1751                         self.ModuleFile
1752                         )
1753                 self.Fdf = Wa.FdfFile
1754                 self.LoadFixAddress = Wa.Platform.LoadFixAddress
1755                 Wa.CreateMakeFile(False)
1756                 # Add ffs build to makefile
1757                 CmdListDict = None
1758                 if GlobalData.gEnableGenfdsMultiThread and self.Fdf:
1759                     CmdListDict = self._GenFfsCmd()
1760                 self.Progress.Stop("done!")
1761                 MaList = []
1762                 ExitFlag = threading.Event()
1763                 ExitFlag.clear()
1764                 self.AutoGenTime += int(round((time.time() - WorkspaceAutoGenTime)))
1765                 for Arch in Wa.ArchList:
1766                     AutoGenStart = time.time()
1767                     GlobalData.gGlobalDefines['ARCH'] = Arch
1768                     Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)
1769                     for Module in Pa.Platform.Modules:
1770                         if self.ModuleFile.Dir == Module.Dir and self.ModuleFile.Name == Module.Name:
1771                             Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)
1772                             if Ma is None: continue
1773                             MaList.append(Ma)
1774                             if Ma.CanSkipbyHash():
1775                                 self.HashSkipModules.append(Ma)
1776                                 continue
1777                             # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'
1778                             if self.Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1779                                 # for target which must generate AutoGen code and makefile
1780                                 if not self.SkipAutoGen or self.Target == 'genc':
1781                                     self.Progress.Start("Generating code")
1782                                     Ma.CreateCodeFile(True)
1783                                     self.Progress.Stop("done!")
1784                                 if self.Target == "genc":
1785                                     return True
1786                                 if not self.SkipAutoGen or self.Target == 'genmake':
1787                                     self.Progress.Start("Generating makefile")
1788                                     if CmdListDict and self.Fdf and (Module.File, Arch) in CmdListDict:
1789                                         Ma.CreateMakeFile(True, CmdListDict[Module.File, Arch])
1790                                         del CmdListDict[Module.File, Arch]
1791                                     else:
1792                                         Ma.CreateMakeFile(True)
1793                                     self.Progress.Stop("done!")
1794                                 if self.Target == "genmake":
1795                                     return True
1796                             self.BuildModules.append(Ma)
1797                     self.AutoGenTime += int(round((time.time() - AutoGenStart)))
1798                     MakeStart = time.time()
1799                     for Ma in self.BuildModules:
1800                         if not Ma.IsBinaryModule:
1801                             Bt = BuildTask.New(ModuleMakeUnit(Ma, self.Target))
1802                         # Break build if any build thread has error
1803                         if BuildTask.HasError():
1804                             # we need a full version of makefile for platform
1805                             ExitFlag.set()
1806                             BuildTask.WaitForComplete()
1807                             Pa.CreateMakeFile(False)
1808                             EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)
1809                         # Start task scheduler
1810                         if not BuildTask.IsOnGoing():
1811                             BuildTask.StartScheduler(self.ThreadNumber, ExitFlag)
1812
1813                     # in case there's an interruption. we need a full version of makefile for platform
1814                     Pa.CreateMakeFile(False)
1815                     if BuildTask.HasError():
1816                         EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)
1817                     self.MakeTime += int(round((time.time() - MakeStart)))
1818
1819                 MakeContiue = time.time()
1820                 ExitFlag.set()
1821                 BuildTask.WaitForComplete()
1822                 self.CreateAsBuiltInf()
1823                 self.MakeTime += int(round((time.time() - MakeContiue)))
1824                 if BuildTask.HasError():
1825                     EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)
1826
1827                 self.BuildReport.AddPlatformReport(Wa, MaList)
1828                 if MaList == []:
1829                     EdkLogger.error(
1830                                 'build',
1831                                 BUILD_ERROR,
1832                                 "Module for [%s] is not a component of active platform."\
1833                                 " Please make sure that the ARCH and inf file path are"\
1834                                 " given in the same as in [%s]" % \
1835                                     (', '.join(Wa.ArchList), self.PlatformFile),
1836                                 ExtraData=self.ModuleFile
1837                                 )
1838                 # Create MAP file when Load Fix Address is enabled.
1839                 if self.Target == "fds" and self.Fdf:
1840                     for Arch in Wa.ArchList:
1841                         #
1842                         # Check whether the set fix address is above 4G for 32bit image.
1843                         #
1844                         if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:
1845                             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")
1846                     #
1847                     # Get Module List
1848                     #
1849                     ModuleList = {}
1850                     for Pa in Wa.AutoGenObjectList:
1851                         for Ma in Pa.ModuleAutoGenList:
1852                             if Ma is None:
1853                                 continue
1854                             if not Ma.IsLibrary:
1855                                 ModuleList[Ma.Guid.upper()] = Ma
1856
1857                     MapBuffer = BytesIO('')
1858                     if self.LoadFixAddress != 0:
1859                         #
1860                         # Rebase module to the preferred memory address before GenFds
1861                         #
1862                         self._CollectModuleMapBuffer(MapBuffer, ModuleList)
1863                     #
1864                     # create FDS again for the updated EFI image
1865                     #
1866                     GenFdsStart = time.time()
1867                     self._Build("fds", Wa)
1868                     self.GenFdsTime += int(round((time.time() - GenFdsStart)))
1869                     #
1870                     # Create MAP file for all platform FVs after GenFds.
1871                     #
1872                     self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)
1873                     #
1874                     # Save MAP buffer into MAP file.
1875                     #
1876                     self._SaveMapFile (MapBuffer, Wa)
1877
1878     def _GenFfsCmd(self):
1879         # convert dictionary of Cmd:(Inf,Arch)
1880         # to a new dictionary of (Inf,Arch):Cmd,Cmd,Cmd...
1881         CmdSetDict = defaultdict(set)
1882         GenFfsDict = GenFds.GenFfsMakefile('', GlobalData.gFdfParser, self, self.ArchList, GlobalData)
1883         for Cmd in GenFfsDict:
1884             tmpInf, tmpArch = GenFfsDict[Cmd]
1885             CmdSetDict[tmpInf, tmpArch].add(Cmd)
1886         return CmdSetDict
1887
1888     ## Build a platform in multi-thread mode
1889     #
1890     def _MultiThreadBuildPlatform(self):
1891         SaveFileOnChange(self.PlatformBuildPath, '# DO NOT EDIT \n# FILE auto-generated\n', False)
1892         for BuildTarget in self.BuildTargetList:
1893             GlobalData.gGlobalDefines['TARGET'] = BuildTarget
1894             index = 0
1895             for ToolChain in self.ToolChainList:
1896                 WorkspaceAutoGenTime = time.time()
1897                 GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain
1898                 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain
1899                 GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[index]
1900                 index += 1
1901                 Wa = WorkspaceAutoGen(
1902                         self.WorkspaceDir,
1903                         self.PlatformFile,
1904                         BuildTarget,
1905                         ToolChain,
1906                         self.ArchList,
1907                         self.BuildDatabase,
1908                         self.TargetTxt,
1909                         self.ToolDef,
1910                         self.Fdf,
1911                         self.FdList,
1912                         self.FvList,
1913                         self.CapList,
1914                         self.SkuId,
1915                         self.UniFlag,
1916                         self.Progress
1917                         )
1918                 self.Fdf = Wa.FdfFile
1919                 self.LoadFixAddress = Wa.Platform.LoadFixAddress
1920                 self.BuildReport.AddPlatformReport(Wa)
1921                 Wa.CreateMakeFile(False)
1922
1923                 # Add ffs build to makefile
1924                 CmdListDict = None
1925                 if GlobalData.gEnableGenfdsMultiThread and self.Fdf:
1926                     CmdListDict = self._GenFfsCmd()
1927
1928                 # multi-thread exit flag
1929                 ExitFlag = threading.Event()
1930                 ExitFlag.clear()
1931                 self.AutoGenTime += int(round((time.time() - WorkspaceAutoGenTime)))
1932                 for Arch in Wa.ArchList:
1933                     AutoGenStart = time.time()
1934                     GlobalData.gGlobalDefines['ARCH'] = Arch
1935                     Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)
1936                     if Pa is None:
1937                         continue
1938                     ModuleList = []
1939                     for Inf in Pa.Platform.Modules:
1940                         ModuleList.append(Inf)
1941                     # Add the INF only list in FDF
1942                     if GlobalData.gFdfParser is not None:
1943                         for InfName in GlobalData.gFdfParser.Profile.InfList:
1944                             Inf = PathClass(NormPath(InfName), self.WorkspaceDir, Arch)
1945                             if Inf in Pa.Platform.Modules:
1946                                 continue
1947                             ModuleList.append(Inf)
1948                     for Module in ModuleList:
1949                         # Get ModuleAutoGen object to generate C code file and makefile
1950                         Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)
1951
1952                         if Ma is None:
1953                             continue
1954                         if Ma.CanSkipbyHash():
1955                             self.HashSkipModules.append(Ma)
1956                             continue
1957
1958                         # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'
1959                         if self.Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1960                             # for target which must generate AutoGen code and makefile
1961                             if not self.SkipAutoGen or self.Target == 'genc':
1962                                 Ma.CreateCodeFile(True)
1963                             if self.Target == "genc":
1964                                 continue
1965
1966                             if not self.SkipAutoGen or self.Target == 'genmake':
1967                                 if CmdListDict and self.Fdf and (Module.File, Arch) in CmdListDict:
1968                                     Ma.CreateMakeFile(True, CmdListDict[Module.File, Arch])
1969                                     del CmdListDict[Module.File, Arch]
1970                                 else:
1971                                     Ma.CreateMakeFile(True)
1972                             if self.Target == "genmake":
1973                                 continue
1974                         self.BuildModules.append(Ma)
1975                     self.Progress.Stop("done!")
1976                     self.AutoGenTime += int(round((time.time() - AutoGenStart)))
1977                     MakeStart = time.time()
1978                     for Ma in self.BuildModules:
1979                         # Generate build task for the module
1980                         if not Ma.IsBinaryModule:
1981                             Bt = BuildTask.New(ModuleMakeUnit(Ma, self.Target))
1982                         # Break build if any build thread has error
1983                         if BuildTask.HasError():
1984                             # we need a full version of makefile for platform
1985                             ExitFlag.set()
1986                             BuildTask.WaitForComplete()
1987                             Pa.CreateMakeFile(False)
1988                             EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)
1989                         # Start task scheduler
1990                         if not BuildTask.IsOnGoing():
1991                             BuildTask.StartScheduler(self.ThreadNumber, ExitFlag)
1992
1993                     # in case there's an interruption. we need a full version of makefile for platform
1994                     Pa.CreateMakeFile(False)
1995                     if BuildTask.HasError():
1996                         EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)
1997                     self.MakeTime += int(round((time.time() - MakeStart)))
1998
1999                 MakeContiue = time.time()
2000
2001                 #
2002                 #
2003                 # All modules have been put in build tasks queue. Tell task scheduler
2004                 # to exit if all tasks are completed
2005                 #
2006                 ExitFlag.set()
2007                 BuildTask.WaitForComplete()
2008                 self.CreateAsBuiltInf()
2009                 self.MakeTime += int(round((time.time() - MakeContiue)))
2010                 #
2011                 # Check for build error, and raise exception if one
2012                 # has been signaled.
2013                 #
2014                 if BuildTask.HasError():
2015                     EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)
2016
2017                 # Create MAP file when Load Fix Address is enabled.
2018                 if self.Target in ["", "all", "fds"]:
2019                     for Arch in Wa.ArchList:
2020                         #
2021                         # Check whether the set fix address is above 4G for 32bit image.
2022                         #
2023                         if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:
2024                             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")
2025                     #
2026                     # Get Module List
2027                     #
2028                     ModuleList = {}
2029                     for Pa in Wa.AutoGenObjectList:
2030                         for Ma in Pa.ModuleAutoGenList:
2031                             if Ma is None:
2032                                 continue
2033                             if not Ma.IsLibrary:
2034                                 ModuleList[Ma.Guid.upper()] = Ma
2035                     #
2036                     # Rebase module to the preferred memory address before GenFds
2037                     #
2038                     MapBuffer = BytesIO('')
2039                     if self.LoadFixAddress != 0:
2040                         self._CollectModuleMapBuffer(MapBuffer, ModuleList)
2041
2042                     if self.Fdf:
2043                         #
2044                         # Generate FD image if there's a FDF file found
2045                         #
2046                         GenFdsStart = time.time()
2047                         if GenFdsApi(Wa.GenFdsCommandDict, self.Db):
2048                             EdkLogger.error("build", COMMAND_FAILURE)
2049
2050                         #
2051                         # Create MAP file for all platform FVs after GenFds.
2052                         #
2053                         self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)
2054                         self.GenFdsTime += int(round((time.time() - GenFdsStart)))
2055                     #
2056                     # Save MAP buffer into MAP file.
2057                     #
2058                     self._SaveMapFile(MapBuffer, Wa)
2059
2060     ## Generate GuidedSectionTools.txt in the FV directories.
2061     #
2062     def CreateGuidedSectionToolsFile(self):
2063         for BuildTarget in self.BuildTargetList:
2064             for ToolChain in self.ToolChainList:
2065                 Wa = WorkspaceAutoGen(
2066                         self.WorkspaceDir,
2067                         self.PlatformFile,
2068                         BuildTarget,
2069                         ToolChain,
2070                         self.ArchList,
2071                         self.BuildDatabase,
2072                         self.TargetTxt,
2073                         self.ToolDef,
2074                         self.Fdf,
2075                         self.FdList,
2076                         self.FvList,
2077                         self.CapList,
2078                         self.SkuId,
2079                         self.UniFlag
2080                         )
2081                 FvDir = Wa.FvDir
2082                 if not os.path.exists(FvDir):
2083                     continue
2084
2085                 for Arch in self.ArchList:
2086                     # Build up the list of supported architectures for this build
2087                     prefix = '%s_%s_%s_' % (BuildTarget, ToolChain, Arch)
2088
2089                     # Look through the tool definitions for GUIDed tools
2090                     guidAttribs = []
2091                     for (attrib, value) in self.ToolDef.ToolsDefTxtDictionary.items():
2092                         if attrib.upper().endswith('_GUID'):
2093                             split = attrib.split('_')
2094                             thisPrefix = '_'.join(split[0:3]) + '_'
2095                             if thisPrefix == prefix:
2096                                 guid = self.ToolDef.ToolsDefTxtDictionary[attrib]
2097                                 guid = guid.lower()
2098                                 toolName = split[3]
2099                                 path = '_'.join(split[0:4]) + '_PATH'
2100                                 path = self.ToolDef.ToolsDefTxtDictionary[path]
2101                                 path = self.GetFullPathOfTool(path)
2102                                 guidAttribs.append((guid, toolName, path))
2103
2104                     # Write out GuidedSecTools.txt
2105                     toolsFile = os.path.join(FvDir, 'GuidedSectionTools.txt')
2106                     toolsFile = open(toolsFile, 'wt')
2107                     for guidedSectionTool in guidAttribs:
2108                         print(' '.join(guidedSectionTool), file=toolsFile)
2109                     toolsFile.close()
2110
2111     ## Returns the full path of the tool.
2112     #
2113     def GetFullPathOfTool (self, tool):
2114         if os.path.exists(tool):
2115             return os.path.realpath(tool)
2116         else:
2117             # We need to search for the tool using the
2118             # PATH environment variable.
2119             for dirInPath in os.environ['PATH'].split(os.pathsep):
2120                 foundPath = os.path.join(dirInPath, tool)
2121                 if os.path.exists(foundPath):
2122                     return os.path.realpath(foundPath)
2123
2124         # If the tool was not found in the path then we just return
2125         # the input tool.
2126         return tool
2127
2128     ## Launch the module or platform build
2129     #
2130     def Launch(self):
2131         if not self.ModuleFile:
2132             if not self.SpawnMode or self.Target not in ["", "all"]:
2133                 self.SpawnMode = False
2134                 self._BuildPlatform()
2135             else:
2136                 self._MultiThreadBuildPlatform()
2137             self.CreateGuidedSectionToolsFile()
2138         else:
2139             self.SpawnMode = False
2140             self._BuildModule()
2141
2142         if self.Target == 'cleanall':
2143             RemoveDirectory(os.path.dirname(GlobalData.gDatabasePath), True)
2144
2145     def CreateAsBuiltInf(self):
2146         for Module in self.BuildModules:
2147             Module.CreateAsBuiltInf()
2148         for Module in self.HashSkipModules:
2149             Module.CreateAsBuiltInf(True)
2150         self.BuildModules = []
2151         self.HashSkipModules = []
2152     ## Do some clean-up works when error occurred
2153     def Relinquish(self):
2154         OldLogLevel = EdkLogger.GetLevel()
2155         EdkLogger.SetLevel(EdkLogger.ERROR)
2156         Utils.Progressor.Abort()
2157         if self.SpawnMode == True:
2158             BuildTask.Abort()
2159         EdkLogger.SetLevel(OldLogLevel)
2160
2161 def ParseDefines(DefineList=[]):
2162     DefineDict = {}
2163     if DefineList is not None:
2164         for Define in DefineList:
2165             DefineTokenList = Define.split("=", 1)
2166             if not GlobalData.gMacroNamePattern.match(DefineTokenList[0]):
2167                 EdkLogger.error('build', FORMAT_INVALID,
2168                                 "The macro name must be in the pattern [A-Z][A-Z0-9_]*",
2169                                 ExtraData=DefineTokenList[0])
2170
2171             if len(DefineTokenList) == 1:
2172                 DefineDict[DefineTokenList[0]] = "TRUE"
2173             else:
2174                 DefineDict[DefineTokenList[0]] = DefineTokenList[1].strip()
2175     return DefineDict
2176
2177 gParamCheck = []
2178 def SingleCheckCallback(option, opt_str, value, parser):
2179     if option not in gParamCheck:
2180         setattr(parser.values, option.dest, value)
2181         gParamCheck.append(option)
2182     else:
2183         parser.error("Option %s only allows one instance in command line!" % option)
2184
2185 def LogBuildTime(Time):
2186     if Time:
2187         TimeDurStr = ''
2188         TimeDur = time.gmtime(Time)
2189         if TimeDur.tm_yday > 1:
2190             TimeDurStr = time.strftime("%H:%M:%S", TimeDur) + ", %d day(s)" % (TimeDur.tm_yday - 1)
2191         else:
2192             TimeDurStr = time.strftime("%H:%M:%S", TimeDur)
2193         return TimeDurStr
2194     else:
2195         return None
2196
2197 ## Parse command line options
2198 #
2199 # Using standard Python module optparse to parse command line option of this tool.
2200 #
2201 #   @retval Opt   A optparse.Values object containing the parsed options
2202 #   @retval Args  Target of build command
2203 #
2204 def MyOptionParser():
2205     Parser = OptionParser(description=__copyright__, version=__version__, prog="build.exe", usage="%prog [options] [all|fds|genc|genmake|clean|cleanall|cleanlib|modules|libraries|run]")
2206     Parser.add_option("-a", "--arch", action="append", type="choice", choices=['IA32', 'X64', 'EBC', 'ARM', 'AARCH64'], dest="TargetArch",
2207         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.")
2208     Parser.add_option("-p", "--platform", action="callback", type="string", dest="PlatformFile", callback=SingleCheckCallback,
2209         help="Build the platform specified by the DSC file name argument, overriding target.txt's ACTIVE_PLATFORM definition.")
2210     Parser.add_option("-m", "--module", action="callback", type="string", dest="ModuleFile", callback=SingleCheckCallback,
2211         help="Build the module specified by the INF file name argument.")
2212     Parser.add_option("-b", "--buildtarget", type="string", dest="BuildTarget", help="Using the TARGET to build the platform, overriding target.txt's TARGET definition.",
2213                       action="append")
2214     Parser.add_option("-t", "--tagname", action="append", type="string", dest="ToolChain",
2215         help="Using the Tool Chain Tagname to build the platform, overriding target.txt's TOOL_CHAIN_TAG definition.")
2216     Parser.add_option("-x", "--sku-id", action="callback", type="string", dest="SkuId", callback=SingleCheckCallback,
2217         help="Using this name of SKU ID to build the platform, overriding SKUID_IDENTIFIER in DSC file.")
2218
2219     Parser.add_option("-n", action="callback", type="int", dest="ThreadNumber", callback=SingleCheckCallback,
2220         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 "\
2221              "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.")
2222
2223     Parser.add_option("-f", "--fdf", action="callback", type="string", dest="FdfFile", callback=SingleCheckCallback,
2224         help="The name of the FDF file to use, which overrides the setting in the DSC file.")
2225     Parser.add_option("-r", "--rom-image", action="append", type="string", dest="RomImage", default=[],
2226         help="The name of FD to be generated. The name must be from [FD] section in FDF file.")
2227     Parser.add_option("-i", "--fv-image", action="append", type="string", dest="FvImage", default=[],
2228         help="The name of FV to be generated. The name must be from [FV] section in FDF file.")
2229     Parser.add_option("-C", "--capsule-image", action="append", type="string", dest="CapName", default=[],
2230         help="The name of Capsule to be generated. The name must be from [Capsule] section in FDF file.")
2231     Parser.add_option("-u", "--skip-autogen", action="store_true", dest="SkipAutoGen", help="Skip AutoGen step.")
2232     Parser.add_option("-e", "--re-parse", action="store_true", dest="Reparse", help="Re-parse all meta-data files.")
2233
2234     Parser.add_option("-c", "--case-insensitive", action="store_true", dest="CaseInsensitive", default=False, help="Don't check case of file name.")
2235
2236     Parser.add_option("-w", "--warning-as-error", action="store_true", dest="WarningAsError", help="Treat warning in tools as error.")
2237     Parser.add_option("-j", "--log", action="store", dest="LogFile", help="Put log in specified file as well as on console.")
2238
2239     Parser.add_option("-s", "--silent", action="store_true", type=None, dest="SilentMode",
2240         help="Make use of silent mode of (n)make.")
2241     Parser.add_option("-q", "--quiet", action="store_true", type=None, help="Disable all messages except FATAL ERRORS.")
2242     Parser.add_option("-v", "--verbose", action="store_true", type=None, help="Turn on verbose output with informational messages printed, "\
2243                                                                                "including library instances selected, final dependency expression, "\
2244                                                                                "and warning messages, etc.")
2245     Parser.add_option("-d", "--debug", action="store", type="int", help="Enable debug messages at specified level.")
2246     Parser.add_option("-D", "--define", action="append", type="string", dest="Macros", help="Macro: \"Name [= Value]\".")
2247
2248     Parser.add_option("-y", "--report-file", action="store", dest="ReportFile", help="Create/overwrite the report to the specified filename.")
2249     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=[],
2250         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].  "\
2251              "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]")
2252     Parser.add_option("-F", "--flag", action="store", type="string", dest="Flag",
2253         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. "\
2254              "This option can also be specified by setting *_*_*_BUILD_FLAGS in [BuildOptions] section of platform DSC. If they are both specified, this value "\
2255              "will override the setting in [BuildOptions] section of platform DSC.")
2256     Parser.add_option("-N", "--no-cache", action="store_true", dest="DisableCache", default=False, help="Disable build cache mechanism")
2257     Parser.add_option("--conf", action="store", type="string", dest="ConfDirectory", help="Specify the customized Conf directory.")
2258     Parser.add_option("--check-usage", action="store_true", dest="CheckUsage", default=False, help="Check usage content of entries listed in INF file.")
2259     Parser.add_option("--ignore-sources", action="store_true", dest="IgnoreSources", default=False, help="Focus to a binary build and ignore all source files")
2260     Parser.add_option("--pcd", action="append", dest="OptionPcd", help="Set PCD value by command line. Format: \"PcdName=Value\" ")
2261     Parser.add_option("-l", "--cmd-len", action="store", type="int", dest="CommandLength", help="Specify the maximum line length of build command. Default is 4096.")
2262     Parser.add_option("--hash", action="store_true", dest="UseHashCache", default=False, help="Enable hash-based caching during build process.")
2263     Parser.add_option("--binary-destination", action="store", type="string", dest="BinCacheDest", help="Generate a cache of binary files in the specified directory.")
2264     Parser.add_option("--binary-source", action="store", type="string", dest="BinCacheSource", help="Consume a cache of binary files from the specified directory.")
2265     Parser.add_option("--genfds-multi-thread", action="store_true", dest="GenfdsMultiThread", default=False, help="Enable GenFds multi thread to generate ffs file.")
2266     (Opt, Args) = Parser.parse_args()
2267     return (Opt, Args)
2268
2269 ## Tool entrance method
2270 #
2271 # This method mainly dispatch specific methods per the command line options.
2272 # If no error found, return zero value so the caller of this tool can know
2273 # if it's executed successfully or not.
2274 #
2275 #   @retval 0     Tool was successful
2276 #   @retval 1     Tool failed
2277 #
2278 def Main():
2279     StartTime = time.time()
2280
2281     # Initialize log system
2282     EdkLogger.Initialize()
2283     GlobalData.gCommand = sys.argv[1:]
2284     #
2285     # Parse the options and args
2286     #
2287     (Option, Target) = MyOptionParser()
2288     GlobalData.gOptions = Option
2289     GlobalData.gCaseInsensitive = Option.CaseInsensitive
2290
2291     # Set log level
2292     if Option.verbose is not None:
2293         EdkLogger.SetLevel(EdkLogger.VERBOSE)
2294     elif Option.quiet is not None:
2295         EdkLogger.SetLevel(EdkLogger.QUIET)
2296     elif Option.debug is not None:
2297         EdkLogger.SetLevel(Option.debug + 1)
2298     else:
2299         EdkLogger.SetLevel(EdkLogger.INFO)
2300
2301     if Option.LogFile is not None:
2302         EdkLogger.SetLogFile(Option.LogFile)
2303
2304     if Option.WarningAsError == True:
2305         EdkLogger.SetWarningAsError()
2306
2307     if platform.platform().find("Windows") >= 0:
2308         GlobalData.gIsWindows = True
2309     else:
2310         GlobalData.gIsWindows = False
2311
2312     EdkLogger.quiet("Build environment: %s" % platform.platform())
2313     EdkLogger.quiet(time.strftime("Build start time: %H:%M:%S, %b.%d %Y\n", time.localtime()));
2314     ReturnCode = 0
2315     MyBuild = None
2316     BuildError = True
2317     try:
2318         if len(Target) == 0:
2319             Target = "all"
2320         elif len(Target) >= 2:
2321             EdkLogger.error("build", OPTION_NOT_SUPPORTED, "More than one targets are not supported.",
2322                             ExtraData="Please select one of: %s" % (' '.join(gSupportedTarget)))
2323         else:
2324             Target = Target[0].lower()
2325
2326         if Target not in gSupportedTarget:
2327             EdkLogger.error("build", OPTION_NOT_SUPPORTED, "Not supported target [%s]." % Target,
2328                             ExtraData="Please select one of: %s" % (' '.join(gSupportedTarget)))
2329
2330         #
2331         # Check environment variable: EDK_TOOLS_PATH, WORKSPACE, PATH
2332         #
2333         CheckEnvVariable()
2334         GlobalData.gCommandLineDefines.update(ParseDefines(Option.Macros))
2335
2336         Workspace = os.getenv("WORKSPACE")
2337         #
2338         # Get files real name in workspace dir
2339         #
2340         GlobalData.gAllFiles = Utils.DirCache(Workspace)
2341
2342         WorkingDirectory = os.getcwd()
2343         if not Option.ModuleFile:
2344             FileList = glob.glob(os.path.normpath(os.path.join(WorkingDirectory, '*.inf')))
2345             FileNum = len(FileList)
2346             if FileNum >= 2:
2347                 EdkLogger.error("build", OPTION_NOT_SUPPORTED, "There are %d INF files in %s." % (FileNum, WorkingDirectory),
2348                                 ExtraData="Please use '-m <INF_FILE_PATH>' switch to choose one.")
2349             elif FileNum == 1:
2350                 Option.ModuleFile = NormFile(FileList[0], Workspace)
2351
2352         if Option.ModuleFile:
2353             if os.path.isabs (Option.ModuleFile):
2354                 if os.path.normcase (os.path.normpath(Option.ModuleFile)).find (Workspace) == 0:
2355                     Option.ModuleFile = NormFile(os.path.normpath(Option.ModuleFile), Workspace)
2356             Option.ModuleFile = PathClass(Option.ModuleFile, Workspace)
2357             ErrorCode, ErrorInfo = Option.ModuleFile.Validate(".inf", False)
2358             if ErrorCode != 0:
2359                 EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)
2360
2361         if Option.PlatformFile is not None:
2362             if os.path.isabs (Option.PlatformFile):
2363                 if os.path.normcase (os.path.normpath(Option.PlatformFile)).find (Workspace) == 0:
2364                     Option.PlatformFile = NormFile(os.path.normpath(Option.PlatformFile), Workspace)
2365             Option.PlatformFile = PathClass(Option.PlatformFile, Workspace)
2366
2367         if Option.FdfFile is not None:
2368             if os.path.isabs (Option.FdfFile):
2369                 if os.path.normcase (os.path.normpath(Option.FdfFile)).find (Workspace) == 0:
2370                     Option.FdfFile = NormFile(os.path.normpath(Option.FdfFile), Workspace)
2371             Option.FdfFile = PathClass(Option.FdfFile, Workspace)
2372             ErrorCode, ErrorInfo = Option.FdfFile.Validate(".fdf", False)
2373             if ErrorCode != 0:
2374                 EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)
2375
2376         if Option.Flag is not None and Option.Flag not in ['-c', '-s']:
2377             EdkLogger.error("build", OPTION_VALUE_INVALID, "UNI flag must be one of -c or -s")
2378
2379         MyBuild = Build(Target, Workspace, Option)
2380         GlobalData.gCommandLineDefines['ARCH'] = ' '.join(MyBuild.ArchList)
2381         if not (MyBuild.LaunchPrebuildFlag and os.path.exists(MyBuild.PlatformBuildPath)):
2382             MyBuild.Launch()
2383
2384         #
2385         # All job done, no error found and no exception raised
2386         #
2387         BuildError = False
2388     except FatalError as X:
2389         if MyBuild is not None:
2390             # for multi-thread build exits safely
2391             MyBuild.Relinquish()
2392         if Option is not None and Option.debug is not None:
2393             EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())
2394         ReturnCode = X.args[0]
2395     except Warning as X:
2396         # error from Fdf parser
2397         if MyBuild is not None:
2398             # for multi-thread build exits safely
2399             MyBuild.Relinquish()
2400         if Option is not None and Option.debug is not None:
2401             EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())
2402         else:
2403             EdkLogger.error(X.ToolName, FORMAT_INVALID, File=X.FileName, Line=X.LineNumber, ExtraData=X.Message, RaiseError=False)
2404         ReturnCode = FORMAT_INVALID
2405     except KeyboardInterrupt:
2406         ReturnCode = ABORT_ERROR
2407         if Option is not None and Option.debug is not None:
2408             EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())
2409     except:
2410         if MyBuild is not None:
2411             # for multi-thread build exits safely
2412             MyBuild.Relinquish()
2413
2414         # try to get the meta-file from the object causing exception
2415         Tb = sys.exc_info()[-1]
2416         MetaFile = GlobalData.gProcessingFile
2417         while Tb is not None:
2418             if 'self' in Tb.tb_frame.f_locals and hasattr(Tb.tb_frame.f_locals['self'], 'MetaFile'):
2419                 MetaFile = Tb.tb_frame.f_locals['self'].MetaFile
2420             Tb = Tb.tb_next
2421         EdkLogger.error(
2422                     "\nbuild",
2423                     CODE_ERROR,
2424                     "Unknown fatal error when processing [%s]" % MetaFile,
2425                     ExtraData="\n(Please send email to edk2-devel@lists.01.org for help, attaching following call stack trace!)\n",
2426                     RaiseError=False
2427                     )
2428         EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())
2429         ReturnCode = CODE_ERROR
2430     finally:
2431         Utils.Progressor.Abort()
2432         Utils.ClearDuplicatedInf()
2433
2434     if ReturnCode == 0:
2435         try:
2436             MyBuild.LaunchPostbuild()
2437             Conclusion = "Done"
2438         except:
2439             Conclusion = "Failed"
2440     elif ReturnCode == ABORT_ERROR:
2441         Conclusion = "Aborted"
2442     else:
2443         Conclusion = "Failed"
2444     FinishTime = time.time()
2445     BuildDuration = time.gmtime(int(round(FinishTime - StartTime)))
2446     BuildDurationStr = ""
2447     if BuildDuration.tm_yday > 1:
2448         BuildDurationStr = time.strftime("%H:%M:%S", BuildDuration) + ", %d day(s)" % (BuildDuration.tm_yday - 1)
2449     else:
2450         BuildDurationStr = time.strftime("%H:%M:%S", BuildDuration)
2451     if MyBuild is not None:
2452         if not BuildError:
2453             MyBuild.BuildReport.GenerateReport(BuildDurationStr, LogBuildTime(MyBuild.AutoGenTime), LogBuildTime(MyBuild.MakeTime), LogBuildTime(MyBuild.GenFdsTime))
2454
2455     EdkLogger.SetLevel(EdkLogger.QUIET)
2456     EdkLogger.quiet("\n- %s -" % Conclusion)
2457     EdkLogger.quiet(time.strftime("Build end time: %H:%M:%S, %b.%d %Y", time.localtime()))
2458     EdkLogger.quiet("Build total time: %s\n" % BuildDurationStr)
2459     return ReturnCode
2460
2461 if __name__ == '__main__':
2462     r = Main()
2463     ## 0-127 is a safe return range, and 1 is a standard default error
2464     if r < 0 or r > 127: r = 1
2465     sys.exit(r)
2466