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