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         for InfFile in ModuleList:
1427             sys.stdout.write (".")
1428             sys.stdout.flush()
1429             ModuleInfo = ModuleList[InfFile]
1430             ModuleName = ModuleInfo.BaseName
1431             ModuleOutputImage = ModuleInfo.Image.FileName
1432             ModuleDebugImage  = os.path.join(ModuleInfo.DebugDir, ModuleInfo.BaseName + '.efi')
1433             ## for SMM module in SMRAM, the SMRAM will be allocated from base to top.
1434             if not ModeIsSmm:
1435                 BaseAddress = BaseAddress - ModuleInfo.Image.Size
1436                 #
1437                 # Update Image to new BaseAddress by GenFw tool
1438                 #
1439                 LaunchCommand(["GenFw", "--rebase", str(BaseAddress), "-r", ModuleOutputImage], ModuleInfo.OutputDir)
1440                 LaunchCommand(["GenFw", "--rebase", str(BaseAddress), "-r", ModuleDebugImage], ModuleInfo.DebugDir)
1441             else:
1442                 #
1443                 # Set new address to the section header only for SMM driver.
1444                 #
1445                 LaunchCommand(["GenFw", "--address", str(BaseAddress), "-r", ModuleOutputImage], ModuleInfo.OutputDir)
1446                 LaunchCommand(["GenFw", "--address", str(BaseAddress), "-r", ModuleDebugImage], ModuleInfo.DebugDir)
1447             #
1448             # Collect funtion address from Map file
1449             #
1450             ImageMapTable = ModuleOutputImage.replace('.efi', '.map')
1451             FunctionList = []
1452             if os.path.exists(ImageMapTable):
1453                 OrigImageBaseAddress = 0
1454                 ImageMap = open(ImageMapTable, 'r')
1455                 for LinStr in ImageMap:
1456                     if len (LinStr.strip()) == 0:
1457                         continue
1458                     #
1459                     # Get the preferred address set on link time.
1460                     #
1461                     if LinStr.find ('Preferred load address is') != -1:
1462                         StrList = LinStr.split()
1463                         OrigImageBaseAddress = int (StrList[len(StrList) - 1], 16)
1464
1465                     StrList = LinStr.split()
1466                     if len (StrList) > 4:
1467                         if StrList[3] == 'f' or StrList[3] == 'F':
1468                             Name = StrList[1]
1469                             RelativeAddress = int (StrList[2], 16) - OrigImageBaseAddress
1470                             FunctionList.append ((Name, RelativeAddress))
1471                             if ModuleInfo.Arch == 'IPF' and Name.endswith('_ModuleEntryPoint'):
1472                                 #
1473                                 # Get the real entry point address for IPF image.
1474                                 #
1475                                 ModuleInfo.Image.EntryPoint = RelativeAddress
1476                 ImageMap.close()
1477             #
1478             # Add general information.
1479             #
1480             if ModeIsSmm:
1481                 MapBuffer.write('\n\n%s (Fixed SMRAM Offset,   BaseAddress=0x%010X,  EntryPoint=0x%010X)\n' % (ModuleName, BaseAddress, BaseAddress + ModuleInfo.Image.EntryPoint))
1482             elif AddrIsOffset:
1483                 MapBuffer.write('\n\n%s (Fixed Memory Offset,  BaseAddress=-0x%010X, EntryPoint=-0x%010X)\n' % (ModuleName, 0 - BaseAddress, 0 - (BaseAddress + ModuleInfo.Image.EntryPoint)))
1484             else:
1485                 MapBuffer.write('\n\n%s (Fixed Memory Address, BaseAddress=0x%010X,  EntryPoint=0x%010X)\n' % (ModuleName, BaseAddress, BaseAddress + ModuleInfo.Image.EntryPoint))
1486             #
1487             # Add guid and general seciton section.
1488             #
1489             TextSectionAddress = 0
1490             DataSectionAddress = 0
1491             for SectionHeader in ModuleInfo.Image.SectionHeaderList:
1492                 if SectionHeader[0] == '.text':
1493                     TextSectionAddress = SectionHeader[1]
1494                 elif SectionHeader[0] in ['.data', '.sdata']:
1495                     DataSectionAddress = SectionHeader[1]
1496             if AddrIsOffset:
1497                 MapBuffer.write('(GUID=%s, .textbaseaddress=-0x%010X, .databaseaddress=-0x%010X)\n' % (ModuleInfo.Guid, 0 - (BaseAddress + TextSectionAddress), 0 - (BaseAddress + DataSectionAddress)))
1498             else:
1499                 MapBuffer.write('(GUID=%s, .textbaseaddress=0x%010X, .databaseaddress=0x%010X)\n' % (ModuleInfo.Guid, BaseAddress + TextSectionAddress, BaseAddress + DataSectionAddress))
1500             #
1501             # Add debug image full path.
1502             #
1503             MapBuffer.write('(IMAGE=%s)\n\n' % (ModuleDebugImage))
1504             #
1505             # Add funtion address
1506             #
1507             for Function in FunctionList:
1508                 if AddrIsOffset:
1509                     MapBuffer.write('  -0x%010X    %s\n' % (0 - (BaseAddress + Function[1]), Function[0]))
1510                 else:
1511                     MapBuffer.write('  0x%010X    %s\n' % (BaseAddress + Function[1], Function[0]))
1512             ImageMap.close()
1513
1514             #
1515             # for SMM module in SMRAM, the SMRAM will be allocated from base to top.
1516             #
1517             if ModeIsSmm:
1518                 BaseAddress = BaseAddress + ModuleInfo.Image.Size
1519
1520     ## Collect MAP information of all FVs
1521     #
1522     def _CollectFvMapBuffer (self, MapBuffer, Wa, ModuleList):
1523         if self.Fdf:
1524             # First get the XIP base address for FV map file.
1525             GuidPattern = re.compile("[-a-fA-F0-9]+")
1526             GuidName = re.compile("\(GUID=[-a-fA-F0-9]+")
1527             for FvName in Wa.FdfProfile.FvDict.keys():
1528                 FvMapBuffer = os.path.join(Wa.FvDir, FvName + '.Fv.map')
1529                 if not os.path.exists(FvMapBuffer):
1530                     continue
1531                 FvMap = open(FvMapBuffer, 'r')
1532                 #skip FV size information
1533                 FvMap.readline()
1534                 FvMap.readline()
1535                 FvMap.readline()
1536                 FvMap.readline()
1537                 for Line in FvMap:
1538                     MatchGuid = GuidPattern.match(Line)
1539                     if MatchGuid is not None:
1540                         #
1541                         # Replace GUID with module name
1542                         #
1543                         GuidString = MatchGuid.group()
1544                         if GuidString.upper() in ModuleList:
1545                             Line = Line.replace(GuidString, ModuleList[GuidString.upper()].Name)
1546                     MapBuffer.write('%s' % (Line))
1547                     #
1548                     # Add the debug image full path.
1549                     #
1550                     MatchGuid = GuidName.match(Line)
1551                     if MatchGuid is not None:
1552                         GuidString = MatchGuid.group().split("=")[1]
1553                         if GuidString.upper() in ModuleList:
1554                             MapBuffer.write('(IMAGE=%s)\n' % (os.path.join(ModuleList[GuidString.upper()].DebugDir, ModuleList[GuidString.upper()].Name + '.efi')))
1555
1556                 FvMap.close()
1557
1558     ## Collect MAP information of all modules
1559     #
1560     def _CollectModuleMapBuffer (self, MapBuffer, ModuleList):
1561         sys.stdout.write ("Generate Load Module At Fix Address Map")
1562         sys.stdout.flush()
1563         PatchEfiImageList = []
1564         PeiModuleList  = {}
1565         BtModuleList   = {}
1566         RtModuleList   = {}
1567         SmmModuleList  = {}
1568         PeiSize = 0
1569         BtSize  = 0
1570         RtSize  = 0
1571         # reserve 4K size in SMRAM to make SMM module address not from 0.
1572         SmmSize = 0x1000
1573         IsIpfPlatform = False
1574         if 'IPF' in self.ArchList:
1575             IsIpfPlatform = True
1576         for ModuleGuid in ModuleList:
1577             Module = ModuleList[ModuleGuid]
1578             GlobalData.gProcessingFile = "%s [%s, %s, %s]" % (Module.MetaFile, Module.Arch, Module.ToolChain, Module.BuildTarget)
1579
1580             OutputImageFile = ''
1581             for ResultFile in Module.CodaTargetList:
1582                 if str(ResultFile.Target).endswith('.efi'):
1583                     #
1584                     # module list for PEI, DXE, RUNTIME and SMM
1585                     #
1586                     OutputImageFile = os.path.join(Module.OutputDir, Module.Name + '.efi')
1587                     ImageClass = PeImageClass (OutputImageFile)
1588                     if not ImageClass.IsValid:
1589                         EdkLogger.error("build", FILE_PARSE_FAILURE, ExtraData=ImageClass.ErrorInfo)
1590                     ImageInfo = PeImageInfo(Module.Name, Module.Guid, Module.Arch, Module.OutputDir, Module.DebugDir, ImageClass)
1591                     if Module.ModuleType in ['PEI_CORE', 'PEIM', 'COMBINED_PEIM_DRIVER', 'PIC_PEIM', 'RELOCATABLE_PEIM', 'DXE_CORE']:
1592                         PeiModuleList[Module.MetaFile] = ImageInfo
1593                         PeiSize += ImageInfo.Image.Size
1594                     elif Module.ModuleType in ['BS_DRIVER', 'DXE_DRIVER', 'UEFI_DRIVER']:
1595                         BtModuleList[Module.MetaFile] = ImageInfo
1596                         BtSize += ImageInfo.Image.Size
1597                     elif Module.ModuleType in ['DXE_RUNTIME_DRIVER', 'RT_DRIVER', 'DXE_SAL_DRIVER', 'SAL_RT_DRIVER']:
1598                         RtModuleList[Module.MetaFile] = ImageInfo
1599                         #IPF runtime driver needs to be at 2 page alignment.
1600                         if IsIpfPlatform and ImageInfo.Image.Size % 0x2000 != 0:
1601                             ImageInfo.Image.Size = (ImageInfo.Image.Size / 0x2000 + 1) * 0x2000
1602                         RtSize += ImageInfo.Image.Size
1603                     elif Module.ModuleType in ['SMM_CORE', 'DXE_SMM_DRIVER', 'MM_STANDALONE', 'MM_CORE_STANDALONE']:
1604                         SmmModuleList[Module.MetaFile] = ImageInfo
1605                         SmmSize += ImageInfo.Image.Size
1606                         if Module.ModuleType == 'DXE_SMM_DRIVER':
1607                             PiSpecVersion = '0x00000000'
1608                             if 'PI_SPECIFICATION_VERSION' in Module.Module.Specification:
1609                                 PiSpecVersion = Module.Module.Specification['PI_SPECIFICATION_VERSION']
1610                             # for PI specification < PI1.1, DXE_SMM_DRIVER also runs as BOOT time driver.
1611                             if int(PiSpecVersion, 16) < 0x0001000A:
1612                                 BtModuleList[Module.MetaFile] = ImageInfo
1613                                 BtSize += ImageInfo.Image.Size
1614                     break
1615             #
1616             # EFI image is final target.
1617             # Check EFI image contains patchable FixAddress related PCDs.
1618             #
1619             if OutputImageFile != '':
1620                 ModuleIsPatch = False
1621                 for Pcd in Module.ModulePcdList:
1622                     if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE and Pcd.TokenCName in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_LIST:
1623                         ModuleIsPatch = True
1624                         break
1625                 if not ModuleIsPatch:
1626                     for Pcd in Module.LibraryPcdList:
1627                         if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE and Pcd.TokenCName in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_LIST:
1628                             ModuleIsPatch = True
1629                             break
1630
1631                 if not ModuleIsPatch:
1632                     continue
1633                 #
1634                 # Module includes the patchable load fix address PCDs.
1635                 # It will be fixed up later.
1636                 #
1637                 PatchEfiImageList.append (OutputImageFile)
1638
1639         #
1640         # Get Top Memory address
1641         #
1642         ReservedRuntimeMemorySize = 0
1643         TopMemoryAddress = 0
1644         if self.LoadFixAddress == 0xFFFFFFFFFFFFFFFF:
1645             TopMemoryAddress = 0
1646         else:
1647             TopMemoryAddress = self.LoadFixAddress
1648             if TopMemoryAddress < RtSize + BtSize + PeiSize:
1649                 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS is too low to load driver")
1650             # Make IPF runtime driver at 2 page alignment.
1651             if IsIpfPlatform:
1652                 ReservedRuntimeMemorySize = TopMemoryAddress % 0x2000
1653                 RtSize = RtSize + ReservedRuntimeMemorySize
1654
1655         #
1656         # Patch FixAddress related PCDs into EFI image
1657         #
1658         for EfiImage in PatchEfiImageList:
1659             EfiImageMap = EfiImage.replace('.efi', '.map')
1660             if not os.path.exists(EfiImageMap):
1661                 continue
1662             #
1663             # Get PCD offset in EFI image by GenPatchPcdTable function
1664             #
1665             PcdTable = parsePcdInfoFromMapFile(EfiImageMap, EfiImage)
1666             #
1667             # Patch real PCD value by PatchPcdValue tool
1668             #
1669             for PcdInfo in PcdTable:
1670                 ReturnValue = 0
1671                 if PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE:
1672                     ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE_DATA_TYPE, str (PeiSize / 0x1000))
1673                 elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE:
1674                     ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE_DATA_TYPE, str (BtSize / 0x1000))
1675                 elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE:
1676                     ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE_DATA_TYPE, str (RtSize / 0x1000))
1677                 elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE and len (SmmModuleList) > 0:
1678                     ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE_DATA_TYPE, str (SmmSize / 0x1000))
1679                 if ReturnValue != 0:
1680                     EdkLogger.error("build", PARAMETER_INVALID, "Patch PCD value failed", ExtraData=ErrorInfo)
1681
1682         MapBuffer.write('PEI_CODE_PAGE_NUMBER      = 0x%x\n' % (PeiSize / 0x1000))
1683         MapBuffer.write('BOOT_CODE_PAGE_NUMBER     = 0x%x\n' % (BtSize / 0x1000))
1684         MapBuffer.write('RUNTIME_CODE_PAGE_NUMBER  = 0x%x\n' % (RtSize / 0x1000))
1685         if len (SmmModuleList) > 0:
1686             MapBuffer.write('SMM_CODE_PAGE_NUMBER      = 0x%x\n' % (SmmSize / 0x1000))
1687
1688         PeiBaseAddr = TopMemoryAddress - RtSize - BtSize
1689         BtBaseAddr  = TopMemoryAddress - RtSize
1690         RtBaseAddr  = TopMemoryAddress - ReservedRuntimeMemorySize
1691
1692         self._RebaseModule (MapBuffer, PeiBaseAddr, PeiModuleList, TopMemoryAddress == 0)
1693         self._RebaseModule (MapBuffer, BtBaseAddr, BtModuleList, TopMemoryAddress == 0)
1694         self._RebaseModule (MapBuffer, RtBaseAddr, RtModuleList, TopMemoryAddress == 0)
1695         self._RebaseModule (MapBuffer, 0x1000, SmmModuleList, AddrIsOffset=False, ModeIsSmm=True)
1696         MapBuffer.write('\n\n')
1697         sys.stdout.write ("\n")
1698         sys.stdout.flush()
1699
1700     ## Save platform Map file
1701     #
1702     def _SaveMapFile (self, MapBuffer, Wa):
1703         #
1704         # Map file path is got.
1705         #
1706         MapFilePath = os.path.join(Wa.BuildDir, Wa.Name + '.map')
1707         #
1708         # Save address map into MAP file.
1709         #
1710         SaveFileOnChange(MapFilePath, MapBuffer.getvalue(), False)
1711         MapBuffer.close()
1712         if self.LoadFixAddress != 0:
1713             sys.stdout.write ("\nLoad Module At Fix Address Map file can be found at %s\n" % (MapFilePath))
1714         sys.stdout.flush()
1715
1716     ## Build active platform for different build targets and different tool chains
1717     #
1718     def _BuildPlatform(self):
1719         SaveFileOnChange(self.PlatformBuildPath, '# DO NOT EDIT \n# FILE auto-generated\n', False)
1720         for BuildTarget in self.BuildTargetList:
1721             GlobalData.gGlobalDefines['TARGET'] = BuildTarget
1722             index = 0
1723             for ToolChain in self.ToolChainList:
1724                 GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain
1725                 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain
1726                 GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[index]
1727                 index += 1
1728                 Wa = WorkspaceAutoGen(
1729                         self.WorkspaceDir,
1730                         self.PlatformFile,
1731                         BuildTarget,
1732                         ToolChain,
1733                         self.ArchList,
1734                         self.BuildDatabase,
1735                         self.TargetTxt,
1736                         self.ToolDef,
1737                         self.Fdf,
1738                         self.FdList,
1739                         self.FvList,
1740                         self.CapList,
1741                         self.SkuId,
1742                         self.UniFlag,
1743                         self.Progress
1744                         )
1745                 self.Fdf = Wa.FdfFile
1746                 self.LoadFixAddress = Wa.Platform.LoadFixAddress
1747                 self.BuildReport.AddPlatformReport(Wa)
1748                 self.Progress.Stop("done!")
1749
1750                 # Add ffs build to makefile
1751                 CmdListDict = {}
1752                 if GlobalData.gEnableGenfdsMultiThread and self.Fdf:
1753                     CmdListDict = self._GenFfsCmd()
1754
1755                 for Arch in Wa.ArchList:
1756                     GlobalData.gGlobalDefines['ARCH'] = Arch
1757                     Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)
1758                     for Module in Pa.Platform.Modules:
1759                         # Get ModuleAutoGen object to generate C code file and makefile
1760                         Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)
1761                         if Ma is None:
1762                             continue
1763                         self.BuildModules.append(Ma)
1764                     self._BuildPa(self.Target, Pa, FfsCommand=CmdListDict)
1765
1766                 # Create MAP file when Load Fix Address is enabled.
1767                 if self.Target in ["", "all", "fds"]:
1768                     for Arch in Wa.ArchList:
1769                         GlobalData.gGlobalDefines['ARCH'] = Arch
1770                         #
1771                         # Check whether the set fix address is above 4G for 32bit image.
1772                         #
1773                         if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:
1774                             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")
1775                     #
1776                     # Get Module List
1777                     #
1778                     ModuleList = {}
1779                     for Pa in Wa.AutoGenObjectList:
1780                         for Ma in Pa.ModuleAutoGenList:
1781                             if Ma is None:
1782                                 continue
1783                             if not Ma.IsLibrary:
1784                                 ModuleList[Ma.Guid.upper()] = Ma
1785
1786                     MapBuffer = StringIO('')
1787                     if self.LoadFixAddress != 0:
1788                         #
1789                         # Rebase module to the preferred memory address before GenFds
1790                         #
1791                         self._CollectModuleMapBuffer(MapBuffer, ModuleList)
1792                     if self.Fdf:
1793                         #
1794                         # create FDS again for the updated EFI image
1795                         #
1796                         self._Build("fds", Wa)
1797                         #
1798                         # Create MAP file for all platform FVs after GenFds.
1799                         #
1800                         self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)
1801                     #
1802                     # Save MAP buffer into MAP file.
1803                     #
1804                     self._SaveMapFile (MapBuffer, Wa)
1805
1806     ## Build active module for different build targets, different tool chains and different archs
1807     #
1808     def _BuildModule(self):
1809         for BuildTarget in self.BuildTargetList:
1810             GlobalData.gGlobalDefines['TARGET'] = BuildTarget
1811             index = 0
1812             for ToolChain in self.ToolChainList:
1813                 WorkspaceAutoGenTime = time.time()
1814                 GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain
1815                 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain
1816                 GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[index]
1817                 index += 1
1818                 #
1819                 # module build needs platform build information, so get platform
1820                 # AutoGen first
1821                 #
1822                 Wa = WorkspaceAutoGen(
1823                         self.WorkspaceDir,
1824                         self.PlatformFile,
1825                         BuildTarget,
1826                         ToolChain,
1827                         self.ArchList,
1828                         self.BuildDatabase,
1829                         self.TargetTxt,
1830                         self.ToolDef,
1831                         self.Fdf,
1832                         self.FdList,
1833                         self.FvList,
1834                         self.CapList,
1835                         self.SkuId,
1836                         self.UniFlag,
1837                         self.Progress,
1838                         self.ModuleFile
1839                         )
1840                 self.Fdf = Wa.FdfFile
1841                 self.LoadFixAddress = Wa.Platform.LoadFixAddress
1842                 Wa.CreateMakeFile(False)
1843                 # Add ffs build to makefile
1844                 CmdListDict = None
1845                 if GlobalData.gEnableGenfdsMultiThread and self.Fdf:
1846                     CmdListDict = self._GenFfsCmd()
1847                 self.Progress.Stop("done!")
1848                 MaList = []
1849                 ExitFlag = threading.Event()
1850                 ExitFlag.clear()
1851                 self.AutoGenTime += int(round((time.time() - WorkspaceAutoGenTime)))
1852                 for Arch in Wa.ArchList:
1853                     AutoGenStart = time.time()
1854                     GlobalData.gGlobalDefines['ARCH'] = Arch
1855                     Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)
1856                     for Module in Pa.Platform.Modules:
1857                         if self.ModuleFile.Dir == Module.Dir and self.ModuleFile.Name == Module.Name:
1858                             Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)
1859                             if Ma is None: continue
1860                             MaList.append(Ma)
1861                             if Ma.CanSkipbyHash():
1862                                 self.HashSkipModules.append(Ma)
1863                                 continue
1864                             # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'
1865                             if self.Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
1866                                 # for target which must generate AutoGen code and makefile
1867                                 if not self.SkipAutoGen or self.Target == 'genc':
1868                                     self.Progress.Start("Generating code")
1869                                     Ma.CreateCodeFile(True)
1870                                     self.Progress.Stop("done!")
1871                                 if self.Target == "genc":
1872                                     return True
1873                                 if not self.SkipAutoGen or self.Target == 'genmake':
1874                                     self.Progress.Start("Generating makefile")
1875                                     if CmdListDict and self.Fdf and (Module.File, Arch) in CmdListDict:
1876                                         Ma.CreateMakeFile(True, CmdListDict[Module.File, Arch])
1877                                         del CmdListDict[Module.File, Arch]
1878                                     else:
1879                                         Ma.CreateMakeFile(True)
1880                                     self.Progress.Stop("done!")
1881                                 if self.Target == "genmake":
1882                                     return True
1883                             self.BuildModules.append(Ma)
1884                     self.AutoGenTime += int(round((time.time() - AutoGenStart)))
1885                     MakeStart = time.time()
1886                     for Ma in self.BuildModules:
1887                         if not Ma.IsBinaryModule:
1888                             Bt = BuildTask.New(ModuleMakeUnit(Ma, self.Target))
1889                         # Break build if any build thread has error
1890                         if BuildTask.HasError():
1891                             # we need a full version of makefile for platform
1892                             ExitFlag.set()
1893                             BuildTask.WaitForComplete()
1894                             Pa.CreateMakeFile(False)
1895                             EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)
1896                         # Start task scheduler
1897                         if not BuildTask.IsOnGoing():
1898                             BuildTask.StartScheduler(self.ThreadNumber, ExitFlag)
1899
1900                     # in case there's an interruption. we need a full version of makefile for platform
1901                     Pa.CreateMakeFile(False)
1902                     if BuildTask.HasError():
1903                         EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)
1904                     self.MakeTime += int(round((time.time() - MakeStart)))
1905
1906                 MakeContiue = time.time()
1907                 ExitFlag.set()
1908                 BuildTask.WaitForComplete()
1909                 self.CreateAsBuiltInf()
1910                 self.MakeTime += int(round((time.time() - MakeContiue)))
1911                 if BuildTask.HasError():
1912                     EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)
1913
1914                 self.BuildReport.AddPlatformReport(Wa, MaList)
1915                 if MaList == []:
1916                     EdkLogger.error(
1917                                 'build',
1918                                 BUILD_ERROR,
1919                                 "Module for [%s] is not a component of active platform."\
1920                                 " Please make sure that the ARCH and inf file path are"\
1921                                 " given in the same as in [%s]" % \
1922                                     (', '.join(Wa.ArchList), self.PlatformFile),
1923                                 ExtraData=self.ModuleFile
1924                                 )
1925                 # Create MAP file when Load Fix Address is enabled.
1926                 if self.Target == "fds" and self.Fdf:
1927                     for Arch in Wa.ArchList:
1928                         #
1929                         # Check whether the set fix address is above 4G for 32bit image.
1930                         #
1931                         if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:
1932                             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")
1933                     #
1934                     # Get Module List
1935                     #
1936                     ModuleList = {}
1937                     for Pa in Wa.AutoGenObjectList:
1938                         for Ma in Pa.ModuleAutoGenList:
1939                             if Ma is None:
1940                                 continue
1941                             if not Ma.IsLibrary:
1942                                 ModuleList[Ma.Guid.upper()] = Ma
1943
1944                     MapBuffer = StringIO('')
1945                     if self.LoadFixAddress != 0:
1946                         #
1947                         # Rebase module to the preferred memory address before GenFds
1948                         #
1949                         self._CollectModuleMapBuffer(MapBuffer, ModuleList)
1950                     #
1951                     # create FDS again for the updated EFI image
1952                     #
1953                     GenFdsStart = time.time()
1954                     self._Build("fds", Wa)
1955                     self.GenFdsTime += int(round((time.time() - GenFdsStart)))
1956                     #
1957                     # Create MAP file for all platform FVs after GenFds.
1958                     #
1959                     self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)
1960                     #
1961                     # Save MAP buffer into MAP file.
1962                     #
1963                     self._SaveMapFile (MapBuffer, Wa)
1964
1965     def _GenFfsCmd(self):
1966         CmdListDict = {}
1967         GenFfsDict = GenFds.GenFfsMakefile('', GlobalData.gFdfParser, self, self.ArchList, GlobalData)
1968         for Cmd in GenFfsDict:
1969             tmpInf, tmpArch = GenFfsDict[Cmd]
1970             if (tmpInf, tmpArch) not in CmdListDict.keys():
1971                 CmdListDict[tmpInf, tmpArch] = [Cmd]
1972             else:
1973                 CmdListDict[tmpInf, tmpArch].append(Cmd)
1974         return CmdListDict
1975
1976     ## Build a platform in multi-thread mode
1977     #
1978     def _MultiThreadBuildPlatform(self):
1979         SaveFileOnChange(self.PlatformBuildPath, '# DO NOT EDIT \n# FILE auto-generated\n', False)
1980         for BuildTarget in self.BuildTargetList:
1981             GlobalData.gGlobalDefines['TARGET'] = BuildTarget
1982             index = 0
1983             for ToolChain in self.ToolChainList:
1984                 WorkspaceAutoGenTime = time.time()
1985                 GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain
1986                 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain
1987                 GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[index]
1988                 index += 1
1989                 Wa = WorkspaceAutoGen(
1990                         self.WorkspaceDir,
1991                         self.PlatformFile,
1992                         BuildTarget,
1993                         ToolChain,
1994                         self.ArchList,
1995                         self.BuildDatabase,
1996                         self.TargetTxt,
1997                         self.ToolDef,
1998                         self.Fdf,
1999                         self.FdList,
2000                         self.FvList,
2001                         self.CapList,
2002                         self.SkuId,
2003                         self.UniFlag,
2004                         self.Progress
2005                         )
2006                 self.Fdf = Wa.FdfFile
2007                 self.LoadFixAddress = Wa.Platform.LoadFixAddress
2008                 self.BuildReport.AddPlatformReport(Wa)
2009                 Wa.CreateMakeFile(False)
2010
2011                 # Add ffs build to makefile
2012                 CmdListDict = None
2013                 if GlobalData.gEnableGenfdsMultiThread and self.Fdf:
2014                     CmdListDict = self._GenFfsCmd()
2015
2016                 # multi-thread exit flag
2017                 ExitFlag = threading.Event()
2018                 ExitFlag.clear()
2019                 self.AutoGenTime += int(round((time.time() - WorkspaceAutoGenTime)))
2020                 for Arch in Wa.ArchList:
2021                     AutoGenStart = time.time()
2022                     GlobalData.gGlobalDefines['ARCH'] = Arch
2023                     Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)
2024                     if Pa is None:
2025                         continue
2026                     ModuleList = []
2027                     for Inf in Pa.Platform.Modules:
2028                         ModuleList.append(Inf)
2029                     # Add the INF only list in FDF
2030                     if GlobalData.gFdfParser is not None:
2031                         for InfName in GlobalData.gFdfParser.Profile.InfList:
2032                             Inf = PathClass(NormPath(InfName), self.WorkspaceDir, Arch)
2033                             if Inf in Pa.Platform.Modules:
2034                                 continue
2035                             ModuleList.append(Inf)
2036                     for Module in ModuleList:
2037                         # Get ModuleAutoGen object to generate C code file and makefile
2038                         Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)
2039
2040                         if Ma is None:
2041                             continue
2042                         if Ma.CanSkipbyHash():
2043                             self.HashSkipModules.append(Ma)
2044                             continue
2045
2046                         # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'
2047                         if self.Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:
2048                             # for target which must generate AutoGen code and makefile
2049                             if not self.SkipAutoGen or self.Target == 'genc':
2050                                 Ma.CreateCodeFile(True)
2051                             if self.Target == "genc":
2052                                 continue
2053
2054                             if not self.SkipAutoGen or self.Target == 'genmake':
2055                                 if CmdListDict and self.Fdf and (Module.File, Arch) in CmdListDict:
2056                                     Ma.CreateMakeFile(True, CmdListDict[Module.File, Arch])
2057                                     del CmdListDict[Module.File, Arch]
2058                                 else:
2059                                     Ma.CreateMakeFile(True)
2060                             if self.Target == "genmake":
2061                                 continue
2062                         self.BuildModules.append(Ma)
2063                     self.Progress.Stop("done!")
2064                     self.AutoGenTime += int(round((time.time() - AutoGenStart)))
2065                     MakeStart = time.time()
2066                     for Ma in self.BuildModules:
2067                         # Generate build task for the module
2068                         if not Ma.IsBinaryModule:
2069                             Bt = BuildTask.New(ModuleMakeUnit(Ma, self.Target))
2070                         # Break build if any build thread has error
2071                         if BuildTask.HasError():
2072                             # we need a full version of makefile for platform
2073                             ExitFlag.set()
2074                             BuildTask.WaitForComplete()
2075                             Pa.CreateMakeFile(False)
2076                             EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)
2077                         # Start task scheduler
2078                         if not BuildTask.IsOnGoing():
2079                             BuildTask.StartScheduler(self.ThreadNumber, ExitFlag)
2080
2081                     # in case there's an interruption. we need a full version of makefile for platform
2082                     Pa.CreateMakeFile(False)
2083                     if BuildTask.HasError():
2084                         EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)
2085                     self.MakeTime += int(round((time.time() - MakeStart)))
2086
2087                 MakeContiue = time.time()
2088                 #
2089                 # Save temp tables to a TmpTableDict.
2090                 #
2091                 for Key in Wa.BuildDatabase._CACHE_:
2092                     if Wa.BuildDatabase._CACHE_[Key]._RawData and Wa.BuildDatabase._CACHE_[Key]._RawData._Table and Wa.BuildDatabase._CACHE_[Key]._RawData._Table.Table:
2093                         if TemporaryTablePattern.match(Wa.BuildDatabase._CACHE_[Key]._RawData._Table.Table):
2094                             TmpTableDict[Wa.BuildDatabase._CACHE_[Key]._RawData._Table.Table] = Wa.BuildDatabase._CACHE_[Key]._RawData._Table.Cur
2095                 #
2096                 #
2097                 # All modules have been put in build tasks queue. Tell task scheduler
2098                 # to exit if all tasks are completed
2099                 #
2100                 ExitFlag.set()
2101                 BuildTask.WaitForComplete()
2102                 self.CreateAsBuiltInf()
2103                 self.MakeTime += int(round((time.time() - MakeContiue)))
2104                 #
2105                 # Check for build error, and raise exception if one
2106                 # has been signaled.
2107                 #
2108                 if BuildTask.HasError():
2109                     EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)
2110
2111                 # Create MAP file when Load Fix Address is enabled.
2112                 if self.Target in ["", "all", "fds"]:
2113                     for Arch in Wa.ArchList:
2114                         #
2115                         # Check whether the set fix address is above 4G for 32bit image.
2116                         #
2117                         if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:
2118                             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")
2119                     #
2120                     # Get Module List
2121                     #
2122                     ModuleList = {}
2123                     for Pa in Wa.AutoGenObjectList:
2124                         for Ma in Pa.ModuleAutoGenList:
2125                             if Ma is None:
2126                                 continue
2127                             if not Ma.IsLibrary:
2128                                 ModuleList[Ma.Guid.upper()] = Ma
2129                     #
2130                     # Rebase module to the preferred memory address before GenFds
2131                     #
2132                     MapBuffer = StringIO('')
2133                     if self.LoadFixAddress != 0:
2134                         self._CollectModuleMapBuffer(MapBuffer, ModuleList)
2135
2136                     if self.Fdf:
2137                         #
2138                         # Generate FD image if there's a FDF file found
2139                         #
2140                         GenFdsStart = time.time()
2141                         LaunchCommand(Wa.GenFdsCommand, os.getcwd())
2142
2143                         #
2144                         # Create MAP file for all platform FVs after GenFds.
2145                         #
2146                         self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)
2147                         self.GenFdsTime += int(round((time.time() - GenFdsStart)))
2148                     #
2149                     # Save MAP buffer into MAP file.
2150                     #
2151                     self._SaveMapFile(MapBuffer, Wa)
2152
2153     ## Generate GuidedSectionTools.txt in the FV directories.
2154     #
2155     def CreateGuidedSectionToolsFile(self):
2156         for BuildTarget in self.BuildTargetList:
2157             for ToolChain in self.ToolChainList:
2158                 Wa = WorkspaceAutoGen(
2159                         self.WorkspaceDir,
2160                         self.PlatformFile,
2161                         BuildTarget,
2162                         ToolChain,
2163                         self.ArchList,
2164                         self.BuildDatabase,
2165                         self.TargetTxt,
2166                         self.ToolDef,
2167                         self.Fdf,
2168                         self.FdList,
2169                         self.FvList,
2170                         self.CapList,
2171                         self.SkuId,
2172                         self.UniFlag
2173                         )
2174                 FvDir = Wa.FvDir
2175                 if not os.path.exists(FvDir):
2176                     continue
2177
2178                 for Arch in self.ArchList:
2179                     # Build up the list of supported architectures for this build
2180                     prefix = '%s_%s_%s_' % (BuildTarget, ToolChain, Arch)
2181
2182                     # Look through the tool definitions for GUIDed tools
2183                     guidAttribs = []
2184                     for (attrib, value) in self.ToolDef.ToolsDefTxtDictionary.iteritems():
2185                         if attrib.upper().endswith('_GUID'):
2186                             split = attrib.split('_')
2187                             thisPrefix = '_'.join(split[0:3]) + '_'
2188                             if thisPrefix == prefix:
2189                                 guid = self.ToolDef.ToolsDefTxtDictionary[attrib]
2190                                 guid = guid.lower()
2191                                 toolName = split[3]
2192                                 path = '_'.join(split[0:4]) + '_PATH'
2193                                 path = self.ToolDef.ToolsDefTxtDictionary[path]
2194                                 path = self.GetFullPathOfTool(path)
2195                                 guidAttribs.append((guid, toolName, path))
2196
2197                     # Write out GuidedSecTools.txt
2198                     toolsFile = os.path.join(FvDir, 'GuidedSectionTools.txt')
2199                     toolsFile = open(toolsFile, 'wt')
2200                     for guidedSectionTool in guidAttribs:
2201                         print >> toolsFile, ' '.join(guidedSectionTool)
2202                     toolsFile.close()
2203
2204     ## Returns the full path of the tool.
2205     #
2206     def GetFullPathOfTool (self, tool):
2207         if os.path.exists(tool):
2208             return os.path.realpath(tool)
2209         else:
2210             # We need to search for the tool using the
2211             # PATH environment variable.
2212             for dirInPath in os.environ['PATH'].split(os.pathsep):
2213                 foundPath = os.path.join(dirInPath, tool)
2214                 if os.path.exists(foundPath):
2215                     return os.path.realpath(foundPath)
2216
2217         # If the tool was not found in the path then we just return
2218         # the input tool.
2219         return tool
2220
2221     ## Launch the module or platform build
2222     #
2223     def Launch(self):
2224         if not self.ModuleFile:
2225             if not self.SpawnMode or self.Target not in ["", "all"]:
2226                 self.SpawnMode = False
2227                 self._BuildPlatform()
2228             else:
2229                 self._MultiThreadBuildPlatform()
2230             self.CreateGuidedSectionToolsFile()
2231         else:
2232             self.SpawnMode = False
2233             self._BuildModule()
2234
2235         if self.Target == 'cleanall':
2236             self.Db.Close()
2237             RemoveDirectory(os.path.dirname(GlobalData.gDatabasePath), True)
2238
2239     def CreateAsBuiltInf(self):
2240         for Module in self.BuildModules:
2241             Module.CreateAsBuiltInf()
2242         for Module in self.HashSkipModules:
2243             Module.CreateAsBuiltInf(True)
2244         self.BuildModules = []
2245         self.HashSkipModules = []
2246     ## Do some clean-up works when error occurred
2247     def Relinquish(self):
2248         OldLogLevel = EdkLogger.GetLevel()
2249         EdkLogger.SetLevel(EdkLogger.ERROR)
2250         #self.DumpBuildData()
2251         Utils.Progressor.Abort()
2252         if self.SpawnMode == True:
2253             BuildTask.Abort()
2254         EdkLogger.SetLevel(OldLogLevel)
2255
2256     def DumpBuildData(self):
2257         CacheDirectory = os.path.dirname(GlobalData.gDatabasePath)
2258         Utils.CreateDirectory(CacheDirectory)
2259         Utils.DataDump(Utils.gFileTimeStampCache, os.path.join(CacheDirectory, "gFileTimeStampCache"))
2260         Utils.DataDump(Utils.gDependencyDatabase, os.path.join(CacheDirectory, "gDependencyDatabase"))
2261
2262     def RestoreBuildData(self):
2263         FilePath = os.path.join(os.path.dirname(GlobalData.gDatabasePath), "gFileTimeStampCache")
2264         if Utils.gFileTimeStampCache == {} and os.path.isfile(FilePath):
2265             Utils.gFileTimeStampCache = Utils.DataRestore(FilePath)
2266             if Utils.gFileTimeStampCache is None:
2267                 Utils.gFileTimeStampCache = {}
2268
2269         FilePath = os.path.join(os.path.dirname(GlobalData.gDatabasePath), "gDependencyDatabase")
2270         if Utils.gDependencyDatabase == {} and os.path.isfile(FilePath):
2271             Utils.gDependencyDatabase = Utils.DataRestore(FilePath)
2272             if Utils.gDependencyDatabase is None:
2273                 Utils.gDependencyDatabase = {}
2274
2275 def ParseDefines(DefineList=[]):
2276     DefineDict = {}
2277     if DefineList is not None:
2278         for Define in DefineList:
2279             DefineTokenList = Define.split("=", 1)
2280             if not GlobalData.gMacroNamePattern.match(DefineTokenList[0]):
2281                 EdkLogger.error('build', FORMAT_INVALID,
2282                                 "The macro name must be in the pattern [A-Z][A-Z0-9_]*",
2283                                 ExtraData=DefineTokenList[0])
2284
2285             if len(DefineTokenList) == 1:
2286                 DefineDict[DefineTokenList[0]] = "TRUE"
2287             else:
2288                 DefineDict[DefineTokenList[0]] = DefineTokenList[1].strip()
2289     return DefineDict
2290
2291 gParamCheck = []
2292 def SingleCheckCallback(option, opt_str, value, parser):
2293     if option not in gParamCheck:
2294         setattr(parser.values, option.dest, value)
2295         gParamCheck.append(option)
2296     else:
2297         parser.error("Option %s only allows one instance in command line!" % option)
2298
2299 def LogBuildTime(Time):
2300     if Time:
2301         TimeDurStr = ''
2302         TimeDur = time.gmtime(Time)
2303         if TimeDur.tm_yday > 1:
2304             TimeDurStr = time.strftime("%H:%M:%S", TimeDur) + ", %d day(s)" % (TimeDur.tm_yday - 1)
2305         else:
2306             TimeDurStr = time.strftime("%H:%M:%S", TimeDur)
2307         return TimeDurStr
2308     else:
2309         return None
2310
2311 ## Parse command line options
2312 #
2313 # Using standard Python module optparse to parse command line option of this tool.
2314 #
2315 #   @retval Opt   A optparse.Values object containing the parsed options
2316 #   @retval Args  Target of build command
2317 #
2318 def MyOptionParser():
2319     Parser = OptionParser(description=__copyright__, version=__version__, prog="build.exe", usage="%prog [options] [all|fds|genc|genmake|clean|cleanall|cleanlib|modules|libraries|run]")
2320     Parser.add_option("-a", "--arch", action="append", type="choice", choices=['IA32', 'X64', 'IPF', 'EBC', 'ARM', 'AARCH64'], dest="TargetArch",
2321         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.")
2322     Parser.add_option("-p", "--platform", action="callback", type="string", dest="PlatformFile", callback=SingleCheckCallback,
2323         help="Build the platform specified by the DSC file name argument, overriding target.txt's ACTIVE_PLATFORM definition.")
2324     Parser.add_option("-m", "--module", action="callback", type="string", dest="ModuleFile", callback=SingleCheckCallback,
2325         help="Build the module specified by the INF file name argument.")
2326     Parser.add_option("-b", "--buildtarget", type="string", dest="BuildTarget", help="Using the TARGET to build the platform, overriding target.txt's TARGET definition.",
2327                       action="append")
2328     Parser.add_option("-t", "--tagname", action="append", type="string", dest="ToolChain",
2329         help="Using the Tool Chain Tagname to build the platform, overriding target.txt's TOOL_CHAIN_TAG definition.")
2330     Parser.add_option("-x", "--sku-id", action="callback", type="string", dest="SkuId", callback=SingleCheckCallback,
2331         help="Using this name of SKU ID to build the platform, overriding SKUID_IDENTIFIER in DSC file.")
2332
2333     Parser.add_option("-n", action="callback", type="int", dest="ThreadNumber", callback=SingleCheckCallback,
2334         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 "\
2335              "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.")
2336
2337     Parser.add_option("-f", "--fdf", action="callback", type="string", dest="FdfFile", callback=SingleCheckCallback,
2338         help="The name of the FDF file to use, which overrides the setting in the DSC file.")
2339     Parser.add_option("-r", "--rom-image", action="append", type="string", dest="RomImage", default=[],
2340         help="The name of FD to be generated. The name must be from [FD] section in FDF file.")
2341     Parser.add_option("-i", "--fv-image", action="append", type="string", dest="FvImage", default=[],
2342         help="The name of FV to be generated. The name must be from [FV] section in FDF file.")
2343     Parser.add_option("-C", "--capsule-image", action="append", type="string", dest="CapName", default=[],
2344         help="The name of Capsule to be generated. The name must be from [Capsule] section in FDF file.")
2345     Parser.add_option("-u", "--skip-autogen", action="store_true", dest="SkipAutoGen", help="Skip AutoGen step.")
2346     Parser.add_option("-e", "--re-parse", action="store_true", dest="Reparse", help="Re-parse all meta-data files.")
2347
2348     Parser.add_option("-c", "--case-insensitive", action="store_true", dest="CaseInsensitive", default=False, help="Don't check case of file name.")
2349
2350     Parser.add_option("-w", "--warning-as-error", action="store_true", dest="WarningAsError", help="Treat warning in tools as error.")
2351     Parser.add_option("-j", "--log", action="store", dest="LogFile", help="Put log in specified file as well as on console.")
2352
2353     Parser.add_option("-s", "--silent", action="store_true", type=None, dest="SilentMode",
2354         help="Make use of silent mode of (n)make.")
2355     Parser.add_option("-q", "--quiet", action="store_true", type=None, help="Disable all messages except FATAL ERRORS.")
2356     Parser.add_option("-v", "--verbose", action="store_true", type=None, help="Turn on verbose output with informational messages printed, "\
2357                                                                                "including library instances selected, final dependency expression, "\
2358                                                                                "and warning messages, etc.")
2359     Parser.add_option("-d", "--debug", action="store", type="int", help="Enable debug messages at specified level.")
2360     Parser.add_option("-D", "--define", action="append", type="string", dest="Macros", help="Macro: \"Name [= Value]\".")
2361
2362     Parser.add_option("-y", "--report-file", action="store", dest="ReportFile", help="Create/overwrite the report to the specified filename.")
2363     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=[],
2364         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].  "\
2365              "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]")
2366     Parser.add_option("-F", "--flag", action="store", type="string", dest="Flag",
2367         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. "\
2368              "This option can also be specified by setting *_*_*_BUILD_FLAGS in [BuildOptions] section of platform DSC. If they are both specified, this value "\
2369              "will override the setting in [BuildOptions] section of platform DSC.")
2370     Parser.add_option("-N", "--no-cache", action="store_true", dest="DisableCache", default=False, help="Disable build cache mechanism")
2371     Parser.add_option("--conf", action="store", type="string", dest="ConfDirectory", help="Specify the customized Conf directory.")
2372     Parser.add_option("--check-usage", action="store_true", dest="CheckUsage", default=False, help="Check usage content of entries listed in INF file.")
2373     Parser.add_option("--ignore-sources", action="store_true", dest="IgnoreSources", default=False, help="Focus to a binary build and ignore all source files")
2374     Parser.add_option("--pcd", action="append", dest="OptionPcd", help="Set PCD value by command line. Format: \"PcdName=Value\" ")
2375     Parser.add_option("-l", "--cmd-len", action="store", type="int", dest="CommandLength", help="Specify the maximum line length of build command. Default is 4096.")
2376     Parser.add_option("--hash", action="store_true", dest="UseHashCache", default=False, help="Enable hash-based caching during build process.")
2377     Parser.add_option("--binary-destination", action="store", type="string", dest="BinCacheDest", help="Generate a cache of binary files in the specified directory.")
2378     Parser.add_option("--binary-source", action="store", type="string", dest="BinCacheSource", help="Consume a cache of binary files from the specified directory.")
2379     Parser.add_option("--genfds-multi-thread", action="store_true", dest="GenfdsMultiThread", default=False, help="Enable GenFds multi thread to generate ffs file.")
2380     (Opt, Args) = Parser.parse_args()
2381     return (Opt, Args)
2382
2383 ## Tool entrance method
2384 #
2385 # This method mainly dispatch specific methods per the command line options.
2386 # If no error found, return zero value so the caller of this tool can know
2387 # if it's executed successfully or not.
2388 #
2389 #   @retval 0     Tool was successful
2390 #   @retval 1     Tool failed
2391 #
2392 def Main():
2393     StartTime = time.time()
2394
2395     # Initialize log system
2396     EdkLogger.Initialize()
2397     GlobalData.gCommand = sys.argv[1:]
2398     #
2399     # Parse the options and args
2400     #
2401     (Option, Target) = MyOptionParser()
2402     GlobalData.gOptions = Option
2403     GlobalData.gCaseInsensitive = Option.CaseInsensitive
2404
2405     # Set log level
2406     if Option.verbose is not None:
2407         EdkLogger.SetLevel(EdkLogger.VERBOSE)
2408     elif Option.quiet is not None:
2409         EdkLogger.SetLevel(EdkLogger.QUIET)
2410     elif Option.debug is not None:
2411         EdkLogger.SetLevel(Option.debug + 1)
2412     else:
2413         EdkLogger.SetLevel(EdkLogger.INFO)
2414
2415     if Option.LogFile is not None:
2416         EdkLogger.SetLogFile(Option.LogFile)
2417
2418     if Option.WarningAsError == True:
2419         EdkLogger.SetWarningAsError()
2420
2421     if platform.platform().find("Windows") >= 0:
2422         GlobalData.gIsWindows = True
2423     else:
2424         GlobalData.gIsWindows = False
2425
2426     EdkLogger.quiet("Build environment: %s" % platform.platform())
2427     EdkLogger.quiet(time.strftime("Build start time: %H:%M:%S, %b.%d %Y\n", time.localtime()));
2428     ReturnCode = 0
2429     MyBuild = None
2430     BuildError = True
2431     try:
2432         if len(Target) == 0:
2433             Target = "all"
2434         elif len(Target) >= 2:
2435             EdkLogger.error("build", OPTION_NOT_SUPPORTED, "More than one targets are not supported.",
2436                             ExtraData="Please select one of: %s" % (' '.join(gSupportedTarget)))
2437         else:
2438             Target = Target[0].lower()
2439
2440         if Target not in gSupportedTarget:
2441             EdkLogger.error("build", OPTION_NOT_SUPPORTED, "Not supported target [%s]." % Target,
2442                             ExtraData="Please select one of: %s" % (' '.join(gSupportedTarget)))
2443
2444         #
2445         # Check environment variable: EDK_TOOLS_PATH, WORKSPACE, PATH
2446         #
2447         CheckEnvVariable()
2448         GlobalData.gCommandLineDefines.update(ParseDefines(Option.Macros))
2449
2450         Workspace = os.getenv("WORKSPACE")
2451         #
2452         # Get files real name in workspace dir
2453         #
2454         GlobalData.gAllFiles = Utils.DirCache(Workspace)
2455
2456         WorkingDirectory = os.getcwd()
2457         if not Option.ModuleFile:
2458             FileList = glob.glob(os.path.normpath(os.path.join(WorkingDirectory, '*.inf')))
2459             FileNum = len(FileList)
2460             if FileNum >= 2:
2461                 EdkLogger.error("build", OPTION_NOT_SUPPORTED, "There are %d INF files in %s." % (FileNum, WorkingDirectory),
2462                                 ExtraData="Please use '-m <INF_FILE_PATH>' switch to choose one.")
2463             elif FileNum == 1:
2464                 Option.ModuleFile = NormFile(FileList[0], Workspace)
2465
2466         if Option.ModuleFile:
2467             if os.path.isabs (Option.ModuleFile):
2468                 if os.path.normcase (os.path.normpath(Option.ModuleFile)).find (Workspace) == 0:
2469                     Option.ModuleFile = NormFile(os.path.normpath(Option.ModuleFile), Workspace)
2470             Option.ModuleFile = PathClass(Option.ModuleFile, Workspace)
2471             ErrorCode, ErrorInfo = Option.ModuleFile.Validate(".inf", False)
2472             if ErrorCode != 0:
2473                 EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)
2474
2475         if Option.PlatformFile is not None:
2476             if os.path.isabs (Option.PlatformFile):
2477                 if os.path.normcase (os.path.normpath(Option.PlatformFile)).find (Workspace) == 0:
2478                     Option.PlatformFile = NormFile(os.path.normpath(Option.PlatformFile), Workspace)
2479             Option.PlatformFile = PathClass(Option.PlatformFile, Workspace)
2480
2481         if Option.FdfFile is not None:
2482             if os.path.isabs (Option.FdfFile):
2483                 if os.path.normcase (os.path.normpath(Option.FdfFile)).find (Workspace) == 0:
2484                     Option.FdfFile = NormFile(os.path.normpath(Option.FdfFile), Workspace)
2485             Option.FdfFile = PathClass(Option.FdfFile, Workspace)
2486             ErrorCode, ErrorInfo = Option.FdfFile.Validate(".fdf", False)
2487             if ErrorCode != 0:
2488                 EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)
2489
2490         if Option.Flag is not None and Option.Flag not in ['-c', '-s']:
2491             EdkLogger.error("build", OPTION_VALUE_INVALID, "UNI flag must be one of -c or -s")
2492
2493         MyBuild = Build(Target, Workspace, Option)
2494         GlobalData.gCommandLineDefines['ARCH'] = ' '.join(MyBuild.ArchList)
2495         if not (MyBuild.LaunchPrebuildFlag and os.path.exists(MyBuild.PlatformBuildPath)):
2496             MyBuild.Launch()
2497         # Drop temp tables to avoid database locked.
2498         for TmpTableName in TmpTableDict:
2499             SqlCommand = """drop table IF EXISTS %s""" % TmpTableName
2500             TmpTableDict[TmpTableName].execute(SqlCommand)
2501         #MyBuild.DumpBuildData()
2502         #
2503         # All job done, no error found and no exception raised
2504         #
2505         BuildError = False
2506     except FatalError, X:
2507         if MyBuild is not None:
2508             # for multi-thread build exits safely
2509             MyBuild.Relinquish()
2510         if Option is not None and Option.debug is not None:
2511             EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())
2512         ReturnCode = X.args[0]
2513     except Warning, X:
2514         # error from Fdf parser
2515         if MyBuild is not None:
2516             # for multi-thread build exits safely
2517             MyBuild.Relinquish()
2518         if Option is not None and Option.debug is not None:
2519             EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())
2520         else:
2521             EdkLogger.error(X.ToolName, FORMAT_INVALID, File=X.FileName, Line=X.LineNumber, ExtraData=X.Message, RaiseError=False)
2522         ReturnCode = FORMAT_INVALID
2523     except KeyboardInterrupt:
2524         ReturnCode = ABORT_ERROR
2525         if Option is not None and Option.debug is not None:
2526             EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())
2527     except:
2528         if MyBuild is not None:
2529             # for multi-thread build exits safely
2530             MyBuild.Relinquish()
2531
2532         # try to get the meta-file from the object causing exception
2533         Tb = sys.exc_info()[-1]
2534         MetaFile = GlobalData.gProcessingFile
2535         while Tb is not None:
2536             if 'self' in Tb.tb_frame.f_locals and hasattr(Tb.tb_frame.f_locals['self'], 'MetaFile'):
2537                 MetaFile = Tb.tb_frame.f_locals['self'].MetaFile
2538             Tb = Tb.tb_next
2539         EdkLogger.error(
2540                     "\nbuild",
2541                     CODE_ERROR,
2542                     "Unknown fatal error when processing [%s]" % MetaFile,
2543                     ExtraData="\n(Please send email to edk2-devel@lists.01.org for help, attaching following call stack trace!)\n",
2544                     RaiseError=False
2545                     )
2546         EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())
2547         ReturnCode = CODE_ERROR
2548     finally:
2549         Utils.Progressor.Abort()
2550         Utils.ClearDuplicatedInf()
2551
2552     if ReturnCode == 0:
2553         try:
2554             MyBuild.LaunchPostbuild()
2555             Conclusion = "Done"
2556         except:
2557             Conclusion = "Failed"
2558     elif ReturnCode == ABORT_ERROR:
2559         Conclusion = "Aborted"
2560     else:
2561         Conclusion = "Failed"
2562     FinishTime = time.time()
2563     BuildDuration = time.gmtime(int(round(FinishTime - StartTime)))
2564     BuildDurationStr = ""
2565     if BuildDuration.tm_yday > 1:
2566         BuildDurationStr = time.strftime("%H:%M:%S", BuildDuration) + ", %d day(s)" % (BuildDuration.tm_yday - 1)
2567     else:
2568         BuildDurationStr = time.strftime("%H:%M:%S", BuildDuration)
2569     if MyBuild is not None:
2570         if not BuildError:
2571             MyBuild.BuildReport.GenerateReport(BuildDurationStr, LogBuildTime(MyBuild.AutoGenTime), LogBuildTime(MyBuild.MakeTime), LogBuildTime(MyBuild.GenFdsTime))
2572         MyBuild.Db.Close()
2573     EdkLogger.SetLevel(EdkLogger.QUIET)
2574     EdkLogger.quiet("\n- %s -" % Conclusion)
2575     EdkLogger.quiet(time.strftime("Build end time: %H:%M:%S, %b.%d %Y", time.localtime()))
2576     EdkLogger.quiet("Build total time: %s\n" % BuildDurationStr)
2577     return ReturnCode
2578
2579 if __name__ == '__main__':
2580     r = Main()
2581     ## 0-127 is a safe return range, and 1 is a standard default error
2582     if r < 0 or r > 127: r = 1
2583     sys.exit(r)
2584