BaseTools/Source/Python/AutoGen/GenMake.py

   1 ## @file
   2 # Create makefile for MS nmake and GNU make
   3 #
   4 # Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>
   5 # SPDX-License-Identifier: BSD-2-Clause-Patent
   6 #
   7
   8 ## Import Modules
   9 #
  10 from __future__ import absolute_import
  11 import Common.LongFilePathOs as os
  12 import sys
  13 import string
  14 import re
  15 import os.path as path
  16 from Common.LongFilePathSupport import OpenLongFilePath as open
  17 from Common.MultipleWorkspace import MultipleWorkspace as mws
  18 from Common.BuildToolError import *
  19 from Common.Misc import *
  20 from Common.StringUtils import *
  21 from .BuildEngine import *
  22 import Common.GlobalData as GlobalData
  23 from collections import OrderedDict
  24 from Common.DataType import TAB_COMPILER_MSFT
  25
  26 ## Regular expression for finding header file inclusions
  27 gIncludePattern = re.compile(r"^[ \t]*[#%]?[ \t]*include(?:[ \t]*(?:\\(?:\r\n|\r|\n))*[ \t]*)*(?:\(?[\"<]?[ \t]*)([-\w.\\/() \t]+)(?:[ \t]*[\">]?\)?)", re.MULTILINE | re.UNICODE | re.IGNORECASE)
  28
  29 ## Regular expression for matching macro used in header file inclusion
  30 gMacroPattern = re.compile("([_A-Z][_A-Z0-9]*)[ \t]*\((.+)\)", re.UNICODE)
  31
  32 gIsFileMap = {}
  33
  34 ## pattern for include style in Edk.x code
  35 gProtocolDefinition = "Protocol/%(HeaderKey)s/%(HeaderKey)s.h"
  36 gGuidDefinition = "Guid/%(HeaderKey)s/%(HeaderKey)s.h"
  37 gArchProtocolDefinition = "ArchProtocol/%(HeaderKey)s/%(HeaderKey)s.h"
  38 gPpiDefinition = "Ppi/%(HeaderKey)s/%(HeaderKey)s.h"
  39 gIncludeMacroConversion = {
  40   "EFI_PROTOCOL_DEFINITION"         :   gProtocolDefinition,
  41   "EFI_GUID_DEFINITION"             :   gGuidDefinition,
  42   "EFI_ARCH_PROTOCOL_DEFINITION"    :   gArchProtocolDefinition,
  43   "EFI_PROTOCOL_PRODUCER"           :   gProtocolDefinition,
  44   "EFI_PROTOCOL_CONSUMER"           :   gProtocolDefinition,
  45   "EFI_PROTOCOL_DEPENDENCY"         :   gProtocolDefinition,
  46   "EFI_ARCH_PROTOCOL_PRODUCER"      :   gArchProtocolDefinition,
  47   "EFI_ARCH_PROTOCOL_CONSUMER"      :   gArchProtocolDefinition,
  48   "EFI_ARCH_PROTOCOL_DEPENDENCY"    :   gArchProtocolDefinition,
  49   "EFI_PPI_DEFINITION"              :   gPpiDefinition,
  50   "EFI_PPI_PRODUCER"                :   gPpiDefinition,
  51   "EFI_PPI_CONSUMER"                :   gPpiDefinition,
  52   "EFI_PPI_DEPENDENCY"              :   gPpiDefinition,
  53 }
  54
  55 ## default makefile type
  56 gMakeType = ""
  57 if sys.platform == "win32":
  58     gMakeType = "nmake"
  59 else:
  60     gMakeType = "gmake"
  61
  62
  63 ## BuildFile class
  64 #
  65 #  This base class encapsules build file and its generation. It uses template to generate
  66 #  the content of build file. The content of build file will be got from AutoGen objects.
  67 #
  68 class BuildFile(object):
  69     ## template used to generate the build file (i.e. makefile if using make)
  70     _TEMPLATE_ = TemplateString('')
  71
  72     _DEFAULT_FILE_NAME_ = "Makefile"
  73
  74     ## default file name for each type of build file
  75     _FILE_NAME_ = {
  76         "nmake" :   "Makefile",
  77         "gmake" :   "GNUmakefile"
  78     }
  79
  80     ## Fixed header string for makefile
  81     _MAKEFILE_HEADER = '''#
  82 # DO NOT EDIT
  83 # This file is auto-generated by build utility
  84 #
  85 # Module Name:
  86 #
  87 #   %s
  88 #
  89 # Abstract:
  90 #
  91 #   Auto-generated makefile for building modules, libraries or platform
  92 #
  93     '''
  94
  95     ## Header string for each type of build file
  96     _FILE_HEADER_ = {
  97         "nmake" :   _MAKEFILE_HEADER % _FILE_NAME_["nmake"],
  98         "gmake" :   _MAKEFILE_HEADER % _FILE_NAME_["gmake"]
  99     }
 100
 101     ## shell commands which can be used in build file in the form of macro
 102     #   $(CP)     copy file command
 103     #   $(MV)     move file command
 104     #   $(RM)     remove file command
 105     #   $(MD)     create dir command
 106     #   $(RD)     remove dir command
 107     #
 108     _SHELL_CMD_ = {
 109         "nmake" : {
 110             "CP"    :   "copy /y",
 111             "MV"    :   "move /y",
 112             "RM"    :   "del /f /q",
 113             "MD"    :   "mkdir",
 114             "RD"    :   "rmdir /s /q",
 115         },
 116
 117         "gmake" : {
 118             "CP"    :   "cp -f",
 119             "MV"    :   "mv -f",
 120             "RM"    :   "rm -f",
 121             "MD"    :   "mkdir -p",
 122             "RD"    :   "rm -r -f",
 123         }
 124     }
 125
 126     ## directory separator
 127     _SEP_ = {
 128         "nmake" :   "\\",
 129         "gmake" :   "/"
 130     }
 131
 132     ## directory creation template
 133     _MD_TEMPLATE_ = {
 134         "nmake" :   'if not exist %(dir)s $(MD) %(dir)s',
 135         "gmake" :   "$(MD) %(dir)s"
 136     }
 137
 138     ## directory removal template
 139     _RD_TEMPLATE_ = {
 140         "nmake" :   'if exist %(dir)s $(RD) %(dir)s',
 141         "gmake" :   "$(RD) %(dir)s"
 142     }
 143     ## cp if exist
 144     _CP_TEMPLATE_ = {
 145         "nmake" :   'if exist %(Src)s $(CP) %(Src)s %(Dst)s',
 146         "gmake" :   "test -f %(Src)s && $(CP) %(Src)s %(Dst)s"
 147     }
 148
 149     _CD_TEMPLATE_ = {
 150         "nmake" :   'if exist %(dir)s cd %(dir)s',
 151         "gmake" :   "test -e %(dir)s && cd %(dir)s"
 152     }
 153
 154     _MAKE_TEMPLATE_ = {
 155         "nmake" :   'if exist %(file)s "$(MAKE)" $(MAKE_FLAGS) -f %(file)s',
 156         "gmake" :   'test -e %(file)s && "$(MAKE)" $(MAKE_FLAGS) -f %(file)s'
 157     }
 158
 159     _INCLUDE_CMD_ = {
 160         "nmake" :   '!INCLUDE',
 161         "gmake" :   "include"
 162     }
 163
 164     _INC_FLAG_ = {TAB_COMPILER_MSFT : "/I", "GCC" : "-I", "INTEL" : "-I", "RVCT" : "-I", "NASM" : "-I"}
 165
 166     ## Constructor of BuildFile
 167     #
 168     #   @param  AutoGenObject   Object of AutoGen class
 169     #
 170     def __init__(self, AutoGenObject):
 171         self._AutoGenObject = AutoGenObject
 172         self._FileType = gMakeType
 173
 174     ## Create build file
 175     #
 176     #   @param  FileType    Type of build file. Only nmake and gmake are supported now.
 177     #
 178     #   @retval TRUE        The build file is created or re-created successfully
 179     #   @retval FALSE       The build file exists and is the same as the one to be generated
 180     #
 181     def Generate(self, FileType=gMakeType):
 182         if FileType not in self._FILE_NAME_:
 183             EdkLogger.error("build", PARAMETER_INVALID, "Invalid build type [%s]" % FileType,
 184                             ExtraData="[%s]" % str(self._AutoGenObject))
 185         self._FileType = FileType
 186         FileContent = self._TEMPLATE_.Replace(self._TemplateDict)
 187         FileName = self._FILE_NAME_[FileType]
 188         return SaveFileOnChange(os.path.join(self._AutoGenObject.MakeFileDir, FileName), FileContent, False)
 189
 190     ## Return a list of directory creation command string
 191     #
 192     #   @param      DirList     The list of directory to be created
 193     #
 194     #   @retval     list        The directory creation command list
 195     #
 196     def GetCreateDirectoryCommand(self, DirList):
 197         return [self._MD_TEMPLATE_[self._FileType] % {'dir':Dir} for Dir in DirList]
 198
 199     ## Return a list of directory removal command string
 200     #
 201     #   @param      DirList     The list of directory to be removed
 202     #
 203     #   @retval     list        The directory removal command list
 204     #
 205     def GetRemoveDirectoryCommand(self, DirList):
 206         return [self._RD_TEMPLATE_[self._FileType] % {'dir':Dir} for Dir in DirList]
 207
 208     def PlaceMacro(self, Path, MacroDefinitions={}):
 209         if Path.startswith("$("):
 210             return Path
 211         else:
 212             PathLength = len(Path)
 213             for MacroName in MacroDefinitions:
 214                 MacroValue = MacroDefinitions[MacroName]
 215                 MacroValueLength = len(MacroValue)
 216                 if MacroValueLength == 0:
 217                     continue
 218                 if MacroValueLength <= PathLength and Path.startswith(MacroValue):
 219                     Path = "$(%s)%s" % (MacroName, Path[MacroValueLength:])
 220                     break
 221             return Path
 222
 223 ## ModuleMakefile class
 224 #
 225 #  This class encapsules makefie and its generation for module. It uses template to generate
 226 #  the content of makefile. The content of makefile will be got from ModuleAutoGen object.
 227 #
 228 class ModuleMakefile(BuildFile):
 229     ## template used to generate the makefile for module
 230     _TEMPLATE_ = TemplateString('''\
 231 ${makefile_header}
 232
 233 #
 234 # Platform Macro Definition
 235 #
 236 PLATFORM_NAME = ${platform_name}
 237 PLATFORM_GUID = ${platform_guid}
 238 PLATFORM_VERSION = ${platform_version}
 239 PLATFORM_RELATIVE_DIR = ${platform_relative_directory}
 240 PLATFORM_DIR = ${platform_dir}
 241 PLATFORM_OUTPUT_DIR = ${platform_output_directory}
 242
 243 #
 244 # Module Macro Definition
 245 #
 246 MODULE_NAME = ${module_name}
 247 MODULE_GUID = ${module_guid}
 248 MODULE_NAME_GUID = ${module_name_guid}
 249 MODULE_VERSION = ${module_version}
 250 MODULE_TYPE = ${module_type}
 251 MODULE_FILE = ${module_file}
 252 MODULE_FILE_BASE_NAME = ${module_file_base_name}
 253 BASE_NAME = $(MODULE_NAME)
 254 MODULE_RELATIVE_DIR = ${module_relative_directory}
 255 PACKAGE_RELATIVE_DIR = ${package_relative_directory}
 256 MODULE_DIR = ${module_dir}
 257 FFS_OUTPUT_DIR = ${ffs_output_directory}
 258
 259 MODULE_ENTRY_POINT = ${module_entry_point}
 260 ARCH_ENTRY_POINT = ${arch_entry_point}
 261 IMAGE_ENTRY_POINT = ${image_entry_point}
 262
 263 ${BEGIN}${module_extra_defines}
 264 ${END}
 265 #
 266 # Build Configuration Macro Definition
 267 #
 268 ARCH = ${architecture}
 269 TOOLCHAIN = ${toolchain_tag}
 270 TOOLCHAIN_TAG = ${toolchain_tag}
 271 TARGET = ${build_target}
 272
 273 #
 274 # Build Directory Macro Definition
 275 #
 276 # PLATFORM_BUILD_DIR = ${platform_build_directory}
 277 BUILD_DIR = ${platform_build_directory}
 278 BIN_DIR = $(BUILD_DIR)${separator}${architecture}
 279 LIB_DIR = $(BIN_DIR)
 280 MODULE_BUILD_DIR = ${module_build_directory}
 281 OUTPUT_DIR = ${module_output_directory}
 282 DEBUG_DIR = ${module_debug_directory}
 283 DEST_DIR_OUTPUT = $(OUTPUT_DIR)
 284 DEST_DIR_DEBUG = $(DEBUG_DIR)
 285
 286 #
 287 # Shell Command Macro
 288 #
 289 ${BEGIN}${shell_command_code} = ${shell_command}
 290 ${END}
 291
 292 #
 293 # Tools definitions specific to this module
 294 #
 295 ${BEGIN}${module_tool_definitions}
 296 ${END}
 297 MAKE_FILE = ${makefile_path}
 298
 299 #
 300 # Build Macro
 301 #
 302 ${BEGIN}${file_macro}
 303 ${END}
 304
 305 COMMON_DEPS = ${BEGIN}${common_dependency_file} \\
 306               ${END}
 307
 308 #
 309 # Overridable Target Macro Definitions
 310 #
 311 FORCE_REBUILD = force_build
 312 INIT_TARGET = init
 313 PCH_TARGET =
 314 BC_TARGET = ${BEGIN}${backward_compatible_target} ${END}
 315 CODA_TARGET = ${BEGIN}${remaining_build_target} \\
 316               ${END}
 317
 318 #
 319 # Default target, which will build dependent libraries in addition to source files
 320 #
 321
 322 all: mbuild
 323
 324
 325 #
 326 # Target used when called from platform makefile, which will bypass the build of dependent libraries
 327 #
 328
 329 pbuild: $(INIT_TARGET) $(BC_TARGET) $(PCH_TARGET) $(CODA_TARGET)
 330
 331 #
 332 # ModuleTarget
 333 #
 334
 335 mbuild: $(INIT_TARGET) $(BC_TARGET) gen_libs $(PCH_TARGET) $(CODA_TARGET)
 336
 337 #
 338 # Build Target used in multi-thread build mode, which will bypass the init and gen_libs targets
 339 #
 340
 341 tbuild: $(BC_TARGET) $(PCH_TARGET) $(CODA_TARGET)
 342
 343 #
 344 # Phony target which is used to force executing commands for a target
 345 #
 346 force_build:
 347 \t-@
 348
 349 #
 350 # Target to update the FD
 351 #
 352
 353 fds: mbuild gen_fds
 354
 355 #
 356 # Initialization target: print build information and create necessary directories
 357 #
 358 init: info dirs
 359
 360 info:
 361 \t-@echo Building ... $(MODULE_DIR)${separator}$(MODULE_FILE) [$(ARCH)]
 362
 363 dirs:
 364 ${BEGIN}\t-@${create_directory_command}\n${END}
 365
 366 strdefs:
 367 \t-@$(CP) $(DEBUG_DIR)${separator}AutoGen.h $(DEBUG_DIR)${separator}$(MODULE_NAME)StrDefs.h
 368
 369 #
 370 # GenLibsTarget
 371 #
 372 gen_libs:
 373 \t${BEGIN}@"$(MAKE)" $(MAKE_FLAGS) -f ${dependent_library_build_directory}${separator}${makefile_name}
 374 \t${END}@cd $(MODULE_BUILD_DIR)
 375
 376 #
 377 # Build Flash Device Image
 378 #
 379 gen_fds:
 380 \t@"$(MAKE)" $(MAKE_FLAGS) -f $(BUILD_DIR)${separator}${makefile_name} fds
 381 \t@cd $(MODULE_BUILD_DIR)
 382
 383 #
 384 # Individual Object Build Targets
 385 #
 386 ${BEGIN}${file_build_target}
 387 ${END}
 388
 389 #
 390 # clean all intermediate files
 391 #
 392 clean:
 393 \t${BEGIN}${clean_command}
 394 \t${END}\t$(RM) AutoGenTimeStamp
 395
 396 #
 397 # clean all generated files
 398 #
 399 cleanall:
 400 ${BEGIN}\t${cleanall_command}
 401 ${END}\t$(RM) *.pdb *.idb > NUL 2>&1
 402 \t$(RM) $(BIN_DIR)${separator}$(MODULE_NAME).efi
 403 \t$(RM) AutoGenTimeStamp
 404
 405 #
 406 # clean all dependent libraries built
 407 #
 408 cleanlib:
 409 \t${BEGIN}-@${library_build_command} cleanall
 410 \t${END}@cd $(MODULE_BUILD_DIR)\n\n''')
 411
 412     _FILE_MACRO_TEMPLATE = TemplateString("${macro_name} = ${BEGIN} \\\n    ${source_file}${END}\n")
 413     _BUILD_TARGET_TEMPLATE = TemplateString("${BEGIN}${target} : ${deps}\n${END}\t${cmd}\n")
 414
 415     ## Constructor of ModuleMakefile
 416     #
 417     #   @param  ModuleAutoGen   Object of ModuleAutoGen class
 418     #
 419     def __init__(self, ModuleAutoGen):
 420         BuildFile.__init__(self, ModuleAutoGen)
 421         self.PlatformInfo = self._AutoGenObject.PlatformInfo
 422
 423         self.ResultFileList = []
 424         self.IntermediateDirectoryList = ["$(DEBUG_DIR)", "$(OUTPUT_DIR)"]
 425
 426         self.FileBuildTargetList = []       # [(src, target string)]
 427         self.BuildTargetList = []           # [target string]
 428         self.PendingBuildTargetList = []    # [FileBuildRule objects]
 429         self.CommonFileDependency = []
 430         self.FileListMacros = {}
 431         self.ListFileMacros = {}
 432         self.ObjTargetDict = OrderedDict()
 433         self.FileCache = {}
 434         self.LibraryBuildCommandList = []
 435         self.LibraryFileList = []
 436         self.LibraryMakefileList = []
 437         self.LibraryBuildDirectoryList = []
 438         self.SystemLibraryList = []
 439         self.Macros = OrderedDict()
 440         self.Macros["OUTPUT_DIR"      ] = self._AutoGenObject.Macros["OUTPUT_DIR"]
 441         self.Macros["DEBUG_DIR"       ] = self._AutoGenObject.Macros["DEBUG_DIR"]
 442         self.Macros["MODULE_BUILD_DIR"] = self._AutoGenObject.Macros["MODULE_BUILD_DIR"]
 443         self.Macros["BIN_DIR"         ] = self._AutoGenObject.Macros["BIN_DIR"]
 444         self.Macros["BUILD_DIR"       ] = self._AutoGenObject.Macros["BUILD_DIR"]
 445         self.Macros["WORKSPACE"       ] = self._AutoGenObject.Macros["WORKSPACE"]
 446         self.Macros["FFS_OUTPUT_DIR"  ] = self._AutoGenObject.Macros["FFS_OUTPUT_DIR"]
 447         self.GenFfsList                 = ModuleAutoGen.GenFfsList
 448         self.MacroList = ['FFS_OUTPUT_DIR', 'MODULE_GUID', 'OUTPUT_DIR']
 449         self.FfsOutputFileList = []
 450
 451     # Compose a dict object containing information used to do replacement in template
 452     @property
 453     def _TemplateDict(self):
 454         if self._FileType not in self._SEP_:
 455             EdkLogger.error("build", PARAMETER_INVALID, "Invalid Makefile type [%s]" % self._FileType,
 456                             ExtraData="[%s]" % str(self._AutoGenObject))
 457         MyAgo = self._AutoGenObject
 458         Separator = self._SEP_[self._FileType]
 459
 460         # break build if no source files and binary files are found
 461         if len(MyAgo.SourceFileList) == 0 and len(MyAgo.BinaryFileList) == 0:
 462             EdkLogger.error("build", AUTOGEN_ERROR, "No files to be built in module [%s, %s, %s]"
 463                             % (MyAgo.BuildTarget, MyAgo.ToolChain, MyAgo.Arch),
 464                             ExtraData="[%s]" % str(MyAgo))
 465
 466         # convert dependent libraries to build command
 467         self.ProcessDependentLibrary()
 468         if len(MyAgo.Module.ModuleEntryPointList) > 0:
 469             ModuleEntryPoint = MyAgo.Module.ModuleEntryPointList[0]
 470         else:
 471             ModuleEntryPoint = "_ModuleEntryPoint"
 472
 473         ArchEntryPoint = ModuleEntryPoint
 474
 475         if MyAgo.Arch == "EBC":
 476             # EBC compiler always use "EfiStart" as entry point. Only applies to EdkII modules
 477             ImageEntryPoint = "EfiStart"
 478         else:
 479             # EdkII modules always use "_ModuleEntryPoint" as entry point
 480             ImageEntryPoint = "_ModuleEntryPoint"
 481
 482         for k, v in MyAgo.Module.Defines.items():
 483             if k not in MyAgo.Macros:
 484                 MyAgo.Macros[k] = v
 485
 486         if 'MODULE_ENTRY_POINT' not in MyAgo.Macros:
 487             MyAgo.Macros['MODULE_ENTRY_POINT'] = ModuleEntryPoint
 488         if 'ARCH_ENTRY_POINT' not in MyAgo.Macros:
 489             MyAgo.Macros['ARCH_ENTRY_POINT'] = ArchEntryPoint
 490         if 'IMAGE_ENTRY_POINT' not in MyAgo.Macros:
 491             MyAgo.Macros['IMAGE_ENTRY_POINT'] = ImageEntryPoint
 492
 493         PCI_COMPRESS_Flag = False
 494         for k, v in MyAgo.Module.Defines.items():
 495             if 'PCI_COMPRESS' == k and 'TRUE' == v:
 496                 PCI_COMPRESS_Flag = True
 497
 498         # tools definitions
 499         ToolsDef = []
 500         IncPrefix = self._INC_FLAG_[MyAgo.ToolChainFamily]
 501         for Tool in MyAgo.BuildOption:
 502             for Attr in MyAgo.BuildOption[Tool]:
 503                 Value = MyAgo.BuildOption[Tool][Attr]
 504                 if Attr == "FAMILY":
 505                     continue
 506                 elif Attr == "PATH":
 507                     ToolsDef.append("%s = %s" % (Tool, Value))
 508                 else:
 509                     # Don't generate MAKE_FLAGS in makefile. It's put in environment variable.
 510                     if Tool == "MAKE":
 511                         continue
 512                     # Remove duplicated include path, if any
 513                     if Attr == "FLAGS":
 514                         Value = RemoveDupOption(Value, IncPrefix, MyAgo.IncludePathList)
 515                         if self._AutoGenObject.BuildRuleFamily == TAB_COMPILER_MSFT and Tool == 'CC' and '/GM' in Value:
 516                             Value = Value.replace(' /MP', '')
 517                             MyAgo.BuildOption[Tool][Attr] = Value
 518                         if Tool == "OPTROM" and PCI_COMPRESS_Flag:
 519                             ValueList = Value.split()
 520                             if ValueList:
 521                                 for i, v in enumerate(ValueList):
 522                                     if '-e' == v:
 523                                         ValueList[i] = '-ec'
 524                                 Value = ' '.join(ValueList)
 525
 526                     ToolsDef.append("%s_%s = %s" % (Tool, Attr, Value))
 527             ToolsDef.append("")
 528
 529         # generate the Response file and Response flag
 530         RespDict = self.CommandExceedLimit()
 531         RespFileList = os.path.join(MyAgo.OutputDir, 'respfilelist.txt')
 532         if RespDict:
 533             RespFileListContent = ''
 534             for Resp in RespDict:
 535                 RespFile = os.path.join(MyAgo.OutputDir, str(Resp).lower() + '.txt')
 536                 StrList = RespDict[Resp].split(' ')
 537                 UnexpandMacro = []
 538                 NewStr = []
 539                 for Str in StrList:
 540                     if '$' in Str:
 541                         UnexpandMacro.append(Str)
 542                     else:
 543                         NewStr.append(Str)
 544                 UnexpandMacroStr = ' '.join(UnexpandMacro)
 545                 NewRespStr = ' '.join(NewStr)
 546                 SaveFileOnChange(RespFile, NewRespStr, False)
 547                 ToolsDef.append("%s = %s" % (Resp, UnexpandMacroStr + ' @' + RespFile))
 548                 RespFileListContent += '@' + RespFile + TAB_LINE_BREAK
 549                 RespFileListContent += NewRespStr + TAB_LINE_BREAK
 550             SaveFileOnChange(RespFileList, RespFileListContent, False)
 551         else:
 552             if os.path.exists(RespFileList):
 553                 os.remove(RespFileList)
 554
 555         # convert source files and binary files to build targets
 556         self.ResultFileList = [str(T.Target) for T in MyAgo.CodaTargetList]
 557         if len(self.ResultFileList) == 0 and len(MyAgo.SourceFileList) != 0:
 558             EdkLogger.error("build", AUTOGEN_ERROR, "Nothing to build",
 559                             ExtraData="[%s]" % str(MyAgo))
 560
 561         self.ProcessBuildTargetList()
 562         self.ParserGenerateFfsCmd()
 563
 564         # Generate macros used to represent input files
 565         FileMacroList = [] # macro name = file list
 566         for FileListMacro in self.FileListMacros:
 567             FileMacro = self._FILE_MACRO_TEMPLATE.Replace(
 568                                                     {
 569                                                         "macro_name"  : FileListMacro,
 570                                                         "source_file" : self.FileListMacros[FileListMacro]
 571                                                     }
 572                                                     )
 573             FileMacroList.append(FileMacro)
 574
 575         # INC_LIST is special
 576         FileMacro = ""
 577         IncludePathList = []
 578         for P in  MyAgo.IncludePathList:
 579             IncludePathList.append(IncPrefix + self.PlaceMacro(P, self.Macros))
 580             if FileBuildRule.INC_LIST_MACRO in self.ListFileMacros:
 581                 self.ListFileMacros[FileBuildRule.INC_LIST_MACRO].append(IncPrefix + P)
 582         FileMacro += self._FILE_MACRO_TEMPLATE.Replace(
 583                                                 {
 584                                                     "macro_name"   : "INC",
 585                                                     "source_file" : IncludePathList
 586                                                 }
 587                                                 )
 588         FileMacroList.append(FileMacro)
 589         # Add support when compiling .nasm source files
 590         for File in self.FileCache.keys():
 591             if not str(File).endswith('.nasm'):
 592                 continue
 593             IncludePathList = []
 594             for P in  MyAgo.IncludePathList:
 595                 IncludePath = self._INC_FLAG_['NASM'] + self.PlaceMacro(P, self.Macros)
 596                 if IncludePath.endswith(os.sep):
 597                     IncludePath = IncludePath.rstrip(os.sep)
 598                 # When compiling .nasm files, need to add a literal backslash at each path
 599                 # To specify a literal backslash at the end of the line, precede it with a caret (^)
 600                 if P == MyAgo.IncludePathList[-1] and os.sep == '\\':
 601                     IncludePath = ''.join([IncludePath, '^', os.sep])
 602                 else:
 603                     IncludePath = os.path.join(IncludePath, '')
 604                 IncludePathList.append(IncludePath)
 605             FileMacroList.append(self._FILE_MACRO_TEMPLATE.Replace({"macro_name": "NASM_INC", "source_file": IncludePathList}))
 606             break
 607
 608         # Generate macros used to represent files containing list of input files
 609         for ListFileMacro in self.ListFileMacros:
 610             ListFileName = os.path.join(MyAgo.OutputDir, "%s.lst" % ListFileMacro.lower()[:len(ListFileMacro) - 5])
 611             FileMacroList.append("%s = %s" % (ListFileMacro, ListFileName))
 612             SaveFileOnChange(
 613                 ListFileName,
 614                 "\n".join(self.ListFileMacros[ListFileMacro]),
 615                 False
 616                 )
 617
 618         # Generate objlist used to create .obj file
 619         for Type in self.ObjTargetDict:
 620             NewLine = ' '.join(list(self.ObjTargetDict[Type]))
 621             FileMacroList.append("OBJLIST_%s = %s" % (list(self.ObjTargetDict.keys()).index(Type), NewLine))
 622
 623         BcTargetList = []
 624
 625         MakefileName = self._FILE_NAME_[self._FileType]
 626         LibraryMakeCommandList = []
 627         for D in self.LibraryBuildDirectoryList:
 628             Command = self._MAKE_TEMPLATE_[self._FileType] % {"file":os.path.join(D, MakefileName)}
 629             LibraryMakeCommandList.append(Command)
 630
 631         package_rel_dir = MyAgo.SourceDir
 632         current_dir = self.Macros["WORKSPACE"]
 633         found = False
 634         while not found and os.sep in package_rel_dir:
 635             index = package_rel_dir.index(os.sep)
 636             current_dir = mws.join(current_dir, package_rel_dir[:index])
 637             if os.path.exists(current_dir):
 638                 for fl in os.listdir(current_dir):
 639                     if fl.endswith('.dec'):
 640                         found = True
 641                         break
 642             package_rel_dir = package_rel_dir[index + 1:]
 643
 644         MakefileTemplateDict = {
 645             "makefile_header"           : self._FILE_HEADER_[self._FileType],
 646             "makefile_path"             : os.path.join("$(MODULE_BUILD_DIR)", MakefileName),
 647             "makefile_name"             : MakefileName,
 648             "platform_name"             : self.PlatformInfo.Name,
 649             "platform_guid"             : self.PlatformInfo.Guid,
 650             "platform_version"          : self.PlatformInfo.Version,
 651             "platform_relative_directory": self.PlatformInfo.SourceDir,
 652             "platform_output_directory" : self.PlatformInfo.OutputDir,
 653             "ffs_output_directory"      : MyAgo.Macros["FFS_OUTPUT_DIR"],
 654             "platform_dir"              : MyAgo.Macros["PLATFORM_DIR"],
 655
 656             "module_name"               : MyAgo.Name,
 657             "module_guid"               : MyAgo.Guid,
 658             "module_name_guid"          : MyAgo.UniqueBaseName,
 659             "module_version"            : MyAgo.Version,
 660             "module_type"               : MyAgo.ModuleType,
 661             "module_file"               : MyAgo.MetaFile.Name,
 662             "module_file_base_name"     : MyAgo.MetaFile.BaseName,
 663             "module_relative_directory" : MyAgo.SourceDir,
 664             "module_dir"                : mws.join (self.Macros["WORKSPACE"], MyAgo.SourceDir),
 665             "package_relative_directory": package_rel_dir,
 666             "module_extra_defines"      : ["%s = %s" % (k, v) for k, v in MyAgo.Module.Defines.items()],
 667
 668             "architecture"              : MyAgo.Arch,
 669             "toolchain_tag"             : MyAgo.ToolChain,
 670             "build_target"              : MyAgo.BuildTarget,
 671
 672             "platform_build_directory"  : self.PlatformInfo.BuildDir,
 673             "module_build_directory"    : MyAgo.BuildDir,
 674             "module_output_directory"   : MyAgo.OutputDir,
 675             "module_debug_directory"    : MyAgo.DebugDir,
 676
 677             "separator"                 : Separator,
 678             "module_tool_definitions"   : ToolsDef,
 679
 680             "shell_command_code"        : list(self._SHELL_CMD_[self._FileType].keys()),
 681             "shell_command"             : list(self._SHELL_CMD_[self._FileType].values()),
 682
 683             "module_entry_point"        : ModuleEntryPoint,
 684             "image_entry_point"         : ImageEntryPoint,
 685             "arch_entry_point"          : ArchEntryPoint,
 686             "remaining_build_target"    : self.ResultFileList,
 687             "common_dependency_file"    : self.CommonFileDependency,
 688             "create_directory_command"  : self.GetCreateDirectoryCommand(self.IntermediateDirectoryList),
 689             "clean_command"             : self.GetRemoveDirectoryCommand(["$(OUTPUT_DIR)"]),
 690             "cleanall_command"          : self.GetRemoveDirectoryCommand(["$(DEBUG_DIR)", "$(OUTPUT_DIR)"]),
 691             "dependent_library_build_directory" : self.LibraryBuildDirectoryList,
 692             "library_build_command"     : LibraryMakeCommandList,
 693             "file_macro"                : FileMacroList,
 694             "file_build_target"         : self.BuildTargetList,
 695             "backward_compatible_target": BcTargetList,
 696         }
 697
 698         return MakefileTemplateDict
 699
 700     def ParserGenerateFfsCmd(self):
 701         #Add Ffs cmd to self.BuildTargetList
 702         OutputFile = ''
 703         DepsFileList = []
 704
 705         for Cmd in self.GenFfsList:
 706             if Cmd[2]:
 707                 for CopyCmd in Cmd[2]:
 708                     Src, Dst = CopyCmd
 709                     Src = self.ReplaceMacro(Src)
 710                     Dst = self.ReplaceMacro(Dst)
 711                     if Dst not in self.ResultFileList:
 712                         self.ResultFileList.append(Dst)
 713                     if '%s :' %(Dst) not in self.BuildTargetList:
 714                         self.BuildTargetList.append("%s :" %(Dst))
 715                         self.BuildTargetList.append('\t' + self._CP_TEMPLATE_[self._FileType] %{'Src': Src, 'Dst': Dst})
 716
 717             FfsCmdList = Cmd[0]
 718             for index, Str in enumerate(FfsCmdList):
 719                 if '-o' == Str:
 720                     OutputFile = FfsCmdList[index + 1]
 721                 if '-i' == Str or "-oi" == Str:
 722                     if DepsFileList == []:
 723                         DepsFileList = [FfsCmdList[index + 1]]
 724                     else:
 725                         DepsFileList.append(FfsCmdList[index + 1])
 726             DepsFileString = ' '.join(DepsFileList).strip()
 727             if DepsFileString == '':
 728                 continue
 729             OutputFile = self.ReplaceMacro(OutputFile)
 730             self.ResultFileList.append(OutputFile)
 731             DepsFileString = self.ReplaceMacro(DepsFileString)
 732             self.BuildTargetList.append('%s : %s' % (OutputFile, DepsFileString))
 733             CmdString = ' '.join(FfsCmdList).strip()
 734             CmdString = self.ReplaceMacro(CmdString)
 735             self.BuildTargetList.append('\t%s' % CmdString)
 736
 737             self.ParseSecCmd(DepsFileList, Cmd[1])
 738             for SecOutputFile, SecDepsFile, SecCmd in self.FfsOutputFileList :
 739                 self.BuildTargetList.append('%s : %s' % (self.ReplaceMacro(SecOutputFile), self.ReplaceMacro(SecDepsFile)))
 740                 self.BuildTargetList.append('\t%s' % self.ReplaceMacro(SecCmd))
 741             self.FfsOutputFileList = []
 742
 743     def ParseSecCmd(self, OutputFileList, CmdTuple):
 744         for OutputFile in OutputFileList:
 745             for SecCmdStr in CmdTuple:
 746                 SecDepsFileList = []
 747                 SecCmdList = SecCmdStr.split()
 748                 CmdName = SecCmdList[0]
 749                 for index, CmdItem in enumerate(SecCmdList):
 750                     if '-o' == CmdItem and OutputFile == SecCmdList[index + 1]:
 751                         index = index + 1
 752                         while index + 1 < len(SecCmdList):
 753                             if not SecCmdList[index+1].startswith('-'):
 754                                 SecDepsFileList.append(SecCmdList[index + 1])
 755                             index = index + 1
 756                         if CmdName == 'Trim':
 757                             SecDepsFileList.append(os.path.join('$(DEBUG_DIR)', os.path.basename(OutputFile).replace('offset', 'efi')))
 758                         if OutputFile.endswith('.ui') or OutputFile.endswith('.ver'):
 759                             SecDepsFileList.append(os.path.join('$(MODULE_DIR)', '$(MODULE_FILE)'))
 760                         self.FfsOutputFileList.append((OutputFile, ' '.join(SecDepsFileList), SecCmdStr))
 761                         if len(SecDepsFileList) > 0:
 762                             self.ParseSecCmd(SecDepsFileList, CmdTuple)
 763                         break
 764                     else:
 765                         continue
 766
 767     def ReplaceMacro(self, str):
 768         for Macro in self.MacroList:
 769             if self._AutoGenObject.Macros[Macro] and self._AutoGenObject.Macros[Macro] in str:
 770                 str = str.replace(self._AutoGenObject.Macros[Macro], '$(' + Macro + ')')
 771         return str
 772
 773     def CommandExceedLimit(self):
 774         FlagDict = {
 775                     'CC'    :  { 'Macro' : '$(CC_FLAGS)',    'Value' : False},
 776                     'PP'    :  { 'Macro' : '$(PP_FLAGS)',    'Value' : False},
 777                     'APP'   :  { 'Macro' : '$(APP_FLAGS)',   'Value' : False},
 778                     'ASLPP' :  { 'Macro' : '$(ASLPP_FLAGS)', 'Value' : False},
 779                     'VFRPP' :  { 'Macro' : '$(VFRPP_FLAGS)', 'Value' : False},
 780                     'ASM'   :  { 'Macro' : '$(ASM_FLAGS)',   'Value' : False},
 781                     'ASLCC' :  { 'Macro' : '$(ASLCC_FLAGS)', 'Value' : False},
 782                    }
 783
 784         RespDict = {}
 785         FileTypeList = []
 786         IncPrefix = self._INC_FLAG_[self._AutoGenObject.ToolChainFamily]
 787
 788         # base on the source files to decide the file type
 789         for File in self._AutoGenObject.SourceFileList:
 790             for type in self._AutoGenObject.FileTypes:
 791                 if File in self._AutoGenObject.FileTypes[type]:
 792                     if type not in FileTypeList:
 793                         FileTypeList.append(type)
 794
 795         # calculate the command-line length
 796         if FileTypeList:
 797             for type in FileTypeList:
 798                 BuildTargets = self._AutoGenObject.BuildRules[type].BuildTargets
 799                 for Target in BuildTargets:
 800                     CommandList = BuildTargets[Target].Commands
 801                     for SingleCommand in CommandList:
 802                         Tool = ''
 803                         SingleCommandLength = len(SingleCommand)
 804                         SingleCommandList = SingleCommand.split()
 805                         if len(SingleCommandList) > 0:
 806                             for Flag in FlagDict:
 807                                 if '$('+ Flag +')' in SingleCommandList[0]:
 808                                     Tool = Flag
 809                                     break
 810                         if Tool:
 811                             if 'PATH' not in self._AutoGenObject.BuildOption[Tool]:
 812                                 EdkLogger.error("build", AUTOGEN_ERROR, "%s_PATH doesn't exist in %s ToolChain and %s Arch." %(Tool, self._AutoGenObject.ToolChain, self._AutoGenObject.Arch), ExtraData="[%s]" % str(self._AutoGenObject))
 813                             SingleCommandLength += len(self._AutoGenObject.BuildOption[Tool]['PATH'])
 814                             for item in SingleCommandList[1:]:
 815                                 if FlagDict[Tool]['Macro'] in item:
 816                                     if 'FLAGS' not in self._AutoGenObject.BuildOption[Tool]:
 817                                         EdkLogger.error("build", AUTOGEN_ERROR, "%s_FLAGS doesn't exist in %s ToolChain and %s Arch." %(Tool, self._AutoGenObject.ToolChain, self._AutoGenObject.Arch), ExtraData="[%s]" % str(self._AutoGenObject))
 818                                     Str = self._AutoGenObject.BuildOption[Tool]['FLAGS']
 819                                     for Option in self._AutoGenObject.BuildOption:
 820                                         for Attr in self._AutoGenObject.BuildOption[Option]:
 821                                             if Str.find(Option + '_' + Attr) != -1:
 822                                                 Str = Str.replace('$(' + Option + '_' + Attr + ')', self._AutoGenObject.BuildOption[Option][Attr])
 823                                     while(Str.find('$(') != -1):
 824                                         for macro in self._AutoGenObject.Macros:
 825                                             MacroName = '$('+ macro + ')'
 826                                             if (Str.find(MacroName) != -1):
 827                                                 Str = Str.replace(MacroName, self._AutoGenObject.Macros[macro])
 828                                                 break
 829                                         else:
 830                                             break
 831                                     SingleCommandLength += len(Str)
 832                                 elif '$(INC)' in item:
 833                                     SingleCommandLength += self._AutoGenObject.IncludePathLength + len(IncPrefix) * len(self._AutoGenObject.IncludePathList)
 834                                 elif item.find('$(') != -1:
 835                                     Str = item
 836                                     for Option in self._AutoGenObject.BuildOption:
 837                                         for Attr in self._AutoGenObject.BuildOption[Option]:
 838                                             if Str.find(Option + '_' + Attr) != -1:
 839                                                 Str = Str.replace('$(' + Option + '_' + Attr + ')', self._AutoGenObject.BuildOption[Option][Attr])
 840                                     while(Str.find('$(') != -1):
 841                                         for macro in self._AutoGenObject.Macros:
 842                                             MacroName = '$('+ macro + ')'
 843                                             if (Str.find(MacroName) != -1):
 844                                                 Str = Str.replace(MacroName, self._AutoGenObject.Macros[macro])
 845                                                 break
 846                                         else:
 847                                             break
 848                                     SingleCommandLength += len(Str)
 849
 850                             if SingleCommandLength > GlobalData.gCommandMaxLength:
 851                                 FlagDict[Tool]['Value'] = True
 852
 853                 # generate the response file content by combine the FLAGS and INC
 854                 for Flag in FlagDict:
 855                     if FlagDict[Flag]['Value']:
 856                         Key = Flag + '_RESP'
 857                         RespMacro = FlagDict[Flag]['Macro'].replace('FLAGS', 'RESP')
 858                         Value = self._AutoGenObject.BuildOption[Flag]['FLAGS']
 859                         for inc in self._AutoGenObject.IncludePathList:
 860                             Value += ' ' + IncPrefix + inc
 861                         for Option in self._AutoGenObject.BuildOption:
 862                             for Attr in self._AutoGenObject.BuildOption[Option]:
 863                                 if Value.find(Option + '_' + Attr) != -1:
 864                                     Value = Value.replace('$(' + Option + '_' + Attr + ')', self._AutoGenObject.BuildOption[Option][Attr])
 865                         while (Value.find('$(') != -1):
 866                             for macro in self._AutoGenObject.Macros:
 867                                 MacroName = '$('+ macro + ')'
 868                                 if (Value.find(MacroName) != -1):
 869                                     Value = Value.replace(MacroName, self._AutoGenObject.Macros[macro])
 870                                     break
 871                             else:
 872                                 break
 873
 874                         if self._AutoGenObject.ToolChainFamily == 'GCC':
 875                             RespDict[Key] = Value.replace('\\', '/')
 876                         else:
 877                             RespDict[Key] = Value
 878                         for Target in BuildTargets:
 879                             for i, SingleCommand in enumerate(BuildTargets[Target].Commands):
 880                                 if FlagDict[Flag]['Macro'] in SingleCommand:
 881                                     BuildTargets[Target].Commands[i] = SingleCommand.replace('$(INC)', '').replace(FlagDict[Flag]['Macro'], RespMacro)
 882         return RespDict
 883
 884     def ProcessBuildTargetList(self):
 885         #
 886         # Search dependency file list for each source file
 887         #
 888         ForceIncludedFile = []
 889         for File in self._AutoGenObject.AutoGenFileList:
 890             if File.Ext == '.h':
 891                 ForceIncludedFile.append(File)
 892         SourceFileList = []
 893         OutPutFileList = []
 894         for Target in self._AutoGenObject.IntroTargetList:
 895             SourceFileList.extend(Target.Inputs)
 896             OutPutFileList.extend(Target.Outputs)
 897
 898         if OutPutFileList:
 899             for Item in OutPutFileList:
 900                 if Item in SourceFileList:
 901                     SourceFileList.remove(Item)
 902
 903         FileDependencyDict = self.GetFileDependency(
 904                                     SourceFileList,
 905                                     ForceIncludedFile,
 906                                     self._AutoGenObject.IncludePathList + self._AutoGenObject.BuildOptionIncPathList
 907                                     )
 908
 909         # Check if header files are listed in metafile
 910         # Get a list of unique module header source files from MetaFile
 911         headerFilesInMetaFileSet = set()
 912         for aFile in self._AutoGenObject.SourceFileList:
 913             aFileName = str(aFile)
 914             if not aFileName.endswith('.h'):
 915                 continue
 916             headerFilesInMetaFileSet.add(aFileName.lower())
 917
 918         # Get a list of unique module autogen files
 919         localAutoGenFileSet = set()
 920         for aFile in self._AutoGenObject.AutoGenFileList:
 921             localAutoGenFileSet.add(str(aFile).lower())
 922
 923         # Get a list of unique module dependency header files
 924         # Exclude autogen files and files not in the source directory
 925         headerFileDependencySet = set()
 926         localSourceDir = str(self._AutoGenObject.SourceDir).lower()
 927         for Dependency in FileDependencyDict.values():
 928             for aFile in Dependency:
 929                 aFileName = str(aFile).lower()
 930                 if not aFileName.endswith('.h'):
 931                     continue
 932                 if aFileName in localAutoGenFileSet:
 933                     continue
 934                 if localSourceDir not in aFileName:
 935                     continue
 936                 headerFileDependencySet.add(aFileName)
 937
 938         # Ensure that gModuleBuildTracking has been initialized per architecture
 939         if self._AutoGenObject.Arch not in GlobalData.gModuleBuildTracking:
 940             GlobalData.gModuleBuildTracking[self._AutoGenObject.Arch] = dict()
 941
 942         # Check if a module dependency header file is missing from the module's MetaFile
 943         for aFile in headerFileDependencySet:
 944             if aFile in headerFilesInMetaFileSet:
 945                 continue
 946             if GlobalData.gUseHashCache:
 947                 GlobalData.gModuleBuildTracking[self._AutoGenObject.Arch][self._AutoGenObject] = 'FAIL_METAFILE'
 948             EdkLogger.warn("build","Module MetaFile [Sources] is missing local header!",
 949                         ExtraData = "Local Header: " + aFile + " not found in " + self._AutoGenObject.MetaFile.Path
 950                         )
 951
 952         DepSet = None
 953         for File,Dependency in FileDependencyDict.items():
 954             if not Dependency:
 955                 FileDependencyDict[File] = ['$(FORCE_REBUILD)']
 956                 continue
 957
 958             self._AutoGenObject.AutoGenDepSet |= set(Dependency)
 959
 960             # skip non-C files
 961             if File.Ext not in [".c", ".C"] or File.Name == "AutoGen.c":
 962                 continue
 963             elif DepSet is None:
 964                 DepSet = set(Dependency)
 965             else:
 966                 DepSet &= set(Dependency)
 967         # in case nothing in SourceFileList
 968         if DepSet is None:
 969             DepSet = set()
 970         #
 971         # Extract common files list in the dependency files
 972         #
 973         for File in DepSet:
 974             self.CommonFileDependency.append(self.PlaceMacro(File.Path, self.Macros))
 975
 976         CmdSumDict = {}
 977         CmdTargetDict = {}
 978         CmdCppDict = {}
 979         DependencyDict = FileDependencyDict.copy()
 980         for File in FileDependencyDict:
 981             # skip non-C files
 982             if File.Ext not in [".c", ".C"] or File.Name == "AutoGen.c":
 983                 continue
 984             NewDepSet = set(FileDependencyDict[File])
 985             NewDepSet -= DepSet
 986             FileDependencyDict[File] = ["$(COMMON_DEPS)"] + list(NewDepSet)
 987             DependencyDict[File] = list(NewDepSet)
 988
 989         # Convert target description object to target string in makefile
 990         if self._AutoGenObject.BuildRuleFamily == TAB_COMPILER_MSFT and TAB_C_CODE_FILE in self._AutoGenObject.Targets:
 991             for T in self._AutoGenObject.Targets[TAB_C_CODE_FILE]:
 992                 NewFile = self.PlaceMacro(str(T), self.Macros)
 993                 if not self.ObjTargetDict.get(T.Target.SubDir):
 994                     self.ObjTargetDict[T.Target.SubDir] = set()
 995                 self.ObjTargetDict[T.Target.SubDir].add(NewFile)
 996         for Type in self._AutoGenObject.Targets:
 997             for T in self._AutoGenObject.Targets[Type]:
 998                 # Generate related macros if needed
 999                 if T.GenFileListMacro and T.FileListMacro not in self.FileListMacros:
1000                     self.FileListMacros[T.FileListMacro] = []
1001                 if T.GenListFile and T.ListFileMacro not in self.ListFileMacros:
1002                     self.ListFileMacros[T.ListFileMacro] = []
1003                 if T.GenIncListFile and T.IncListFileMacro not in self.ListFileMacros:
1004                     self.ListFileMacros[T.IncListFileMacro] = []
1005
1006                 Deps = []
1007                 CCodeDeps = []
1008                 # Add force-dependencies
1009                 for Dep in T.Dependencies:
1010                     Deps.append(self.PlaceMacro(str(Dep), self.Macros))
1011                     if Dep != '$(MAKE_FILE)':
1012                         CCodeDeps.append(self.PlaceMacro(str(Dep), self.Macros))
1013                 # Add inclusion-dependencies
1014                 if len(T.Inputs) == 1 and T.Inputs[0] in FileDependencyDict:
1015                     for F in FileDependencyDict[T.Inputs[0]]:
1016                         Deps.append(self.PlaceMacro(str(F), self.Macros))
1017                 # Add source-dependencies
1018                 for F in T.Inputs:
1019                     NewFile = self.PlaceMacro(str(F), self.Macros)
1020                     # In order to use file list macro as dependency
1021                     if T.GenListFile:
1022                         # gnu tools need forward slash path separator, even on Windows
1023                         self.ListFileMacros[T.ListFileMacro].append(str(F).replace ('\\', '/'))
1024                         self.FileListMacros[T.FileListMacro].append(NewFile)
1025                     elif T.GenFileListMacro:
1026                         self.FileListMacros[T.FileListMacro].append(NewFile)
1027                     else:
1028                         Deps.append(NewFile)
1029
1030                 # Use file list macro as dependency
1031                 if T.GenFileListMacro:
1032                     Deps.append("$(%s)" % T.FileListMacro)
1033                     if Type in [TAB_OBJECT_FILE, TAB_STATIC_LIBRARY]:
1034                         Deps.append("$(%s)" % T.ListFileMacro)
1035
1036                 if self._AutoGenObject.BuildRuleFamily == TAB_COMPILER_MSFT and Type == TAB_C_CODE_FILE:
1037                     T, CmdTarget, CmdTargetDict, CmdCppDict = self.ParserCCodeFile(T, Type, CmdSumDict, CmdTargetDict, CmdCppDict, DependencyDict)
1038                     TargetDict = {"target": self.PlaceMacro(T.Target.Path, self.Macros), "cmd": "\n\t".join(T.Commands),"deps": CCodeDeps}
1039                     CmdLine = self._BUILD_TARGET_TEMPLATE.Replace(TargetDict).rstrip().replace('\t$(OBJLIST', '$(OBJLIST')
1040                     if T.Commands:
1041                         CmdLine = '%s%s' %(CmdLine, TAB_LINE_BREAK)
1042                     if CCodeDeps or CmdLine:
1043                         self.BuildTargetList.append(CmdLine)
1044                 else:
1045                     TargetDict = {"target": self.PlaceMacro(T.Target.Path, self.Macros), "cmd": "\n\t".join(T.Commands),"deps": Deps}
1046                     self.BuildTargetList.append(self._BUILD_TARGET_TEMPLATE.Replace(TargetDict))
1047
1048     def ParserCCodeFile(self, T, Type, CmdSumDict, CmdTargetDict, CmdCppDict, DependencyDict):
1049         if not CmdSumDict:
1050             for item in self._AutoGenObject.Targets[Type]:
1051                 CmdSumDict[item.Target.SubDir] = item.Target.BaseName
1052                 for CppPath in item.Inputs:
1053                     Path = self.PlaceMacro(CppPath.Path, self.Macros)
1054                     if CmdCppDict.get(item.Target.SubDir):
1055                         CmdCppDict[item.Target.SubDir].append(Path)
1056                     else:
1057                         CmdCppDict[item.Target.SubDir] = ['$(MAKE_FILE)', Path]
1058                     if CppPath.Path in DependencyDict:
1059                         for Temp in DependencyDict[CppPath.Path]:
1060                             try:
1061                                 Path = self.PlaceMacro(Temp.Path, self.Macros)
1062                             except:
1063                                 continue
1064                             if Path not in (self.CommonFileDependency + CmdCppDict[item.Target.SubDir]):
1065                                 CmdCppDict[item.Target.SubDir].append(Path)
1066         if T.Commands:
1067             CommandList = T.Commands[:]
1068             for Item in CommandList[:]:
1069                 SingleCommandList = Item.split()
1070                 if len(SingleCommandList) > 0 and self.CheckCCCmd(SingleCommandList):
1071                     for Temp in SingleCommandList:
1072                         if Temp.startswith('/Fo'):
1073                             CmdSign = '%s%s' % (Temp.rsplit(TAB_SLASH, 1)[0], TAB_SLASH)
1074                             break
1075                     else: continue
1076                     if CmdSign not in list(CmdTargetDict.keys()):
1077                         CmdTargetDict[CmdSign] = Item.replace(Temp, CmdSign)
1078                     else:
1079                         CmdTargetDict[CmdSign] = "%s %s" % (CmdTargetDict[CmdSign], SingleCommandList[-1])
1080                     Index = CommandList.index(Item)
1081                     CommandList.pop(Index)
1082                     if SingleCommandList[-1].endswith("%s%s.c" % (TAB_SLASH, CmdSumDict[CmdSign.lstrip('/Fo').rsplit(TAB_SLASH, 1)[0]])):
1083                         Cpplist = CmdCppDict[T.Target.SubDir]
1084                         Cpplist.insert(0, '$(OBJLIST_%d): $(COMMON_DEPS)' % list(self.ObjTargetDict.keys()).index(T.Target.SubDir))
1085                         T.Commands[Index] = '%s\n\t%s' % (' \\\n\t'.join(Cpplist), CmdTargetDict[CmdSign])
1086                     else:
1087                         T.Commands.pop(Index)
1088         return T, CmdSumDict, CmdTargetDict, CmdCppDict
1089
1090     def CheckCCCmd(self, CommandList):
1091         for cmd in CommandList:
1092             if '$(CC)' in cmd:
1093                 return True
1094         return False
1095     ## For creating makefile targets for dependent libraries
1096     def ProcessDependentLibrary(self):
1097         for LibraryAutoGen in self._AutoGenObject.LibraryAutoGenList:
1098             if not LibraryAutoGen.IsBinaryModule and not LibraryAutoGen.CanSkipbyHash():
1099                 self.LibraryBuildDirectoryList.append(self.PlaceMacro(LibraryAutoGen.BuildDir, self.Macros))
1100
1101     ## Return a list containing source file's dependencies
1102     #
1103     #   @param      FileList        The list of source files
1104     #   @param      ForceInculeList The list of files which will be included forcely
1105     #   @param      SearchPathList  The list of search path
1106     #
1107     #   @retval     dict            The mapping between source file path and its dependencies
1108     #
1109     def GetFileDependency(self, FileList, ForceInculeList, SearchPathList):
1110         Dependency = {}
1111         for F in FileList:
1112             Dependency[F] = self.GetDependencyList(F, ForceInculeList, SearchPathList)
1113         return Dependency
1114
1115     ## Find dependencies for one source file
1116     #
1117     #  By searching recursively "#include" directive in file, find out all the
1118     #  files needed by given source file. The dependencies will be only searched
1119     #  in given search path list.
1120     #
1121     #   @param      File            The source file
1122     #   @param      ForceInculeList The list of files which will be included forcely
1123     #   @param      SearchPathList  The list of search path
1124     #
1125     #   @retval     list            The list of files the given source file depends on
1126     #
1127     def GetDependencyList(self, File, ForceList, SearchPathList):
1128         EdkLogger.debug(EdkLogger.DEBUG_1, "Try to get dependency files for %s" % File)
1129         FileStack = [File] + ForceList
1130         DependencySet = set()
1131
1132         if self._AutoGenObject.Arch not in gDependencyDatabase:
1133             gDependencyDatabase[self._AutoGenObject.Arch] = {}
1134         DepDb = gDependencyDatabase[self._AutoGenObject.Arch]
1135
1136         while len(FileStack) > 0:
1137             F = FileStack.pop()
1138
1139             FullPathDependList = []
1140             if F in self.FileCache:
1141                 for CacheFile in self.FileCache[F]:
1142                     FullPathDependList.append(CacheFile)
1143                     if CacheFile not in DependencySet:
1144                         FileStack.append(CacheFile)
1145                 DependencySet.update(FullPathDependList)
1146                 continue
1147
1148             CurrentFileDependencyList = []
1149             if F in DepDb:
1150                 CurrentFileDependencyList = DepDb[F]
1151             else:
1152                 try:
1153                     Fd = open(F.Path, 'rb')
1154                     FileContent = Fd.read()
1155                     Fd.close()
1156                 except BaseException as X:
1157                     EdkLogger.error("build", FILE_OPEN_FAILURE, ExtraData=F.Path + "\n\t" + str(X))
1158                 if len(FileContent) == 0:
1159                     continue
1160                 try:
1161                     if FileContent[0] == 0xff or FileContent[0] == 0xfe:
1162                         FileContent = FileContent.decode('utf-16')
1163                     else:
1164                         FileContent = FileContent.decode()
1165                 except:
1166                     # The file is not txt file. for example .mcb file
1167                     continue
1168                 IncludedFileList = gIncludePattern.findall(FileContent)
1169
1170                 for Inc in IncludedFileList:
1171                     Inc = Inc.strip()
1172                     # if there's macro used to reference header file, expand it
1173                     HeaderList = gMacroPattern.findall(Inc)
1174                     if len(HeaderList) == 1 and len(HeaderList[0]) == 2:
1175                         HeaderType = HeaderList[0][0]
1176                         HeaderKey = HeaderList[0][1]
1177                         if HeaderType in gIncludeMacroConversion:
1178                             Inc = gIncludeMacroConversion[HeaderType] % {"HeaderKey" : HeaderKey}
1179                         else:
1180                             # not known macro used in #include, always build the file by
1181                             # returning a empty dependency
1182                             self.FileCache[File] = []
1183                             return []
1184                     Inc = os.path.normpath(Inc)
1185                     CurrentFileDependencyList.append(Inc)
1186                 DepDb[F] = CurrentFileDependencyList
1187
1188             CurrentFilePath = F.Dir
1189             PathList = [CurrentFilePath] + SearchPathList
1190             for Inc in CurrentFileDependencyList:
1191                 for SearchPath in PathList:
1192                     FilePath = os.path.join(SearchPath, Inc)
1193                     if FilePath in gIsFileMap:
1194                         if not gIsFileMap[FilePath]:
1195                             continue
1196                     # If isfile is called too many times, the performance is slow down.
1197                     elif not os.path.isfile(FilePath):
1198                         gIsFileMap[FilePath] = False
1199                         continue
1200                     else:
1201                         gIsFileMap[FilePath] = True
1202                     FilePath = PathClass(FilePath)
1203                     FullPathDependList.append(FilePath)
1204                     if FilePath not in DependencySet:
1205                         FileStack.append(FilePath)
1206                     break
1207                 else:
1208                     EdkLogger.debug(EdkLogger.DEBUG_9, "%s included by %s was not found "\
1209                                     "in any given path:\n\t%s" % (Inc, F, "\n\t".join(SearchPathList)))
1210
1211             self.FileCache[F] = FullPathDependList
1212             DependencySet.update(FullPathDependList)
1213
1214         DependencySet.update(ForceList)
1215         if File in DependencySet:
1216             DependencySet.remove(File)
1217         DependencyList = list(DependencySet)  # remove duplicate ones
1218
1219         return DependencyList
1220
1221 ## CustomMakefile class
1222 #
1223 #  This class encapsules makefie and its generation for module. It uses template to generate
1224 #  the content of makefile. The content of makefile will be got from ModuleAutoGen object.
1225 #
1226 class CustomMakefile(BuildFile):
1227     ## template used to generate the makefile for module with custom makefile
1228     _TEMPLATE_ = TemplateString('''\
1229 ${makefile_header}
1230
1231 #
1232 # Platform Macro Definition
1233 #
1234 PLATFORM_NAME = ${platform_name}
1235 PLATFORM_GUID = ${platform_guid}
1236 PLATFORM_VERSION = ${platform_version}
1237 PLATFORM_RELATIVE_DIR = ${platform_relative_directory}
1238 PLATFORM_DIR = ${platform_dir}
1239 PLATFORM_OUTPUT_DIR = ${platform_output_directory}
1240
1241 #
1242 # Module Macro Definition
1243 #
1244 MODULE_NAME = ${module_name}
1245 MODULE_GUID = ${module_guid}
1246 MODULE_NAME_GUID = ${module_name_guid}
1247 MODULE_VERSION = ${module_version}
1248 MODULE_TYPE = ${module_type}
1249 MODULE_FILE = ${module_file}
1250 MODULE_FILE_BASE_NAME = ${module_file_base_name}
1251 BASE_NAME = $(MODULE_NAME)
1252 MODULE_RELATIVE_DIR = ${module_relative_directory}
1253 MODULE_DIR = ${module_dir}
1254
1255 #
1256 # Build Configuration Macro Definition
1257 #
1258 ARCH = ${architecture}
1259 TOOLCHAIN = ${toolchain_tag}
1260 TOOLCHAIN_TAG = ${toolchain_tag}
1261 TARGET = ${build_target}
1262
1263 #
1264 # Build Directory Macro Definition
1265 #
1266 # PLATFORM_BUILD_DIR = ${platform_build_directory}
1267 BUILD_DIR = ${platform_build_directory}
1268 BIN_DIR = $(BUILD_DIR)${separator}${architecture}
1269 LIB_DIR = $(BIN_DIR)
1270 MODULE_BUILD_DIR = ${module_build_directory}
1271 OUTPUT_DIR = ${module_output_directory}
1272 DEBUG_DIR = ${module_debug_directory}
1273 DEST_DIR_OUTPUT = $(OUTPUT_DIR)
1274 DEST_DIR_DEBUG = $(DEBUG_DIR)
1275
1276 #
1277 # Tools definitions specific to this module
1278 #
1279 ${BEGIN}${module_tool_definitions}
1280 ${END}
1281 MAKE_FILE = ${makefile_path}
1282
1283 #
1284 # Shell Command Macro
1285 #
1286 ${BEGIN}${shell_command_code} = ${shell_command}
1287 ${END}
1288
1289 ${custom_makefile_content}
1290
1291 #
1292 # Target used when called from platform makefile, which will bypass the build of dependent libraries
1293 #
1294
1295 pbuild: init all
1296
1297
1298 #
1299 # ModuleTarget
1300 #
1301
1302 mbuild: init all
1303
1304 #
1305 # Build Target used in multi-thread build mode, which no init target is needed
1306 #
1307
1308 tbuild: all
1309
1310 #
1311 # Initialization target: print build information and create necessary directories
1312 #
1313 init:
1314 \t-@echo Building ... $(MODULE_DIR)${separator}$(MODULE_FILE) [$(ARCH)]
1315 ${BEGIN}\t-@${create_directory_command}\n${END}\
1316
1317 ''')
1318
1319     ## Constructor of CustomMakefile
1320     #
1321     #   @param  ModuleAutoGen   Object of ModuleAutoGen class
1322     #
1323     def __init__(self, ModuleAutoGen):
1324         BuildFile.__init__(self, ModuleAutoGen)
1325         self.PlatformInfo = self._AutoGenObject.PlatformInfo
1326         self.IntermediateDirectoryList = ["$(DEBUG_DIR)", "$(OUTPUT_DIR)"]
1327
1328     # Compose a dict object containing information used to do replacement in template
1329     @property
1330     def _TemplateDict(self):
1331         Separator = self._SEP_[self._FileType]
1332         MyAgo = self._AutoGenObject
1333         if self._FileType not in MyAgo.CustomMakefile:
1334             EdkLogger.error('build', OPTION_NOT_SUPPORTED, "No custom makefile for %s" % self._FileType,
1335                             ExtraData="[%s]" % str(MyAgo))
1336         MakefilePath = mws.join(
1337                                 MyAgo.WorkspaceDir,
1338                                 MyAgo.CustomMakefile[self._FileType]
1339                                 )
1340         try:
1341             CustomMakefile = open(MakefilePath, 'r').read()
1342         except:
1343             EdkLogger.error('build', FILE_OPEN_FAILURE, File=str(MyAgo),
1344                             ExtraData=MyAgo.CustomMakefile[self._FileType])
1345
1346         # tools definitions
1347         ToolsDef = []
1348         for Tool in MyAgo.BuildOption:
1349             # Don't generate MAKE_FLAGS in makefile. It's put in environment variable.
1350             if Tool == "MAKE":
1351                 continue
1352             for Attr in MyAgo.BuildOption[Tool]:
1353                 if Attr == "FAMILY":
1354                     continue
1355                 elif Attr == "PATH":
1356                     ToolsDef.append("%s = %s" % (Tool, MyAgo.BuildOption[Tool][Attr]))
1357                 else:
1358                     ToolsDef.append("%s_%s = %s" % (Tool, Attr, MyAgo.BuildOption[Tool][Attr]))
1359             ToolsDef.append("")
1360
1361         MakefileName = self._FILE_NAME_[self._FileType]
1362         MakefileTemplateDict = {
1363             "makefile_header"           : self._FILE_HEADER_[self._FileType],
1364             "makefile_path"             : os.path.join("$(MODULE_BUILD_DIR)", MakefileName),
1365             "platform_name"             : self.PlatformInfo.Name,
1366             "platform_guid"             : self.PlatformInfo.Guid,
1367             "platform_version"          : self.PlatformInfo.Version,
1368             "platform_relative_directory": self.PlatformInfo.SourceDir,
1369             "platform_output_directory" : self.PlatformInfo.OutputDir,
1370             "platform_dir"              : MyAgo.Macros["PLATFORM_DIR"],
1371
1372             "module_name"               : MyAgo.Name,
1373             "module_guid"               : MyAgo.Guid,
1374             "module_name_guid"          : MyAgo.UniqueBaseName,
1375             "module_version"            : MyAgo.Version,
1376             "module_type"               : MyAgo.ModuleType,
1377             "module_file"               : MyAgo.MetaFile,
1378             "module_file_base_name"     : MyAgo.MetaFile.BaseName,
1379             "module_relative_directory" : MyAgo.SourceDir,
1380             "module_dir"                : mws.join (MyAgo.WorkspaceDir, MyAgo.SourceDir),
1381
1382             "architecture"              : MyAgo.Arch,
1383             "toolchain_tag"             : MyAgo.ToolChain,
1384             "build_target"              : MyAgo.BuildTarget,
1385
1386             "platform_build_directory"  : self.PlatformInfo.BuildDir,
1387             "module_build_directory"    : MyAgo.BuildDir,
1388             "module_output_directory"   : MyAgo.OutputDir,
1389             "module_debug_directory"    : MyAgo.DebugDir,
1390
1391             "separator"                 : Separator,
1392             "module_tool_definitions"   : ToolsDef,
1393
1394             "shell_command_code"        : list(self._SHELL_CMD_[self._FileType].keys()),
1395             "shell_command"             : list(self._SHELL_CMD_[self._FileType].values()),
1396
1397             "create_directory_command"  : self.GetCreateDirectoryCommand(self.IntermediateDirectoryList),
1398             "custom_makefile_content"   : CustomMakefile
1399         }
1400
1401         return MakefileTemplateDict
1402
1403 ## PlatformMakefile class
1404 #
1405 #  This class encapsules makefie and its generation for platform. It uses
1406 # template to generate the content of makefile. The content of makefile will be
1407 # got from PlatformAutoGen object.
1408 #
1409 class PlatformMakefile(BuildFile):
1410     ## template used to generate the makefile for platform
1411     _TEMPLATE_ = TemplateString('''\
1412 ${makefile_header}
1413
1414 #
1415 # Platform Macro Definition
1416 #
1417 PLATFORM_NAME = ${platform_name}
1418 PLATFORM_GUID = ${platform_guid}
1419 PLATFORM_VERSION = ${platform_version}
1420 PLATFORM_FILE = ${platform_file}
1421 PLATFORM_DIR = ${platform_dir}
1422 PLATFORM_OUTPUT_DIR = ${platform_output_directory}
1423
1424 #
1425 # Build Configuration Macro Definition
1426 #
1427 TOOLCHAIN = ${toolchain_tag}
1428 TOOLCHAIN_TAG = ${toolchain_tag}
1429 TARGET = ${build_target}
1430
1431 #
1432 # Build Directory Macro Definition
1433 #
1434 BUILD_DIR = ${platform_build_directory}
1435 FV_DIR = ${platform_build_directory}${separator}FV
1436
1437 #
1438 # Shell Command Macro
1439 #
1440 ${BEGIN}${shell_command_code} = ${shell_command}
1441 ${END}
1442
1443 MAKE = ${make_path}
1444 MAKE_FILE = ${makefile_path}
1445
1446 #
1447 # Default target
1448 #
1449 all: init build_libraries build_modules
1450
1451 #
1452 # Initialization target: print build information and create necessary directories
1453 #
1454 init:
1455 \t-@echo Building ... $(PLATFORM_FILE) [${build_architecture_list}]
1456 \t${BEGIN}-@${create_directory_command}
1457 \t${END}
1458 #
1459 # library build target
1460 #
1461 libraries: init build_libraries
1462
1463 #
1464 # module build target
1465 #
1466 modules: init build_libraries build_modules
1467
1468 #
1469 # Build all libraries:
1470 #
1471 build_libraries:
1472 ${BEGIN}\t@"$(MAKE)" $(MAKE_FLAGS) -f ${library_makefile_list} pbuild
1473 ${END}\t@cd $(BUILD_DIR)
1474
1475 #
1476 # Build all modules:
1477 #
1478 build_modules:
1479 ${BEGIN}\t@"$(MAKE)" $(MAKE_FLAGS) -f ${module_makefile_list} pbuild
1480 ${END}\t@cd $(BUILD_DIR)
1481
1482 #
1483 # Clean intermediate files
1484 #
1485 clean:
1486 \t${BEGIN}-@${library_build_command} clean
1487 \t${END}${BEGIN}-@${module_build_command} clean
1488 \t${END}@cd $(BUILD_DIR)
1489
1490 #
1491 # Clean all generated files except to makefile
1492 #
1493 cleanall:
1494 ${BEGIN}\t${cleanall_command}
1495 ${END}
1496
1497 #
1498 # Clean all library files
1499 #
1500 cleanlib:
1501 \t${BEGIN}-@${library_build_command} cleanall
1502 \t${END}@cd $(BUILD_DIR)\n
1503 ''')
1504
1505     ## Constructor of PlatformMakefile
1506     #
1507     #   @param  ModuleAutoGen   Object of PlatformAutoGen class
1508     #
1509     def __init__(self, PlatformAutoGen):
1510         BuildFile.__init__(self, PlatformAutoGen)
1511         self.ModuleBuildCommandList = []
1512         self.ModuleMakefileList = []
1513         self.IntermediateDirectoryList = []
1514         self.ModuleBuildDirectoryList = []
1515         self.LibraryBuildDirectoryList = []
1516         self.LibraryMakeCommandList = []
1517
1518     # Compose a dict object containing information used to do replacement in template
1519     @property
1520     def _TemplateDict(self):
1521         Separator = self._SEP_[self._FileType]
1522
1523         MyAgo = self._AutoGenObject
1524         if "MAKE" not in MyAgo.ToolDefinition or "PATH" not in MyAgo.ToolDefinition["MAKE"]:
1525             EdkLogger.error("build", OPTION_MISSING, "No MAKE command defined. Please check your tools_def.txt!",
1526                             ExtraData="[%s]" % str(MyAgo))
1527
1528         self.IntermediateDirectoryList = ["$(BUILD_DIR)"]
1529         self.ModuleBuildDirectoryList = self.GetModuleBuildDirectoryList()
1530         self.LibraryBuildDirectoryList = self.GetLibraryBuildDirectoryList()
1531
1532         MakefileName = self._FILE_NAME_[self._FileType]
1533         LibraryMakefileList = []
1534         LibraryMakeCommandList = []
1535         for D in self.LibraryBuildDirectoryList:
1536             D = self.PlaceMacro(D, {"BUILD_DIR":MyAgo.BuildDir})
1537             Makefile = os.path.join(D, MakefileName)
1538             Command = self._MAKE_TEMPLATE_[self._FileType] % {"file":Makefile}
1539             LibraryMakefileList.append(Makefile)
1540             LibraryMakeCommandList.append(Command)
1541         self.LibraryMakeCommandList = LibraryMakeCommandList
1542
1543         ModuleMakefileList = []
1544         ModuleMakeCommandList = []
1545         for D in self.ModuleBuildDirectoryList:
1546             D = self.PlaceMacro(D, {"BUILD_DIR":MyAgo.BuildDir})
1547             Makefile = os.path.join(D, MakefileName)
1548             Command = self._MAKE_TEMPLATE_[self._FileType] % {"file":Makefile}
1549             ModuleMakefileList.append(Makefile)
1550             ModuleMakeCommandList.append(Command)
1551
1552         MakefileTemplateDict = {
1553             "makefile_header"           : self._FILE_HEADER_[self._FileType],
1554             "makefile_path"             : os.path.join("$(BUILD_DIR)", MakefileName),
1555             "make_path"                 : MyAgo.ToolDefinition["MAKE"]["PATH"],
1556             "makefile_name"             : MakefileName,
1557             "platform_name"             : MyAgo.Name,
1558             "platform_guid"             : MyAgo.Guid,
1559             "platform_version"          : MyAgo.Version,
1560             "platform_file"             : MyAgo.MetaFile,
1561             "platform_relative_directory": MyAgo.SourceDir,
1562             "platform_output_directory" : MyAgo.OutputDir,
1563             "platform_build_directory"  : MyAgo.BuildDir,
1564             "platform_dir"              : MyAgo.Macros["PLATFORM_DIR"],
1565
1566             "toolchain_tag"             : MyAgo.ToolChain,
1567             "build_target"              : MyAgo.BuildTarget,
1568             "shell_command_code"        : list(self._SHELL_CMD_[self._FileType].keys()),
1569             "shell_command"             : list(self._SHELL_CMD_[self._FileType].values()),
1570             "build_architecture_list"   : MyAgo.Arch,
1571             "architecture"              : MyAgo.Arch,
1572             "separator"                 : Separator,
1573             "create_directory_command"  : self.GetCreateDirectoryCommand(self.IntermediateDirectoryList),
1574             "cleanall_command"          : self.GetRemoveDirectoryCommand(self.IntermediateDirectoryList),
1575             "library_makefile_list"     : LibraryMakefileList,
1576             "module_makefile_list"      : ModuleMakefileList,
1577             "library_build_command"     : LibraryMakeCommandList,
1578             "module_build_command"      : ModuleMakeCommandList,
1579         }
1580
1581         return MakefileTemplateDict
1582
1583     ## Get the root directory list for intermediate files of all modules build
1584     #
1585     #   @retval     list    The list of directory
1586     #
1587     def GetModuleBuildDirectoryList(self):
1588         DirList = []
1589         for ModuleAutoGen in self._AutoGenObject.ModuleAutoGenList:
1590             if not ModuleAutoGen.IsBinaryModule:
1591                 DirList.append(os.path.join(self._AutoGenObject.BuildDir, ModuleAutoGen.BuildDir))
1592         return DirList
1593
1594     ## Get the root directory list for intermediate files of all libraries build
1595     #
1596     #   @retval     list    The list of directory
1597     #
1598     def GetLibraryBuildDirectoryList(self):
1599         DirList = []
1600         for LibraryAutoGen in self._AutoGenObject.LibraryAutoGenList:
1601             if not LibraryAutoGen.IsBinaryModule and not LibraryAutoGen.CanSkipbyHash():
1602                 DirList.append(os.path.join(self._AutoGenObject.BuildDir, LibraryAutoGen.BuildDir))
1603         return DirList
1604
1605 ## TopLevelMakefile class
1606 #
1607 #  This class encapsules makefie and its generation for entrance makefile. It
1608 # uses template to generate the content of makefile. The content of makefile
1609 # will be got from WorkspaceAutoGen object.
1610 #
1611 class TopLevelMakefile(BuildFile):
1612     ## template used to generate toplevel makefile
1613     _TEMPLATE_ = TemplateString('''${BEGIN}\tGenFds -f ${fdf_file} --conf=${conf_directory} -o ${platform_build_directory} -t ${toolchain_tag} -b ${build_target} -p ${active_platform} -a ${build_architecture_list} ${extra_options}${END}${BEGIN} -r ${fd} ${END}${BEGIN} -i ${fv} ${END}${BEGIN} -C ${cap} ${END}${BEGIN} -D ${macro} ${END}''')
1614
1615     ## Constructor of TopLevelMakefile
1616     #
1617     #   @param  Workspace   Object of WorkspaceAutoGen class
1618     #
1619     def __init__(self, Workspace):
1620         BuildFile.__init__(self, Workspace)
1621         self.IntermediateDirectoryList = []
1622
1623     # Compose a dict object containing information used to do replacement in template
1624     @property
1625     def _TemplateDict(self):
1626         Separator = self._SEP_[self._FileType]
1627
1628         # any platform autogen object is ok because we just need common information
1629         MyAgo = self._AutoGenObject
1630
1631         if "MAKE" not in MyAgo.ToolDefinition or "PATH" not in MyAgo.ToolDefinition["MAKE"]:
1632             EdkLogger.error("build", OPTION_MISSING, "No MAKE command defined. Please check your tools_def.txt!",
1633                             ExtraData="[%s]" % str(MyAgo))
1634
1635         for Arch in MyAgo.ArchList:
1636             self.IntermediateDirectoryList.append(Separator.join(["$(BUILD_DIR)", Arch]))
1637         self.IntermediateDirectoryList.append("$(FV_DIR)")
1638
1639         # TRICK: for not generating GenFds call in makefile if no FDF file
1640         MacroList = []
1641         if MyAgo.FdfFile is not None and MyAgo.FdfFile != "":
1642             FdfFileList = [MyAgo.FdfFile]
1643             # macros passed to GenFds
1644             MacroDict = {}
1645             MacroDict.update(GlobalData.gGlobalDefines)
1646             MacroDict.update(GlobalData.gCommandLineDefines)
1647             for MacroName in MacroDict:
1648                 if MacroDict[MacroName] != "":
1649                     MacroList.append('"%s=%s"' % (MacroName, MacroDict[MacroName].replace('\\', '\\\\')))
1650                 else:
1651                     MacroList.append('"%s"' % MacroName)
1652         else:
1653             FdfFileList = []
1654
1655         # pass extra common options to external program called in makefile, currently GenFds.exe
1656         ExtraOption = ''
1657         LogLevel = EdkLogger.GetLevel()
1658         if LogLevel == EdkLogger.VERBOSE:
1659             ExtraOption += " -v"
1660         elif LogLevel <= EdkLogger.DEBUG_9:
1661             ExtraOption += " -d %d" % (LogLevel - 1)
1662         elif LogLevel == EdkLogger.QUIET:
1663             ExtraOption += " -q"
1664
1665         if GlobalData.gCaseInsensitive:
1666             ExtraOption += " -c"
1667         if GlobalData.gEnableGenfdsMultiThread:
1668             ExtraOption += " --genfds-multi-thread"
1669         if GlobalData.gIgnoreSource:
1670             ExtraOption += " --ignore-sources"
1671
1672         for pcd in GlobalData.BuildOptionPcd:
1673             if pcd[2]:
1674                 pcdname = '.'.join(pcd[0:3])
1675             else:
1676                 pcdname = '.'.join(pcd[0:2])
1677             if pcd[3].startswith('{'):
1678                 ExtraOption += " --pcd " + pcdname + '=' + 'H' + '"' + pcd[3] + '"'
1679             else:
1680                 ExtraOption += " --pcd " + pcdname + '=' + pcd[3]
1681
1682         MakefileName = self._FILE_NAME_[self._FileType]
1683         SubBuildCommandList = []
1684         for A in MyAgo.ArchList:
1685             Command = self._MAKE_TEMPLATE_[self._FileType] % {"file":os.path.join("$(BUILD_DIR)", A, MakefileName)}
1686             SubBuildCommandList.append(Command)
1687
1688         MakefileTemplateDict = {
1689             "makefile_header"           : self._FILE_HEADER_[self._FileType],
1690             "makefile_path"             : os.path.join("$(BUILD_DIR)", MakefileName),
1691             "make_path"                 : MyAgo.ToolDefinition["MAKE"]["PATH"],
1692             "platform_name"             : MyAgo.Name,
1693             "platform_guid"             : MyAgo.Guid,
1694             "platform_version"          : MyAgo.Version,
1695             "platform_build_directory"  : MyAgo.BuildDir,
1696             "conf_directory"            : GlobalData.gConfDirectory,
1697
1698             "toolchain_tag"             : MyAgo.ToolChain,
1699             "build_target"              : MyAgo.BuildTarget,
1700             "shell_command_code"        : list(self._SHELL_CMD_[self._FileType].keys()),
1701             "shell_command"             : list(self._SHELL_CMD_[self._FileType].values()),
1702             'arch'                      : list(MyAgo.ArchList),
1703             "build_architecture_list"   : ','.join(MyAgo.ArchList),
1704             "separator"                 : Separator,
1705             "create_directory_command"  : self.GetCreateDirectoryCommand(self.IntermediateDirectoryList),
1706             "cleanall_command"          : self.GetRemoveDirectoryCommand(self.IntermediateDirectoryList),
1707             "sub_build_command"         : SubBuildCommandList,
1708             "fdf_file"                  : FdfFileList,
1709             "active_platform"           : str(MyAgo),
1710             "fd"                        : MyAgo.FdTargetList,
1711             "fv"                        : MyAgo.FvTargetList,
1712             "cap"                       : MyAgo.CapTargetList,
1713             "extra_options"             : ExtraOption,
1714             "macro"                     : MacroList,
1715         }
1716
1717         return MakefileTemplateDict
1718
1719     ## Get the root directory list for intermediate files of all modules build
1720     #
1721     #   @retval     list    The list of directory
1722     #
1723     def GetModuleBuildDirectoryList(self):
1724         DirList = []
1725         for ModuleAutoGen in self._AutoGenObject.ModuleAutoGenList:
1726             if not ModuleAutoGen.IsBinaryModule:
1727                 DirList.append(os.path.join(self._AutoGenObject.BuildDir, ModuleAutoGen.BuildDir))
1728         return DirList
1729
1730     ## Get the root directory list for intermediate files of all libraries build
1731     #
1732     #   @retval     list    The list of directory
1733     #
1734     def GetLibraryBuildDirectoryList(self):
1735         DirList = []
1736         for LibraryAutoGen in self._AutoGenObject.LibraryAutoGenList:
1737             if not LibraryAutoGen.IsBinaryModule and not LibraryAutoGen.CanSkipbyHash():
1738                 DirList.append(os.path.join(self._AutoGenObject.BuildDir, LibraryAutoGen.BuildDir))
1739         return DirList
1740
1741 # This acts like the main() function for the script, unless it is 'import'ed into another script.
1742 if __name__ == '__main__':
1743     pass
1744