BaseTools/Source/Python/AutoGen/GenMake.py

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