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