[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
from __future__ import absolute_import\r
import os.path as path\r
import sys\r
import os\r
import re\r
import glob\r
import time\r
import platform\r
import traceback\r
import multiprocessing\r
from threading import Thread,Event,BoundedSemaphore\r
import threading\r
from subprocess import Popen,PIPE\r
from collections import OrderedDict, defaultdict\r
from Common.buildoptions import BuildOption,BuildTarget\r
from AutoGen.PlatformAutoGen import PlatformAutoGen\r
from AutoGen.ModuleAutoGen import ModuleAutoGen\r
from AutoGen.WorkspaceAutoGen import WorkspaceAutoGen\r
from AutoGen.AutoGenWorker import AutoGenWorkerInProcess,AutoGenManager,\\r
    LogAgent\r
from AutoGen import GenMake\r
from Common import Misc as Utils\r
\r
from Common.TargetTxtClassObject import TargetTxt\r
from Common.ToolDefClassObject import ToolDef\r
from Common.Misc import PathClass,SaveFileOnChange,RemoveDirectory\r
from Common.StringUtils import NormPath\r
from Common.MultipleWorkspace import MultipleWorkspace as mws\r
from Common.BuildToolError import *\r
from Common.DataType import *\r
import Common.EdkLogger as EdkLogger\r
\r
from Workspace.WorkspaceDatabase import BuildDB\r
\r
from BuildReport import BuildReport\r
from GenPatchPcdTable.GenPatchPcdTable import PeImageClass,parsePcdInfoFromMapFile\r
from PatchPcdValue.PatchPcdValue import PatchBinaryFile\r
\r
import Common.GlobalData as GlobalData\r
from GenFds.GenFds import GenFds, GenFdsApi\r
import multiprocessing as mp\r
from multiprocessing import Manager\r
\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, BuildCommand,Target):\r
        Dependency = [ModuleMakeUnit(La, BuildCommand,Target) for La in Obj.LibraryAutoGenList]\r
        BuildUnit.__init__(self, 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, BuildCommand, Target):\r
        Dependency = [ModuleMakeUnit(Lib, BuildCommand, Target) for Lib in self.BuildObject.LibraryAutoGenList]\r
        Dependency.extend([ModuleMakeUnit(Mod, BuildCommand,Target) for Mod in self.BuildObject.ModuleAutoGenList])\r
        BuildUnit.__init__(self, 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.CanSkipbyCache(GlobalData.gCacheIR):\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,log_q):\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   = 1\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      = TargetTxt\r
        self.ToolDef        = ToolDef\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
        GlobalData.gDatabasePath = os.path.normpath(os.path.join(GlobalData.gConfDirectory, GlobalData.gDatabasePath))\r
        if not os.path.exists(os.path.join(GlobalData.gConfDirectory, '.cache')):\r
            os.makedirs(os.path.join(GlobalData.gConfDirectory, '.cache'))\r
        self.Db = BuildDB\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 = TargetTxt\r
            self.ToolDef   = ToolDef\r
        if not (self.LaunchPrebuildFlag and os.path.exists(self.PlatformBuildPath)):\r
            self.InitBuild()\r
\r
        self.AutoGenMgr = None\r
        EdkLogger.info("")\r
        os.chdir(self.WorkspaceDir)\r
        GlobalData.gCacheIR = Manager().dict()\r
        self.log_q = log_q\r
    def StartAutoGen(self,mqueue, DataPipe,SkipAutoGen,PcdMaList,share_data):\r
        try:\r
            if SkipAutoGen:\r
                return True,0\r
            feedback_q = mp.Queue()\r
            file_lock = mp.Lock()\r
            error_event = mp.Event()\r
            GlobalData.file_lock = file_lock\r
            FfsCmd = DataPipe.Get("FfsCommand")\r
            if FfsCmd is None:\r
                FfsCmd = {}\r
            GlobalData.FfsCmd = FfsCmd\r
            GlobalData.libConstPcd = DataPipe.Get("LibConstPcd")\r
            GlobalData.Refes = DataPipe.Get("REFS")\r
            auto_workers = [AutoGenWorkerInProcess(mqueue,DataPipe.dump_file,feedback_q,file_lock,share_data,self.log_q,error_event) for _ in range(self.ThreadNumber)]\r
            self.AutoGenMgr = AutoGenManager(auto_workers,feedback_q,error_event)\r
            self.AutoGenMgr.start()\r
            for w in auto_workers:\r
                w.start()\r
            if PcdMaList is not None:\r
                for PcdMa in PcdMaList:\r
                    if GlobalData.gBinCacheSource and self.Target in [None, "", "all"]:\r
                        PcdMa.GenModuleFilesHash(share_data)\r
                        PcdMa.GenPreMakefileHash(share_data)\r
                        if PcdMa.CanSkipbyPreMakefileCache(share_data):\r
                           continue\r
\r
                    PcdMa.CreateCodeFile(False)\r
                    PcdMa.CreateMakeFile(False,GenFfsList = DataPipe.Get("FfsCommand").get((PcdMa.MetaFile.File, PcdMa.Arch),[]))\r
\r
                    if GlobalData.gBinCacheSource and self.Target in [None, "", "all"]:\r
                        PcdMa.GenMakeHeaderFilesHash(share_data)\r
                        PcdMa.GenMakeHash(share_data)\r
                        if PcdMa.CanSkipbyMakeCache(share_data):\r
                            continue\r
\r
            self.AutoGenMgr.join()\r
            rt = self.AutoGenMgr.Status\r
            return rt, 0\r
        except FatalError as e:\r
            return False, e.args[0]\r
        except:\r
            return False, UNKNOWN_ERROR\r
\r
    ## Load configuration\r
    #\r
    #   This method will parse target.txt and get the build configurations.\r
    #\r
    def LoadConfiguration(self):\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 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
        self.ThreadNumber   = ThreadNum()\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=None, PcdMaList=None):\r
        if AutoGenObject is None:\r
            return False\r
        if FfsCommand is None:\r
            FfsCommand = {}\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
            mqueue = mp.Queue()\r
            for m in AutoGenObject.GetAllModuleInfo:\r
                mqueue.put(m)\r
\r
            AutoGenObject.DataPipe.DataContainer = {"FfsCommand":FfsCommand}\r
            AutoGenObject.DataPipe.DataContainer = {"CommandTarget": self.Target}\r
            self.Progress.Start("Generating makefile and code")\r
            data_pipe_file = os.path.join(AutoGenObject.BuildDir, "GlobalVar_%s_%s.bin" % (str(AutoGenObject.Guid),AutoGenObject.Arch))\r
            AutoGenObject.DataPipe.dump(data_pipe_file)\r
            autogen_rt,errorcode = self.StartAutoGen(mqueue, AutoGenObject.DataPipe, self.SkipAutoGen, PcdMaList, GlobalData.gCacheIR)\r
            self.Progress.Stop("done!")\r
            if not autogen_rt:\r
                self.AutoGenMgr.TerminateWorkers()\r
                self.AutoGenMgr.join(0.1)\r
                raise FatalError(errorcode)\r
            AutoGenObject.CreateCodeFile(False)\r
            AutoGenObject.CreateMakeFile(False)\r
        else:\r
            # always recreate top/platform makefile when clean, just in case of inconsistency\r
            AutoGenObject.CreateCodeFile(True)\r
            AutoGenObject.CreateMakeFile(True)\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
            if GlobalData.gBinCacheDest:\r
                self.UpdateBuildCache()\r
            self.BuildModules = []\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
            if GlobalData.gBinCacheDest:\r
                self.UpdateBuildCache()\r
            self.BuildModules = []\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(True)\r
            AutoGenObject.CreateMakeFile(True)\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
            if GlobalData.gBinCacheDest:\r
                self.UpdateBuildCache()\r
            self.BuildModules = []\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(r"\(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
                    PcdMaList    = []\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,Pa.DataPipe)\r
                        if Ma is None:\r
                            continue\r
                        if Ma.PcdIsDriver:\r
                            Ma.PlatformInfo = Pa\r
                            Ma.Workspace = Wa\r
                            PcdMaList.append(Ma)\r
                        self.BuildModules.append(Ma)\r
                    self._BuildPa(self.Target, Pa, FfsCommand=CmdListDict,PcdMaList=PcdMaList)\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
\r
                # Add Platform and Package level hash in share_data for module hash calculation later\r
                if GlobalData.gBinCacheSource or GlobalData.gBinCacheDest:\r
                    GlobalData.gCacheIR[('PlatformHash')] = GlobalData.gPlatformHash\r
                    for PkgName in GlobalData.gPackageHash.keys():\r
                        GlobalData.gCacheIR[(PkgName, 'PackageHash')] = GlobalData.gPackageHash[PkgName]\r
                GlobalData.file_lock = mp.Lock()\r
                GlobalData.FfsCmd = CmdListDict\r
\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
                    GlobalData.libConstPcd = Pa.DataPipe.Get("LibConstPcd")\r
                    GlobalData.Refes = Pa.DataPipe.Get("REFS")\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,Pa.DataPipe)\r
                            if Ma is None:\r
                                continue\r
                            MaList.append(Ma)\r
\r
                            if GlobalData.gBinCacheSource and self.Target in [None, "", "all"]:\r
                                Ma.GenModuleFilesHash(GlobalData.gCacheIR)\r
                                Ma.GenPreMakefileHash(GlobalData.gCacheIR)\r
                                if Ma.CanSkipbyPreMakefileCache(GlobalData.gCacheIR):\r
                                   self.HashSkipModules.append(Ma)\r
                                   EdkLogger.quiet("cache hit: %s[%s]" % (Ma.MetaFile.Path, Ma.Arch))\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
                                    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
\r
                                if GlobalData.gBinCacheSource and self.Target in [None, "", "all"]:\r
                                    Ma.GenMakeHeaderFilesHash(GlobalData.gCacheIR)\r
                                    Ma.GenMakeHash(GlobalData.gCacheIR)\r
                                    if Ma.CanSkipbyMakeCache(GlobalData.gCacheIR):\r
                                        self.HashSkipModules.append(Ma)\r
                                        EdkLogger.quiet("cache hit: %s[%s]" % (Ma.MetaFile.Path, Ma.Arch))\r
                                        continue\r
                                    else:\r
                                        EdkLogger.quiet("cache miss: %s[%s]" % (Ma.MetaFile.Path, Ma.Arch))\r
                                        Ma.PrintFirstMakeCacheMissFile(GlobalData.gCacheIR)\r
\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, Pa.BuildCommand,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
                if GlobalData.gBinCacheDest:\r
                    self.UpdateBuildCache()\r
                self.BuildModules = []\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 = {}\r
                if GlobalData.gEnableGenfdsMultiThread and self.Fdf:\r
                    CmdListDict = self._GenFfsCmd(Wa.ArchList)\r
\r
                # Add Platform and Package level hash in share_data for module hash calculation later\r
                if GlobalData.gBinCacheSource or GlobalData.gBinCacheDest:\r
                    GlobalData.gCacheIR[('PlatformHash')] = GlobalData.gPlatformHash\r
                    for PkgName in GlobalData.gPackageHash.keys():\r
                        GlobalData.gCacheIR[(PkgName, 'PackageHash')] = GlobalData.gPackageHash[PkgName]\r
\r
                # multi-thread exit flag\r
                ExitFlag = threading.Event()\r
                ExitFlag.clear()\r
                self.AutoGenTime += int(round((time.time() - WorkspaceAutoGenTime)))\r
                self.BuildModules = []\r
                TotalModules = []\r
                for Arch in Wa.ArchList:\r
                    PcdMaList    = []\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
                    Pa.DataPipe.DataContainer = {"FfsCommand":CmdListDict}\r
                    Pa.DataPipe.DataContainer = {"Workspace_timestamp": Wa._SrcTimeStamp}\r
                    Pa.DataPipe.DataContainer = {"CommandTarget": self.Target}\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,Pa.DataPipe)\r
\r
                        if Ma is None:\r
                            continue\r
                        if Ma.PcdIsDriver:\r
                            Ma.PlatformInfo = Pa\r
                            Ma.Workspace = Wa\r
                            PcdMaList.append(Ma)\r
                        TotalModules.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
\r
                    mqueue = mp.Queue()\r
                    for m in Pa.GetAllModuleInfo:\r
                        mqueue.put(m)\r
                    data_pipe_file = os.path.join(Pa.BuildDir, "GlobalVar_%s_%s.bin" % (str(Pa.Guid),Pa.Arch))\r
                    Pa.DataPipe.dump(data_pipe_file)\r
                    autogen_rt, errorcode = self.StartAutoGen(mqueue, Pa.DataPipe, self.SkipAutoGen, PcdMaList,  GlobalData.gCacheIR)\r
\r
                    # Skip cache hit modules\r
                    if GlobalData.gBinCacheSource:\r
                        for Ma in TotalModules:\r
                            if (Ma.MetaFile.Path, Ma.Arch) in GlobalData.gCacheIR and \\r
                                GlobalData.gCacheIR[(Ma.MetaFile.Path, Ma.Arch)].PreMakeCacheHit:\r
                                    self.HashSkipModules.append(Ma)\r
                                    continue\r
                            if (Ma.MetaFile.Path, Ma.Arch) in GlobalData.gCacheIR and \\r
                                GlobalData.gCacheIR[(Ma.MetaFile.Path, Ma.Arch)].MakeCacheHit:\r
                                    self.HashSkipModules.append(Ma)\r
                                    continue\r
                            self.BuildModules.append(Ma)\r
                    else:\r
                        self.BuildModules.extend(TotalModules)\r
\r
                    if not autogen_rt:\r
                        self.AutoGenMgr.TerminateWorkers()\r
                        self.AutoGenMgr.join(0.1)\r
                        raise FatalError(errorcode)\r
                self.AutoGenTime += int(round((time.time() - AutoGenStart)))\r
                self.Progress.Stop("done!")\r
\r
                if GlobalData.gBinCacheSource:\r
                    EdkLogger.quiet("Total cache hit driver num: %s, cache miss driver num: %s" % (len(set(self.HashSkipModules)), len(set(self.BuildModules))))\r
                    CacheHitMa = set()\r
                    CacheNotHitMa = set()\r
                    for IR in GlobalData.gCacheIR.keys():\r
                        if 'PlatformHash' in IR or 'PackageHash' in IR:\r
                            continue\r
                        if GlobalData.gCacheIR[IR].PreMakeCacheHit or GlobalData.gCacheIR[IR].MakeCacheHit:\r
                            CacheHitMa.add(IR)\r
                        else:\r
                            # There might be binary module or module which has .inc files, not count for cache miss\r
                            CacheNotHitMa.add(IR)\r
                    EdkLogger.quiet("Total module num: %s, cache hit module num: %s" % (len(CacheHitMa)+len(CacheNotHitMa), len(CacheHitMa)))\r
\r
                for Arch in Wa.ArchList:\r
                    MakeStart = time.time()\r
                    for Ma in set(self.BuildModules):\r
                        # Generate build task for the module\r
                        if not Ma.IsBinaryModule:\r
                            Bt = BuildTask.New(ModuleMakeUnit(Ma, Pa.BuildCommand,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
                if GlobalData.gBinCacheDest:\r
                    self.UpdateBuildCache()\r
                self.BuildModules = []\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
        for Module in self.BuildModules:\r
            Module.CreateAsBuiltInf()\r
\r
    def UpdateBuildCache(self):\r
        all_lib_set = set()\r
        all_mod_set = set()\r
        for Module in self.BuildModules:\r
            Module.CopyModuleToCache()\r
            all_mod_set.add(Module)\r
        for Module in self.HashSkipModules:\r
            Module.CopyModuleToCache()\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.CopyModuleToCache()\r
        all_lib_set.clear()\r
        all_mod_set.clear()\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
\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
def ThreadNum():\r
    ThreadNumber = BuildOption.ThreadNumber\r
    if ThreadNumber is None:\r
        ThreadNumber = TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_MAX_CONCURRENT_THREAD_NUMBER]\r
        if ThreadNumber == '':\r
            ThreadNumber = 0\r
        else:\r
            ThreadNumber = int(ThreadNumber, 0)\r
\r
    if ThreadNumber == 0:\r
        try:\r
            ThreadNumber = multiprocessing.cpu_count()\r
        except (ImportError, NotImplementedError):\r
            ThreadNumber = 1\r
    return ThreadNumber\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
LogQMaxSize = ThreadNum() * 10\r
def Main():\r
    StartTime = time.time()\r
\r
    #\r
    # Create a log Queue\r
    #\r
    LogQ = mp.Queue(LogQMaxSize)\r
    # Initialize log system\r
    EdkLogger.LogClientInitialize(LogQ)\r
    GlobalData.gCommand = sys.argv[1:]\r
    #\r
    # Parse the options and args\r
    #\r
    Option, Target = BuildOption, BuildTarget\r
    GlobalData.gOptions = Option\r
    GlobalData.gCaseInsensitive = Option.CaseInsensitive\r
\r
    # Set log level\r
    LogLevel = EdkLogger.INFO\r
    if Option.verbose is not None:\r
        EdkLogger.SetLevel(EdkLogger.VERBOSE)\r
        LogLevel = EdkLogger.VERBOSE\r
    elif Option.quiet is not None:\r
        EdkLogger.SetLevel(EdkLogger.QUIET)\r
        LogLevel = EdkLogger.QUIET\r
    elif Option.debug is not None:\r
        EdkLogger.SetLevel(Option.debug + 1)\r
        LogLevel = Option.debug + 1\r
    else:\r
        EdkLogger.SetLevel(EdkLogger.INFO)\r
\r
    if Option.WarningAsError == True:\r
        EdkLogger.SetWarningAsError()\r
    Log_Agent = LogAgent(LogQ,LogLevel,Option.LogFile)\r
    Log_Agent.start()\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,LogQ)\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
        if MyBuild is not None:\r
\r
            # for multi-thread build exits safely\r
            MyBuild.Relinquish()\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
    Log_Agent.kill()\r
    Log_Agent.join()\r
    return ReturnCode\r
\r
if __name__ == '__main__':\r
    try:\r
        mp.set_start_method('spawn')\r
    except:\r
        pass\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