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