BaseTools/Source/Python/build/build.py

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