Check In tool source code based on Build tool project revision r1655.

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@8964 6f19259b-4bc3-4df7-8a09-765794883524

1 files changed, 1389 insertions, 0 deletions

diff --git a/BaseTools/Source/Python/AutoGen/GenMake.py b/BaseTools/Source/Python/AutoGen/GenMake.py
new file mode 100644
index 0000000000..f689a8692d
--- /dev/null
+++ b/BaseTools/Source/Python/AutoGen/GenMake.py
@@ -0,0 +1,1389 @@
+## @file
+# Create makefile for MS nmake and GNU make
+#
+# Copyright (c) 2007, Intel Corporation
+# All rights reserved. This program and the accompanying materials
+# are licensed and made available under the terms and conditions of the BSD License
+# which accompanies this distribution.  The full text of the license may be found at
+# http://opensource.org/licenses/bsd-license.php
+#
+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+#
+
+## Import Modules
+#
+import os
+import sys
+import string
+import re
+import os.path as path
+
+from Common.BuildToolError import *
+from Common.Misc import *
+from Common.String import *
+from BuildEngine import *
+import Common.GlobalData as GlobalData
+
+## Regular expression for finding header file inclusions
+gIncludePattern = re.compile(r"^[ \t]*#[ \t]*include(?:[ \t]*(?:\\(?:\r\n|\r|\n))*[ \t]*)*(?:[\"<][ \t]*)([\w.\\/]+)(?:[ \t]*[\">])", re.MULTILINE|re.UNICODE)
+
+## Regular expression for matching macro used in header file inclusion
+gMacroPattern = re.compile("([_A-Z][_A-Z0-9]*)[ \t]*\((.+)\)", re.UNICODE)
+
+## pattern for include style in R8.x code
+gProtocolDefinition = "Protocol/%(HeaderKey)s/%(HeaderKey)s.h"
+gGuidDefinition = "Guid/%(HeaderKey)s/%(HeaderKey)s.h"
+gArchProtocolDefinition = "ArchProtocol/%(HeaderKey)s/%(HeaderKey)s.h"
+gPpiDefinition = "Ppi/%(HeaderKey)s/%(HeaderKey)s.h"
+gIncludeMacroConversion = {
+  "EFI_PROTOCOL_DEFINITION"         :   gProtocolDefinition,
+  "EFI_GUID_DEFINITION"             :   gGuidDefinition,
+  "EFI_ARCH_PROTOCOL_DEFINITION"    :   gArchProtocolDefinition,
+  "EFI_PROTOCOL_PRODUCER"           :   gProtocolDefinition,
+  "EFI_PROTOCOL_CONSUMER"           :   gProtocolDefinition,
+  "EFI_PROTOCOL_DEPENDENCY"         :   gProtocolDefinition,
+  "EFI_ARCH_PROTOCOL_PRODUCER"      :   gArchProtocolDefinition,
+  "EFI_ARCH_PROTOCOL_CONSUMER"      :   gArchProtocolDefinition,
+  "EFI_ARCH_PROTOCOL_DEPENDENCY"    :   gArchProtocolDefinition,
+  "EFI_PPI_DEFINITION"              :   gPpiDefinition,
+  "EFI_PPI_PRODUCER"                :   gPpiDefinition,
+  "EFI_PPI_CONSUMER"                :   gPpiDefinition,
+  "EFI_PPI_DEPENDENCY"              :   gPpiDefinition,
+}
+
+## default makefile type
+gMakeType = ""
+if sys.platform == "win32":
+    gMakeType = "nmake"
+else:
+    gMakeType = "gmake"
+
+
+## BuildFile class
+#
+#  This base class encapsules build file and its generation. It uses template to generate
+#  the content of build file. The content of build file will be got from AutoGen objects.
+#
+class BuildFile(object):
+    ## template used to generate the build file (i.e. makefile if using make)
+    _TEMPLATE_ = TemplateString('')
+
+    _DEFAULT_FILE_NAME_ = "Makefile"
+
+    ## default file name for each type of build file
+    _FILE_NAME_ = {
+        "nmake" :   "Makefile",
+        "gmake" :   "GNUmakefile"
+    }
+
+    ## Fixed header string for makefile
+    _MAKEFILE_HEADER = '''#
+# DO NOT EDIT
+# This file is auto-generated by build utility
+#
+# Module Name:
+#
+#   %s
+#
+# Abstract:
+#
+#   Auto-generated makefile for building modules, libraries or platform
+#
+    '''
+
+    ## Header string for each type of build file
+    _FILE_HEADER_ = {
+        "nmake" :   _MAKEFILE_HEADER % _FILE_NAME_["nmake"],
+        "gmake" :   _MAKEFILE_HEADER % _FILE_NAME_["gmake"]
+    }
+
+    ## shell commands which can be used in build file in the form of macro
+    #   $(CP)     copy file command
+    #   $(MV)     move file command
+    #   $(RM)     remove file command
+    #   $(MD)     create dir command
+    #   $(RD)     remove dir command
+    #
+    _SHELL_CMD_ = {
+        "nmake" : {
+            "CP"    :   "copy /y",
+            "MV"    :   "move /y",
+            "RM"    :   "del /f /q",
+            "MD"    :   "mkdir",
+            "RD"    :   "rmdir /s /q",
+        },
+
+        "gmake" : {
+            "CP"    :   "cp -f",
+            "MV"    :   "mv -f",
+            "RM"    :   "rm -f",
+            "MD"    :   "mkdir -p",
+            "RD"    :   "rm -r -f",
+        }
+    }
+
+    ## directory separator
+    _SEP_ = {
+        "nmake" :   "\\",
+        "gmake" :   "/"
+    }
+
+    ## directory creation template
+    _MD_TEMPLATE_ = {
+        "nmake" :   'if not exist %(dir)s $(MD) %(dir)s',
+        "gmake" :   "$(MD) %(dir)s"
+    }
+
+    ## directory removal template
+    _RD_TEMPLATE_ = {
+        "nmake" :   'if exist %(dir)s $(RD) %(dir)s',
+        "gmake" :   "$(RD) %(dir)s"
+    }
+
+    _CD_TEMPLATE_ = {
+        "nmake" :   'if exist %(dir)s cd %(dir)s',
+        "gmake" :   "test -e %(dir)s && cd %(dir)s"
+    }
+
+    _MAKE_TEMPLATE_ = {
+        "nmake" :   'if exist %(file)s "$(MAKE)" $(MAKE_FLAGS) -f %(file)s',
+        "gmake" :   'test -e %(file)s && "$(MAKE)" $(MAKE_FLAGS) -f %(file)s'
+    }
+
+    _INCLUDE_CMD_ = {
+        "nmake" :   '!INCLUDE',
+        "gmake" :   "include"
+    }
+
+    _INC_FLAG_ = {"MSFT" : "/I", "GCC" : "-I", "INTEL" : "-I", "RVCT" : "-I"}
+
+    ## Constructor of BuildFile
+    #
+    #   @param  AutoGenObject   Object of AutoGen class
+    #
+    def __init__(self, AutoGenObject):
+        self._AutoGenObject = AutoGenObject
+        self._FileType = gMakeType
+
+    ## Create build file
+    #
+    #   @param  FileType    Type of build file. Only nmake and gmake are supported now.
+    #
+    #   @retval TRUE        The build file is created or re-created successfully
+    #   @retval FALSE       The build file exists and is the same as the one to be generated
+    #
+    def Generate(self, FileType=gMakeType):
+        if FileType not in self._FILE_NAME_:
+            EdkLogger.error("build", PARAMETER_INVALID, "Invalid build type [%s]" % FileType,
+                            ExtraData="[%s]" % str(self._AutoGenObject))
+        self._FileType = FileType
+        FileContent = self._TEMPLATE_.Replace(self._TemplateDict)
+        FileName = self._FILE_NAME_[FileType]
+        return SaveFileOnChange(os.path.join(self._AutoGenObject.MakeFileDir, FileName), FileContent, False)
+
+    ## Return a list of directory creation command string
+    #
+    #   @param      DirList     The list of directory to be created
+    #
+    #   @retval     list        The directory creation command list
+    #
+    def GetCreateDirectoryCommand(self, DirList):
+        return [self._MD_TEMPLATE_[self._FileType] % {'dir':Dir} for Dir in DirList]
+
+    ## Return a list of directory removal command string
+    #
+    #   @param      DirList     The list of directory to be removed
+    #
+    #   @retval     list        The directory removal command list
+    #
+    def GetRemoveDirectoryCommand(self, DirList):
+        return [self._RD_TEMPLATE_[self._FileType] % {'dir':Dir} for Dir in DirList]
+
+    def PlaceMacro(self, Path, MacroDefinitions={}):
+        if Path.startswith("$("):
+            return Path
+        else:
+            PathLength = len(Path)
+            for MacroName in MacroDefinitions:
+                MacroValue = MacroDefinitions[MacroName]
+                MacroValueLength = len(MacroValue)
+                if MacroValueLength <= PathLength and Path.startswith(MacroValue):
+                    Path = "$(%s)%s" % (MacroName, Path[MacroValueLength:])
+                    break
+            return Path
+
+## ModuleMakefile class
+#
+#  This class encapsules makefie and its generation for module. It uses template to generate
+#  the content of makefile. The content of makefile will be got from ModuleAutoGen object.
+#
+class ModuleMakefile(BuildFile):
+    ## template used to generate the makefile for module
+    _TEMPLATE_ = TemplateString('''\
+${makefile_header}
+
+#
+# Platform Macro Definition
+#
+PLATFORM_NAME = ${platform_name}
+PLATFORM_GUID = ${platform_guid}
+PLATFORM_VERSION = ${platform_version}
+PLATFORM_RELATIVE_DIR = ${platform_relative_directory}
+PLATFORM_DIR = $(WORKSPACE)${separator}${platform_relative_directory}
+PLATFORM_OUTPUT_DIR = ${platform_output_directory}
+
+#
+# Module Macro Definition
+#
+MODULE_NAME = ${module_name}
+MODULE_GUID = ${module_guid}
+MODULE_VERSION = ${module_version}
+MODULE_TYPE = ${module_type}
+MODULE_FILE = ${module_file}
+MODULE_FILE_BASE_NAME = ${module_file_base_name}
+BASE_NAME = $(MODULE_NAME)
+MODULE_RELATIVE_DIR = ${module_relative_directory}
+MODULE_DIR = $(WORKSPACE)${separator}${module_relative_directory}
+
+MODULE_ENTRY_POINT = ${module_entry_point}
+ARCH_ENTRY_POINT = ${arch_entry_point}
+IMAGE_ENTRY_POINT = ${image_entry_point}
+
+${BEGIN}${module_extra_defines}
+${END}
+#
+# Build Configuration Macro Definition
+#
+ARCH = ${architecture}
+TOOLCHAIN = ${toolchain_tag}
+TOOLCHAIN_TAG = ${toolchain_tag}
+TARGET = ${build_target}
+
+#
+# Build Directory Macro Definition
+#
+# PLATFORM_BUILD_DIR = ${platform_build_directory}
+BUILD_DIR = ${platform_build_directory}
+BIN_DIR = $(BUILD_DIR)${separator}${architecture}
+LIB_DIR = $(BIN_DIR)
+MODULE_BUILD_DIR = ${module_build_directory}
+OUTPUT_DIR = ${module_output_directory}
+DEBUG_DIR = ${module_debug_directory}
+DEST_DIR_OUTPUT = $(OUTPUT_DIR)
+DEST_DIR_DEBUG = $(DEBUG_DIR)
+
+#
+# Shell Command Macro
+#
+${BEGIN}${shell_command_code} = ${shell_command}
+${END}
+
+#
+# Tools definitions specific to this module
+#
+${BEGIN}${module_tool_definitions}
+${END}
+MAKE_FILE = ${makefile_path}
+
+#
+# Build Macro
+#
+${BEGIN}${file_macro}
+${END}
+
+COMMON_DEPS = ${BEGIN}${common_dependency_file} \\
+              ${END}
+
+#
+# Overridable Target Macro Definitions
+#
+FORCE_REBUILD = force_build
+INIT_TARGET = init
+PCH_TARGET =
+BC_TARGET = ${BEGIN}${backward_compatible_target} ${END}
+CODA_TARGET = ${BEGIN}${remaining_build_target} \\
+              ${END}
+
+#
+# Default target, which will build dependent libraries in addition to source files
+#
+
+all: mbuild
+
+
+#
+# Target used when called from platform makefile, which will bypass the build of dependent libraries
+#
+
+pbuild: $(INIT_TARGET) $(BC_TARGET) $(PCH_TARGET) $(CODA_TARGET)
+
+#
+# ModuleTarget
+#
+
+mbuild: $(INIT_TARGET) $(BC_TARGET) gen_libs $(PCH_TARGET) $(CODA_TARGET)
+
+#
+# Build Target used in multi-thread build mode, which will bypass the init and gen_libs targets
+#
+
+tbuild: $(BC_TARGET) $(PCH_TARGET) $(CODA_TARGET)
+
+#
+# Phony target which is used to force executing commands for a target
+#
+force_build:
+\t-@
+
+#
+# Target to update the FD
+#
+
+fds: mbuild gen_fds
+
+#
+# Initialization target: print build information and create necessary directories
+#
+init: info dirs
+
+info:
+\t-@echo Building ... $(MODULE_DIR)${separator}$(MODULE_FILE) [$(ARCH)]
+
+dirs:
+${BEGIN}\t-@${create_directory_command}\n${END}
+
+strdefs:
+\t-@$(CP) $(DEBUG_DIR)${separator}AutoGen.h $(DEBUG_DIR)${separator}$(MODULE_NAME)StrDefs.h
+
+#
+# GenLibsTarget
+#
+gen_libs:
+\t${BEGIN}@"$(MAKE)" $(MAKE_FLAGS) -f ${dependent_library_build_directory}${separator}${makefile_name}
+\t${END}@cd $(MODULE_BUILD_DIR)
+
+#
+# Build Flash Device Image
+#
+gen_fds:
+\t@"$(MAKE)" $(MAKE_FLAGS) -f $(BUILD_DIR)${separator}${makefile_name} fds
+\t@cd $(MODULE_BUILD_DIR)
+
+#
+# Individual Object Build Targets
+#
+${BEGIN}${file_build_target}
+${END}
+
+#
+# clean all intermediate files
+#
+clean:
+\t${BEGIN}${clean_command}
+\t${END}
+
+#
+# clean all generated files
+#
+cleanall:
+${BEGIN}\t${cleanall_command}
+${END}\t$(RM) *.pdb *.idb > NUL 2>&1
+\t$(RM) $(BIN_DIR)${separator}$(MODULE_NAME).efi
+
+#
+# clean all dependent libraries built
+#
+cleanlib:
+\t${BEGIN}-@${library_build_command} cleanall
+\t${END}@cd $(MODULE_BUILD_DIR)\n\n''')
+
+    _FILE_MACRO_TEMPLATE = TemplateString("${macro_name} = ${BEGIN} \\\n    ${source_file}${END}\n")
+    _BUILD_TARGET_TEMPLATE = TemplateString("${BEGIN}${target} : ${deps}\n${END}\t${cmd}\n")
+
+    ## Constructor of ModuleMakefile
+    #
+    #   @param  ModuleAutoGen   Object of ModuleAutoGen class
+    #
+    def __init__(self, ModuleAutoGen):
+        BuildFile.__init__(self, ModuleAutoGen)
+        self.PlatformInfo = self._AutoGenObject.PlatformInfo
+
+        self.ResultFileList = []
+        self.IntermediateDirectoryList = ["$(DEBUG_DIR)", "$(OUTPUT_DIR)"]
+
+        self.SourceFileDatabase = {}        # {file type : file path}
+        self.DestFileDatabase = {}          # {file type : file path}
+        self.FileBuildTargetList = []       # [(src, target string)]
+        self.BuildTargetList = []           # [target string]
+        self.PendingBuildTargetList = []    # [FileBuildRule objects]
+        self.CommonFileDependency = []
+        self.FileListMacros = {}
+        self.ListFileMacros = {}
+
+        self.FileDependency = []
+        self.LibraryBuildCommandList = []
+        self.LibraryFileList = []
+        self.LibraryMakefileList = []
+        self.LibraryBuildDirectoryList = []
+        self.SystemLibraryList = []
+        self.Macros = sdict()
+        self.Macros["OUTPUT_DIR"      ] = self._AutoGenObject.Macros["OUTPUT_DIR"]
+        self.Macros["DEBUG_DIR"       ] = self._AutoGenObject.Macros["DEBUG_DIR"]
+        self.Macros["MODULE_BUILD_DIR"] = self._AutoGenObject.Macros["MODULE_BUILD_DIR"]
+        self.Macros["BIN_DIR"         ] = self._AutoGenObject.Macros["BIN_DIR"]
+        self.Macros["BUILD_DIR"       ] = self._AutoGenObject.Macros["BUILD_DIR"]
+        self.Macros["WORKSPACE"       ] = self._AutoGenObject.Macros["WORKSPACE"]
+
+    # Compose a dict object containing information used to do replacement in template
+    def _CreateTemplateDict(self):
+        if self._FileType not in self._SEP_:
+            EdkLogger.error("build", PARAMETER_INVALID, "Invalid Makefile type [%s]" % self._FileType,
+                            ExtraData="[%s]" % str(self._AutoGenObject))
+        Separator = self._SEP_[self._FileType]
+
+        # break build if no source files and binary files are found
+        if len(self._AutoGenObject.SourceFileList) == 0 and len(self._AutoGenObject.BinaryFileList) == 0:
+            EdkLogger.error("build", AUTOGEN_ERROR, "No files to be built in module [%s, %s, %s]"
+                            % (self._AutoGenObject.BuildTarget, self._AutoGenObject.ToolChain, self._AutoGenObject.Arch),
+                            ExtraData="[%s]" % str(self._AutoGenObject))
+
+        # convert dependent libaries to build command
+        self.ProcessDependentLibrary()
+        if len(self._AutoGenObject.Module.ModuleEntryPointList) > 0:
+            ModuleEntryPoint = self._AutoGenObject.Module.ModuleEntryPointList[0]
+        else:
+            ModuleEntryPoint = "_ModuleEntryPoint"
+
+        # Intel EBC compiler enforces EfiMain
+        if self._AutoGenObject.AutoGenVersion < 0x00010005 and self._AutoGenObject.Arch == "EBC":
+            ArchEntryPoint = "EfiMain"
+        else:
+            ArchEntryPoint = ModuleEntryPoint
+
+        if self._AutoGenObject.Arch == "EBC":
+            # EBC compiler always use "EfiStart" as entry point. Only applies to R9 modules
+            ImageEntryPoint = "EfiStart"
+        elif self._AutoGenObject.AutoGenVersion < 0x00010005:
+            # R8 modules use entry point specified in INF file
+            ImageEntryPoint = ModuleEntryPoint
+        else:
+            # R9 modules always use "_ModuleEntryPoint" as entry point
+            ImageEntryPoint = "_ModuleEntryPoint"
+
+        # tools definitions
+        ToolsDef = []
+        IncPrefix = self._INC_FLAG_[self._AutoGenObject.ToolChainFamily]
+        for Tool in self._AutoGenObject.BuildOption:
+            for Attr in self._AutoGenObject.BuildOption[Tool]:
+                Value = self._AutoGenObject.BuildOption[Tool][Attr]
+                if Attr == "FAMILY":
+                    continue
+                elif Attr == "PATH":
+                    ToolsDef.append("%s = %s" % (Tool, Value))
+                else:
+                    # Don't generate MAKE_FLAGS in makefile. It's put in environment variable.
+                    if Tool == "MAKE":
+                        continue
+                    # Remove duplicated include path, if any
+                    if Attr == "FLAGS":
+                        Value = RemoveDupOption(Value, IncPrefix, self._AutoGenObject.IncludePathList)
+                    ToolsDef.append("%s_%s = %s" % (Tool, Attr, Value))
+            ToolsDef.append("")
+
+        # convert source files and binary files to build targets
+        self.ResultFileList = [str(T.Target) for T in self._AutoGenObject.CodaTargetList]
+        if len(self.ResultFileList) == 0:
+            EdkLogger.error("build", AUTOGEN_ERROR, "Nothing to build",
+                            ExtraData="[%s]" % str(self._AutoGenObject))
+
+        self.ProcessBuildTargetList()
+
+        # Generate macros used to represent input files
+        FileMacroList = [] # macro name = file list
+        for FileListMacro in self.FileListMacros:
+            FileMacro = self._FILE_MACRO_TEMPLATE.Replace(
+                                                    {
+                                                        "macro_name"  : FileListMacro,
+                                                        "source_file" : self.FileListMacros[FileListMacro]
+                                                    }
+                                                    )
+            FileMacroList.append(FileMacro)
+
+        # INC_LIST is special
+        FileMacro = ""
+        IncludePathList = []
+        for P in  self._AutoGenObject.IncludePathList:
+            IncludePathList.append(IncPrefix+self.PlaceMacro(P, self.Macros))
+            if FileBuildRule.INC_LIST_MACRO in self.ListFileMacros:
+                self.ListFileMacros[FileBuildRule.INC_LIST_MACRO].append(IncPrefix+P)
+        FileMacro += self._FILE_MACRO_TEMPLATE.Replace(
+                                                {
+                                                    "macro_name"   : "INC",
+                                                    "source_file" : IncludePathList
+                                                }
+                                                )
+        FileMacroList.append(FileMacro)
+
+        # Generate macros used to represent files containing list of input files
+        for ListFileMacro in self.ListFileMacros:
+            ListFileName = os.path.join(self._AutoGenObject.OutputDir, "%s.lst" % ListFileMacro.lower()[:len(ListFileMacro)-5])
+            FileMacroList.append("%s = %s" % (ListFileMacro, ListFileName))
+            SaveFileOnChange(
+                ListFileName,
+                "\n".join(self.ListFileMacros[ListFileMacro]),
+                False
+                )
+
+        # R8 modules need <BaseName>StrDefs.h for string ID
+        #if self._AutoGenObject.AutoGenVersion < 0x00010005 and len(self._AutoGenObject.UnicodeFileList) > 0:
+        #    BcTargetList = ['strdefs']
+        #else:
+        #    BcTargetList = []
+        BcTargetList = []
+
+        MakefileName = self._FILE_NAME_[self._FileType]
+        LibraryMakeCommandList = []
+        for D in self.LibraryBuildDirectoryList:
+            Command = self._MAKE_TEMPLATE_[self._FileType] % {"file":os.path.join(D, MakefileName)}
+            LibraryMakeCommandList.append(Command)
+
+        MakefileTemplateDict = {
+            "makefile_header"           : self._FILE_HEADER_[self._FileType],
+            "makefile_path"             : os.path.join("$(MODULE_BUILD_DIR)", MakefileName),
+            "makefile_name"             : MakefileName,
+            "platform_name"             : self.PlatformInfo.Name,
+            "platform_guid"             : self.PlatformInfo.Guid,
+            "platform_version"          : self.PlatformInfo.Version,
+            "platform_relative_directory": self.PlatformInfo.SourceDir,
+            "platform_output_directory" : self.PlatformInfo.OutputDir,
+
+            "module_name"               : self._AutoGenObject.Name,
+            "module_guid"               : self._AutoGenObject.Guid,
+            "module_version"            : self._AutoGenObject.Version,
+            "module_type"               : self._AutoGenObject.ModuleType,
+            "module_file"               : self._AutoGenObject.MetaFile.Name,
+            "module_file_base_name"     : self._AutoGenObject.MetaFile.BaseName,
+            "module_relative_directory" : self._AutoGenObject.SourceDir,
+            "module_extra_defines"      : ["%s = %s" % (k, v) for k,v in self._AutoGenObject.Module.Defines.iteritems()],
+
+            "architecture"              : self._AutoGenObject.Arch,
+            "toolchain_tag"             : self._AutoGenObject.ToolChain,
+            "build_target"              : self._AutoGenObject.BuildTarget,
+
+            "platform_build_directory"  : self.PlatformInfo.BuildDir,
+            "module_build_directory"    : self._AutoGenObject.BuildDir,
+            "module_output_directory"   : self._AutoGenObject.OutputDir,
+            "module_debug_directory"    : self._AutoGenObject.DebugDir,
+
+            "separator"                 : Separator,
+            "module_tool_definitions"   : ToolsDef,
+
+            "shell_command_code"        : self._SHELL_CMD_[self._FileType].keys(),
+            "shell_command"             : self._SHELL_CMD_[self._FileType].values(),
+
+            "module_entry_point"        : ModuleEntryPoint,
+            "image_entry_point"         : ImageEntryPoint,
+            "arch_entry_point"          : ArchEntryPoint,
+            "remaining_build_target"    : self.ResultFileList,
+            "common_dependency_file"    : self.CommonFileDependency,
+            "create_directory_command"  : self.GetCreateDirectoryCommand(self.IntermediateDirectoryList),
+            "clean_command"             : self.GetRemoveDirectoryCommand(["$(OUTPUT_DIR)"]),
+            "cleanall_command"          : self.GetRemoveDirectoryCommand(["$(DEBUG_DIR)", "$(OUTPUT_DIR)"]),
+            "dependent_library_build_directory" : self.LibraryBuildDirectoryList,
+            "library_build_command"     : LibraryMakeCommandList,
+            "file_macro"                : FileMacroList,
+            "file_build_target"         : self.BuildTargetList,
+            "backward_compatible_target": BcTargetList,
+        }
+
+        return MakefileTemplateDict
+
+    def ProcessBuildTargetList(self):
+        #
+        # Search dependency file list for each source file
+        #
+        ForceIncludedFile = []
+        for File in self._AutoGenObject.AutoGenFileList:
+            if File.Ext == '.h':
+                ForceIncludedFile.append(File)
+        SourceFileList = []
+        for Target in self._AutoGenObject.IntroTargetList:
+            SourceFileList.extend(Target.Inputs)
+
+        self.FileDependency = self.GetFileDependency(
+                                    SourceFileList,
+                                    ForceIncludedFile,
+                                    self._AutoGenObject.IncludePathList
+                                    )
+        DepSet = None
+        for File in self.FileDependency:
+            if not self.FileDependency[File]:
+                self.FileDependency[File] = ['$(FORCE_REBUILD)']
+                continue
+            # skip non-C files
+            if File.Ext not in [".c", ".C"] or File.Name == "AutoGen.c":
+                continue
+            elif DepSet == None:
+                DepSet = set(self.FileDependency[File])
+            else:
+                DepSet &= set(self.FileDependency[File])
+        # in case nothing in SourceFileList
+        if DepSet == None:
+            DepSet = set()
+        #
+        # Extract comman files list in the dependency files
+        #
+        for File in DepSet:
+            self.CommonFileDependency.append(self.PlaceMacro(File.Path, self.Macros))
+
+        for File in self.FileDependency:
+            # skip non-C files
+            if File.Ext not in [".c", ".C"] or File.Name == "AutoGen.c":
+                continue
+            NewDepSet = set(self.FileDependency[File])
+            NewDepSet -= DepSet
+            self.FileDependency[File] = ["$(COMMON_DEPS)"] + list(NewDepSet)
+
+        # Convert target description object to target string in makefile
+        for Type in self._AutoGenObject.Targets:
+            for T in self._AutoGenObject.Targets[Type]:
+                # Generate related macros if needed
+                if T.GenFileListMacro and T.FileListMacro not in self.FileListMacros:
+                    self.FileListMacros[T.FileListMacro] = []
+                if T.GenListFile and T.ListFileMacro not in self.ListFileMacros:
+                    self.ListFileMacros[T.ListFileMacro] = []
+                if T.GenIncListFile and T.IncListFileMacro not in self.ListFileMacros:
+                    self.ListFileMacros[T.IncListFileMacro] = []
+
+                Deps = []
+                # Add force-dependencies
+                for Dep in T.Dependencies:
+                    Deps.append(self.PlaceMacro(str(Dep), self.Macros))
+                # Add inclusion-dependencies
+                if len(T.Inputs) == 1 and T.Inputs[0] in self.FileDependency:
+                    for F in self.FileDependency[T.Inputs[0]]:
+                        Deps.append(self.PlaceMacro(str(F), self.Macros))
+                # Add source-dependencies
+                for F in T.Inputs:
+                    NewFile = self.PlaceMacro(str(F), self.Macros)
+                    # In order to use file list macro as dependency
+                    if T.GenListFile:
+                        self.ListFileMacros[T.ListFileMacro].append(str(F))
+                        self.FileListMacros[T.FileListMacro].append(NewFile)
+                    elif T.GenFileListMacro:
+                        self.FileListMacros[T.FileListMacro].append(NewFile)
+                    else:
+                        Deps.append(NewFile)
+
+                # Use file list macro as dependency
+                if T.GenFileListMacro:
+                    Deps.append("$(%s)" % T.FileListMacro)
+
+                TargetDict = {
+                    "target"    :   self.PlaceMacro(T.Target.Path, self.Macros),
+                    "cmd"       :   "\n\t".join(T.Commands),
+                    "deps"      :   Deps
+                }
+                self.BuildTargetList.append(self._BUILD_TARGET_TEMPLATE.Replace(TargetDict))
+
+    ## For creating makefile targets for dependent libraries
+    def ProcessDependentLibrary(self):
+        for LibraryAutoGen in self._AutoGenObject.LibraryAutoGenList:
+            self.LibraryBuildDirectoryList.append(self.PlaceMacro(LibraryAutoGen.BuildDir, self.Macros))
+
+    ## Return a list containing source file's dependencies
+    #
+    #   @param      FileList        The list of source files
+    #   @param      ForceInculeList The list of files which will be included forcely
+    #   @param      SearchPathList  The list of search path
+    #
+    #   @retval     dict            The mapping between source file path and its dependencies
+    #
+    def GetFileDependency(self, FileList, ForceInculeList, SearchPathList):
+        Dependency = {}
+        for F in FileList:
+            Dependency[F] = self.GetDependencyList(F, ForceInculeList, SearchPathList)
+        return Dependency
+
+    ## Find dependencies for one source file
+    #
+    #  By searching recursively "#include" directive in file, find out all the
+    #  files needed by given source file. The dependecies will be only searched
+    #  in given search path list.
+    #
+    #   @param      File            The source file
+    #   @param      ForceInculeList The list of files which will be included forcely
+    #   @param      SearchPathList  The list of search path
+    #
+    #   @retval     list            The list of files the given source file depends on
+    #
+    def GetDependencyList(self, File, ForceList, SearchPathList):
+        EdkLogger.debug(EdkLogger.DEBUG_1, "Try to get dependency files for %s" % File)
+        FileStack = [File] + ForceList
+        DependencySet = set()
+        MacroUsedByIncludedFile = False
+
+        if self._AutoGenObject.Arch not in gDependencyDatabase:
+            gDependencyDatabase[self._AutoGenObject.Arch] = {}
+        DepDb = gDependencyDatabase[self._AutoGenObject.Arch]
+
+        while len(FileStack) > 0:
+            F = FileStack.pop()
+
+            CurrentFileDependencyList = []
+            if F in DepDb:
+                CurrentFileDependencyList = DepDb[F]
+                for Dep in CurrentFileDependencyList:
+                    if Dep not in FileStack and Dep not in DependencySet:
+                        FileStack.append(Dep)
+            else:
+                try:
+                    Fd = open(F.Path, 'r')
+                except BaseException, X:
+                    EdkLogger.error("build", FILE_OPEN_FAILURE, ExtraData=F.Path+"\n\t"+str(X))
+
+                FileContent = Fd.read()
+                Fd.close()
+                if len(FileContent) == 0:
+                    continue
+
+                if FileContent[0] == 0xff or FileContent[0] == 0xfe:
+                    FileContent = unicode(FileContent, "utf-16")
+                IncludedFileList = gIncludePattern.findall(FileContent)
+
+                CurrentFilePath = F.Dir
+                for Inc in IncludedFileList:
+                    # if there's macro used to reference header file, expand it
+                    HeaderList = gMacroPattern.findall(Inc)
+                    if len(HeaderList) == 1 and len(HeaderList[0]) == 2:
+                        HeaderType = HeaderList[0][0]
+                        HeaderKey = HeaderList[0][1]
+                        if HeaderType in gIncludeMacroConversion:
+                            Inc = gIncludeMacroConversion[HeaderType] % {"HeaderKey" : HeaderKey}
+                        else:
+                            # not known macro used in #include
+                            MacroUsedByIncludedFile = True
+                            continue
+                    Inc = os.path.normpath(Inc)
+                    for SearchPath in [CurrentFilePath] + SearchPathList:
+                        FilePath = os.path.join(SearchPath, Inc)
+                        if not os.path.exists(FilePath) or FilePath in CurrentFileDependencyList:
+                            continue
+                        FilePath = PathClass(FilePath)
+                        CurrentFileDependencyList.append(FilePath)
+                        if FilePath not in FileStack and FilePath not in DependencySet:
+                            FileStack.append(FilePath)
+                        break
+                    else:
+                        EdkLogger.debug(EdkLogger.DEBUG_9, "%s included by %s was not found"\
+                                        "in any given path:\n\t%s" % (Inc, F, "\n\t".join(SearchPathList)))
+
+                if not MacroUsedByIncludedFile:
+                    if F == File:
+                        CurrentFileDependencyList += ForceList
+                    #
+                    # Don't keep the file in cache if it uses macro in included file.
+                    # So it will be scanned again if another file includes this file.
+                    #
+                    DepDb[F] = CurrentFileDependencyList
+            DependencySet.update(CurrentFileDependencyList)
+
+        #
+        # If there's macro used in included file, always build the file by
+        # returning a empty dependency
+        #
+        if MacroUsedByIncludedFile:
+            DependencyList = []
+        else:
+            DependencyList = list(DependencySet)  # remove duplicate ones
+
+        return DependencyList
+
+    _TemplateDict = property(_CreateTemplateDict)
+
+## CustomMakefile class
+#
+#  This class encapsules makefie and its generation for module. It uses template to generate
+#  the content of makefile. The content of makefile will be got from ModuleAutoGen object.
+#
+class CustomMakefile(BuildFile):
+    ## template used to generate the makefile for module with custom makefile
+    _TEMPLATE_ = TemplateString('''\
+${makefile_header}
+
+#
+# Platform Macro Definition
+#
+PLATFORM_NAME = ${platform_name}
+PLATFORM_GUID = ${platform_guid}
+PLATFORM_VERSION = ${platform_version}
+PLATFORM_RELATIVE_DIR = ${platform_relative_directory}
+PLATFORM_DIR = $(WORKSPACE)${separator}${platform_relative_directory}
+PLATFORM_OUTPUT_DIR = ${platform_output_directory}
+
+#
+# Module Macro Definition
+#
+MODULE_NAME = ${module_name}
+MODULE_GUID = ${module_guid}
+MODULE_VERSION = ${module_version}
+MODULE_TYPE = ${module_type}
+MODULE_FILE = ${module_file}
+MODULE_FILE_BASE_NAME = ${module_file_base_name}
+BASE_NAME = $(MODULE_NAME)
+MODULE_RELATIVE_DIR = ${module_relative_directory}
+MODULE_DIR = $(WORKSPACE)${separator}${module_relative_directory}
+
+#
+# Build Configuration Macro Definition
+#
+ARCH = ${architecture}
+TOOLCHAIN = ${toolchain_tag}
+TOOLCHAIN_TAG = ${toolchain_tag}
+TARGET = ${build_target}
+
+#
+# Build Directory Macro Definition
+#
+# PLATFORM_BUILD_DIR = ${platform_build_directory}
+BUILD_DIR = ${platform_build_directory}
+BIN_DIR = $(BUILD_DIR)${separator}${architecture}
+LIB_DIR = $(BIN_DIR)
+MODULE_BUILD_DIR = ${module_build_directory}
+OUTPUT_DIR = ${module_output_directory}
+DEBUG_DIR = ${module_debug_directory}
+DEST_DIR_OUTPUT = $(OUTPUT_DIR)
+DEST_DIR_DEBUG = $(DEBUG_DIR)
+
+#
+# Tools definitions specific to this module
+#
+${BEGIN}${module_tool_definitions}
+${END}
+MAKE_FILE = ${makefile_path}
+
+#
+# Shell Command Macro
+#
+${BEGIN}${shell_command_code} = ${shell_command}
+${END}
+
+${custom_makefile_content}
+
+#
+# Target used when called from platform makefile, which will bypass the build of dependent libraries
+#
+
+pbuild: init all
+
+
+#
+# ModuleTarget
+#
+
+mbuild: init all
+
+#
+# Build Target used in multi-thread build mode, which no init target is needed
+#
+
+tbuild: all
+
+#
+# Initialization target: print build information and create necessary directories
+#
+init:
+\t-@echo Building ... $(MODULE_DIR)${separator}$(MODULE_FILE) [$(ARCH)]
+${BEGIN}\t-@${create_directory_command}\n${END}\
+
+''')
+
+    ## Constructor of CustomMakefile
+    #
+    #   @param  ModuleAutoGen   Object of ModuleAutoGen class
+    #
+    def __init__(self, ModuleAutoGen):
+        BuildFile.__init__(self, ModuleAutoGen)
+        self.PlatformInfo = self._AutoGenObject.PlatformInfo
+        self.IntermediateDirectoryList = ["$(DEBUG_DIR)", "$(OUTPUT_DIR)"]
+
+    # Compose a dict object containing information used to do replacement in template
+    def _CreateTemplateDict(self):
+        Separator = self._SEP_[self._FileType]
+        if self._FileType not in self._AutoGenObject.CustomMakefile:
+            EdkLogger.error('build', OPTION_NOT_SUPPORTED, "No custom makefile for %s" % self._FileType,
+                            ExtraData="[%s]" % str(self._AutoGenObject))
+        MakefilePath = os.path.join(
+                                self._AutoGenObject.WorkspaceDir,
+                                self._AutoGenObject.CustomMakefile[self._FileType]
+                                )
+        try:
+            CustomMakefile = open(MakefilePath, 'r').read()
+        except:
+            EdkLogger.error('build', FILE_OPEN_FAILURE, File=str(self._AutoGenObject),
+                            ExtraData=self._AutoGenObject.CustomMakefile[self._FileType])
+
+        # tools definitions
+        ToolsDef = []
+        for Tool in self._AutoGenObject.BuildOption:
+            # Don't generate MAKE_FLAGS in makefile. It's put in environment variable.
+            if Tool == "MAKE":
+                continue
+            for Attr in self._AutoGenObject.BuildOption[Tool]:
+                if Attr == "FAMILY":
+                    continue
+                elif Attr == "PATH":
+                    ToolsDef.append("%s = %s" % (Tool, self._AutoGenObject.BuildOption[Tool][Attr]))
+                else:
+                    ToolsDef.append("%s_%s = %s" % (Tool, Attr, self._AutoGenObject.BuildOption[Tool][Attr]))
+            ToolsDef.append("")
+
+        MakefileName = self._FILE_NAME_[self._FileType]
+        MakefileTemplateDict = {
+            "makefile_header"           : self._FILE_HEADER_[self._FileType],
+            "makefile_path"             : os.path.join("$(MODULE_BUILD_DIR)", MakefileName),
+            "platform_name"             : self.PlatformInfo.Name,
+            "platform_guid"             : self.PlatformInfo.Guid,
+            "platform_version"          : self.PlatformInfo.Version,
+            "platform_relative_directory": self.PlatformInfo.SourceDir,
+            "platform_output_directory" : self.PlatformInfo.OutputDir,
+
+            "module_name"               : self._AutoGenObject.Name,
+            "module_guid"               : self._AutoGenObject.Guid,
+            "module_version"            : self._AutoGenObject.Version,
+            "module_type"               : self._AutoGenObject.ModuleType,
+            "module_file"               : self._AutoGenObject.MetaFile,
+            "module_file_base_name"     : self._AutoGenObject.MetaFile.BaseName,
+            "module_relative_directory" : self._AutoGenObject.SourceDir,
+
+            "architecture"              : self._AutoGenObject.Arch,
+            "toolchain_tag"             : self._AutoGenObject.ToolChain,
+            "build_target"              : self._AutoGenObject.BuildTarget,
+
+            "platform_build_directory"  : self.PlatformInfo.BuildDir,
+            "module_build_directory"    : self._AutoGenObject.BuildDir,
+            "module_output_directory"   : self._AutoGenObject.OutputDir,
+            "module_debug_directory"    : self._AutoGenObject.DebugDir,
+
+            "separator"                 : Separator,
+            "module_tool_definitions"   : ToolsDef,
+
+            "shell_command_code"        : self._SHELL_CMD_[self._FileType].keys(),
+            "shell_command"             : self._SHELL_CMD_[self._FileType].values(),
+
+            "create_directory_command"  : self.GetCreateDirectoryCommand(self.IntermediateDirectoryList),
+            "custom_makefile_content"   : CustomMakefile
+        }
+
+        return MakefileTemplateDict
+
+    _TemplateDict = property(_CreateTemplateDict)
+
+## PlatformMakefile class
+#
+#  This class encapsules makefie and its generation for platform. It uses
+# template to generate the content of makefile. The content of makefile will be
+# got from PlatformAutoGen object.
+#
+class PlatformMakefile(BuildFile):
+    ## template used to generate the makefile for platform
+    _TEMPLATE_ = TemplateString('''\
+${makefile_header}
+
+#
+# Platform Macro Definition
+#
+PLATFORM_NAME = ${platform_name}
+PLATFORM_GUID = ${platform_guid}
+PLATFORM_VERSION = ${platform_version}
+PLATFORM_FILE = ${platform_file}
+PLATFORM_DIR = $(WORKSPACE)${separator}${platform_relative_directory}
+PLATFORM_OUTPUT_DIR = ${platform_output_directory}
+
+#
+# Build Configuration Macro Definition
+#
+TOOLCHAIN = ${toolchain_tag}
+TOOLCHAIN_TAG = ${toolchain_tag}
+TARGET = ${build_target}
+
+#
+# Build Directory Macro Definition
+#
+BUILD_DIR = ${platform_build_directory}
+FV_DIR = ${platform_build_directory}${separator}FV
+
+#
+# Shell Command Macro
+#
+${BEGIN}${shell_command_code} = ${shell_command}
+${END}
+
+MAKE = ${make_path}
+MAKE_FILE = ${makefile_path}
+
+#
+# Default target
+#
+all: init build_libraries build_modules
+
+#
+# Initialization target: print build information and create necessary directories
+#
+init:
+\t-@echo Building ... $(PLATFORM_FILE) [${build_architecture_list}]
+\t${BEGIN}-@${create_directory_command}
+\t${END}
+#
+# library build target
+#
+libraries: init build_libraries
+
+#
+# module build target
+#
+modules: init build_libraries build_modules
+
+#
+# Build all libraries:
+#
+build_libraries:
+${BEGIN}\t@"$(MAKE)" $(MAKE_FLAGS) -f ${library_makefile_list} pbuild
+${END}\t@cd $(BUILD_DIR)
+
+#
+# Build all modules:
+#
+build_modules:
+${BEGIN}\t@"$(MAKE)" $(MAKE_FLAGS) -f ${module_makefile_list} pbuild
+${END}\t@cd $(BUILD_DIR)
+
+#
+# Clean intermediate files
+#
+clean:
+\t${BEGIN}-@${library_build_command} clean
+\t${END}${BEGIN}-@${module_build_command} clean
+\t${END}@cd $(BUILD_DIR)
+
+#
+# Clean all generated files except to makefile
+#
+cleanall:
+${BEGIN}\t${cleanall_command}
+${END}
+
+#
+# Clean all library files
+#
+cleanlib:
+\t${BEGIN}-@${library_build_command} cleanall
+\t${END}@cd $(BUILD_DIR)\n
+''')
+
+    ## Constructor of PlatformMakefile
+    #
+    #   @param  ModuleAutoGen   Object of PlatformAutoGen class
+    #
+    def __init__(self, PlatformAutoGen):
+        BuildFile.__init__(self, PlatformAutoGen)
+        self.ModuleBuildCommandList = []
+        self.ModuleMakefileList = []
+        self.IntermediateDirectoryList = []
+        self.ModuleBuildDirectoryList = []
+        self.LibraryBuildDirectoryList = []
+
+    # Compose a dict object containing information used to do replacement in template
+    def _CreateTemplateDict(self):
+        Separator = self._SEP_[self._FileType]
+
+        PlatformInfo = self._AutoGenObject
+        if "MAKE" not in PlatformInfo.ToolDefinition or "PATH" not in PlatformInfo.ToolDefinition["MAKE"]:
+            EdkLogger.error("build", OPTION_MISSING, "No MAKE command defined. Please check your tools_def.txt!",
+                            ExtraData="[%s]" % str(self._AutoGenObject))
+
+        self.IntermediateDirectoryList = ["$(BUILD_DIR)"]
+        self.ModuleBuildDirectoryList = self.GetModuleBuildDirectoryList()
+        self.LibraryBuildDirectoryList = self.GetLibraryBuildDirectoryList()
+
+        MakefileName = self._FILE_NAME_[self._FileType]
+        LibraryMakefileList = []
+        LibraryMakeCommandList = []
+        for D in self.LibraryBuildDirectoryList:
+            D = self.PlaceMacro(D, {"BUILD_DIR":PlatformInfo.BuildDir})
+            Makefile = os.path.join(D, MakefileName)
+            Command = self._MAKE_TEMPLATE_[self._FileType] % {"file":Makefile}
+            LibraryMakefileList.append(Makefile)
+            LibraryMakeCommandList.append(Command)
+
+        ModuleMakefileList = []
+        ModuleMakeCommandList = []
+        for D in self.ModuleBuildDirectoryList:
+            D = self.PlaceMacro(D, {"BUILD_DIR":PlatformInfo.BuildDir})
+            Makefile = os.path.join(D, MakefileName)
+            Command = self._MAKE_TEMPLATE_[self._FileType] % {"file":Makefile}
+            ModuleMakefileList.append(Makefile)
+            ModuleMakeCommandList.append(Command)
+
+        MakefileTemplateDict = {
+            "makefile_header"           : self._FILE_HEADER_[self._FileType],
+            "makefile_path"             : os.path.join("$(BUILD_DIR)", MakefileName),
+            "make_path"                 : PlatformInfo.ToolDefinition["MAKE"]["PATH"],
+            "makefile_name"             : MakefileName,
+            "platform_name"             : PlatformInfo.Name,
+            "platform_guid"             : PlatformInfo.Guid,
+            "platform_version"          : PlatformInfo.Version,
+            "platform_file"             : self._AutoGenObject.MetaFile,
+            "platform_relative_directory": PlatformInfo.SourceDir,
+            "platform_output_directory" : PlatformInfo.OutputDir,
+            "platform_build_directory"  : PlatformInfo.BuildDir,
+
+            "toolchain_tag"             : PlatformInfo.ToolChain,
+            "build_target"              : PlatformInfo.BuildTarget,
+            "shell_command_code"        : self._SHELL_CMD_[self._FileType].keys(),
+            "shell_command"             : self._SHELL_CMD_[self._FileType].values(),
+            "build_architecture_list"   : self._AutoGenObject.Arch,
+            "architecture"              : self._AutoGenObject.Arch,
+            "separator"                 : Separator,
+            "create_directory_command"  : self.GetCreateDirectoryCommand(self.IntermediateDirectoryList),
+            "cleanall_command"          : self.GetRemoveDirectoryCommand(self.IntermediateDirectoryList),
+            "library_makefile_list"     : LibraryMakefileList,
+            "module_makefile_list"      : ModuleMakefileList,
+            "library_build_command"     : LibraryMakeCommandList,
+            "module_build_command"      : ModuleMakeCommandList,
+        }
+
+        return MakefileTemplateDict
+
+    ## Get the root directory list for intermediate files of all modules build
+    #
+    #   @retval     list    The list of directory
+    #
+    def GetModuleBuildDirectoryList(self):
+        DirList = []
+        for ModuleAutoGen in self._AutoGenObject.ModuleAutoGenList:
+            DirList.append(os.path.join(self._AutoGenObject.BuildDir, ModuleAutoGen.BuildDir))
+        return DirList
+
+    ## Get the root directory list for intermediate files of all libraries build
+    #
+    #   @retval     list    The list of directory
+    #
+    def GetLibraryBuildDirectoryList(self):
+        DirList = []
+        for LibraryAutoGen in self._AutoGenObject.LibraryAutoGenList:
+            DirList.append(os.path.join(self._AutoGenObject.BuildDir, LibraryAutoGen.BuildDir))
+        return DirList
+
+    _TemplateDict = property(_CreateTemplateDict)
+
+## TopLevelMakefile class
+#
+#  This class encapsules makefie and its generation for entrance makefile. It
+# uses template to generate the content of makefile. The content of makefile
+# will be got from WorkspaceAutoGen object.
+#
+class TopLevelMakefile(BuildFile):
+    ## template used to generate toplevel makefile
+    _TEMPLATE_ = TemplateString('''\
+${makefile_header}
+
+#
+# Platform Macro Definition
+#
+PLATFORM_NAME = ${platform_name}
+PLATFORM_GUID = ${platform_guid}
+PLATFORM_VERSION = ${platform_version}
+
+#
+# Build Configuration Macro Definition
+#
+TOOLCHAIN = ${toolchain_tag}
+TOOLCHAIN_TAG = ${toolchain_tag}
+TARGET = ${build_target}
+
+#
+# Build Directory Macro Definition
+#
+BUILD_DIR = ${platform_build_directory}
+FV_DIR = ${platform_build_directory}${separator}FV
+
+#
+# Shell Command Macro
+#
+${BEGIN}${shell_command_code} = ${shell_command}
+${END}
+
+MAKE = ${make_path}
+MAKE_FILE = ${makefile_path}
+
+#
+# Default target
+#
+all: modules fds
+
+#
+# Initialization target: print build information and create necessary directories
+#
+init:
+\t-@
+\t${BEGIN}-@${create_directory_command}
+\t${END}
+#
+# library build target
+#
+libraries: init
+${BEGIN}\t@cd $(BUILD_DIR)${separator}${arch} && "$(MAKE)" $(MAKE_FLAGS) libraries
+${END}\t@cd $(BUILD_DIR)
+
+#
+# module build target
+#
+modules: init
+${BEGIN}\t@cd $(BUILD_DIR)${separator}${arch} && "$(MAKE)" $(MAKE_FLAGS) modules
+${END}\t@cd $(BUILD_DIR)
+
+#
+# Flash Device Image Target
+#
+fds: init
+\t-@cd $(FV_DIR)
+${BEGIN}\tGenFds -f ${fdf_file} -o $(BUILD_DIR) -t $(TOOLCHAIN) -b $(TARGET) -p ${active_platform} -a ${build_architecture_list} ${extra_options}${END}${BEGIN} -r ${fd} ${END}${BEGIN} -i ${fv} ${END}${BEGIN} -D ${macro} ${END}
+
+#
+# run command for emulator platform only
+#
+run:
+\tcd $(BUILD_DIR)${separator}IA32 && ".${separator}SecMain"
+\tcd $(BUILD_DIR)
+
+#
+# Clean intermediate files
+#
+clean:
+${BEGIN}\t-@${sub_build_command} clean
+${END}\t@cd $(BUILD_DIR)
+
+#
+# Clean all generated files except to makefile
+#
+cleanall:
+${BEGIN}\t${cleanall_command}
+${END}
+
+#
+# Clean all library files
+#
+cleanlib:
+${BEGIN}\t-@${sub_build_command} cleanlib
+${END}\t@cd $(BUILD_DIR)\n
+''')
+
+    ## Constructor of TopLevelMakefile
+    #
+    #   @param  Workspace   Object of WorkspaceAutoGen class
+    #
+    def __init__(self, Workspace):
+        BuildFile.__init__(self, Workspace)
+        self.IntermediateDirectoryList = []
+
+    # Compose a dict object containing information used to do replacement in template
+    def _CreateTemplateDict(self):
+        Separator = self._SEP_[self._FileType]
+
+        # any platform autogen object is ok because we just need common information
+        PlatformInfo = self._AutoGenObject
+
+        if "MAKE" not in PlatformInfo.ToolDefinition or "PATH" not in PlatformInfo.ToolDefinition["MAKE"]:
+            EdkLogger.error("build", OPTION_MISSING, "No MAKE command defined. Please check your tools_def.txt!",
+                            ExtraData="[%s]" % str(self._AutoGenObject))
+
+        for Arch in PlatformInfo.ArchList:
+            self.IntermediateDirectoryList.append(Separator.join(["$(BUILD_DIR)", Arch]))
+        self.IntermediateDirectoryList.append("$(FV_DIR)")
+
+        # TRICK: for not generating GenFds call in makefile if no FDF file
+        MacroList = []
+        if PlatformInfo.FdfFile != None and PlatformInfo.FdfFile != "":
+            FdfFileList = [PlatformInfo.FdfFile]
+            # macros passed to GenFds
+            for MacroName in GlobalData.gGlobalDefines:
+                MacroList.append('"%s=%s"' % (MacroName, GlobalData.gGlobalDefines[MacroName]))
+        else:
+            FdfFileList = []
+
+        # pass extra common options to external program called in makefile, currently GenFds.exe
+        ExtraOption = ''
+        LogLevel = EdkLogger.GetLevel()
+        if LogLevel == EdkLogger.VERBOSE:
+            ExtraOption += " -v"
+        elif LogLevel <= EdkLogger.DEBUG_9:
+            ExtraOption += " -d %d" % (LogLevel - 1)
+        elif LogLevel == EdkLogger.QUIET:
+            ExtraOption += " -q"
+
+        if GlobalData.gCaseInsensitive:
+            ExtraOption += " -c"
+
+        MakefileName = self._FILE_NAME_[self._FileType]
+        SubBuildCommandList = []
+        for A in PlatformInfo.ArchList:
+            Command = self._MAKE_TEMPLATE_[self._FileType] % {"file":os.path.join("$(BUILD_DIR)", A, MakefileName)}
+            SubBuildCommandList.append(Command)
+
+        MakefileTemplateDict = {
+            "makefile_header"           : self._FILE_HEADER_[self._FileType],
+            "makefile_path"             : os.path.join("$(BUILD_DIR)", MakefileName),
+            "make_path"                 : PlatformInfo.ToolDefinition["MAKE"]["PATH"],
+            "platform_name"             : PlatformInfo.Name,
+            "platform_guid"             : PlatformInfo.Guid,
+            "platform_version"          : PlatformInfo.Version,
+            "platform_build_directory"  : PlatformInfo.BuildDir,
+
+            "toolchain_tag"             : PlatformInfo.ToolChain,
+            "build_target"              : PlatformInfo.BuildTarget,
+            "shell_command_code"        : self._SHELL_CMD_[self._FileType].keys(),
+            "shell_command"             : self._SHELL_CMD_[self._FileType].values(),
+            'arch'                      : list(PlatformInfo.ArchList),
+            "build_architecture_list"   : ','.join(PlatformInfo.ArchList),
+            "separator"                 : Separator,
+            "create_directory_command"  : self.GetCreateDirectoryCommand(self.IntermediateDirectoryList),
+            "cleanall_command"          : self.GetRemoveDirectoryCommand(self.IntermediateDirectoryList),
+            "sub_build_command"         : SubBuildCommandList,
+            "fdf_file"                  : FdfFileList,
+            "active_platform"           : str(PlatformInfo),
+            "fd"                        : PlatformInfo.FdTargetList,
+            "fv"                        : PlatformInfo.FvTargetList,
+            "extra_options"             : ExtraOption,
+            "macro"                     : MacroList,
+        }
+
+        return MakefileTemplateDict
+
+    ## Get the root directory list for intermediate files of all modules build
+    #
+    #   @retval     list    The list of directory
+    #
+    def GetModuleBuildDirectoryList(self):
+        DirList = []
+        for ModuleAutoGen in self._AutoGenObject.ModuleAutoGenList:
+            DirList.append(os.path.join(self._AutoGenObject.BuildDir, ModuleAutoGen.BuildDir))
+        return DirList
+
+    ## Get the root directory list for intermediate files of all libraries build
+    #
+    #   @retval     list    The list of directory
+    #
+    def GetLibraryBuildDirectoryList(self):
+        DirList = []
+        for LibraryAutoGen in self._AutoGenObject.LibraryAutoGenList:
+            DirList.append(os.path.join(self._AutoGenObject.BuildDir, LibraryAutoGen.BuildDir))
+        return DirList
+
+    _TemplateDict = property(_CreateTemplateDict)
+
+# This acts like the main() function for the script, unless it is 'import'ed into another script.
+if __name__ == '__main__':
+    pass
+