BaseTools: Refactor hash tracking after checking for Sources section

[mirror_edk2.git] / BaseTools / Source / Python / build / build.py

## @file\r
# build a platform or a module\r
#\r
#  Copyright (c) 2014, Hewlett-Packard Development Company, L.P.<BR>\r
#  Copyright (c) 2007 - 2019, Intel Corporation. All rights reserved.<BR>\r
#  Copyright (c) 2018, Hewlett Packard Enterprise Development, L.P.<BR>\r
#\r
#  SPDX-License-Identifier: BSD-2-Clause-Patent\r
#\r
\r
##\r
# Import Modules\r
#\r
from __future__ import print_function\r
import Common.LongFilePathOs as os\r
import re\r
import sys\r
import glob\r
import time\r
import platform\r
import traceback\r
import encodings.ascii\r
import multiprocessing\r
\r
from struct import *\r
from threading import *\r
import threading\r
from optparse import OptionParser\r
from subprocess import *\r
from Common import Misc as Utils\r
\r
from Common.LongFilePathSupport import OpenLongFilePath as open\r
from Common.TargetTxtClassObject import TargetTxtClassObject\r
from Common.ToolDefClassObject import ToolDefClassObject\r
from Common.DataType import *\r
from Common.BuildVersion import gBUILD_VERSION\r
from AutoGen.AutoGen import *\r
from Common.BuildToolError import *\r
from Workspace.WorkspaceDatabase import WorkspaceDatabase\r
from Common.MultipleWorkspace import MultipleWorkspace as mws\r
\r
from BuildReport import BuildReport\r
from GenPatchPcdTable.GenPatchPcdTable import *\r
from PatchPcdValue.PatchPcdValue import *\r
\r
import Common.EdkLogger\r
import Common.GlobalData as GlobalData\r
from GenFds.GenFds import GenFds, GenFdsApi\r
\r
from collections import OrderedDict, defaultdict\r
\r
# Version and Copyright\r
VersionNumber = "0.60" + ' ' + gBUILD_VERSION\r
__version__ = "%prog Version " + VersionNumber\r
__copyright__ = "Copyright (c) 2007 - 2018, Intel Corporation  All rights reserved."\r
\r
## standard targets of build command\r
gSupportedTarget = ['all', 'genc', 'genmake', 'modules', 'libraries', 'fds', 'clean', 'cleanall', 'cleanlib', 'run']\r
\r
## build configuration file\r
gBuildConfiguration = "target.txt"\r
gToolsDefinition = "tools_def.txt"\r
\r
TemporaryTablePattern = re.compile(r'^_\d+_\d+_[a-fA-F0-9]+$')\r
TmpTableDict = {}\r
\r
## Check environment PATH variable to make sure the specified tool is found\r
#\r
#   If the tool is found in the PATH, then True is returned\r
#   Otherwise, False is returned\r
#\r
def IsToolInPath(tool):\r
    if 'PATHEXT' in os.environ:\r
        extns = os.environ['PATHEXT'].split(os.path.pathsep)\r
    else:\r
        extns = ('',)\r
    for pathDir in os.environ['PATH'].split(os.path.pathsep):\r
        for ext in extns:\r
            if os.path.exists(os.path.join(pathDir, tool + ext)):\r
                return True\r
    return False\r
\r
## Check environment variables\r
#\r
#  Check environment variables that must be set for build. Currently they are\r
#\r
#   WORKSPACE           The directory all packages/platforms start from\r
#   EDK_TOOLS_PATH      The directory contains all tools needed by the build\r
#   PATH                $(EDK_TOOLS_PATH)/Bin/<sys> must be set in PATH\r
#\r
#   If any of above environment variable is not set or has error, the build\r
#   will be broken.\r
#\r
def CheckEnvVariable():\r
    # check WORKSPACE\r
    if "WORKSPACE" not in os.environ:\r
        EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "Environment variable not found",\r
                        ExtraData="WORKSPACE")\r
\r
    WorkspaceDir = os.path.normcase(os.path.normpath(os.environ["WORKSPACE"]))\r
    if not os.path.exists(WorkspaceDir):\r
        EdkLogger.error("build", FILE_NOT_FOUND, "WORKSPACE doesn't exist", ExtraData=WorkspaceDir)\r
    elif ' ' in WorkspaceDir:\r
        EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in WORKSPACE path",\r
                        ExtraData=WorkspaceDir)\r
    os.environ["WORKSPACE"] = WorkspaceDir\r
\r
    # set multiple workspace\r
    PackagesPath = os.getenv("PACKAGES_PATH")\r
    mws.setWs(WorkspaceDir, PackagesPath)\r
    if mws.PACKAGES_PATH:\r
        for Path in mws.PACKAGES_PATH:\r
            if not os.path.exists(Path):\r
                EdkLogger.error("build", FILE_NOT_FOUND, "One Path in PACKAGES_PATH doesn't exist", ExtraData=Path)\r
            elif ' ' in Path:\r
                EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in PACKAGES_PATH", ExtraData=Path)\r
\r
\r
    os.environ["EDK_TOOLS_PATH"] = os.path.normcase(os.environ["EDK_TOOLS_PATH"])\r
\r
    # check EDK_TOOLS_PATH\r
    if "EDK_TOOLS_PATH" not in os.environ:\r
        EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "Environment variable not found",\r
                        ExtraData="EDK_TOOLS_PATH")\r
\r
    # check PATH\r
    if "PATH" not in os.environ:\r
        EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "Environment variable not found",\r
                        ExtraData="PATH")\r
\r
    GlobalData.gWorkspace = WorkspaceDir\r
\r
    GlobalData.gGlobalDefines["WORKSPACE"]  = WorkspaceDir\r
    GlobalData.gGlobalDefines["EDK_TOOLS_PATH"] = os.environ["EDK_TOOLS_PATH"]\r
\r
## Get normalized file path\r
#\r
# Convert the path to be local format, and remove the WORKSPACE path at the\r
# beginning if the file path is given in full path.\r
#\r
# @param  FilePath      File path to be normalized\r
# @param  Workspace     Workspace path which the FilePath will be checked against\r
#\r
# @retval string        The normalized file path\r
#\r
def NormFile(FilePath, Workspace):\r
    # check if the path is absolute or relative\r
    if os.path.isabs(FilePath):\r
        FileFullPath = os.path.normpath(FilePath)\r
    else:\r
        FileFullPath = os.path.normpath(mws.join(Workspace, FilePath))\r
        Workspace = mws.getWs(Workspace, FilePath)\r
\r
    # check if the file path exists or not\r
    if not os.path.isfile(FileFullPath):\r
        EdkLogger.error("build", FILE_NOT_FOUND, ExtraData="\t%s (Please give file in absolute path or relative to WORKSPACE)" % FileFullPath)\r
\r
    # remove workspace directory from the beginning part of the file path\r
    if Workspace[-1] in ["\\", "/"]:\r
        return FileFullPath[len(Workspace):]\r
    else:\r
        return FileFullPath[(len(Workspace) + 1):]\r
\r
## Get the output of an external program\r
#\r
# This is the entrance method of thread reading output of an external program and\r
# putting them in STDOUT/STDERR of current program.\r
#\r
# @param  From      The stream message read from\r
# @param  To        The stream message put on\r
# @param  ExitFlag  The flag used to indicate stopping reading\r
#\r
def ReadMessage(From, To, ExitFlag):\r
    while True:\r
        # read one line a time\r
        Line = From.readline()\r
        # empty string means "end"\r
        if Line is not None and Line != b"":\r
            To(Line.rstrip().decode(encoding='utf-8', errors='ignore'))\r
        else:\r
            break\r
        if ExitFlag.isSet():\r
            break\r
\r
## Launch an external program\r
#\r
# This method will call subprocess.Popen to execute an external program with\r
# given options in specified directory. Because of the dead-lock issue during\r
# redirecting output of the external program, threads are used to to do the\r
# redirection work.\r
#\r
# @param  Command               A list or string containing the call of the program\r
# @param  WorkingDir            The directory in which the program will be running\r
#\r
def LaunchCommand(Command, WorkingDir):\r
    BeginTime = time.time()\r
    # if working directory doesn't exist, Popen() will raise an exception\r
    if not os.path.isdir(WorkingDir):\r
        EdkLogger.error("build", FILE_NOT_FOUND, ExtraData=WorkingDir)\r
\r
    # Command is used as the first Argument in following Popen().\r
    # It could be a string or sequence. We find that if command is a string in following Popen(),\r
    # ubuntu may fail with an error message that the command is not found.\r
    # So here we may need convert command from string to list instance.\r
    if platform.system() != 'Windows':\r
        if not isinstance(Command, list):\r
            Command = Command.split()\r
        Command = ' '.join(Command)\r
\r
    Proc = None\r
    EndOfProcedure = None\r
    try:\r
        # launch the command\r
        Proc = Popen(Command, stdout=PIPE, stderr=PIPE, env=os.environ, cwd=WorkingDir, bufsize=-1, shell=True)\r
\r
        # launch two threads to read the STDOUT and STDERR\r
        EndOfProcedure = Event()\r
        EndOfProcedure.clear()\r
        if Proc.stdout:\r
            StdOutThread = Thread(target=ReadMessage, args=(Proc.stdout, EdkLogger.info, EndOfProcedure))\r
            StdOutThread.setName("STDOUT-Redirector")\r
            StdOutThread.setDaemon(False)\r
            StdOutThread.start()\r
\r
        if Proc.stderr:\r
            StdErrThread = Thread(target=ReadMessage, args=(Proc.stderr, EdkLogger.quiet, EndOfProcedure))\r
            StdErrThread.setName("STDERR-Redirector")\r
            StdErrThread.setDaemon(False)\r
            StdErrThread.start()\r
\r
        # waiting for program exit\r
        Proc.wait()\r
    except: # in case of aborting\r
        # terminate the threads redirecting the program output\r
        EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())\r
        if EndOfProcedure is not None:\r
            EndOfProcedure.set()\r
        if Proc is None:\r
            if not isinstance(Command, type("")):\r
                Command = " ".join(Command)\r
            EdkLogger.error("build", COMMAND_FAILURE, "Failed to start command", ExtraData="%s [%s]" % (Command, WorkingDir))\r
\r
    if Proc.stdout:\r
        StdOutThread.join()\r
    if Proc.stderr:\r
        StdErrThread.join()\r
\r
    # check the return code of the program\r
    if Proc.returncode != 0:\r
        if not isinstance(Command, type("")):\r
            Command = " ".join(Command)\r
        # print out the Response file and its content when make failure\r
        RespFile = os.path.join(WorkingDir, 'OUTPUT', 'respfilelist.txt')\r
        if os.path.isfile(RespFile):\r
            f = open(RespFile)\r
            RespContent = f.read()\r
            f.close()\r
            EdkLogger.info(RespContent)\r
\r
        EdkLogger.error("build", COMMAND_FAILURE, ExtraData="%s [%s]" % (Command, WorkingDir))\r
    return "%dms" % (int(round((time.time() - BeginTime) * 1000)))\r
\r
## The smallest unit that can be built in multi-thread build mode\r
#\r
# This is the base class of build unit. The "Obj" parameter must provide\r
# __str__(), __eq__() and __hash__() methods. Otherwise there could be build units\r
# missing build.\r
#\r
# Currently the "Obj" should be only ModuleAutoGen or PlatformAutoGen objects.\r
#\r
class BuildUnit:\r
    ## The constructor\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  Obj         The object the build is working on\r
    #   @param  Target      The build target name, one of gSupportedTarget\r
    #   @param  Dependency  The BuildUnit(s) which must be completed in advance\r
    #   @param  WorkingDir  The directory build command starts in\r
    #\r
    def __init__(self, Obj, BuildCommand, Target, Dependency, WorkingDir="."):\r
        self.BuildObject = Obj\r
        self.Dependency = Dependency\r
        self.WorkingDir = WorkingDir\r
        self.Target = Target\r
        self.BuildCommand = BuildCommand\r
        if not BuildCommand:\r
            EdkLogger.error("build", OPTION_MISSING,\r
                            "No build command found for this module. "\r
                            "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %\r
                                (Obj.BuildTarget, Obj.ToolChain, Obj.Arch),\r
                            ExtraData=str(Obj))\r
\r
\r
    ## str() method\r
    #\r
    #   It just returns the string representation of self.BuildObject\r
    #\r
    #   @param  self        The object pointer\r
    #\r
    def __str__(self):\r
        return str(self.BuildObject)\r
\r
    ## "==" operator method\r
    #\r
    #   It just compares self.BuildObject with "Other". So self.BuildObject must\r
    #   provide its own __eq__() method.\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  Other       The other BuildUnit object compared to\r
    #\r
    def __eq__(self, Other):\r
        return Other and self.BuildObject == Other.BuildObject \\r
                and Other.BuildObject \\r
                and self.BuildObject.Arch == Other.BuildObject.Arch\r
\r
    ## hash() method\r
    #\r
    #   It just returns the hash value of self.BuildObject which must be hashable.\r
    #\r
    #   @param  self        The object pointer\r
    #\r
    def __hash__(self):\r
        return hash(self.BuildObject) + hash(self.BuildObject.Arch)\r
\r
    def __repr__(self):\r
        return repr(self.BuildObject)\r
\r
## The smallest module unit that can be built by nmake/make command in multi-thread build mode\r
#\r
# This class is for module build by nmake/make build system. The "Obj" parameter\r
# must provide __str__(), __eq__() and __hash__() methods. Otherwise there could\r
# be make units missing build.\r
#\r
# Currently the "Obj" should be only ModuleAutoGen object.\r
#\r
class ModuleMakeUnit(BuildUnit):\r
    ## The constructor\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  Obj         The ModuleAutoGen object the build is working on\r
    #   @param  Target      The build target name, one of gSupportedTarget\r
    #\r
    def __init__(self, Obj, Target):\r
        Dependency = [ModuleMakeUnit(La, Target) for La in Obj.LibraryAutoGenList]\r
        BuildUnit.__init__(self, Obj, Obj.BuildCommand, Target, Dependency, Obj.MakeFileDir)\r
        if Target in [None, "", "all"]:\r
            self.Target = "tbuild"\r
\r
## The smallest platform unit that can be built by nmake/make command in multi-thread build mode\r
#\r
# This class is for platform build by nmake/make build system. The "Obj" parameter\r
# must provide __str__(), __eq__() and __hash__() methods. Otherwise there could\r
# be make units missing build.\r
#\r
# Currently the "Obj" should be only PlatformAutoGen object.\r
#\r
class PlatformMakeUnit(BuildUnit):\r
    ## The constructor\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  Obj         The PlatformAutoGen object the build is working on\r
    #   @param  Target      The build target name, one of gSupportedTarget\r
    #\r
    def __init__(self, Obj, Target):\r
        Dependency = [ModuleMakeUnit(Lib, Target) for Lib in self.BuildObject.LibraryAutoGenList]\r
        Dependency.extend([ModuleMakeUnit(Mod, Target) for Mod in self.BuildObject.ModuleAutoGenList])\r
        BuildUnit.__init__(self, Obj, Obj.BuildCommand, Target, Dependency, Obj.MakeFileDir)\r
\r
## The class representing the task of a module build or platform build\r
#\r
# This class manages the build tasks in multi-thread build mode. Its jobs include\r
# scheduling thread running, catching thread error, monitor the thread status, etc.\r
#\r
class BuildTask:\r
    # queue for tasks waiting for schedule\r
    _PendingQueue = OrderedDict()\r
    _PendingQueueLock = threading.Lock()\r
\r
    # queue for tasks ready for running\r
    _ReadyQueue = OrderedDict()\r
    _ReadyQueueLock = threading.Lock()\r
\r
    # queue for run tasks\r
    _RunningQueue = OrderedDict()\r
    _RunningQueueLock = threading.Lock()\r
\r
    # queue containing all build tasks, in case duplicate build\r
    _TaskQueue = OrderedDict()\r
\r
    # flag indicating error occurs in a running thread\r
    _ErrorFlag = threading.Event()\r
    _ErrorFlag.clear()\r
    _ErrorMessage = ""\r
\r
    # BoundedSemaphore object used to control the number of running threads\r
    _Thread = None\r
\r
    # flag indicating if the scheduler is started or not\r
    _SchedulerStopped = threading.Event()\r
    _SchedulerStopped.set()\r
\r
    ## Start the task scheduler thread\r
    #\r
    #   @param  MaxThreadNumber     The maximum thread number\r
    #   @param  ExitFlag            Flag used to end the scheduler\r
    #\r
    @staticmethod\r
    def StartScheduler(MaxThreadNumber, ExitFlag):\r
        SchedulerThread = Thread(target=BuildTask.Scheduler, args=(MaxThreadNumber, ExitFlag))\r
        SchedulerThread.setName("Build-Task-Scheduler")\r
        SchedulerThread.setDaemon(False)\r
        SchedulerThread.start()\r
        # wait for the scheduler to be started, especially useful in Linux\r
        while not BuildTask.IsOnGoing():\r
            time.sleep(0.01)\r
\r
    ## Scheduler method\r
    #\r
    #   @param  MaxThreadNumber     The maximum thread number\r
    #   @param  ExitFlag            Flag used to end the scheduler\r
    #\r
    @staticmethod\r
    def Scheduler(MaxThreadNumber, ExitFlag):\r
        BuildTask._SchedulerStopped.clear()\r
        try:\r
            # use BoundedSemaphore to control the maximum running threads\r
            BuildTask._Thread = BoundedSemaphore(MaxThreadNumber)\r
            #\r
            # scheduling loop, which will exits when no pending/ready task and\r
            # indicated to do so, or there's error in running thread\r
            #\r
            while (len(BuildTask._PendingQueue) > 0 or len(BuildTask._ReadyQueue) > 0 \\r
                   or not ExitFlag.isSet()) and not BuildTask._ErrorFlag.isSet():\r
                EdkLogger.debug(EdkLogger.DEBUG_8, "Pending Queue (%d), Ready Queue (%d)"\r
                                % (len(BuildTask._PendingQueue), len(BuildTask._ReadyQueue)))\r
\r
                # get all pending tasks\r
                BuildTask._PendingQueueLock.acquire()\r
                BuildObjectList = list(BuildTask._PendingQueue.keys())\r
                #\r
                # check if their dependency is resolved, and if true, move them\r
                # into ready queue\r
                #\r
                for BuildObject in BuildObjectList:\r
                    Bt = BuildTask._PendingQueue[BuildObject]\r
                    if Bt.IsReady():\r
                        BuildTask._ReadyQueue[BuildObject] = BuildTask._PendingQueue.pop(BuildObject)\r
                BuildTask._PendingQueueLock.release()\r
\r
                # launch build thread until the maximum number of threads is reached\r
                while not BuildTask._ErrorFlag.isSet():\r
                    # empty ready queue, do nothing further\r
                    if len(BuildTask._ReadyQueue) == 0:\r
                        break\r
\r
                    # wait for active thread(s) exit\r
                    BuildTask._Thread.acquire(True)\r
\r
                    # start a new build thread\r
                    Bo, Bt = BuildTask._ReadyQueue.popitem()\r
\r
                    # move into running queue\r
                    BuildTask._RunningQueueLock.acquire()\r
                    BuildTask._RunningQueue[Bo] = Bt\r
                    BuildTask._RunningQueueLock.release()\r
\r
                    Bt.Start()\r
                    # avoid tense loop\r
                    time.sleep(0.01)\r
\r
                # avoid tense loop\r
                time.sleep(0.01)\r
\r
            # wait for all running threads exit\r
            if BuildTask._ErrorFlag.isSet():\r
                EdkLogger.quiet("\nWaiting for all build threads exit...")\r
            # while not BuildTask._ErrorFlag.isSet() and \\r
            while len(BuildTask._RunningQueue) > 0:\r
                EdkLogger.verbose("Waiting for thread ending...(%d)" % len(BuildTask._RunningQueue))\r
                EdkLogger.debug(EdkLogger.DEBUG_8, "Threads [%s]" % ", ".join(Th.getName() for Th in threading.enumerate()))\r
                # avoid tense loop\r
                time.sleep(0.1)\r
        except BaseException as X:\r
            #\r
            # TRICK: hide the output of threads left running, so that the user can\r
            #        catch the error message easily\r
            #\r
            EdkLogger.SetLevel(EdkLogger.ERROR)\r
            BuildTask._ErrorFlag.set()\r
            BuildTask._ErrorMessage = "build thread scheduler error\n\t%s" % str(X)\r
\r
        BuildTask._PendingQueue.clear()\r
        BuildTask._ReadyQueue.clear()\r
        BuildTask._RunningQueue.clear()\r
        BuildTask._TaskQueue.clear()\r
        BuildTask._SchedulerStopped.set()\r
\r
    ## Wait for all running method exit\r
    #\r
    @staticmethod\r
    def WaitForComplete():\r
        BuildTask._SchedulerStopped.wait()\r
\r
    ## Check if the scheduler is running or not\r
    #\r
    @staticmethod\r
    def IsOnGoing():\r
        return not BuildTask._SchedulerStopped.isSet()\r
\r
    ## Abort the build\r
    @staticmethod\r
    def Abort():\r
        if BuildTask.IsOnGoing():\r
            BuildTask._ErrorFlag.set()\r
            BuildTask.WaitForComplete()\r
\r
    ## Check if there's error in running thread\r
    #\r
    #   Since the main thread cannot catch exceptions in other thread, we have to\r
    #   use threading.Event to communicate this formation to main thread.\r
    #\r
    @staticmethod\r
    def HasError():\r
        return BuildTask._ErrorFlag.isSet()\r
\r
    ## Get error message in running thread\r
    #\r
    #   Since the main thread cannot catch exceptions in other thread, we have to\r
    #   use a static variable to communicate this message to main thread.\r
    #\r
    @staticmethod\r
    def GetErrorMessage():\r
        return BuildTask._ErrorMessage\r
\r
    ## Factory method to create a BuildTask object\r
    #\r
    #   This method will check if a module is building or has been built. And if\r
    #   true, just return the associated BuildTask object in the _TaskQueue. If\r
    #   not, create and return a new BuildTask object. The new BuildTask object\r
    #   will be appended to the _PendingQueue for scheduling later.\r
    #\r
    #   @param  BuildItem       A BuildUnit object representing a build object\r
    #   @param  Dependency      The dependent build object of BuildItem\r
    #\r
    @staticmethod\r
    def New(BuildItem, Dependency=None):\r
        if BuildItem in BuildTask._TaskQueue:\r
            Bt = BuildTask._TaskQueue[BuildItem]\r
            return Bt\r
\r
        Bt = BuildTask()\r
        Bt._Init(BuildItem, Dependency)\r
        BuildTask._TaskQueue[BuildItem] = Bt\r
\r
        BuildTask._PendingQueueLock.acquire()\r
        BuildTask._PendingQueue[BuildItem] = Bt\r
        BuildTask._PendingQueueLock.release()\r
\r
        return Bt\r
\r
    ## The real constructor of BuildTask\r
    #\r
    #   @param  BuildItem       A BuildUnit object representing a build object\r
    #   @param  Dependency      The dependent build object of BuildItem\r
    #\r
    def _Init(self, BuildItem, Dependency=None):\r
        self.BuildItem = BuildItem\r
\r
        self.DependencyList = []\r
        if Dependency is None:\r
            Dependency = BuildItem.Dependency\r
        else:\r
            Dependency.extend(BuildItem.Dependency)\r
        self.AddDependency(Dependency)\r
        # flag indicating build completes, used to avoid unnecessary re-build\r
        self.CompleteFlag = False\r
\r
    ## Check if all dependent build tasks are completed or not\r
    #\r
    def IsReady(self):\r
        ReadyFlag = True\r
        for Dep in self.DependencyList:\r
            if Dep.CompleteFlag == True:\r
                continue\r
            ReadyFlag = False\r
            break\r
\r
        return ReadyFlag\r
\r
    ## Add dependent build task\r
    #\r
    #   @param  Dependency      The list of dependent build objects\r
    #\r
    def AddDependency(self, Dependency):\r
        for Dep in Dependency:\r
            if not Dep.BuildObject.IsBinaryModule and not Dep.BuildObject.CanSkipbyHash():\r
                self.DependencyList.append(BuildTask.New(Dep))    # BuildTask list\r
\r
    ## The thread wrapper of LaunchCommand function\r
    #\r
    # @param  Command               A list or string contains the call of the command\r
    # @param  WorkingDir            The directory in which the program will be running\r
    #\r
    def _CommandThread(self, Command, WorkingDir):\r
        try:\r
            self.BuildItem.BuildObject.BuildTime = LaunchCommand(Command, WorkingDir)\r
            self.CompleteFlag = True\r
\r
            # Run hash operation post dependency, to account for libs\r
            if GlobalData.gUseHashCache and self.BuildItem.BuildObject.IsLibrary:\r
                HashFile = path.join(self.BuildItem.BuildObject.BuildDir, self.BuildItem.BuildObject.Name + ".hash")\r
                SaveFileOnChange(HashFile, self.BuildItem.BuildObject.GenModuleHash(), True)\r
        except:\r
            #\r
            # TRICK: hide the output of threads left running, so that the user can\r
            #        catch the error message easily\r
            #\r
            if not BuildTask._ErrorFlag.isSet():\r
                GlobalData.gBuildingModule = "%s [%s, %s, %s]" % (str(self.BuildItem.BuildObject),\r
                                                                  self.BuildItem.BuildObject.Arch,\r
                                                                  self.BuildItem.BuildObject.ToolChain,\r
                                                                  self.BuildItem.BuildObject.BuildTarget\r
                                                                 )\r
            EdkLogger.SetLevel(EdkLogger.ERROR)\r
            BuildTask._ErrorFlag.set()\r
            BuildTask._ErrorMessage = "%s broken\n    %s [%s]" % \\r
                                      (threading.currentThread().getName(), Command, WorkingDir)\r
\r
        # Set the value used by hash invalidation flow in GlobalData.gModuleBuildTracking to 'SUCCESS'\r
        # If Module or Lib is being tracked, it did not fail header check test, and built successfully\r
        if (self.BuildItem.BuildObject.Arch in GlobalData.gModuleBuildTracking and\r
           self.BuildItem.BuildObject in GlobalData.gModuleBuildTracking[self.BuildItem.BuildObject.Arch] and\r
           GlobalData.gModuleBuildTracking[self.BuildItem.BuildObject.Arch][self.BuildItem.BuildObject] != 'FAIL_METAFILE' and\r
           not BuildTask._ErrorFlag.isSet()\r
           ):\r
            GlobalData.gModuleBuildTracking[self.BuildItem.BuildObject.Arch][self.BuildItem.BuildObject] = 'SUCCESS'\r
\r
        # indicate there's a thread is available for another build task\r
        BuildTask._RunningQueueLock.acquire()\r
        BuildTask._RunningQueue.pop(self.BuildItem)\r
        BuildTask._RunningQueueLock.release()\r
        BuildTask._Thread.release()\r
\r
    ## Start build task thread\r
    #\r
    def Start(self):\r
        EdkLogger.quiet("Building ... %s" % repr(self.BuildItem))\r
        Command = self.BuildItem.BuildCommand + [self.BuildItem.Target]\r
        self.BuildTread = Thread(target=self._CommandThread, args=(Command, self.BuildItem.WorkingDir))\r
        self.BuildTread.setName("build thread")\r
        self.BuildTread.setDaemon(False)\r
        self.BuildTread.start()\r
\r
## The class contains the information related to EFI image\r
#\r
class PeImageInfo():\r
    ## Constructor\r
    #\r
    # Constructor will load all required image information.\r
    #\r
    #   @param  BaseName          The full file path of image.\r
    #   @param  Guid              The GUID for image.\r
    #   @param  Arch              Arch of this image.\r
    #   @param  OutputDir         The output directory for image.\r
    #   @param  DebugDir          The debug directory for image.\r
    #   @param  ImageClass        PeImage Information\r
    #\r
    def __init__(self, BaseName, Guid, Arch, OutputDir, DebugDir, ImageClass):\r
        self.BaseName         = BaseName\r
        self.Guid             = Guid\r
        self.Arch             = Arch\r
        self.OutputDir        = OutputDir\r
        self.DebugDir         = DebugDir\r
        self.Image            = ImageClass\r
        self.Image.Size       = (self.Image.Size // 0x1000 + 1) * 0x1000\r
\r
## The class implementing the EDK2 build process\r
#\r
#   The build process includes:\r
#       1. Load configuration from target.txt and tools_def.txt in $(WORKSPACE)/Conf\r
#       2. Parse DSC file of active platform\r
#       3. Parse FDF file if any\r
#       4. Establish build database, including parse all other files (module, package)\r
#       5. Create AutoGen files (C code file, depex file, makefile) if necessary\r
#       6. Call build command\r
#\r
class Build():\r
    ## Constructor\r
    #\r
    # Constructor will load all necessary configurations, parse platform, modules\r
    # and packages and the establish a database for AutoGen.\r
    #\r
    #   @param  Target              The build command target, one of gSupportedTarget\r
    #   @param  WorkspaceDir        The directory of workspace\r
    #   @param  BuildOptions        Build options passed from command line\r
    #\r
    def __init__(self, Target, WorkspaceDir, BuildOptions):\r
        self.WorkspaceDir   = WorkspaceDir\r
        self.Target         = Target\r
        self.PlatformFile   = BuildOptions.PlatformFile\r
        self.ModuleFile     = BuildOptions.ModuleFile\r
        self.ArchList       = BuildOptions.TargetArch\r
        self.ToolChainList  = BuildOptions.ToolChain\r
        self.BuildTargetList= BuildOptions.BuildTarget\r
        self.Fdf            = BuildOptions.FdfFile\r
        self.FdList         = BuildOptions.RomImage\r
        self.FvList         = BuildOptions.FvImage\r
        self.CapList        = BuildOptions.CapName\r
        self.SilentMode     = BuildOptions.SilentMode\r
        self.ThreadNumber   = BuildOptions.ThreadNumber\r
        self.SkipAutoGen    = BuildOptions.SkipAutoGen\r
        self.Reparse        = BuildOptions.Reparse\r
        self.SkuId          = BuildOptions.SkuId\r
        if self.SkuId:\r
            GlobalData.gSKUID_CMD = self.SkuId\r
        self.ConfDirectory = BuildOptions.ConfDirectory\r
        self.SpawnMode      = True\r
        self.BuildReport    = BuildReport(BuildOptions.ReportFile, BuildOptions.ReportType)\r
        self.TargetTxt      = TargetTxtClassObject()\r
        self.ToolDef        = ToolDefClassObject()\r
        self.AutoGenTime    = 0\r
        self.MakeTime       = 0\r
        self.GenFdsTime     = 0\r
        GlobalData.BuildOptionPcd     = BuildOptions.OptionPcd if BuildOptions.OptionPcd else []\r
        #Set global flag for build mode\r
        GlobalData.gIgnoreSource = BuildOptions.IgnoreSources\r
        GlobalData.gUseHashCache = BuildOptions.UseHashCache\r
        GlobalData.gBinCacheDest   = BuildOptions.BinCacheDest\r
        GlobalData.gBinCacheSource = BuildOptions.BinCacheSource\r
        GlobalData.gEnableGenfdsMultiThread = BuildOptions.GenfdsMultiThread\r
        GlobalData.gDisableIncludePathCheck = BuildOptions.DisableIncludePathCheck\r
\r
        if GlobalData.gBinCacheDest and not GlobalData.gUseHashCache:\r
            EdkLogger.error("build", OPTION_NOT_SUPPORTED, ExtraData="--binary-destination must be used together with --hash.")\r
\r
        if GlobalData.gBinCacheSource and not GlobalData.gUseHashCache:\r
            EdkLogger.error("build", OPTION_NOT_SUPPORTED, ExtraData="--binary-source must be used together with --hash.")\r
\r
        if GlobalData.gBinCacheDest and GlobalData.gBinCacheSource:\r
            EdkLogger.error("build", OPTION_NOT_SUPPORTED, ExtraData="--binary-destination can not be used together with --binary-source.")\r
\r
        if GlobalData.gBinCacheSource:\r
            BinCacheSource = os.path.normpath(GlobalData.gBinCacheSource)\r
            if not os.path.isabs(BinCacheSource):\r
                BinCacheSource = mws.join(self.WorkspaceDir, BinCacheSource)\r
            GlobalData.gBinCacheSource = BinCacheSource\r
        else:\r
            if GlobalData.gBinCacheSource is not None:\r
                EdkLogger.error("build", OPTION_VALUE_INVALID, ExtraData="Invalid value of option --binary-source.")\r
\r
        if GlobalData.gBinCacheDest:\r
            BinCacheDest = os.path.normpath(GlobalData.gBinCacheDest)\r
            if not os.path.isabs(BinCacheDest):\r
                BinCacheDest = mws.join(self.WorkspaceDir, BinCacheDest)\r
            GlobalData.gBinCacheDest = BinCacheDest\r
        else:\r
            if GlobalData.gBinCacheDest is not None:\r
                EdkLogger.error("build", OPTION_VALUE_INVALID, ExtraData="Invalid value of option --binary-destination.")\r
\r
        if self.ConfDirectory:\r
            # Get alternate Conf location, if it is absolute, then just use the absolute directory name\r
            ConfDirectoryPath = os.path.normpath(self.ConfDirectory)\r
\r
            if not os.path.isabs(ConfDirectoryPath):\r
                # Since alternate directory name is not absolute, the alternate directory is located within the WORKSPACE\r
                # This also handles someone specifying the Conf directory in the workspace. Using --conf=Conf\r
                ConfDirectoryPath = mws.join(self.WorkspaceDir, ConfDirectoryPath)\r
        else:\r
            if "CONF_PATH" in os.environ:\r
                ConfDirectoryPath = os.path.normcase(os.path.normpath(os.environ["CONF_PATH"]))\r
            else:\r
                # Get standard WORKSPACE/Conf use the absolute path to the WORKSPACE/Conf\r
                ConfDirectoryPath = mws.join(self.WorkspaceDir, 'Conf')\r
        GlobalData.gConfDirectory = ConfDirectoryPath\r
        GlobalData.gDatabasePath = os.path.normpath(os.path.join(ConfDirectoryPath, GlobalData.gDatabasePath))\r
\r
        self.Db = WorkspaceDatabase()\r
        self.BuildDatabase = self.Db.BuildObject\r
        self.Platform = None\r
        self.ToolChainFamily = None\r
        self.LoadFixAddress = 0\r
        self.UniFlag        = BuildOptions.Flag\r
        self.BuildModules = []\r
        self.HashSkipModules = []\r
        self.Db_Flag = False\r
        self.LaunchPrebuildFlag = False\r
        self.PlatformBuildPath = os.path.join(GlobalData.gConfDirectory, '.cache', '.PlatformBuild')\r
        if BuildOptions.CommandLength:\r
            GlobalData.gCommandMaxLength = BuildOptions.CommandLength\r
\r
        # print dot character during doing some time-consuming work\r
        self.Progress = Utils.Progressor()\r
        # print current build environment and configuration\r
        EdkLogger.quiet("%-16s = %s" % ("WORKSPACE", os.environ["WORKSPACE"]))\r
        if "PACKAGES_PATH" in os.environ:\r
            # WORKSPACE env has been converted before. Print the same path style with WORKSPACE env.\r
            EdkLogger.quiet("%-16s = %s" % ("PACKAGES_PATH", os.path.normcase(os.path.normpath(os.environ["PACKAGES_PATH"]))))\r
        EdkLogger.quiet("%-16s = %s" % ("EDK_TOOLS_PATH", os.environ["EDK_TOOLS_PATH"]))\r
        if "EDK_TOOLS_BIN" in os.environ:\r
            # Print the same path style with WORKSPACE env.\r
            EdkLogger.quiet("%-16s = %s" % ("EDK_TOOLS_BIN", os.path.normcase(os.path.normpath(os.environ["EDK_TOOLS_BIN"]))))\r
        EdkLogger.quiet("%-16s = %s" % ("CONF_PATH", GlobalData.gConfDirectory))\r
        if "PYTHON3_ENABLE" in os.environ:\r
            PYTHON3_ENABLE = os.environ["PYTHON3_ENABLE"]\r
            if PYTHON3_ENABLE != "TRUE":\r
                PYTHON3_ENABLE = "FALSE"\r
            EdkLogger.quiet("%-16s = %s" % ("PYTHON3_ENABLE", PYTHON3_ENABLE))\r
        if "PYTHON_COMMAND" in os.environ:\r
            EdkLogger.quiet("%-16s = %s" % ("PYTHON_COMMAND", os.environ["PYTHON_COMMAND"]))\r
        self.InitPreBuild()\r
        self.InitPostBuild()\r
        if self.Prebuild:\r
            EdkLogger.quiet("%-16s = %s" % ("PREBUILD", self.Prebuild))\r
        if self.Postbuild:\r
            EdkLogger.quiet("%-16s = %s" % ("POSTBUILD", self.Postbuild))\r
        if self.Prebuild:\r
            self.LaunchPrebuild()\r
            self.TargetTxt = TargetTxtClassObject()\r
            self.ToolDef   = ToolDefClassObject()\r
        if not (self.LaunchPrebuildFlag and os.path.exists(self.PlatformBuildPath)):\r
            self.InitBuild()\r
\r
        EdkLogger.info("")\r
        os.chdir(self.WorkspaceDir)\r
\r
    ## Load configuration\r
    #\r
    #   This method will parse target.txt and get the build configurations.\r
    #\r
    def LoadConfiguration(self):\r
        #\r
        # Check target.txt and tools_def.txt and Init them\r
        #\r
        BuildConfigurationFile = os.path.normpath(os.path.join(GlobalData.gConfDirectory, gBuildConfiguration))\r
        if os.path.isfile(BuildConfigurationFile) == True:\r
            StatusCode = self.TargetTxt.LoadTargetTxtFile(BuildConfigurationFile)\r
\r
            ToolDefinitionFile = self.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_TOOL_CHAIN_CONF]\r
            if ToolDefinitionFile == '':\r
                ToolDefinitionFile = gToolsDefinition\r
                ToolDefinitionFile = os.path.normpath(mws.join(self.WorkspaceDir, 'Conf', ToolDefinitionFile))\r
            if os.path.isfile(ToolDefinitionFile) == True:\r
                StatusCode = self.ToolDef.LoadToolDefFile(ToolDefinitionFile)\r
            else:\r
                EdkLogger.error("build", FILE_NOT_FOUND, ExtraData=ToolDefinitionFile)\r
        else:\r
            EdkLogger.error("build", FILE_NOT_FOUND, ExtraData=BuildConfigurationFile)\r
\r
        # if no ARCH given in command line, get it from target.txt\r
        if not self.ArchList:\r
            self.ArchList = self.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_TARGET_ARCH]\r
        self.ArchList = tuple(self.ArchList)\r
\r
        # if no build target given in command line, get it from target.txt\r
        if not self.BuildTargetList:\r
            self.BuildTargetList = self.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_TARGET]\r
\r
        # if no tool chain given in command line, get it from target.txt\r
        if not self.ToolChainList:\r
            self.ToolChainList = self.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_TOOL_CHAIN_TAG]\r
            if self.ToolChainList is None or len(self.ToolChainList) == 0:\r
                EdkLogger.error("build", RESOURCE_NOT_AVAILABLE, ExtraData="No toolchain given. Don't know how to build.\n")\r
\r
        # check if the tool chains are defined or not\r
        NewToolChainList = []\r
        for ToolChain in self.ToolChainList:\r
            if ToolChain not in self.ToolDef.ToolsDefTxtDatabase[TAB_TOD_DEFINES_TOOL_CHAIN_TAG]:\r
                EdkLogger.warn("build", "Tool chain [%s] is not defined" % ToolChain)\r
            else:\r
                NewToolChainList.append(ToolChain)\r
        # if no tool chain available, break the build\r
        if len(NewToolChainList) == 0:\r
            EdkLogger.error("build", RESOURCE_NOT_AVAILABLE,\r
                            ExtraData="[%s] not defined. No toolchain available for build!\n" % ", ".join(self.ToolChainList))\r
        else:\r
            self.ToolChainList = NewToolChainList\r
\r
        ToolChainFamily = []\r
        ToolDefinition = self.ToolDef.ToolsDefTxtDatabase\r
        for Tool in self.ToolChainList:\r
            if TAB_TOD_DEFINES_FAMILY not in ToolDefinition or Tool not in ToolDefinition[TAB_TOD_DEFINES_FAMILY] \\r
               or not ToolDefinition[TAB_TOD_DEFINES_FAMILY][Tool]:\r
                EdkLogger.warn("build", "No tool chain family found in configuration for %s. Default to MSFT." % Tool)\r
                ToolChainFamily.append(TAB_COMPILER_MSFT)\r
            else:\r
                ToolChainFamily.append(ToolDefinition[TAB_TOD_DEFINES_FAMILY][Tool])\r
        self.ToolChainFamily = ToolChainFamily\r
\r
        if self.ThreadNumber is None:\r
            self.ThreadNumber = self.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_MAX_CONCURRENT_THREAD_NUMBER]\r
            if self.ThreadNumber == '':\r
                self.ThreadNumber = 0\r
            else:\r
                self.ThreadNumber = int(self.ThreadNumber, 0)\r
\r
        if self.ThreadNumber == 0:\r
            try:\r
                self.ThreadNumber = multiprocessing.cpu_count()\r
            except (ImportError, NotImplementedError):\r
                self.ThreadNumber = 1\r
\r
        if not self.PlatformFile:\r
            PlatformFile = self.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_ACTIVE_PLATFORM]\r
            if not PlatformFile:\r
                # Try to find one in current directory\r
                WorkingDirectory = os.getcwd()\r
                FileList = glob.glob(os.path.normpath(os.path.join(WorkingDirectory, '*.dsc')))\r
                FileNum = len(FileList)\r
                if FileNum >= 2:\r
                    EdkLogger.error("build", OPTION_MISSING,\r
                                    ExtraData="There are %d DSC files in %s. Use '-p' to specify one.\n" % (FileNum, WorkingDirectory))\r
                elif FileNum == 1:\r
                    PlatformFile = FileList[0]\r
                else:\r
                    EdkLogger.error("build", RESOURCE_NOT_AVAILABLE,\r
                                    ExtraData="No active platform specified in target.txt or command line! Nothing can be built.\n")\r
\r
            self.PlatformFile = PathClass(NormFile(PlatformFile, self.WorkspaceDir), self.WorkspaceDir)\r
\r
    ## Initialize build configuration\r
    #\r
    #   This method will parse DSC file and merge the configurations from\r
    #   command line and target.txt, then get the final build configurations.\r
    #\r
    def InitBuild(self):\r
        # parse target.txt, tools_def.txt, and platform file\r
        self.LoadConfiguration()\r
\r
        # Allow case-insensitive for those from command line or configuration file\r
        ErrorCode, ErrorInfo = self.PlatformFile.Validate(".dsc", False)\r
        if ErrorCode != 0:\r
            EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)\r
\r
\r
    def InitPreBuild(self):\r
        self.LoadConfiguration()\r
        ErrorCode, ErrorInfo = self.PlatformFile.Validate(".dsc", False)\r
        if ErrorCode != 0:\r
            EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)\r
        if self.BuildTargetList:\r
            GlobalData.gGlobalDefines['TARGET'] = self.BuildTargetList[0]\r
        if self.ArchList:\r
            GlobalData.gGlobalDefines['ARCH'] = self.ArchList[0]\r
        if self.ToolChainList:\r
            GlobalData.gGlobalDefines['TOOLCHAIN'] = self.ToolChainList[0]\r
            GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = self.ToolChainList[0]\r
        if self.ToolChainFamily:\r
            GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[0]\r
        if 'PREBUILD' in GlobalData.gCommandLineDefines:\r
            self.Prebuild   = GlobalData.gCommandLineDefines.get('PREBUILD')\r
        else:\r
            self.Db_Flag = True\r
            Platform = self.Db.MapPlatform(str(self.PlatformFile))\r
            self.Prebuild = str(Platform.Prebuild)\r
        if self.Prebuild:\r
            PrebuildList = []\r
            #\r
            # Evaluate all arguments and convert arguments that are WORKSPACE\r
            # relative paths to absolute paths.  Filter arguments that look like\r
            # flags or do not follow the file/dir naming rules to avoid false\r
            # positives on this conversion.\r
            #\r
            for Arg in self.Prebuild.split():\r
                #\r
                # Do not modify Arg if it looks like a flag or an absolute file path\r
                #\r
                if Arg.startswith('-')  or os.path.isabs(Arg):\r
                    PrebuildList.append(Arg)\r
                    continue\r
                #\r
                # Do not modify Arg if it does not look like a Workspace relative\r
                # path that starts with a valid package directory name\r
                #\r
                if not Arg[0].isalpha() or os.path.dirname(Arg) == '':\r
                    PrebuildList.append(Arg)\r
                    continue\r
                #\r
                # If Arg looks like a WORKSPACE relative path, then convert to an\r
                # absolute path and check to see if the file exists.\r
                #\r
                Temp = mws.join(self.WorkspaceDir, Arg)\r
                if os.path.isfile(Temp):\r
                    Arg = Temp\r
                PrebuildList.append(Arg)\r
            self.Prebuild       = ' '.join(PrebuildList)\r
            self.Prebuild += self.PassCommandOption(self.BuildTargetList, self.ArchList, self.ToolChainList, self.PlatformFile, self.Target)\r
\r
    def InitPostBuild(self):\r
        if 'POSTBUILD' in GlobalData.gCommandLineDefines:\r
            self.Postbuild = GlobalData.gCommandLineDefines.get('POSTBUILD')\r
        else:\r
            Platform = self.Db.MapPlatform(str(self.PlatformFile))\r
            self.Postbuild = str(Platform.Postbuild)\r
        if self.Postbuild:\r
            PostbuildList = []\r
            #\r
            # Evaluate all arguments and convert arguments that are WORKSPACE\r
            # relative paths to absolute paths.  Filter arguments that look like\r
            # flags or do not follow the file/dir naming rules to avoid false\r
            # positives on this conversion.\r
            #\r
            for Arg in self.Postbuild.split():\r
                #\r
                # Do not modify Arg if it looks like a flag or an absolute file path\r
                #\r
                if Arg.startswith('-')  or os.path.isabs(Arg):\r
                    PostbuildList.append(Arg)\r
                    continue\r
                #\r
                # Do not modify Arg if it does not look like a Workspace relative\r
                # path that starts with a valid package directory name\r
                #\r
                if not Arg[0].isalpha() or os.path.dirname(Arg) == '':\r
                    PostbuildList.append(Arg)\r
                    continue\r
                #\r
                # If Arg looks like a WORKSPACE relative path, then convert to an\r
                # absolute path and check to see if the file exists.\r
                #\r
                Temp = mws.join(self.WorkspaceDir, Arg)\r
                if os.path.isfile(Temp):\r
                    Arg = Temp\r
                PostbuildList.append(Arg)\r
            self.Postbuild       = ' '.join(PostbuildList)\r
            self.Postbuild += self.PassCommandOption(self.BuildTargetList, self.ArchList, self.ToolChainList, self.PlatformFile, self.Target)\r
\r
    def PassCommandOption(self, BuildTarget, TargetArch, ToolChain, PlatformFile, Target):\r
        BuildStr = ''\r
        if GlobalData.gCommand and isinstance(GlobalData.gCommand, list):\r
            BuildStr += ' ' + ' '.join(GlobalData.gCommand)\r
        TargetFlag = False\r
        ArchFlag = False\r
        ToolChainFlag = False\r
        PlatformFileFlag = False\r
\r
        if GlobalData.gOptions and not GlobalData.gOptions.BuildTarget:\r
            TargetFlag = True\r
        if GlobalData.gOptions and not GlobalData.gOptions.TargetArch:\r
            ArchFlag = True\r
        if GlobalData.gOptions and not GlobalData.gOptions.ToolChain:\r
            ToolChainFlag = True\r
        if GlobalData.gOptions and not GlobalData.gOptions.PlatformFile:\r
            PlatformFileFlag = True\r
\r
        if TargetFlag and BuildTarget:\r
            if isinstance(BuildTarget, list) or isinstance(BuildTarget, tuple):\r
                BuildStr += ' -b ' + ' -b '.join(BuildTarget)\r
            elif isinstance(BuildTarget, str):\r
                BuildStr += ' -b ' + BuildTarget\r
        if ArchFlag and TargetArch:\r
            if isinstance(TargetArch, list) or isinstance(TargetArch, tuple):\r
                BuildStr += ' -a ' + ' -a '.join(TargetArch)\r
            elif isinstance(TargetArch, str):\r
                BuildStr += ' -a ' + TargetArch\r
        if ToolChainFlag and ToolChain:\r
            if isinstance(ToolChain, list) or isinstance(ToolChain, tuple):\r
                BuildStr += ' -t ' + ' -t '.join(ToolChain)\r
            elif isinstance(ToolChain, str):\r
                BuildStr += ' -t ' + ToolChain\r
        if PlatformFileFlag and PlatformFile:\r
            if isinstance(PlatformFile, list) or isinstance(PlatformFile, tuple):\r
                BuildStr += ' -p ' + ' -p '.join(PlatformFile)\r
            elif isinstance(PlatformFile, str):\r
                BuildStr += ' -p' + PlatformFile\r
        BuildStr += ' --conf=' + GlobalData.gConfDirectory\r
        if Target:\r
            BuildStr += ' ' + Target\r
\r
        return BuildStr\r
\r
    def LaunchPrebuild(self):\r
        if self.Prebuild:\r
            EdkLogger.info("\n- Prebuild Start -\n")\r
            self.LaunchPrebuildFlag = True\r
            #\r
            # The purpose of .PrebuildEnv file is capture environment variable settings set by the prebuild script\r
            # and preserve them for the rest of the main build step, because the child process environment will\r
            # evaporate as soon as it exits, we cannot get it in build step.\r
            #\r
            PrebuildEnvFile = os.path.join(GlobalData.gConfDirectory, '.cache', '.PrebuildEnv')\r
            if os.path.isfile(PrebuildEnvFile):\r
                os.remove(PrebuildEnvFile)\r
            if os.path.isfile(self.PlatformBuildPath):\r
                os.remove(self.PlatformBuildPath)\r
            if sys.platform == "win32":\r
                args = ' && '.join((self.Prebuild, 'set > ' + PrebuildEnvFile))\r
                Process = Popen(args, stdout=PIPE, stderr=PIPE, shell=True)\r
            else:\r
                args = ' && '.join((self.Prebuild, 'env > ' + PrebuildEnvFile))\r
                Process = Popen(args, stdout=PIPE, stderr=PIPE, shell=True)\r
\r
            # launch two threads to read the STDOUT and STDERR\r
            EndOfProcedure = Event()\r
            EndOfProcedure.clear()\r
            if Process.stdout:\r
                StdOutThread = Thread(target=ReadMessage, args=(Process.stdout, EdkLogger.info, EndOfProcedure))\r
                StdOutThread.setName("STDOUT-Redirector")\r
                StdOutThread.setDaemon(False)\r
                StdOutThread.start()\r
\r
            if Process.stderr:\r
                StdErrThread = Thread(target=ReadMessage, args=(Process.stderr, EdkLogger.quiet, EndOfProcedure))\r
                StdErrThread.setName("STDERR-Redirector")\r
                StdErrThread.setDaemon(False)\r
                StdErrThread.start()\r
            # waiting for program exit\r
            Process.wait()\r
\r
            if Process.stdout:\r
                StdOutThread.join()\r
            if Process.stderr:\r
                StdErrThread.join()\r
            if Process.returncode != 0 :\r
                EdkLogger.error("Prebuild", PREBUILD_ERROR, 'Prebuild process is not success!')\r
\r
            if os.path.exists(PrebuildEnvFile):\r
                f = open(PrebuildEnvFile)\r
                envs = f.readlines()\r
                f.close()\r
                envs = [l.split("=", 1) for l in envs ]\r
                envs = [[I.strip() for I in item] for item in envs if len(item) == 2]\r
                os.environ.update(dict(envs))\r
            EdkLogger.info("\n- Prebuild Done -\n")\r
\r
    def LaunchPostbuild(self):\r
        if self.Postbuild:\r
            EdkLogger.info("\n- Postbuild Start -\n")\r
            if sys.platform == "win32":\r
                Process = Popen(self.Postbuild, stdout=PIPE, stderr=PIPE, shell=True)\r
            else:\r
                Process = Popen(self.Postbuild, stdout=PIPE, stderr=PIPE, shell=True)\r
            # launch two threads to read the STDOUT and STDERR\r
            EndOfProcedure = Event()\r
            EndOfProcedure.clear()\r
            if Process.stdout:\r
                StdOutThread = Thread(target=ReadMessage, args=(Process.stdout, EdkLogger.info, EndOfProcedure))\r
                StdOutThread.setName("STDOUT-Redirector")\r
                StdOutThread.setDaemon(False)\r
                StdOutThread.start()\r
\r
            if Process.stderr:\r
                StdErrThread = Thread(target=ReadMessage, args=(Process.stderr, EdkLogger.quiet, EndOfProcedure))\r
                StdErrThread.setName("STDERR-Redirector")\r
                StdErrThread.setDaemon(False)\r
                StdErrThread.start()\r
            # waiting for program exit\r
            Process.wait()\r
\r
            if Process.stdout:\r
                StdOutThread.join()\r
            if Process.stderr:\r
                StdErrThread.join()\r
            if Process.returncode != 0 :\r
                EdkLogger.error("Postbuild", POSTBUILD_ERROR, 'Postbuild process is not success!')\r
            EdkLogger.info("\n- Postbuild Done -\n")\r
\r
    ## Error handling for hash feature\r
    #\r
    # On BuildTask error, iterate through the Module Build tracking\r
    # dictionary to determine wheather a module failed to build. Invalidate\r
    # the hash associated with that module by removing it from storage.\r
    #\r
    #\r
    def invalidateHash(self):\r
        # Only for hashing feature\r
        if not GlobalData.gUseHashCache:\r
            return\r
\r
        # GlobalData.gModuleBuildTracking contains only modules or libs that cannot be skipped by hash\r
        for moduleAutoGenObjArch in GlobalData.gModuleBuildTracking.keys():\r
            for moduleAutoGenObj in GlobalData.gModuleBuildTracking[moduleAutoGenObjArch].keys():\r
                # Skip invalidating for Successful Module/Lib builds\r
                if GlobalData.gModuleBuildTracking[moduleAutoGenObjArch][moduleAutoGenObj] == 'SUCCESS':\r
                    continue\r
\r
                # The module failed to build, failed to start building, or failed the header check test from this point on\r
\r
                # Remove .hash from build\r
                ModuleHashFile = os.path.join(moduleAutoGenObj.BuildDir, moduleAutoGenObj.Name + ".hash")\r
                if os.path.exists(ModuleHashFile):\r
                    os.remove(ModuleHashFile)\r
\r
                # Remove .hash file from cache\r
                if GlobalData.gBinCacheDest:\r
                    FileDir = os.path.join(GlobalData.gBinCacheDest, moduleAutoGenObj.Arch, moduleAutoGenObj.SourceDir, moduleAutoGenObj.MetaFile.BaseName)\r
                    HashFile = os.path.join(FileDir, moduleAutoGenObj.Name + '.hash')\r
                    if os.path.exists(HashFile):\r
                        os.remove(HashFile)\r
\r
    ## Build a module or platform\r
    #\r
    # Create autogen code and makefile for a module or platform, and the launch\r
    # "make" command to build it\r
    #\r
    #   @param  Target                      The target of build command\r
    #   @param  Platform                    The platform file\r
    #   @param  Module                      The module file\r
    #   @param  BuildTarget                 The name of build target, one of "DEBUG", "RELEASE"\r
    #   @param  ToolChain                   The name of toolchain to build\r
    #   @param  Arch                        The arch of the module/platform\r
    #   @param  CreateDepModuleCodeFile     Flag used to indicate creating code\r
    #                                       for dependent modules/Libraries\r
    #   @param  CreateDepModuleMakeFile     Flag used to indicate creating makefile\r
    #                                       for dependent modules/Libraries\r
    #\r
    def _BuildPa(self, Target, AutoGenObject, CreateDepsCodeFile=True, CreateDepsMakeFile=True, BuildModule=False, FfsCommand={}):\r
        if AutoGenObject is None:\r
            return False\r
\r
        # skip file generation for cleanxxx targets, run and fds target\r
        if Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:\r
            # for target which must generate AutoGen code and makefile\r
            if not self.SkipAutoGen or Target == 'genc':\r
                self.Progress.Start("Generating code")\r
                AutoGenObject.CreateCodeFile(CreateDepsCodeFile)\r
                self.Progress.Stop("done!")\r
            if Target == "genc":\r
                return True\r
\r
            if not self.SkipAutoGen or Target == 'genmake':\r
                self.Progress.Start("Generating makefile")\r
                AutoGenObject.CreateMakeFile(CreateDepsMakeFile, FfsCommand)\r
                self.Progress.Stop("done!")\r
            if Target == "genmake":\r
                return True\r
        else:\r
            # always recreate top/platform makefile when clean, just in case of inconsistency\r
            AutoGenObject.CreateCodeFile(False)\r
            AutoGenObject.CreateMakeFile(False)\r
\r
        if EdkLogger.GetLevel() == EdkLogger.QUIET:\r
            EdkLogger.quiet("Building ... %s" % repr(AutoGenObject))\r
\r
        BuildCommand = AutoGenObject.BuildCommand\r
        if BuildCommand is None or len(BuildCommand) == 0:\r
            EdkLogger.error("build", OPTION_MISSING,\r
                            "No build command found for this module. "\r
                            "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %\r
                                (AutoGenObject.BuildTarget, AutoGenObject.ToolChain, AutoGenObject.Arch),\r
                            ExtraData=str(AutoGenObject))\r
\r
        makefile = GenMake.BuildFile(AutoGenObject)._FILE_NAME_[GenMake.gMakeType]\r
\r
        # run\r
        if Target == 'run':\r
            return True\r
\r
        # build modules\r
        if BuildModule:\r
            BuildCommand = BuildCommand + [Target]\r
            LaunchCommand(BuildCommand, AutoGenObject.MakeFileDir)\r
            self.CreateAsBuiltInf()\r
            return True\r
\r
        # build library\r
        if Target == 'libraries':\r
            for Lib in AutoGenObject.LibraryBuildDirectoryList:\r
                NewBuildCommand = BuildCommand + ['-f', os.path.normpath(os.path.join(Lib, makefile)), 'pbuild']\r
                LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
            return True\r
\r
        # build module\r
        if Target == 'modules':\r
            for Lib in AutoGenObject.LibraryBuildDirectoryList:\r
                NewBuildCommand = BuildCommand + ['-f', os.path.normpath(os.path.join(Lib, makefile)), 'pbuild']\r
                LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
            for Mod in AutoGenObject.ModuleBuildDirectoryList:\r
                NewBuildCommand = BuildCommand + ['-f', os.path.normpath(os.path.join(Mod, makefile)), 'pbuild']\r
                LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
            self.CreateAsBuiltInf()\r
            return True\r
\r
        # cleanlib\r
        if Target == 'cleanlib':\r
            for Lib in AutoGenObject.LibraryBuildDirectoryList:\r
                LibMakefile = os.path.normpath(os.path.join(Lib, makefile))\r
                if os.path.exists(LibMakefile):\r
                    NewBuildCommand = BuildCommand + ['-f', LibMakefile, 'cleanall']\r
                    LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
            return True\r
\r
        # clean\r
        if Target == 'clean':\r
            for Mod in AutoGenObject.ModuleBuildDirectoryList:\r
                ModMakefile = os.path.normpath(os.path.join(Mod, makefile))\r
                if os.path.exists(ModMakefile):\r
                    NewBuildCommand = BuildCommand + ['-f', ModMakefile, 'cleanall']\r
                    LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
            for Lib in AutoGenObject.LibraryBuildDirectoryList:\r
                LibMakefile = os.path.normpath(os.path.join(Lib, makefile))\r
                if os.path.exists(LibMakefile):\r
                    NewBuildCommand = BuildCommand + ['-f', LibMakefile, 'cleanall']\r
                    LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
            return True\r
\r
        # cleanall\r
        if Target == 'cleanall':\r
            try:\r
                #os.rmdir(AutoGenObject.BuildDir)\r
                RemoveDirectory(AutoGenObject.BuildDir, True)\r
            except WindowsError as X:\r
                EdkLogger.error("build", FILE_DELETE_FAILURE, ExtraData=str(X))\r
        return True\r
\r
    ## Build a module or platform\r
    #\r
    # Create autogen code and makefile for a module or platform, and the launch\r
    # "make" command to build it\r
    #\r
    #   @param  Target                      The target of build command\r
    #   @param  Platform                    The platform file\r
    #   @param  Module                      The module file\r
    #   @param  BuildTarget                 The name of build target, one of "DEBUG", "RELEASE"\r
    #   @param  ToolChain                   The name of toolchain to build\r
    #   @param  Arch                        The arch of the module/platform\r
    #   @param  CreateDepModuleCodeFile     Flag used to indicate creating code\r
    #                                       for dependent modules/Libraries\r
    #   @param  CreateDepModuleMakeFile     Flag used to indicate creating makefile\r
    #                                       for dependent modules/Libraries\r
    #\r
    def _Build(self, Target, AutoGenObject, CreateDepsCodeFile=True, CreateDepsMakeFile=True, BuildModule=False):\r
        if AutoGenObject is None:\r
            return False\r
\r
        # skip file generation for cleanxxx targets, run and fds target\r
        if Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:\r
            # for target which must generate AutoGen code and makefile\r
            if not self.SkipAutoGen or Target == 'genc':\r
                self.Progress.Start("Generating code")\r
                AutoGenObject.CreateCodeFile(CreateDepsCodeFile)\r
                self.Progress.Stop("done!")\r
            if Target == "genc":\r
                return True\r
\r
            if not self.SkipAutoGen or Target == 'genmake':\r
                self.Progress.Start("Generating makefile")\r
                AutoGenObject.CreateMakeFile(CreateDepsMakeFile)\r
                #AutoGenObject.CreateAsBuiltInf()\r
                self.Progress.Stop("done!")\r
            if Target == "genmake":\r
                return True\r
        else:\r
            # always recreate top/platform makefile when clean, just in case of inconsistency\r
            AutoGenObject.CreateCodeFile(False)\r
            AutoGenObject.CreateMakeFile(False)\r
\r
        if EdkLogger.GetLevel() == EdkLogger.QUIET:\r
            EdkLogger.quiet("Building ... %s" % repr(AutoGenObject))\r
\r
        BuildCommand = AutoGenObject.BuildCommand\r
        if BuildCommand is None or len(BuildCommand) == 0:\r
            EdkLogger.error("build", OPTION_MISSING,\r
                            "No build command found for this module. "\r
                            "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %\r
                                (AutoGenObject.BuildTarget, AutoGenObject.ToolChain, AutoGenObject.Arch),\r
                            ExtraData=str(AutoGenObject))\r
\r
        # build modules\r
        if BuildModule:\r
            if Target != 'fds':\r
                BuildCommand = BuildCommand + [Target]\r
            AutoGenObject.BuildTime = LaunchCommand(BuildCommand, AutoGenObject.MakeFileDir)\r
            self.CreateAsBuiltInf()\r
            return True\r
\r
        # genfds\r
        if Target == 'fds':\r
            if GenFdsApi(AutoGenObject.GenFdsCommandDict, self.Db):\r
                EdkLogger.error("build", COMMAND_FAILURE)\r
            return True\r
\r
        # run\r
        if Target == 'run':\r
            return True\r
\r
        # build library\r
        if Target == 'libraries':\r
            pass\r
\r
        # not build modules\r
\r
\r
        # cleanall\r
        if Target == 'cleanall':\r
            try:\r
                #os.rmdir(AutoGenObject.BuildDir)\r
                RemoveDirectory(AutoGenObject.BuildDir, True)\r
            except WindowsError as X:\r
                EdkLogger.error("build", FILE_DELETE_FAILURE, ExtraData=str(X))\r
        return True\r
\r
    ## Rebase module image and Get function address for the input module list.\r
    #\r
    def _RebaseModule (self, MapBuffer, BaseAddress, ModuleList, AddrIsOffset = True, ModeIsSmm = False):\r
        if ModeIsSmm:\r
            AddrIsOffset = False\r
        for InfFile in ModuleList:\r
            sys.stdout.write (".")\r
            sys.stdout.flush()\r
            ModuleInfo = ModuleList[InfFile]\r
            ModuleName = ModuleInfo.BaseName\r
            ModuleOutputImage = ModuleInfo.Image.FileName\r
            ModuleDebugImage  = os.path.join(ModuleInfo.DebugDir, ModuleInfo.BaseName + '.efi')\r
            ## for SMM module in SMRAM, the SMRAM will be allocated from base to top.\r
            if not ModeIsSmm:\r
                BaseAddress = BaseAddress - ModuleInfo.Image.Size\r
                #\r
                # Update Image to new BaseAddress by GenFw tool\r
                #\r
                LaunchCommand(["GenFw", "--rebase", str(BaseAddress), "-r", ModuleOutputImage], ModuleInfo.OutputDir)\r
                LaunchCommand(["GenFw", "--rebase", str(BaseAddress), "-r", ModuleDebugImage], ModuleInfo.DebugDir)\r
            else:\r
                #\r
                # Set new address to the section header only for SMM driver.\r
                #\r
                LaunchCommand(["GenFw", "--address", str(BaseAddress), "-r", ModuleOutputImage], ModuleInfo.OutputDir)\r
                LaunchCommand(["GenFw", "--address", str(BaseAddress), "-r", ModuleDebugImage], ModuleInfo.DebugDir)\r
            #\r
            # Collect function address from Map file\r
            #\r
            ImageMapTable = ModuleOutputImage.replace('.efi', '.map')\r
            FunctionList = []\r
            if os.path.exists(ImageMapTable):\r
                OrigImageBaseAddress = 0\r
                ImageMap = open(ImageMapTable, 'r')\r
                for LinStr in ImageMap:\r
                    if len (LinStr.strip()) == 0:\r
                        continue\r
                    #\r
                    # Get the preferred address set on link time.\r
                    #\r
                    if LinStr.find ('Preferred load address is') != -1:\r
                        StrList = LinStr.split()\r
                        OrigImageBaseAddress = int (StrList[len(StrList) - 1], 16)\r
\r
                    StrList = LinStr.split()\r
                    if len (StrList) > 4:\r
                        if StrList[3] == 'f' or StrList[3] == 'F':\r
                            Name = StrList[1]\r
                            RelativeAddress = int (StrList[2], 16) - OrigImageBaseAddress\r
                            FunctionList.append ((Name, RelativeAddress))\r
\r
                ImageMap.close()\r
            #\r
            # Add general information.\r
            #\r
            if ModeIsSmm:\r
                MapBuffer.append('\n\n%s (Fixed SMRAM Offset,   BaseAddress=0x%010X,  EntryPoint=0x%010X)\n' % (ModuleName, BaseAddress, BaseAddress + ModuleInfo.Image.EntryPoint))\r
            elif AddrIsOffset:\r
                MapBuffer.append('\n\n%s (Fixed Memory Offset,  BaseAddress=-0x%010X, EntryPoint=-0x%010X)\n' % (ModuleName, 0 - BaseAddress, 0 - (BaseAddress + ModuleInfo.Image.EntryPoint)))\r
            else:\r
                MapBuffer.append('\n\n%s (Fixed Memory Address, BaseAddress=0x%010X,  EntryPoint=0x%010X)\n' % (ModuleName, BaseAddress, BaseAddress + ModuleInfo.Image.EntryPoint))\r
            #\r
            # Add guid and general seciton section.\r
            #\r
            TextSectionAddress = 0\r
            DataSectionAddress = 0\r
            for SectionHeader in ModuleInfo.Image.SectionHeaderList:\r
                if SectionHeader[0] == '.text':\r
                    TextSectionAddress = SectionHeader[1]\r
                elif SectionHeader[0] in ['.data', '.sdata']:\r
                    DataSectionAddress = SectionHeader[1]\r
            if AddrIsOffset:\r
                MapBuffer.append('(GUID=%s, .textbaseaddress=-0x%010X, .databaseaddress=-0x%010X)\n' % (ModuleInfo.Guid, 0 - (BaseAddress + TextSectionAddress), 0 - (BaseAddress + DataSectionAddress)))\r
            else:\r
                MapBuffer.append('(GUID=%s, .textbaseaddress=0x%010X, .databaseaddress=0x%010X)\n' % (ModuleInfo.Guid, BaseAddress + TextSectionAddress, BaseAddress + DataSectionAddress))\r
            #\r
            # Add debug image full path.\r
            #\r
            MapBuffer.append('(IMAGE=%s)\n\n' % (ModuleDebugImage))\r
            #\r
            # Add function address\r
            #\r
            for Function in FunctionList:\r
                if AddrIsOffset:\r
                    MapBuffer.append('  -0x%010X    %s\n' % (0 - (BaseAddress + Function[1]), Function[0]))\r
                else:\r
                    MapBuffer.append('  0x%010X    %s\n' % (BaseAddress + Function[1], Function[0]))\r
            ImageMap.close()\r
\r
            #\r
            # for SMM module in SMRAM, the SMRAM will be allocated from base to top.\r
            #\r
            if ModeIsSmm:\r
                BaseAddress = BaseAddress + ModuleInfo.Image.Size\r
\r
    ## Collect MAP information of all FVs\r
    #\r
    def _CollectFvMapBuffer (self, MapBuffer, Wa, ModuleList):\r
        if self.Fdf:\r
            # First get the XIP base address for FV map file.\r
            GuidPattern = re.compile("[-a-fA-F0-9]+")\r
            GuidName = re.compile("\(GUID=[-a-fA-F0-9]+")\r
            for FvName in Wa.FdfProfile.FvDict:\r
                FvMapBuffer = os.path.join(Wa.FvDir, FvName + '.Fv.map')\r
                if not os.path.exists(FvMapBuffer):\r
                    continue\r
                FvMap = open(FvMapBuffer, 'r')\r
                #skip FV size information\r
                FvMap.readline()\r
                FvMap.readline()\r
                FvMap.readline()\r
                FvMap.readline()\r
                for Line in FvMap:\r
                    MatchGuid = GuidPattern.match(Line)\r
                    if MatchGuid is not None:\r
                        #\r
                        # Replace GUID with module name\r
                        #\r
                        GuidString = MatchGuid.group()\r
                        if GuidString.upper() in ModuleList:\r
                            Line = Line.replace(GuidString, ModuleList[GuidString.upper()].Name)\r
                    MapBuffer.append(Line)\r
                    #\r
                    # Add the debug image full path.\r
                    #\r
                    MatchGuid = GuidName.match(Line)\r
                    if MatchGuid is not None:\r
                        GuidString = MatchGuid.group().split("=")[1]\r
                        if GuidString.upper() in ModuleList:\r
                            MapBuffer.append('(IMAGE=%s)\n' % (os.path.join(ModuleList[GuidString.upper()].DebugDir, ModuleList[GuidString.upper()].Name + '.efi')))\r
\r
                FvMap.close()\r
\r
    ## Collect MAP information of all modules\r
    #\r
    def _CollectModuleMapBuffer (self, MapBuffer, ModuleList):\r
        sys.stdout.write ("Generate Load Module At Fix Address Map")\r
        sys.stdout.flush()\r
        PatchEfiImageList = []\r
        PeiModuleList  = {}\r
        BtModuleList   = {}\r
        RtModuleList   = {}\r
        SmmModuleList  = {}\r
        PeiSize = 0\r
        BtSize  = 0\r
        RtSize  = 0\r
        # reserve 4K size in SMRAM to make SMM module address not from 0.\r
        SmmSize = 0x1000\r
        for ModuleGuid in ModuleList:\r
            Module = ModuleList[ModuleGuid]\r
            GlobalData.gProcessingFile = "%s [%s, %s, %s]" % (Module.MetaFile, Module.Arch, Module.ToolChain, Module.BuildTarget)\r
\r
            OutputImageFile = ''\r
            for ResultFile in Module.CodaTargetList:\r
                if str(ResultFile.Target).endswith('.efi'):\r
                    #\r
                    # module list for PEI, DXE, RUNTIME and SMM\r
                    #\r
                    OutputImageFile = os.path.join(Module.OutputDir, Module.Name + '.efi')\r
                    ImageClass = PeImageClass (OutputImageFile)\r
                    if not ImageClass.IsValid:\r
                        EdkLogger.error("build", FILE_PARSE_FAILURE, ExtraData=ImageClass.ErrorInfo)\r
                    ImageInfo = PeImageInfo(Module.Name, Module.Guid, Module.Arch, Module.OutputDir, Module.DebugDir, ImageClass)\r
                    if Module.ModuleType in [SUP_MODULE_PEI_CORE, SUP_MODULE_PEIM, EDK_COMPONENT_TYPE_COMBINED_PEIM_DRIVER, EDK_COMPONENT_TYPE_PIC_PEIM, EDK_COMPONENT_TYPE_RELOCATABLE_PEIM, SUP_MODULE_DXE_CORE]:\r
                        PeiModuleList[Module.MetaFile] = ImageInfo\r
                        PeiSize += ImageInfo.Image.Size\r
                    elif Module.ModuleType in [EDK_COMPONENT_TYPE_BS_DRIVER, SUP_MODULE_DXE_DRIVER, SUP_MODULE_UEFI_DRIVER]:\r
                        BtModuleList[Module.MetaFile] = ImageInfo\r
                        BtSize += ImageInfo.Image.Size\r
                    elif Module.ModuleType in [SUP_MODULE_DXE_RUNTIME_DRIVER, EDK_COMPONENT_TYPE_RT_DRIVER, SUP_MODULE_DXE_SAL_DRIVER, EDK_COMPONENT_TYPE_SAL_RT_DRIVER]:\r
                        RtModuleList[Module.MetaFile] = ImageInfo\r
                        RtSize += ImageInfo.Image.Size\r
                    elif Module.ModuleType in [SUP_MODULE_SMM_CORE, SUP_MODULE_DXE_SMM_DRIVER, SUP_MODULE_MM_STANDALONE, SUP_MODULE_MM_CORE_STANDALONE]:\r
                        SmmModuleList[Module.MetaFile] = ImageInfo\r
                        SmmSize += ImageInfo.Image.Size\r
                        if Module.ModuleType == SUP_MODULE_DXE_SMM_DRIVER:\r
                            PiSpecVersion = Module.Module.Specification.get('PI_SPECIFICATION_VERSION', '0x00000000')\r
                            # for PI specification < PI1.1, DXE_SMM_DRIVER also runs as BOOT time driver.\r
                            if int(PiSpecVersion, 16) < 0x0001000A:\r
                                BtModuleList[Module.MetaFile] = ImageInfo\r
                                BtSize += ImageInfo.Image.Size\r
                    break\r
            #\r
            # EFI image is final target.\r
            # Check EFI image contains patchable FixAddress related PCDs.\r
            #\r
            if OutputImageFile != '':\r
                ModuleIsPatch = False\r
                for Pcd in Module.ModulePcdList:\r
                    if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE and Pcd.TokenCName in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SET:\r
                        ModuleIsPatch = True\r
                        break\r
                if not ModuleIsPatch:\r
                    for Pcd in Module.LibraryPcdList:\r
                        if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE and Pcd.TokenCName in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SET:\r
                            ModuleIsPatch = True\r
                            break\r
\r
                if not ModuleIsPatch:\r
                    continue\r
                #\r
                # Module includes the patchable load fix address PCDs.\r
                # It will be fixed up later.\r
                #\r
                PatchEfiImageList.append (OutputImageFile)\r
\r
        #\r
        # Get Top Memory address\r
        #\r
        ReservedRuntimeMemorySize = 0\r
        TopMemoryAddress = 0\r
        if self.LoadFixAddress == 0xFFFFFFFFFFFFFFFF:\r
            TopMemoryAddress = 0\r
        else:\r
            TopMemoryAddress = self.LoadFixAddress\r
            if TopMemoryAddress < RtSize + BtSize + PeiSize:\r
                EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS is too low to load driver")\r
\r
        #\r
        # Patch FixAddress related PCDs into EFI image\r
        #\r
        for EfiImage in PatchEfiImageList:\r
            EfiImageMap = EfiImage.replace('.efi', '.map')\r
            if not os.path.exists(EfiImageMap):\r
                continue\r
            #\r
            # Get PCD offset in EFI image by GenPatchPcdTable function\r
            #\r
            PcdTable = parsePcdInfoFromMapFile(EfiImageMap, EfiImage)\r
            #\r
            # Patch real PCD value by PatchPcdValue tool\r
            #\r
            for PcdInfo in PcdTable:\r
                ReturnValue = 0\r
                if PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE:\r
                    ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE_DATA_TYPE, str (PeiSize // 0x1000))\r
                elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE:\r
                    ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE_DATA_TYPE, str (BtSize // 0x1000))\r
                elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE:\r
                    ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE_DATA_TYPE, str (RtSize // 0x1000))\r
                elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE and len (SmmModuleList) > 0:\r
                    ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE_DATA_TYPE, str (SmmSize // 0x1000))\r
                if ReturnValue != 0:\r
                    EdkLogger.error("build", PARAMETER_INVALID, "Patch PCD value failed", ExtraData=ErrorInfo)\r
\r
        MapBuffer.append('PEI_CODE_PAGE_NUMBER      = 0x%x\n' % (PeiSize // 0x1000))\r
        MapBuffer.append('BOOT_CODE_PAGE_NUMBER     = 0x%x\n' % (BtSize // 0x1000))\r
        MapBuffer.append('RUNTIME_CODE_PAGE_NUMBER  = 0x%x\n' % (RtSize // 0x1000))\r
        if len (SmmModuleList) > 0:\r
            MapBuffer.append('SMM_CODE_PAGE_NUMBER      = 0x%x\n' % (SmmSize // 0x1000))\r
\r
        PeiBaseAddr = TopMemoryAddress - RtSize - BtSize\r
        BtBaseAddr  = TopMemoryAddress - RtSize\r
        RtBaseAddr  = TopMemoryAddress - ReservedRuntimeMemorySize\r
\r
        self._RebaseModule (MapBuffer, PeiBaseAddr, PeiModuleList, TopMemoryAddress == 0)\r
        self._RebaseModule (MapBuffer, BtBaseAddr, BtModuleList, TopMemoryAddress == 0)\r
        self._RebaseModule (MapBuffer, RtBaseAddr, RtModuleList, TopMemoryAddress == 0)\r
        self._RebaseModule (MapBuffer, 0x1000, SmmModuleList, AddrIsOffset=False, ModeIsSmm=True)\r
        MapBuffer.append('\n\n')\r
        sys.stdout.write ("\n")\r
        sys.stdout.flush()\r
\r
    ## Save platform Map file\r
    #\r
    def _SaveMapFile (self, MapBuffer, Wa):\r
        #\r
        # Map file path is got.\r
        #\r
        MapFilePath = os.path.join(Wa.BuildDir, Wa.Name + '.map')\r
        #\r
        # Save address map into MAP file.\r
        #\r
        SaveFileOnChange(MapFilePath, ''.join(MapBuffer), False)\r
        if self.LoadFixAddress != 0:\r
            sys.stdout.write ("\nLoad Module At Fix Address Map file can be found at %s\n" % (MapFilePath))\r
        sys.stdout.flush()\r
\r
    ## Build active platform for different build targets and different tool chains\r
    #\r
    def _BuildPlatform(self):\r
        SaveFileOnChange(self.PlatformBuildPath, '# DO NOT EDIT \n# FILE auto-generated\n', False)\r
        for BuildTarget in self.BuildTargetList:\r
            GlobalData.gGlobalDefines['TARGET'] = BuildTarget\r
            index = 0\r
            for ToolChain in self.ToolChainList:\r
                GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain\r
                GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain\r
                GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[index]\r
                index += 1\r
                Wa = WorkspaceAutoGen(\r
                        self.WorkspaceDir,\r
                        self.PlatformFile,\r
                        BuildTarget,\r
                        ToolChain,\r
                        self.ArchList,\r
                        self.BuildDatabase,\r
                        self.TargetTxt,\r
                        self.ToolDef,\r
                        self.Fdf,\r
                        self.FdList,\r
                        self.FvList,\r
                        self.CapList,\r
                        self.SkuId,\r
                        self.UniFlag,\r
                        self.Progress\r
                        )\r
                self.Fdf = Wa.FdfFile\r
                self.LoadFixAddress = Wa.Platform.LoadFixAddress\r
                self.BuildReport.AddPlatformReport(Wa)\r
                self.Progress.Stop("done!")\r
\r
                # Add ffs build to makefile\r
                CmdListDict = {}\r
                if GlobalData.gEnableGenfdsMultiThread and self.Fdf:\r
                    CmdListDict = self._GenFfsCmd(Wa.ArchList)\r
\r
                for Arch in Wa.ArchList:\r
                    GlobalData.gGlobalDefines['ARCH'] = Arch\r
                    Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)\r
                    for Module in Pa.Platform.Modules:\r
                        # Get ModuleAutoGen object to generate C code file and makefile\r
                        Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)\r
                        if Ma is None:\r
                            continue\r
                        self.BuildModules.append(Ma)\r
                    self._BuildPa(self.Target, Pa, FfsCommand=CmdListDict)\r
\r
                # Create MAP file when Load Fix Address is enabled.\r
                if self.Target in ["", "all", "fds"]:\r
                    for Arch in Wa.ArchList:\r
                        GlobalData.gGlobalDefines['ARCH'] = Arch\r
                        #\r
                        # Check whether the set fix address is above 4G for 32bit image.\r
                        #\r
                        if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:\r
                            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")\r
                    #\r
                    # Get Module List\r
                    #\r
                    ModuleList = {}\r
                    for Pa in Wa.AutoGenObjectList:\r
                        for Ma in Pa.ModuleAutoGenList:\r
                            if Ma is None:\r
                                continue\r
                            if not Ma.IsLibrary:\r
                                ModuleList[Ma.Guid.upper()] = Ma\r
\r
                    MapBuffer = []\r
                    if self.LoadFixAddress != 0:\r
                        #\r
                        # Rebase module to the preferred memory address before GenFds\r
                        #\r
                        self._CollectModuleMapBuffer(MapBuffer, ModuleList)\r
                    if self.Fdf:\r
                        #\r
                        # create FDS again for the updated EFI image\r
                        #\r
                        self._Build("fds", Wa)\r
                        #\r
                        # Create MAP file for all platform FVs after GenFds.\r
                        #\r
                        self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)\r
                    #\r
                    # Save MAP buffer into MAP file.\r
                    #\r
                    self._SaveMapFile (MapBuffer, Wa)\r
\r
    ## Build active module for different build targets, different tool chains and different archs\r
    #\r
    def _BuildModule(self):\r
        for BuildTarget in self.BuildTargetList:\r
            GlobalData.gGlobalDefines['TARGET'] = BuildTarget\r
            index = 0\r
            for ToolChain in self.ToolChainList:\r
                WorkspaceAutoGenTime = time.time()\r
                GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain\r
                GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain\r
                GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[index]\r
                index += 1\r
                #\r
                # module build needs platform build information, so get platform\r
                # AutoGen first\r
                #\r
                Wa = WorkspaceAutoGen(\r
                        self.WorkspaceDir,\r
                        self.PlatformFile,\r
                        BuildTarget,\r
                        ToolChain,\r
                        self.ArchList,\r
                        self.BuildDatabase,\r
                        self.TargetTxt,\r
                        self.ToolDef,\r
                        self.Fdf,\r
                        self.FdList,\r
                        self.FvList,\r
                        self.CapList,\r
                        self.SkuId,\r
                        self.UniFlag,\r
                        self.Progress,\r
                        self.ModuleFile\r
                        )\r
                self.Fdf = Wa.FdfFile\r
                self.LoadFixAddress = Wa.Platform.LoadFixAddress\r
                Wa.CreateMakeFile(False)\r
                # Add ffs build to makefile\r
                CmdListDict = None\r
                if GlobalData.gEnableGenfdsMultiThread and self.Fdf:\r
                    CmdListDict = self._GenFfsCmd(Wa.ArchList)\r
                self.Progress.Stop("done!")\r
                MaList = []\r
                ExitFlag = threading.Event()\r
                ExitFlag.clear()\r
                self.AutoGenTime += int(round((time.time() - WorkspaceAutoGenTime)))\r
                for Arch in Wa.ArchList:\r
                    AutoGenStart = time.time()\r
                    GlobalData.gGlobalDefines['ARCH'] = Arch\r
                    Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)\r
                    for Module in Pa.Platform.Modules:\r
                        if self.ModuleFile.Dir == Module.Dir and self.ModuleFile.Name == Module.Name:\r
                            Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)\r
                            if Ma is None:\r
                                continue\r
                            MaList.append(Ma)\r
                            if Ma.CanSkipbyHash():\r
                                self.HashSkipModules.append(Ma)\r
                                continue\r
                            # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'\r
                            if self.Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:\r
                                # for target which must generate AutoGen code and makefile\r
                                if not self.SkipAutoGen or self.Target == 'genc':\r
                                    self.Progress.Start("Generating code")\r
                                    Ma.CreateCodeFile(True)\r
                                    self.Progress.Stop("done!")\r
                                if self.Target == "genc":\r
                                    return True\r
                                if not self.SkipAutoGen or self.Target == 'genmake':\r
                                    self.Progress.Start("Generating makefile")\r
                                    if CmdListDict and self.Fdf and (Module.File, Arch) in CmdListDict:\r
                                        Ma.CreateMakeFile(True, CmdListDict[Module.File, Arch])\r
                                        del CmdListDict[Module.File, Arch]\r
                                    else:\r
                                        Ma.CreateMakeFile(True)\r
                                    self.Progress.Stop("done!")\r
                                if self.Target == "genmake":\r
                                    return True\r
                            self.BuildModules.append(Ma)\r
                            # Initialize all modules in tracking to 'FAIL'\r
                            if Ma.Arch not in GlobalData.gModuleBuildTracking:\r
                                GlobalData.gModuleBuildTracking[Ma.Arch] = dict()\r
                            if Ma not in GlobalData.gModuleBuildTracking[Ma.Arch]:\r
                                GlobalData.gModuleBuildTracking[Ma.Arch][Ma] = 'FAIL'\r
                    self.AutoGenTime += int(round((time.time() - AutoGenStart)))\r
                    MakeStart = time.time()\r
                    for Ma in self.BuildModules:\r
                        if not Ma.IsBinaryModule:\r
                            Bt = BuildTask.New(ModuleMakeUnit(Ma, self.Target))\r
                        # Break build if any build thread has error\r
                        if BuildTask.HasError():\r
                            # we need a full version of makefile for platform\r
                            ExitFlag.set()\r
                            BuildTask.WaitForComplete()\r
                            self.invalidateHash()\r
                            Pa.CreateMakeFile(False)\r
                            EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)\r
                        # Start task scheduler\r
                        if not BuildTask.IsOnGoing():\r
                            BuildTask.StartScheduler(self.ThreadNumber, ExitFlag)\r
\r
                    # in case there's an interruption. we need a full version of makefile for platform\r
                    Pa.CreateMakeFile(False)\r
                    if BuildTask.HasError():\r
                        self.invalidateHash()\r
                        EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)\r
                    self.MakeTime += int(round((time.time() - MakeStart)))\r
\r
                MakeContiue = time.time()\r
                ExitFlag.set()\r
                BuildTask.WaitForComplete()\r
                self.CreateAsBuiltInf()\r
                self.MakeTime += int(round((time.time() - MakeContiue)))\r
                if BuildTask.HasError():\r
                    self.invalidateHash()\r
                    EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)\r
\r
                self.BuildReport.AddPlatformReport(Wa, MaList)\r
                if MaList == []:\r
                    EdkLogger.error(\r
                                'build',\r
                                BUILD_ERROR,\r
                                "Module for [%s] is not a component of active platform."\\r
                                " Please make sure that the ARCH and inf file path are"\\r
                                " given in the same as in [%s]" % \\r
                                    (', '.join(Wa.ArchList), self.PlatformFile),\r
                                ExtraData=self.ModuleFile\r
                                )\r
                # Create MAP file when Load Fix Address is enabled.\r
                if self.Target == "fds" and self.Fdf:\r
                    for Arch in Wa.ArchList:\r
                        #\r
                        # Check whether the set fix address is above 4G for 32bit image.\r
                        #\r
                        if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:\r
                            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")\r
                    #\r
                    # Get Module List\r
                    #\r
                    ModuleList = {}\r
                    for Pa in Wa.AutoGenObjectList:\r
                        for Ma in Pa.ModuleAutoGenList:\r
                            if Ma is None:\r
                                continue\r
                            if not Ma.IsLibrary:\r
                                ModuleList[Ma.Guid.upper()] = Ma\r
\r
                    MapBuffer = []\r
                    if self.LoadFixAddress != 0:\r
                        #\r
                        # Rebase module to the preferred memory address before GenFds\r
                        #\r
                        self._CollectModuleMapBuffer(MapBuffer, ModuleList)\r
                    #\r
                    # create FDS again for the updated EFI image\r
                    #\r
                    GenFdsStart = time.time()\r
                    self._Build("fds", Wa)\r
                    self.GenFdsTime += int(round((time.time() - GenFdsStart)))\r
                    #\r
                    # Create MAP file for all platform FVs after GenFds.\r
                    #\r
                    self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)\r
                    #\r
                    # Save MAP buffer into MAP file.\r
                    #\r
                    self._SaveMapFile (MapBuffer, Wa)\r
        self.invalidateHash()\r
\r
    def _GenFfsCmd(self,ArchList):\r
        # convert dictionary of Cmd:(Inf,Arch)\r
        # to a new dictionary of (Inf,Arch):Cmd,Cmd,Cmd...\r
        CmdSetDict = defaultdict(set)\r
        GenFfsDict = GenFds.GenFfsMakefile('', GlobalData.gFdfParser, self, ArchList, GlobalData)\r
        for Cmd in GenFfsDict:\r
            tmpInf, tmpArch = GenFfsDict[Cmd]\r
            CmdSetDict[tmpInf, tmpArch].add(Cmd)\r
        return CmdSetDict\r
\r
    ## Build a platform in multi-thread mode\r
    #\r
    def _MultiThreadBuildPlatform(self):\r
        SaveFileOnChange(self.PlatformBuildPath, '# DO NOT EDIT \n# FILE auto-generated\n', False)\r
        for BuildTarget in self.BuildTargetList:\r
            GlobalData.gGlobalDefines['TARGET'] = BuildTarget\r
            index = 0\r
            for ToolChain in self.ToolChainList:\r
                WorkspaceAutoGenTime = time.time()\r
                GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain\r
                GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain\r
                GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[index]\r
                index += 1\r
                Wa = WorkspaceAutoGen(\r
                        self.WorkspaceDir,\r
                        self.PlatformFile,\r
                        BuildTarget,\r
                        ToolChain,\r
                        self.ArchList,\r
                        self.BuildDatabase,\r
                        self.TargetTxt,\r
                        self.ToolDef,\r
                        self.Fdf,\r
                        self.FdList,\r
                        self.FvList,\r
                        self.CapList,\r
                        self.SkuId,\r
                        self.UniFlag,\r
                        self.Progress\r
                        )\r
                self.Fdf = Wa.FdfFile\r
                self.LoadFixAddress = Wa.Platform.LoadFixAddress\r
                self.BuildReport.AddPlatformReport(Wa)\r
                Wa.CreateMakeFile(False)\r
\r
                # Add ffs build to makefile\r
                CmdListDict = None\r
                if GlobalData.gEnableGenfdsMultiThread and self.Fdf:\r
                    CmdListDict = self._GenFfsCmd(Wa.ArchList)\r
\r
                # multi-thread exit flag\r
                ExitFlag = threading.Event()\r
                ExitFlag.clear()\r
                self.AutoGenTime += int(round((time.time() - WorkspaceAutoGenTime)))\r
                for Arch in Wa.ArchList:\r
                    AutoGenStart = time.time()\r
                    GlobalData.gGlobalDefines['ARCH'] = Arch\r
                    Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)\r
                    if Pa is None:\r
                        continue\r
                    ModuleList = []\r
                    for Inf in Pa.Platform.Modules:\r
                        ModuleList.append(Inf)\r
                    # Add the INF only list in FDF\r
                    if GlobalData.gFdfParser is not None:\r
                        for InfName in GlobalData.gFdfParser.Profile.InfList:\r
                            Inf = PathClass(NormPath(InfName), self.WorkspaceDir, Arch)\r
                            if Inf in Pa.Platform.Modules:\r
                                continue\r
                            ModuleList.append(Inf)\r
                    for Module in ModuleList:\r
                        # Get ModuleAutoGen object to generate C code file and makefile\r
                        Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)\r
\r
                        if Ma is None:\r
                            continue\r
                        if Ma.CanSkipbyHash():\r
                            self.HashSkipModules.append(Ma)\r
                            continue\r
\r
                        # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'\r
                        if self.Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:\r
                            # for target which must generate AutoGen code and makefile\r
                            if not self.SkipAutoGen or self.Target == 'genc':\r
                                Ma.CreateCodeFile(True)\r
                            if self.Target == "genc":\r
                                continue\r
\r
                            if not self.SkipAutoGen or self.Target == 'genmake':\r
                                if CmdListDict and self.Fdf and (Module.File, Arch) in CmdListDict:\r
                                    Ma.CreateMakeFile(True, CmdListDict[Module.File, Arch])\r
                                    del CmdListDict[Module.File, Arch]\r
                                else:\r
                                    Ma.CreateMakeFile(True)\r
                            if self.Target == "genmake":\r
                                continue\r
                        self.BuildModules.append(Ma)\r
                        # Initialize all modules in tracking to 'FAIL'\r
                        if Ma.Arch not in GlobalData.gModuleBuildTracking:\r
                            GlobalData.gModuleBuildTracking[Ma.Arch] = dict()\r
                        if Ma not in GlobalData.gModuleBuildTracking[Ma.Arch]:\r
                            GlobalData.gModuleBuildTracking[Ma.Arch][Ma] = 'FAIL'\r
                    self.Progress.Stop("done!")\r
                    self.AutoGenTime += int(round((time.time() - AutoGenStart)))\r
                    MakeStart = time.time()\r
                    for Ma in self.BuildModules:\r
                        # Generate build task for the module\r
                        if not Ma.IsBinaryModule:\r
                            Bt = BuildTask.New(ModuleMakeUnit(Ma, self.Target))\r
                        # Break build if any build thread has error\r
                        if BuildTask.HasError():\r
                            # we need a full version of makefile for platform\r
                            ExitFlag.set()\r
                            BuildTask.WaitForComplete()\r
                            self.invalidateHash()\r
                            Pa.CreateMakeFile(False)\r
                            EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)\r
                        # Start task scheduler\r
                        if not BuildTask.IsOnGoing():\r
                            BuildTask.StartScheduler(self.ThreadNumber, ExitFlag)\r
\r
                    # in case there's an interruption. we need a full version of makefile for platform\r
                    Pa.CreateMakeFile(False)\r
                    if BuildTask.HasError():\r
                        self.invalidateHash()\r
                        EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)\r
                    self.MakeTime += int(round((time.time() - MakeStart)))\r
\r
                MakeContiue = time.time()\r
\r
                #\r
                #\r
                # All modules have been put in build tasks queue. Tell task scheduler\r
                # to exit if all tasks are completed\r
                #\r
                ExitFlag.set()\r
                BuildTask.WaitForComplete()\r
                self.CreateAsBuiltInf()\r
                self.MakeTime += int(round((time.time() - MakeContiue)))\r
                #\r
                # Check for build error, and raise exception if one\r
                # has been signaled.\r
                #\r
                if BuildTask.HasError():\r
                    self.invalidateHash()\r
                    EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)\r
\r
                # Create MAP file when Load Fix Address is enabled.\r
                if self.Target in ["", "all", "fds"]:\r
                    for Arch in Wa.ArchList:\r
                        #\r
                        # Check whether the set fix address is above 4G for 32bit image.\r
                        #\r
                        if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:\r
                            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")\r
                    #\r
                    # Get Module List\r
                    #\r
                    ModuleList = {}\r
                    for Pa in Wa.AutoGenObjectList:\r
                        for Ma in Pa.ModuleAutoGenList:\r
                            if Ma is None:\r
                                continue\r
                            if not Ma.IsLibrary:\r
                                ModuleList[Ma.Guid.upper()] = Ma\r
                    #\r
                    # Rebase module to the preferred memory address before GenFds\r
                    #\r
                    MapBuffer = []\r
                    if self.LoadFixAddress != 0:\r
                        self._CollectModuleMapBuffer(MapBuffer, ModuleList)\r
\r
                    if self.Fdf:\r
                        #\r
                        # Generate FD image if there's a FDF file found\r
                        #\r
                        GenFdsStart = time.time()\r
                        if GenFdsApi(Wa.GenFdsCommandDict, self.Db):\r
                            EdkLogger.error("build", COMMAND_FAILURE)\r
\r
                        #\r
                        # Create MAP file for all platform FVs after GenFds.\r
                        #\r
                        self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)\r
                        self.GenFdsTime += int(round((time.time() - GenFdsStart)))\r
                    #\r
                    # Save MAP buffer into MAP file.\r
                    #\r
                    self._SaveMapFile(MapBuffer, Wa)\r
        self.invalidateHash()\r
\r
    ## Generate GuidedSectionTools.txt in the FV directories.\r
    #\r
    def CreateGuidedSectionToolsFile(self):\r
        for BuildTarget in self.BuildTargetList:\r
            for ToolChain in self.ToolChainList:\r
                Wa = WorkspaceAutoGen(\r
                        self.WorkspaceDir,\r
                        self.PlatformFile,\r
                        BuildTarget,\r
                        ToolChain,\r
                        self.ArchList,\r
                        self.BuildDatabase,\r
                        self.TargetTxt,\r
                        self.ToolDef,\r
                        self.Fdf,\r
                        self.FdList,\r
                        self.FvList,\r
                        self.CapList,\r
                        self.SkuId,\r
                        self.UniFlag\r
                        )\r
                FvDir = Wa.FvDir\r
                if not os.path.exists(FvDir):\r
                    continue\r
\r
                for Arch in self.ArchList:\r
                    # Build up the list of supported architectures for this build\r
                    prefix = '%s_%s_%s_' % (BuildTarget, ToolChain, Arch)\r
\r
                    # Look through the tool definitions for GUIDed tools\r
                    guidAttribs = []\r
                    for (attrib, value) in self.ToolDef.ToolsDefTxtDictionary.items():\r
                        if attrib.upper().endswith('_GUID'):\r
                            split = attrib.split('_')\r
                            thisPrefix = '_'.join(split[0:3]) + '_'\r
                            if thisPrefix == prefix:\r
                                guid = self.ToolDef.ToolsDefTxtDictionary[attrib]\r
                                guid = guid.lower()\r
                                toolName = split[3]\r
                                path = '_'.join(split[0:4]) + '_PATH'\r
                                path = self.ToolDef.ToolsDefTxtDictionary[path]\r
                                path = self.GetFullPathOfTool(path)\r
                                guidAttribs.append((guid, toolName, path))\r
\r
                    # Write out GuidedSecTools.txt\r
                    toolsFile = os.path.join(FvDir, 'GuidedSectionTools.txt')\r
                    toolsFile = open(toolsFile, 'wt')\r
                    for guidedSectionTool in guidAttribs:\r
                        print(' '.join(guidedSectionTool), file=toolsFile)\r
                    toolsFile.close()\r
\r
    ## Returns the full path of the tool.\r
    #\r
    def GetFullPathOfTool (self, tool):\r
        if os.path.exists(tool):\r
            return os.path.realpath(tool)\r
        else:\r
            # We need to search for the tool using the\r
            # PATH environment variable.\r
            for dirInPath in os.environ['PATH'].split(os.pathsep):\r
                foundPath = os.path.join(dirInPath, tool)\r
                if os.path.exists(foundPath):\r
                    return os.path.realpath(foundPath)\r
\r
        # If the tool was not found in the path then we just return\r
        # the input tool.\r
        return tool\r
\r
    ## Launch the module or platform build\r
    #\r
    def Launch(self):\r
        if not self.ModuleFile:\r
            if not self.SpawnMode or self.Target not in ["", "all"]:\r
                self.SpawnMode = False\r
                self._BuildPlatform()\r
            else:\r
                self._MultiThreadBuildPlatform()\r
            self.CreateGuidedSectionToolsFile()\r
        else:\r
            self.SpawnMode = False\r
            self._BuildModule()\r
\r
        if self.Target == 'cleanall':\r
            RemoveDirectory(os.path.dirname(GlobalData.gDatabasePath), True)\r
\r
    def CreateAsBuiltInf(self):\r
        all_lib_set = set()\r
        all_mod_set = set()\r
        for Module in self.BuildModules:\r
            Module.CreateAsBuiltInf()\r
            all_mod_set.add(Module)\r
        for Module in self.HashSkipModules:\r
            Module.CreateAsBuiltInf(True)\r
            all_mod_set.add(Module)\r
        for Module in all_mod_set:\r
            for lib in Module.LibraryAutoGenList:\r
                all_lib_set.add(lib)\r
        for lib in all_lib_set:\r
            lib.CreateAsBuiltInf(True)\r
        all_lib_set.clear()\r
        all_mod_set.clear()\r
        self.BuildModules = []\r
        self.HashSkipModules = []\r
    ## Do some clean-up works when error occurred\r
    def Relinquish(self):\r
        OldLogLevel = EdkLogger.GetLevel()\r
        EdkLogger.SetLevel(EdkLogger.ERROR)\r
        Utils.Progressor.Abort()\r
        if self.SpawnMode == True:\r
            BuildTask.Abort()\r
        EdkLogger.SetLevel(OldLogLevel)\r
\r
def ParseDefines(DefineList=[]):\r
    DefineDict = {}\r
    if DefineList is not None:\r
        for Define in DefineList:\r
            DefineTokenList = Define.split("=", 1)\r
            if not GlobalData.gMacroNamePattern.match(DefineTokenList[0]):\r
                EdkLogger.error('build', FORMAT_INVALID,\r
                                "The macro name must be in the pattern [A-Z][A-Z0-9_]*",\r
                                ExtraData=DefineTokenList[0])\r
\r
            if len(DefineTokenList) == 1:\r
                DefineDict[DefineTokenList[0]] = "TRUE"\r
            else:\r
                DefineDict[DefineTokenList[0]] = DefineTokenList[1].strip()\r
    return DefineDict\r
\r
gParamCheck = []\r
def SingleCheckCallback(option, opt_str, value, parser):\r
    if option not in gParamCheck:\r
        setattr(parser.values, option.dest, value)\r
        gParamCheck.append(option)\r
    else:\r
        parser.error("Option %s only allows one instance in command line!" % option)\r
\r
def LogBuildTime(Time):\r
    if Time:\r
        TimeDurStr = ''\r
        TimeDur = time.gmtime(Time)\r
        if TimeDur.tm_yday > 1:\r
            TimeDurStr = time.strftime("%H:%M:%S", TimeDur) + ", %d day(s)" % (TimeDur.tm_yday - 1)\r
        else:\r
            TimeDurStr = time.strftime("%H:%M:%S", TimeDur)\r
        return TimeDurStr\r
    else:\r
        return None\r
\r
## Parse command line options\r
#\r
# Using standard Python module optparse to parse command line option of this tool.\r
#\r
#   @retval Opt   A optparse.Values object containing the parsed options\r
#   @retval Args  Target of build command\r
#\r
def MyOptionParser():\r
    Parser = OptionParser(description=__copyright__, version=__version__, prog="build.exe", usage="%prog [options] [all|fds|genc|genmake|clean|cleanall|cleanlib|modules|libraries|run]")\r
    Parser.add_option("-a", "--arch", action="append", type="choice", choices=['IA32', 'X64', 'EBC', 'ARM', 'AARCH64'], dest="TargetArch",\r
        help="ARCHS is one of list: IA32, X64, ARM, AARCH64 or EBC, which overrides target.txt's TARGET_ARCH definition. To specify more archs, please repeat this option.")\r
    Parser.add_option("-p", "--platform", action="callback", type="string", dest="PlatformFile", callback=SingleCheckCallback,\r
        help="Build the platform specified by the DSC file name argument, overriding target.txt's ACTIVE_PLATFORM definition.")\r
    Parser.add_option("-m", "--module", action="callback", type="string", dest="ModuleFile", callback=SingleCheckCallback,\r
        help="Build the module specified by the INF file name argument.")\r
    Parser.add_option("-b", "--buildtarget", type="string", dest="BuildTarget", help="Using the TARGET to build the platform, overriding target.txt's TARGET definition.",\r
                      action="append")\r
    Parser.add_option("-t", "--tagname", action="append", type="string", dest="ToolChain",\r
        help="Using the Tool Chain Tagname to build the platform, overriding target.txt's TOOL_CHAIN_TAG definition.")\r
    Parser.add_option("-x", "--sku-id", action="callback", type="string", dest="SkuId", callback=SingleCheckCallback,\r
        help="Using this name of SKU ID to build the platform, overriding SKUID_IDENTIFIER in DSC file.")\r
\r
    Parser.add_option("-n", action="callback", type="int", dest="ThreadNumber", callback=SingleCheckCallback,\r
        help="Build the platform using multi-threaded compiler. The value overrides target.txt's MAX_CONCURRENT_THREAD_NUMBER. When value is set to 0, tool automatically detect number of "\\r
             "processor threads, set value to 1 means disable multi-thread build, and set value to more than 1 means user specify the threads number to build.")\r
\r
    Parser.add_option("-f", "--fdf", action="callback", type="string", dest="FdfFile", callback=SingleCheckCallback,\r
        help="The name of the FDF file to use, which overrides the setting in the DSC file.")\r
    Parser.add_option("-r", "--rom-image", action="append", type="string", dest="RomImage", default=[],\r
        help="The name of FD to be generated. The name must be from [FD] section in FDF file.")\r
    Parser.add_option("-i", "--fv-image", action="append", type="string", dest="FvImage", default=[],\r
        help="The name of FV to be generated. The name must be from [FV] section in FDF file.")\r
    Parser.add_option("-C", "--capsule-image", action="append", type="string", dest="CapName", default=[],\r
        help="The name of Capsule to be generated. The name must be from [Capsule] section in FDF file.")\r
    Parser.add_option("-u", "--skip-autogen", action="store_true", dest="SkipAutoGen", help="Skip AutoGen step.")\r
    Parser.add_option("-e", "--re-parse", action="store_true", dest="Reparse", help="Re-parse all meta-data files.")\r
\r
    Parser.add_option("-c", "--case-insensitive", action="store_true", dest="CaseInsensitive", default=False, help="Don't check case of file name.")\r
\r
    Parser.add_option("-w", "--warning-as-error", action="store_true", dest="WarningAsError", help="Treat warning in tools as error.")\r
    Parser.add_option("-j", "--log", action="store", dest="LogFile", help="Put log in specified file as well as on console.")\r
\r
    Parser.add_option("-s", "--silent", action="store_true", type=None, dest="SilentMode",\r
        help="Make use of silent mode of (n)make.")\r
    Parser.add_option("-q", "--quiet", action="store_true", type=None, help="Disable all messages except FATAL ERRORS.")\r
    Parser.add_option("-v", "--verbose", action="store_true", type=None, help="Turn on verbose output with informational messages printed, "\\r
                                                                               "including library instances selected, final dependency expression, "\\r
                                                                               "and warning messages, etc.")\r
    Parser.add_option("-d", "--debug", action="store", type="int", help="Enable debug messages at specified level.")\r
    Parser.add_option("-D", "--define", action="append", type="string", dest="Macros", help="Macro: \"Name [= Value]\".")\r
\r
    Parser.add_option("-y", "--report-file", action="store", dest="ReportFile", help="Create/overwrite the report to the specified filename.")\r
    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=[],\r
        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].  "\\r
             "To specify more than one flag, repeat this option on the command line and the default flag set is [PCD, LIBRARY, FLASH, DEPEX, HASH, BUILD_FLAGS, FIXED_ADDRESS]")\r
    Parser.add_option("-F", "--flag", action="store", type="string", dest="Flag",\r
        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. "\\r
             "This option can also be specified by setting *_*_*_BUILD_FLAGS in [BuildOptions] section of platform DSC. If they are both specified, this value "\\r
             "will override the setting in [BuildOptions] section of platform DSC.")\r
    Parser.add_option("-N", "--no-cache", action="store_true", dest="DisableCache", default=False, help="Disable build cache mechanism")\r
    Parser.add_option("--conf", action="store", type="string", dest="ConfDirectory", help="Specify the customized Conf directory.")\r
    Parser.add_option("--check-usage", action="store_true", dest="CheckUsage", default=False, help="Check usage content of entries listed in INF file.")\r
    Parser.add_option("--ignore-sources", action="store_true", dest="IgnoreSources", default=False, help="Focus to a binary build and ignore all source files")\r
    Parser.add_option("--pcd", action="append", dest="OptionPcd", help="Set PCD value by command line. Format: \"PcdName=Value\" ")\r
    Parser.add_option("-l", "--cmd-len", action="store", type="int", dest="CommandLength", help="Specify the maximum line length of build command. Default is 4096.")\r
    Parser.add_option("--hash", action="store_true", dest="UseHashCache", default=False, help="Enable hash-based caching during build process.")\r
    Parser.add_option("--binary-destination", action="store", type="string", dest="BinCacheDest", help="Generate a cache of binary files in the specified directory.")\r
    Parser.add_option("--binary-source", action="store", type="string", dest="BinCacheSource", help="Consume a cache of binary files from the specified directory.")\r
    Parser.add_option("--genfds-multi-thread", action="store_true", dest="GenfdsMultiThread", default=False, help="Enable GenFds multi thread to generate ffs file.")\r
    Parser.add_option("--disable-include-path-check", action="store_true", dest="DisableIncludePathCheck", default=False, help="Disable the include path check for outside of package.")\r
    (Opt, Args) = Parser.parse_args()\r
    return (Opt, Args)\r
\r
## Tool entrance method\r
#\r
# This method mainly dispatch specific methods per the command line options.\r
# If no error found, return zero value so the caller of this tool can know\r
# if it's executed successfully or not.\r
#\r
#   @retval 0     Tool was successful\r
#   @retval 1     Tool failed\r
#\r
def Main():\r
    StartTime = time.time()\r
\r
    # Initialize log system\r
    EdkLogger.Initialize()\r
    GlobalData.gCommand = sys.argv[1:]\r
    #\r
    # Parse the options and args\r
    #\r
    (Option, Target) = MyOptionParser()\r
    GlobalData.gOptions = Option\r
    GlobalData.gCaseInsensitive = Option.CaseInsensitive\r
\r
    # Set log level\r
    if Option.verbose is not None:\r
        EdkLogger.SetLevel(EdkLogger.VERBOSE)\r
    elif Option.quiet is not None:\r
        EdkLogger.SetLevel(EdkLogger.QUIET)\r
    elif Option.debug is not None:\r
        EdkLogger.SetLevel(Option.debug + 1)\r
    else:\r
        EdkLogger.SetLevel(EdkLogger.INFO)\r
\r
    if Option.LogFile is not None:\r
        EdkLogger.SetLogFile(Option.LogFile)\r
\r
    if Option.WarningAsError == True:\r
        EdkLogger.SetWarningAsError()\r
\r
    if platform.platform().find("Windows") >= 0:\r
        GlobalData.gIsWindows = True\r
    else:\r
        GlobalData.gIsWindows = False\r
\r
    EdkLogger.quiet("Build environment: %s" % platform.platform())\r
    EdkLogger.quiet(time.strftime("Build start time: %H:%M:%S, %b.%d %Y\n", time.localtime()));\r
    ReturnCode = 0\r
    MyBuild = None\r
    BuildError = True\r
    try:\r
        if len(Target) == 0:\r
            Target = "all"\r
        elif len(Target) >= 2:\r
            EdkLogger.error("build", OPTION_NOT_SUPPORTED, "More than one targets are not supported.",\r
                            ExtraData="Please select one of: %s" % (' '.join(gSupportedTarget)))\r
        else:\r
            Target = Target[0].lower()\r
\r
        if Target not in gSupportedTarget:\r
            EdkLogger.error("build", OPTION_NOT_SUPPORTED, "Not supported target [%s]." % Target,\r
                            ExtraData="Please select one of: %s" % (' '.join(gSupportedTarget)))\r
\r
        #\r
        # Check environment variable: EDK_TOOLS_PATH, WORKSPACE, PATH\r
        #\r
        CheckEnvVariable()\r
        GlobalData.gCommandLineDefines.update(ParseDefines(Option.Macros))\r
\r
        Workspace = os.getenv("WORKSPACE")\r
        #\r
        # Get files real name in workspace dir\r
        #\r
        GlobalData.gAllFiles = Utils.DirCache(Workspace)\r
\r
        WorkingDirectory = os.getcwd()\r
        if not Option.ModuleFile:\r
            FileList = glob.glob(os.path.normpath(os.path.join(WorkingDirectory, '*.inf')))\r
            FileNum = len(FileList)\r
            if FileNum >= 2:\r
                EdkLogger.error("build", OPTION_NOT_SUPPORTED, "There are %d INF files in %s." % (FileNum, WorkingDirectory),\r
                                ExtraData="Please use '-m <INF_FILE_PATH>' switch to choose one.")\r
            elif FileNum == 1:\r
                Option.ModuleFile = NormFile(FileList[0], Workspace)\r
\r
        if Option.ModuleFile:\r
            if os.path.isabs (Option.ModuleFile):\r
                if os.path.normcase (os.path.normpath(Option.ModuleFile)).find (Workspace) == 0:\r
                    Option.ModuleFile = NormFile(os.path.normpath(Option.ModuleFile), Workspace)\r
            Option.ModuleFile = PathClass(Option.ModuleFile, Workspace)\r
            ErrorCode, ErrorInfo = Option.ModuleFile.Validate(".inf", False)\r
            if ErrorCode != 0:\r
                EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)\r
\r
        if Option.PlatformFile is not None:\r
            if os.path.isabs (Option.PlatformFile):\r
                if os.path.normcase (os.path.normpath(Option.PlatformFile)).find (Workspace) == 0:\r
                    Option.PlatformFile = NormFile(os.path.normpath(Option.PlatformFile), Workspace)\r
            Option.PlatformFile = PathClass(Option.PlatformFile, Workspace)\r
\r
        if Option.FdfFile is not None:\r
            if os.path.isabs (Option.FdfFile):\r
                if os.path.normcase (os.path.normpath(Option.FdfFile)).find (Workspace) == 0:\r
                    Option.FdfFile = NormFile(os.path.normpath(Option.FdfFile), Workspace)\r
            Option.FdfFile = PathClass(Option.FdfFile, Workspace)\r
            ErrorCode, ErrorInfo = Option.FdfFile.Validate(".fdf", False)\r
            if ErrorCode != 0:\r
                EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)\r
\r
        if Option.Flag is not None and Option.Flag not in ['-c', '-s']:\r
            EdkLogger.error("build", OPTION_VALUE_INVALID, "UNI flag must be one of -c or -s")\r
\r
        MyBuild = Build(Target, Workspace, Option)\r
        GlobalData.gCommandLineDefines['ARCH'] = ' '.join(MyBuild.ArchList)\r
        if not (MyBuild.LaunchPrebuildFlag and os.path.exists(MyBuild.PlatformBuildPath)):\r
            MyBuild.Launch()\r
\r
        #\r
        # All job done, no error found and no exception raised\r
        #\r
        BuildError = False\r
    except FatalError as X:\r
        if MyBuild is not None:\r
            # for multi-thread build exits safely\r
            MyBuild.Relinquish()\r
        if Option is not None and Option.debug is not None:\r
            EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())\r
        ReturnCode = X.args[0]\r
    except Warning as X:\r
        # error from Fdf parser\r
        if MyBuild is not None:\r
            # for multi-thread build exits safely\r
            MyBuild.Relinquish()\r
        if Option is not None and Option.debug is not None:\r
            EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())\r
        else:\r
            EdkLogger.error(X.ToolName, FORMAT_INVALID, File=X.FileName, Line=X.LineNumber, ExtraData=X.Message, RaiseError=False)\r
        ReturnCode = FORMAT_INVALID\r
    except KeyboardInterrupt:\r
        ReturnCode = ABORT_ERROR\r
        if Option is not None and Option.debug is not None:\r
            EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())\r
    except:\r
        if MyBuild is not None:\r
            # for multi-thread build exits safely\r
            MyBuild.Relinquish()\r
\r
        # try to get the meta-file from the object causing exception\r
        Tb = sys.exc_info()[-1]\r
        MetaFile = GlobalData.gProcessingFile\r
        while Tb is not None:\r
            if 'self' in Tb.tb_frame.f_locals and hasattr(Tb.tb_frame.f_locals['self'], 'MetaFile'):\r
                MetaFile = Tb.tb_frame.f_locals['self'].MetaFile\r
            Tb = Tb.tb_next\r
        EdkLogger.error(\r
                    "\nbuild",\r
                    CODE_ERROR,\r
                    "Unknown fatal error when processing [%s]" % MetaFile,\r
                    ExtraData="\n(Please send email to %s for help, attaching following call stack trace!)\n" % MSG_EDKII_MAIL_ADDR,\r
                    RaiseError=False\r
                    )\r
        EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())\r
        ReturnCode = CODE_ERROR\r
    finally:\r
        Utils.Progressor.Abort()\r
        Utils.ClearDuplicatedInf()\r
\r
    if ReturnCode == 0:\r
        try:\r
            MyBuild.LaunchPostbuild()\r
            Conclusion = "Done"\r
        except:\r
            Conclusion = "Failed"\r
    elif ReturnCode == ABORT_ERROR:\r
        Conclusion = "Aborted"\r
    else:\r
        Conclusion = "Failed"\r
    FinishTime = time.time()\r
    BuildDuration = time.gmtime(int(round(FinishTime - StartTime)))\r
    BuildDurationStr = ""\r
    if BuildDuration.tm_yday > 1:\r
        BuildDurationStr = time.strftime("%H:%M:%S", BuildDuration) + ", %d day(s)" % (BuildDuration.tm_yday - 1)\r
    else:\r
        BuildDurationStr = time.strftime("%H:%M:%S", BuildDuration)\r
    if MyBuild is not None:\r
        if not BuildError:\r
            MyBuild.BuildReport.GenerateReport(BuildDurationStr, LogBuildTime(MyBuild.AutoGenTime), LogBuildTime(MyBuild.MakeTime), LogBuildTime(MyBuild.GenFdsTime))\r
\r
    EdkLogger.SetLevel(EdkLogger.QUIET)\r
    EdkLogger.quiet("\n- %s -" % Conclusion)\r
    EdkLogger.quiet(time.strftime("Build end time: %H:%M:%S, %b.%d %Y", time.localtime()))\r
    EdkLogger.quiet("Build total time: %s\n" % BuildDurationStr)\r
    return ReturnCode\r
\r
if __name__ == '__main__':\r
    r = Main()\r
    ## 0-127 is a safe return range, and 1 is a standard default error\r
    if r < 0 or r > 127: r = 1\r
    sys.exit(r)\r
\r