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