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