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