BaseTools/Build: Support python scripts in PREBUILD/POSTBUILD
[mirror_edk2.git] / BaseTools / Source / Python / build / build.py
CommitLineData
52302d4d
LG
1## @file\r
2# build a platform or a module\r
3#\r
997a5d1b 4# Copyright (c) 2014, Hewlett-Packard Development Company, L.P.<BR>\r
99adfe9f 5# Copyright (c) 2007 - 2017, Intel Corporation. All rights reserved.<BR>\r
52302d4d 6#\r
40d841f6 7# This program and the accompanying materials\r
52302d4d
LG
8# are licensed and made available under the terms and conditions of the BSD License\r
9# which accompanies this distribution. The full text of the license may be found at\r
10# http://opensource.org/licenses/bsd-license.php\r
11#\r
12# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
13# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
14#\r
15\r
16##\r
17# Import Modules\r
18#\r
1be2ed90 19import Common.LongFilePathOs as os\r
52302d4d
LG
20import re\r
21import StringIO\r
22import sys\r
23import glob\r
24import time\r
25import platform\r
26import traceback\r
4afd3d04 27import encodings.ascii\r
f0dc69e6 28import itertools\r
52302d4d
LG
29\r
30from struct import *\r
31from threading import *\r
32from optparse import OptionParser\r
33from subprocess import *\r
34from Common import Misc as Utils\r
35\r
1be2ed90
HC
36from Common.LongFilePathSupport import OpenLongFilePath as open\r
37from Common.LongFilePathSupport import LongFilePath\r
52302d4d
LG
38from Common.TargetTxtClassObject import *\r
39from Common.ToolDefClassObject import *\r
40from Common.DataType import *\r
b36d134f 41from Common.BuildVersion import gBUILD_VERSION\r
52302d4d
LG
42from AutoGen.AutoGen import *\r
43from Common.BuildToolError import *\r
44from Workspace.WorkspaceDatabase import *\r
05cc51ad 45from Common.MultipleWorkspace import MultipleWorkspace as mws\r
52302d4d
LG
46\r
47from BuildReport import BuildReport\r
48from GenPatchPcdTable.GenPatchPcdTable import *\r
49from PatchPcdValue.PatchPcdValue import *\r
50\r
51import Common.EdkLogger\r
52import Common.GlobalData as GlobalData\r
53\r
54# Version and Copyright\r
4d10d18d 55VersionNumber = "0.60" + ' ' + gBUILD_VERSION\r
52302d4d 56__version__ = "%prog Version " + VersionNumber\r
99adfe9f 57__copyright__ = "Copyright (c) 2007 - 2017, Intel Corporation All rights reserved."\r
52302d4d
LG
58\r
59## standard targets of build command\r
60gSupportedTarget = ['all', 'genc', 'genmake', 'modules', 'libraries', 'fds', 'clean', 'cleanall', 'cleanlib', 'run']\r
61\r
62## build configuration file\r
97fa0ee9
YL
63gBuildConfiguration = "target.txt"\r
64gToolsDefinition = "tools_def.txt"\r
52302d4d 65\r
64b2609f
LG
66TemporaryTablePattern = re.compile(r'^_\d+_\d+_[a-fA-F0-9]+$')\r
67TmpTableDict = {}\r
68\r
52302d4d
LG
69## Check environment PATH variable to make sure the specified tool is found\r
70#\r
71# If the tool is found in the PATH, then True is returned\r
72# Otherwise, False is returned\r
73#\r
74def IsToolInPath(tool):\r
75 if os.environ.has_key('PATHEXT'):\r
76 extns = os.environ['PATHEXT'].split(os.path.pathsep)\r
77 else:\r
78 extns = ('',)\r
79 for pathDir in os.environ['PATH'].split(os.path.pathsep):\r
80 for ext in extns:\r
81 if os.path.exists(os.path.join(pathDir, tool + ext)):\r
82 return True\r
83 return False\r
84\r
85## Check environment variables\r
86#\r
87# Check environment variables that must be set for build. Currently they are\r
88#\r
89# WORKSPACE The directory all packages/platforms start from\r
90# EDK_TOOLS_PATH The directory contains all tools needed by the build\r
91# PATH $(EDK_TOOLS_PATH)/Bin/<sys> must be set in PATH\r
92#\r
93# If any of above environment variable is not set or has error, the build\r
94# will be broken.\r
95#\r
96def CheckEnvVariable():\r
97 # check WORKSPACE\r
98 if "WORKSPACE" not in os.environ:\r
99 EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "Environment variable not found",\r
100 ExtraData="WORKSPACE")\r
101\r
102 WorkspaceDir = os.path.normcase(os.path.normpath(os.environ["WORKSPACE"]))\r
103 if not os.path.exists(WorkspaceDir):\r
104 EdkLogger.error("build", FILE_NOT_FOUND, "WORKSPACE doesn't exist", ExtraData="%s" % WorkspaceDir)\r
105 elif ' ' in WorkspaceDir:\r
106 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in WORKSPACE path",\r
107 ExtraData=WorkspaceDir)\r
108 os.environ["WORKSPACE"] = WorkspaceDir\r
05cc51ad
LY
109 \r
110 # set multiple workspace\r
111 PackagesPath = os.getenv("PACKAGES_PATH")\r
112 mws.setWs(WorkspaceDir, PackagesPath)\r
f6190a01
YZ
113 if mws.PACKAGES_PATH:\r
114 for Path in mws.PACKAGES_PATH:\r
115 if not os.path.exists(Path):\r
116 EdkLogger.error("build", FILE_NOT_FOUND, "One Path in PACKAGES_PATH doesn't exist", ExtraData="%s" % Path)\r
117 elif ' ' in Path:\r
118 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in PACKAGES_PATH", ExtraData=Path)\r
52302d4d
LG
119\r
120 #\r
b36d134f 121 # Check EFI_SOURCE (Edk build convention). EDK_SOURCE will always point to ECP\r
52302d4d 122 #\r
da92f276 123 if "ECP_SOURCE" not in os.environ:\r
05cc51ad 124 os.environ["ECP_SOURCE"] = mws.join(WorkspaceDir, GlobalData.gEdkCompatibilityPkg)\r
52302d4d
LG
125 if "EFI_SOURCE" not in os.environ:\r
126 os.environ["EFI_SOURCE"] = os.environ["ECP_SOURCE"]\r
127 if "EDK_SOURCE" not in os.environ:\r
128 os.environ["EDK_SOURCE"] = os.environ["ECP_SOURCE"]\r
129\r
130 #\r
131 # Unify case of characters on case-insensitive systems\r
132 #\r
133 EfiSourceDir = os.path.normcase(os.path.normpath(os.environ["EFI_SOURCE"]))\r
134 EdkSourceDir = os.path.normcase(os.path.normpath(os.environ["EDK_SOURCE"]))\r
135 EcpSourceDir = os.path.normcase(os.path.normpath(os.environ["ECP_SOURCE"]))\r
4afd3d04 136\r
52302d4d
LG
137 os.environ["EFI_SOURCE"] = EfiSourceDir\r
138 os.environ["EDK_SOURCE"] = EdkSourceDir\r
139 os.environ["ECP_SOURCE"] = EcpSourceDir\r
140 os.environ["EDK_TOOLS_PATH"] = os.path.normcase(os.environ["EDK_TOOLS_PATH"])\r
4afd3d04 141\r
52302d4d 142 if not os.path.exists(EcpSourceDir):\r
b36d134f 143 EdkLogger.verbose("ECP_SOURCE = %s doesn't exist. Edk modules could not be built." % EcpSourceDir)\r
52302d4d
LG
144 elif ' ' in EcpSourceDir:\r
145 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in ECP_SOURCE path",\r
146 ExtraData=EcpSourceDir)\r
147 if not os.path.exists(EdkSourceDir):\r
148 if EdkSourceDir == EcpSourceDir:\r
b36d134f 149 EdkLogger.verbose("EDK_SOURCE = %s doesn't exist. Edk modules could not be built." % EdkSourceDir)\r
52302d4d
LG
150 else:\r
151 EdkLogger.error("build", PARAMETER_INVALID, "EDK_SOURCE does not exist",\r
152 ExtraData=EdkSourceDir)\r
153 elif ' ' in EdkSourceDir:\r
154 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in EDK_SOURCE path",\r
155 ExtraData=EdkSourceDir)\r
156 if not os.path.exists(EfiSourceDir):\r
157 if EfiSourceDir == EcpSourceDir:\r
b36d134f 158 EdkLogger.verbose("EFI_SOURCE = %s doesn't exist. Edk modules could not be built." % EfiSourceDir)\r
52302d4d
LG
159 else:\r
160 EdkLogger.error("build", PARAMETER_INVALID, "EFI_SOURCE does not exist",\r
161 ExtraData=EfiSourceDir)\r
162 elif ' ' in EfiSourceDir:\r
163 EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in EFI_SOURCE path",\r
164 ExtraData=EfiSourceDir)\r
165\r
31b27ef1
LG
166 # check those variables on single workspace case\r
167 if not PackagesPath:\r
168 # change absolute path to relative path to WORKSPACE\r
169 if EfiSourceDir.upper().find(WorkspaceDir.upper()) != 0:\r
170 EdkLogger.error("build", PARAMETER_INVALID, "EFI_SOURCE is not under WORKSPACE",\r
171 ExtraData="WORKSPACE = %s\n EFI_SOURCE = %s" % (WorkspaceDir, EfiSourceDir))\r
172 if EdkSourceDir.upper().find(WorkspaceDir.upper()) != 0:\r
173 EdkLogger.error("build", PARAMETER_INVALID, "EDK_SOURCE is not under WORKSPACE",\r
174 ExtraData="WORKSPACE = %s\n EDK_SOURCE = %s" % (WorkspaceDir, EdkSourceDir))\r
175 if EcpSourceDir.upper().find(WorkspaceDir.upper()) != 0:\r
176 EdkLogger.error("build", PARAMETER_INVALID, "ECP_SOURCE is not under WORKSPACE",\r
177 ExtraData="WORKSPACE = %s\n ECP_SOURCE = %s" % (WorkspaceDir, EcpSourceDir))\r
52302d4d
LG
178\r
179 # check EDK_TOOLS_PATH\r
180 if "EDK_TOOLS_PATH" not in os.environ:\r
181 EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "Environment variable not found",\r
182 ExtraData="EDK_TOOLS_PATH")\r
183\r
184 # check PATH\r
185 if "PATH" not in os.environ:\r
186 EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "Environment variable not found",\r
187 ExtraData="PATH")\r
188\r
189 GlobalData.gWorkspace = WorkspaceDir\r
190 GlobalData.gEfiSource = EfiSourceDir\r
191 GlobalData.gEdkSource = EdkSourceDir\r
192 GlobalData.gEcpSource = EcpSourceDir\r
193\r
0d2711a6
LG
194 GlobalData.gGlobalDefines["WORKSPACE"] = WorkspaceDir\r
195 GlobalData.gGlobalDefines["EFI_SOURCE"] = EfiSourceDir\r
196 GlobalData.gGlobalDefines["EDK_SOURCE"] = EdkSourceDir\r
197 GlobalData.gGlobalDefines["ECP_SOURCE"] = EcpSourceDir\r
198 GlobalData.gGlobalDefines["EDK_TOOLS_PATH"] = os.environ["EDK_TOOLS_PATH"]\r
05cc51ad 199 \r
52302d4d
LG
200## Get normalized file path\r
201#\r
202# Convert the path to be local format, and remove the WORKSPACE path at the\r
203# beginning if the file path is given in full path.\r
204#\r
205# @param FilePath File path to be normalized\r
206# @param Workspace Workspace path which the FilePath will be checked against\r
207#\r
208# @retval string The normalized file path\r
209#\r
210def NormFile(FilePath, Workspace):\r
211 # check if the path is absolute or relative\r
212 if os.path.isabs(FilePath):\r
213 FileFullPath = os.path.normpath(FilePath)\r
214 else:\r
05cc51ad
LY
215 FileFullPath = os.path.normpath(mws.join(Workspace, FilePath))\r
216 Workspace = mws.getWs(Workspace, FilePath)\r
52302d4d
LG
217\r
218 # check if the file path exists or not\r
219 if not os.path.isfile(FileFullPath):\r
47fea6af 220 EdkLogger.error("build", FILE_NOT_FOUND, ExtraData="\t%s (Please give file in absolute path or relative to WORKSPACE)" % FileFullPath)\r
52302d4d
LG
221\r
222 # remove workspace directory from the beginning part of the file path\r
223 if Workspace[-1] in ["\\", "/"]:\r
224 return FileFullPath[len(Workspace):]\r
225 else:\r
226 return FileFullPath[(len(Workspace) + 1):]\r
227\r
228## Get the output of an external program\r
229#\r
230# This is the entrance method of thread reading output of an external program and\r
231# putting them in STDOUT/STDERR of current program.\r
232#\r
233# @param From The stream message read from\r
234# @param To The stream message put on\r
235# @param ExitFlag The flag used to indicate stopping reading\r
236#\r
237def ReadMessage(From, To, ExitFlag):\r
238 while True:\r
239 # read one line a time\r
240 Line = From.readline()\r
241 # empty string means "end"\r
242 if Line != None and Line != "":\r
243 To(Line.rstrip())\r
244 else:\r
245 break\r
246 if ExitFlag.isSet():\r
247 break\r
248\r
249## Launch an external program\r
250#\r
251# This method will call subprocess.Popen to execute an external program with\r
252# given options in specified directory. Because of the dead-lock issue during\r
253# redirecting output of the external program, threads are used to to do the\r
254# redirection work.\r
255#\r
256# @param Command A list or string containing the call of the program\r
257# @param WorkingDir The directory in which the program will be running\r
258#\r
259def LaunchCommand(Command, WorkingDir):\r
260 # if working directory doesn't exist, Popen() will raise an exception\r
261 if not os.path.isdir(WorkingDir):\r
262 EdkLogger.error("build", FILE_NOT_FOUND, ExtraData=WorkingDir)\r
01ce3538
HC
263 \r
264 # Command is used as the first Argument in following Popen().\r
265 # It could be a string or sequence. We find that if command is a string in following Popen(),\r
266 # ubuntu may fail with an error message that the command is not found.\r
267 # So here we may need convert command from string to list instance.\r
ed728046
HW
268 if platform.system() != 'Windows':\r
269 if not isinstance(Command, list):\r
df0cee8d 270 Command = Command.split()\r
ed728046 271 Command = ' '.join(Command)\r
df0cee8d 272\r
52302d4d
LG
273 Proc = None\r
274 EndOfProcedure = None\r
275 try:\r
276 # launch the command\r
71f5913e 277 Proc = Popen(Command, stdout=PIPE, stderr=PIPE, env=os.environ, cwd=WorkingDir, bufsize=-1, shell=True)\r
52302d4d
LG
278\r
279 # launch two threads to read the STDOUT and STDERR\r
280 EndOfProcedure = Event()\r
281 EndOfProcedure.clear()\r
282 if Proc.stdout:\r
283 StdOutThread = Thread(target=ReadMessage, args=(Proc.stdout, EdkLogger.info, EndOfProcedure))\r
284 StdOutThread.setName("STDOUT-Redirector")\r
285 StdOutThread.setDaemon(False)\r
286 StdOutThread.start()\r
287\r
288 if Proc.stderr:\r
289 StdErrThread = Thread(target=ReadMessage, args=(Proc.stderr, EdkLogger.quiet, EndOfProcedure))\r
290 StdErrThread.setName("STDERR-Redirector")\r
291 StdErrThread.setDaemon(False)\r
292 StdErrThread.start()\r
293\r
294 # waiting for program exit\r
295 Proc.wait()\r
296 except: # in case of aborting\r
297 # terminate the threads redirecting the program output\r
790f60f2 298 EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())\r
52302d4d
LG
299 if EndOfProcedure != None:\r
300 EndOfProcedure.set()\r
301 if Proc == None:\r
302 if type(Command) != type(""):\r
303 Command = " ".join(Command)\r
304 EdkLogger.error("build", COMMAND_FAILURE, "Failed to start command", ExtraData="%s [%s]" % (Command, WorkingDir))\r
305\r
306 if Proc.stdout:\r
307 StdOutThread.join()\r
308 if Proc.stderr:\r
309 StdErrThread.join()\r
310\r
311 # check the return code of the program\r
312 if Proc.returncode != 0:\r
313 if type(Command) != type(""):\r
314 Command = " ".join(Command)\r
725cdb8f
YZ
315 # print out the Response file and its content when make failure\r
316 RespFile = os.path.join(WorkingDir, 'OUTPUT', 'respfilelist.txt')\r
317 if os.path.isfile(RespFile):\r
318 f = open(RespFile)\r
319 RespContent = f.read()\r
320 f.close()\r
321 EdkLogger.info(RespContent)\r
322\r
52302d4d
LG
323 EdkLogger.error("build", COMMAND_FAILURE, ExtraData="%s [%s]" % (Command, WorkingDir))\r
324\r
325## The smallest unit that can be built in multi-thread build mode\r
326#\r
327# This is the base class of build unit. The "Obj" parameter must provide\r
328# __str__(), __eq__() and __hash__() methods. Otherwise there could be build units\r
329# missing build.\r
330#\r
331# Currently the "Obj" should be only ModuleAutoGen or PlatformAutoGen objects.\r
332#\r
333class BuildUnit:\r
334 ## The constructor\r
335 #\r
336 # @param self The object pointer\r
337 # @param Obj The object the build is working on\r
338 # @param Target The build target name, one of gSupportedTarget\r
339 # @param Dependency The BuildUnit(s) which must be completed in advance\r
340 # @param WorkingDir The directory build command starts in\r
341 #\r
342 def __init__(self, Obj, BuildCommand, Target, Dependency, WorkingDir="."):\r
343 self.BuildObject = Obj\r
344 self.Dependency = Dependency\r
345 self.WorkingDir = WorkingDir\r
346 self.Target = Target\r
347 self.BuildCommand = BuildCommand\r
0d2711a6
LG
348 if not BuildCommand:\r
349 EdkLogger.error("build", OPTION_MISSING,\r
350 "No build command found for this module. "\r
4afd3d04 351 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %\r
0d2711a6 352 (Obj.BuildTarget, Obj.ToolChain, Obj.Arch),\r
52302d4d
LG
353 ExtraData=str(Obj))\r
354\r
0d2711a6 355\r
52302d4d
LG
356 ## str() method\r
357 #\r
08dd311f 358 # It just returns the string representation of self.BuildObject\r
52302d4d
LG
359 #\r
360 # @param self The object pointer\r
361 #\r
362 def __str__(self):\r
363 return str(self.BuildObject)\r
364\r
365 ## "==" operator method\r
366 #\r
367 # It just compares self.BuildObject with "Other". So self.BuildObject must\r
368 # provide its own __eq__() method.\r
369 #\r
370 # @param self The object pointer\r
371 # @param Other The other BuildUnit object compared to\r
372 #\r
373 def __eq__(self, Other):\r
374 return Other != None and self.BuildObject == Other.BuildObject \\r
375 and self.BuildObject.Arch == Other.BuildObject.Arch\r
376\r
377 ## hash() method\r
378 #\r
379 # It just returns the hash value of self.BuildObject which must be hashable.\r
380 #\r
381 # @param self The object pointer\r
382 #\r
383 def __hash__(self):\r
384 return hash(self.BuildObject) + hash(self.BuildObject.Arch)\r
385\r
386 def __repr__(self):\r
387 return repr(self.BuildObject)\r
388\r
389## The smallest module unit that can be built by nmake/make command in multi-thread build mode\r
390#\r
391# This class is for module build by nmake/make build system. The "Obj" parameter\r
392# must provide __str__(), __eq__() and __hash__() methods. Otherwise there could\r
393# be make units missing build.\r
394#\r
395# Currently the "Obj" should be only ModuleAutoGen object.\r
396#\r
397class ModuleMakeUnit(BuildUnit):\r
398 ## The constructor\r
399 #\r
400 # @param self The object pointer\r
401 # @param Obj The ModuleAutoGen object the build is working on\r
402 # @param Target The build target name, one of gSupportedTarget\r
403 #\r
404 def __init__(self, Obj, Target):\r
405 Dependency = [ModuleMakeUnit(La, Target) for La in Obj.LibraryAutoGenList]\r
406 BuildUnit.__init__(self, Obj, Obj.BuildCommand, Target, Dependency, Obj.MakeFileDir)\r
407 if Target in [None, "", "all"]:\r
408 self.Target = "tbuild"\r
409\r
410## The smallest platform unit that can be built by nmake/make command in multi-thread build mode\r
411#\r
412# This class is for platform build by nmake/make build system. The "Obj" parameter\r
413# must provide __str__(), __eq__() and __hash__() methods. Otherwise there could\r
414# be make units missing build.\r
415#\r
416# Currently the "Obj" should be only PlatformAutoGen object.\r
417#\r
418class PlatformMakeUnit(BuildUnit):\r
419 ## The constructor\r
420 #\r
421 # @param self The object pointer\r
422 # @param Obj The PlatformAutoGen object the build is working on\r
423 # @param Target The build target name, one of gSupportedTarget\r
424 #\r
425 def __init__(self, Obj, Target):\r
426 Dependency = [ModuleMakeUnit(Lib, Target) for Lib in self.BuildObject.LibraryAutoGenList]\r
427 Dependency.extend([ModuleMakeUnit(Mod, Target) for Mod in self.BuildObject.ModuleAutoGenList])\r
428 BuildUnit.__init__(self, Obj, Obj.BuildCommand, Target, Dependency, Obj.MakeFileDir)\r
429\r
430## The class representing the task of a module build or platform build\r
431#\r
432# This class manages the build tasks in multi-thread build mode. Its jobs include\r
433# scheduling thread running, catching thread error, monitor the thread status, etc.\r
434#\r
435class BuildTask:\r
436 # queue for tasks waiting for schedule\r
437 _PendingQueue = sdict()\r
438 _PendingQueueLock = threading.Lock()\r
439\r
440 # queue for tasks ready for running\r
441 _ReadyQueue = sdict()\r
442 _ReadyQueueLock = threading.Lock()\r
443\r
444 # queue for run tasks\r
445 _RunningQueue = sdict()\r
446 _RunningQueueLock = threading.Lock()\r
447\r
448 # queue containing all build tasks, in case duplicate build\r
449 _TaskQueue = sdict()\r
450\r
451 # flag indicating error occurs in a running thread\r
452 _ErrorFlag = threading.Event()\r
453 _ErrorFlag.clear()\r
454 _ErrorMessage = ""\r
455\r
456 # BoundedSemaphore object used to control the number of running threads\r
457 _Thread = None\r
458\r
459 # flag indicating if the scheduler is started or not\r
460 _SchedulerStopped = threading.Event()\r
461 _SchedulerStopped.set()\r
462\r
463 ## Start the task scheduler thread\r
464 #\r
465 # @param MaxThreadNumber The maximum thread number\r
466 # @param ExitFlag Flag used to end the scheduler\r
467 #\r
468 @staticmethod\r
469 def StartScheduler(MaxThreadNumber, ExitFlag):\r
470 SchedulerThread = Thread(target=BuildTask.Scheduler, args=(MaxThreadNumber, ExitFlag))\r
471 SchedulerThread.setName("Build-Task-Scheduler")\r
472 SchedulerThread.setDaemon(False)\r
473 SchedulerThread.start()\r
474 # wait for the scheduler to be started, especially useful in Linux\r
475 while not BuildTask.IsOnGoing():\r
476 time.sleep(0.01)\r
477\r
478 ## Scheduler method\r
479 #\r
480 # @param MaxThreadNumber The maximum thread number\r
481 # @param ExitFlag Flag used to end the scheduler\r
482 #\r
483 @staticmethod\r
484 def Scheduler(MaxThreadNumber, ExitFlag):\r
485 BuildTask._SchedulerStopped.clear()\r
486 try:\r
487 # use BoundedSemaphore to control the maximum running threads\r
488 BuildTask._Thread = BoundedSemaphore(MaxThreadNumber)\r
489 #\r
490 # scheduling loop, which will exits when no pending/ready task and\r
491 # indicated to do so, or there's error in running thread\r
492 #\r
493 while (len(BuildTask._PendingQueue) > 0 or len(BuildTask._ReadyQueue) > 0 \\r
494 or not ExitFlag.isSet()) and not BuildTask._ErrorFlag.isSet():\r
495 EdkLogger.debug(EdkLogger.DEBUG_8, "Pending Queue (%d), Ready Queue (%d)"\r
496 % (len(BuildTask._PendingQueue), len(BuildTask._ReadyQueue)))\r
497\r
498 # get all pending tasks\r
499 BuildTask._PendingQueueLock.acquire()\r
500 BuildObjectList = BuildTask._PendingQueue.keys()\r
501 #\r
502 # check if their dependency is resolved, and if true, move them\r
503 # into ready queue\r
504 #\r
505 for BuildObject in BuildObjectList:\r
506 Bt = BuildTask._PendingQueue[BuildObject]\r
507 if Bt.IsReady():\r
508 BuildTask._ReadyQueue[BuildObject] = BuildTask._PendingQueue.pop(BuildObject)\r
509 BuildTask._PendingQueueLock.release()\r
510\r
511 # launch build thread until the maximum number of threads is reached\r
512 while not BuildTask._ErrorFlag.isSet():\r
513 # empty ready queue, do nothing further\r
514 if len(BuildTask._ReadyQueue) == 0:\r
515 break\r
516\r
517 # wait for active thread(s) exit\r
518 BuildTask._Thread.acquire(True)\r
519\r
520 # start a new build thread\r
521 Bo = BuildTask._ReadyQueue.keys()[0]\r
522 Bt = BuildTask._ReadyQueue.pop(Bo)\r
523\r
524 # move into running queue\r
525 BuildTask._RunningQueueLock.acquire()\r
526 BuildTask._RunningQueue[Bo] = Bt\r
527 BuildTask._RunningQueueLock.release()\r
528\r
529 Bt.Start()\r
530 # avoid tense loop\r
531 time.sleep(0.01)\r
532\r
533 # avoid tense loop\r
534 time.sleep(0.01)\r
535\r
536 # wait for all running threads exit\r
537 if BuildTask._ErrorFlag.isSet():\r
538 EdkLogger.quiet("\nWaiting for all build threads exit...")\r
539 # while not BuildTask._ErrorFlag.isSet() and \\r
540 while len(BuildTask._RunningQueue) > 0:\r
541 EdkLogger.verbose("Waiting for thread ending...(%d)" % len(BuildTask._RunningQueue))\r
542 EdkLogger.debug(EdkLogger.DEBUG_8, "Threads [%s]" % ", ".join([Th.getName() for Th in threading.enumerate()]))\r
543 # avoid tense loop\r
544 time.sleep(0.1)\r
545 except BaseException, X:\r
546 #\r
547 # TRICK: hide the output of threads left runing, so that the user can\r
548 # catch the error message easily\r
549 #\r
550 EdkLogger.SetLevel(EdkLogger.ERROR)\r
551 BuildTask._ErrorFlag.set()\r
552 BuildTask._ErrorMessage = "build thread scheduler error\n\t%s" % str(X)\r
553\r
554 BuildTask._PendingQueue.clear()\r
555 BuildTask._ReadyQueue.clear()\r
556 BuildTask._RunningQueue.clear()\r
557 BuildTask._TaskQueue.clear()\r
558 BuildTask._SchedulerStopped.set()\r
559\r
560 ## Wait for all running method exit\r
561 #\r
562 @staticmethod\r
563 def WaitForComplete():\r
564 BuildTask._SchedulerStopped.wait()\r
565\r
566 ## Check if the scheduler is running or not\r
567 #\r
568 @staticmethod\r
569 def IsOnGoing():\r
570 return not BuildTask._SchedulerStopped.isSet()\r
571\r
572 ## Abort the build\r
573 @staticmethod\r
574 def Abort():\r
575 if BuildTask.IsOnGoing():\r
576 BuildTask._ErrorFlag.set()\r
577 BuildTask.WaitForComplete()\r
578\r
579 ## Check if there's error in running thread\r
580 #\r
581 # Since the main thread cannot catch exceptions in other thread, we have to\r
582 # use threading.Event to communicate this formation to main thread.\r
583 #\r
584 @staticmethod\r
585 def HasError():\r
586 return BuildTask._ErrorFlag.isSet()\r
587\r
588 ## Get error message in running thread\r
589 #\r
590 # Since the main thread cannot catch exceptions in other thread, we have to\r
591 # use a static variable to communicate this message to main thread.\r
592 #\r
593 @staticmethod\r
594 def GetErrorMessage():\r
595 return BuildTask._ErrorMessage\r
596\r
597 ## Factory method to create a BuildTask object\r
598 #\r
599 # This method will check if a module is building or has been built. And if\r
600 # true, just return the associated BuildTask object in the _TaskQueue. If\r
601 # not, create and return a new BuildTask object. The new BuildTask object\r
602 # will be appended to the _PendingQueue for scheduling later.\r
603 #\r
604 # @param BuildItem A BuildUnit object representing a build object\r
605 # @param Dependency The dependent build object of BuildItem\r
606 #\r
607 @staticmethod\r
608 def New(BuildItem, Dependency=None):\r
609 if BuildItem in BuildTask._TaskQueue:\r
610 Bt = BuildTask._TaskQueue[BuildItem]\r
611 return Bt\r
612\r
613 Bt = BuildTask()\r
614 Bt._Init(BuildItem, Dependency)\r
615 BuildTask._TaskQueue[BuildItem] = Bt\r
616\r
617 BuildTask._PendingQueueLock.acquire()\r
618 BuildTask._PendingQueue[BuildItem] = Bt\r
619 BuildTask._PendingQueueLock.release()\r
620\r
621 return Bt\r
622\r
623 ## The real constructor of BuildTask\r
624 #\r
625 # @param BuildItem A BuildUnit object representing a build object\r
626 # @param Dependency The dependent build object of BuildItem\r
627 #\r
628 def _Init(self, BuildItem, Dependency=None):\r
629 self.BuildItem = BuildItem\r
630\r
631 self.DependencyList = []\r
632 if Dependency == None:\r
633 Dependency = BuildItem.Dependency\r
634 else:\r
635 Dependency.extend(BuildItem.Dependency)\r
636 self.AddDependency(Dependency)\r
637 # flag indicating build completes, used to avoid unnecessary re-build\r
638 self.CompleteFlag = False\r
639\r
640 ## Check if all dependent build tasks are completed or not\r
641 #\r
642 def IsReady(self):\r
643 ReadyFlag = True\r
644 for Dep in self.DependencyList:\r
645 if Dep.CompleteFlag == True:\r
646 continue\r
647 ReadyFlag = False\r
648 break\r
649\r
650 return ReadyFlag\r
651\r
652 ## Add dependent build task\r
653 #\r
654 # @param Dependency The list of dependent build objects\r
655 #\r
656 def AddDependency(self, Dependency):\r
657 for Dep in Dependency:\r
97fa0ee9
YL
658 if not Dep.BuildObject.IsBinaryModule:\r
659 self.DependencyList.append(BuildTask.New(Dep)) # BuildTask list\r
52302d4d
LG
660\r
661 ## The thread wrapper of LaunchCommand function\r
662 #\r
663 # @param Command A list or string contains the call of the command\r
664 # @param WorkingDir The directory in which the program will be running\r
665 #\r
666 def _CommandThread(self, Command, WorkingDir):\r
667 try:\r
668 LaunchCommand(Command, WorkingDir)\r
669 self.CompleteFlag = True\r
670 except:\r
671 #\r
672 # TRICK: hide the output of threads left runing, so that the user can\r
673 # catch the error message easily\r
674 #\r
675 if not BuildTask._ErrorFlag.isSet():\r
676 GlobalData.gBuildingModule = "%s [%s, %s, %s]" % (str(self.BuildItem.BuildObject),\r
677 self.BuildItem.BuildObject.Arch,\r
678 self.BuildItem.BuildObject.ToolChain,\r
679 self.BuildItem.BuildObject.BuildTarget\r
680 )\r
681 EdkLogger.SetLevel(EdkLogger.ERROR)\r
682 BuildTask._ErrorFlag.set()\r
683 BuildTask._ErrorMessage = "%s broken\n %s [%s]" % \\r
684 (threading.currentThread().getName(), Command, WorkingDir)\r
685 # indicate there's a thread is available for another build task\r
686 BuildTask._RunningQueueLock.acquire()\r
687 BuildTask._RunningQueue.pop(self.BuildItem)\r
688 BuildTask._RunningQueueLock.release()\r
689 BuildTask._Thread.release()\r
690\r
691 ## Start build task thread\r
692 #\r
693 def Start(self):\r
694 EdkLogger.quiet("Building ... %s" % repr(self.BuildItem))\r
695 Command = self.BuildItem.BuildCommand + [self.BuildItem.Target]\r
696 self.BuildTread = Thread(target=self._CommandThread, args=(Command, self.BuildItem.WorkingDir))\r
697 self.BuildTread.setName("build thread")\r
698 self.BuildTread.setDaemon(False)\r
699 self.BuildTread.start()\r
700\r
701## The class contains the information related to EFI image\r
702#\r
703class PeImageInfo():\r
704 ## Constructor\r
705 #\r
706 # Constructor will load all required image information.\r
707 #\r
4afd3d04 708 # @param BaseName The full file path of image.\r
52302d4d
LG
709 # @param Guid The GUID for image.\r
710 # @param Arch Arch of this image.\r
f3decdc3
LG
711 # @param OutputDir The output directory for image.\r
712 # @param DebugDir The debug directory for image.\r
52302d4d
LG
713 # @param ImageClass PeImage Information\r
714 #\r
f3decdc3 715 def __init__(self, BaseName, Guid, Arch, OutputDir, DebugDir, ImageClass):\r
52302d4d
LG
716 self.BaseName = BaseName\r
717 self.Guid = Guid\r
718 self.Arch = Arch\r
f3decdc3
LG
719 self.OutputDir = OutputDir\r
720 self.DebugDir = DebugDir\r
52302d4d
LG
721 self.Image = ImageClass\r
722 self.Image.Size = (self.Image.Size / 0x1000 + 1) * 0x1000\r
723\r
724## The class implementing the EDK2 build process\r
725#\r
726# The build process includes:\r
727# 1. Load configuration from target.txt and tools_def.txt in $(WORKSPACE)/Conf\r
728# 2. Parse DSC file of active platform\r
729# 3. Parse FDF file if any\r
730# 4. Establish build database, including parse all other files (module, package)\r
731# 5. Create AutoGen files (C code file, depex file, makefile) if necessary\r
732# 6. Call build command\r
733#\r
734class Build():\r
735 ## Constructor\r
736 #\r
737 # Constructor will load all necessary configurations, parse platform, modules\r
738 # and packages and the establish a database for AutoGen.\r
739 #\r
740 # @param Target The build command target, one of gSupportedTarget\r
741 # @param WorkspaceDir The directory of workspace\r
0d2711a6
LG
742 # @param BuildOptions Build options passed from command line\r
743 #\r
744 def __init__(self, Target, WorkspaceDir, BuildOptions):\r
745 self.WorkspaceDir = WorkspaceDir\r
52302d4d 746 self.Target = Target\r
0d2711a6
LG
747 self.PlatformFile = BuildOptions.PlatformFile\r
748 self.ModuleFile = BuildOptions.ModuleFile\r
749 self.ArchList = BuildOptions.TargetArch\r
750 self.ToolChainList = BuildOptions.ToolChain\r
751 self.BuildTargetList= BuildOptions.BuildTarget\r
752 self.Fdf = BuildOptions.FdfFile\r
753 self.FdList = BuildOptions.RomImage\r
754 self.FvList = BuildOptions.FvImage\r
755 self.CapList = BuildOptions.CapName\r
756 self.SilentMode = BuildOptions.SilentMode\r
757 self.ThreadNumber = BuildOptions.ThreadNumber\r
758 self.SkipAutoGen = BuildOptions.SkipAutoGen\r
759 self.Reparse = BuildOptions.Reparse\r
760 self.SkuId = BuildOptions.SkuId\r
97fa0ee9 761 self.ConfDirectory = BuildOptions.ConfDirectory\r
52302d4d 762 self.SpawnMode = True\r
0d2711a6 763 self.BuildReport = BuildReport(BuildOptions.ReportFile, BuildOptions.ReportType)\r
52302d4d
LG
764 self.TargetTxt = TargetTxtClassObject()\r
765 self.ToolDef = ToolDefClassObject()\r
763e8edf 766 GlobalData.BuildOptionPcd = BuildOptions.OptionPcd\r
fae62ff2
HC
767 #Set global flag for build mode\r
768 GlobalData.gIgnoreSource = BuildOptions.IgnoreSources\r
97fa0ee9
YL
769\r
770 if self.ConfDirectory:\r
771 # Get alternate Conf location, if it is absolute, then just use the absolute directory name\r
772 ConfDirectoryPath = os.path.normpath(self.ConfDirectory)\r
773\r
774 if not os.path.isabs(ConfDirectoryPath):\r
775 # Since alternate directory name is not absolute, the alternate directory is located within the WORKSPACE\r
776 # This also handles someone specifying the Conf directory in the workspace. Using --conf=Conf\r
05cc51ad 777 ConfDirectoryPath = mws.join(self.WorkspaceDir, ConfDirectoryPath)\r
97fa0ee9 778 else:\r
00bcb5c2
YZ
779 if "CONF_PATH" in os.environ:\r
780 ConfDirectoryPath = os.path.normcase(os.path.normpath(os.environ["CONF_PATH"]))\r
781 else:\r
782 # Get standard WORKSPACE/Conf use the absolute path to the WORKSPACE/Conf\r
783 ConfDirectoryPath = mws.join(self.WorkspaceDir, 'Conf')\r
97fa0ee9
YL
784 GlobalData.gConfDirectory = ConfDirectoryPath\r
785 GlobalData.gDatabasePath = os.path.normpath(os.path.join(ConfDirectoryPath, GlobalData.gDatabasePath))\r
786\r
0d2711a6
LG
787 if BuildOptions.DisableCache:\r
788 self.Db = WorkspaceDatabase(":memory:")\r
789 else:\r
97fa0ee9
YL
790 self.Db = WorkspaceDatabase(GlobalData.gDatabasePath, self.Reparse)\r
791 self.BuildDatabase = self.Db.BuildObject\r
792 self.Platform = None\r
40b4e21d 793 self.ToolChainFamily = None\r
52302d4d 794 self.LoadFixAddress = 0\r
0d2711a6 795 self.UniFlag = BuildOptions.Flag\r
a0a2cd1e 796 self.BuildModules = []\r
f0dc69e6
YZ
797 self.Db_Flag = False\r
798 self.LaunchPrebuildFlag = False\r
799 self.PrebuildScript = ''\r
800 self.PostbuildScript = ''\r
801 self.PlatformBuildPath = os.path.join(GlobalData.gConfDirectory,'.cache', '.PlatformBuild')\r
725cdb8f
YZ
802 if BuildOptions.CommandLength:\r
803 GlobalData.gCommandMaxLength = BuildOptions.CommandLength\r
804\r
e56468c0 805 # print dot character during doing some time-consuming work\r
52302d4d 806 self.Progress = Utils.Progressor()\r
52302d4d 807 # print current build environment and configuration\r
0d2711a6 808 EdkLogger.quiet("%-16s = %s" % ("WORKSPACE", os.environ["WORKSPACE"]))\r
f25da33d
LG
809 if "PACKAGES_PATH" in os.environ:\r
810 # WORKSPACE env has been converted before. Print the same path style with WORKSPACE env. \r
811 EdkLogger.quiet("%-16s = %s" % ("PACKAGES_PATH", os.path.normcase(os.path.normpath(os.environ["PACKAGES_PATH"]))))\r
0d2711a6
LG
812 EdkLogger.quiet("%-16s = %s" % ("ECP_SOURCE", os.environ["ECP_SOURCE"]))\r
813 EdkLogger.quiet("%-16s = %s" % ("EDK_SOURCE", os.environ["EDK_SOURCE"]))\r
814 EdkLogger.quiet("%-16s = %s" % ("EFI_SOURCE", os.environ["EFI_SOURCE"]))\r
815 EdkLogger.quiet("%-16s = %s" % ("EDK_TOOLS_PATH", os.environ["EDK_TOOLS_PATH"]))\r
f25da33d
LG
816 if "EDK_TOOLS_BIN" in os.environ:\r
817 # Print the same path style with WORKSPACE env. \r
818 EdkLogger.quiet("%-16s = %s" % ("EDK_TOOLS_BIN", os.path.normcase(os.path.normpath(os.environ["EDK_TOOLS_BIN"]))))\r
00bcb5c2 819 EdkLogger.quiet("%-16s = %s" % ("CONF_PATH", GlobalData.gConfDirectory))\r
f0dc69e6
YZ
820 self.InitPreBuild()\r
821 self.InitPostBuild()\r
822 if self.PrebuildScript:\r
823 EdkLogger.quiet("%-16s = %s" % ("PREBUILD", self.PrebuildScript))\r
824 if self.PostbuildScript:\r
825 EdkLogger.quiet("%-16s = %s" % ("POSTBUILD", self.PostbuildScript))\r
826 if self.PrebuildScript:\r
827 self.LaunchPrebuild()\r
a0c9ce31
YZ
828 self.TargetTxt = TargetTxtClassObject()\r
829 self.ToolDef = ToolDefClassObject()\r
f0dc69e6
YZ
830 if not (self.LaunchPrebuildFlag and os.path.exists(self.PlatformBuildPath)):\r
831 self.InitBuild()\r
52302d4d 832\r
f0dc69e6 833 EdkLogger.info("")\r
52302d4d 834 os.chdir(self.WorkspaceDir)\r
52302d4d
LG
835\r
836 ## Load configuration\r
837 #\r
838 # This method will parse target.txt and get the build configurations.\r
839 #\r
840 def LoadConfiguration(self):\r
841 #\r
842 # Check target.txt and tools_def.txt and Init them\r
843 #\r
97fa0ee9 844 BuildConfigurationFile = os.path.normpath(os.path.join(GlobalData.gConfDirectory, gBuildConfiguration))\r
52302d4d
LG
845 if os.path.isfile(BuildConfigurationFile) == True:\r
846 StatusCode = self.TargetTxt.LoadTargetTxtFile(BuildConfigurationFile)\r
847\r
848 ToolDefinitionFile = self.TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_TOOL_CHAIN_CONF]\r
849 if ToolDefinitionFile == '':\r
850 ToolDefinitionFile = gToolsDefinition\r
05cc51ad 851 ToolDefinitionFile = os.path.normpath(mws.join(self.WorkspaceDir, 'Conf', ToolDefinitionFile))\r
52302d4d
LG
852 if os.path.isfile(ToolDefinitionFile) == True:\r
853 StatusCode = self.ToolDef.LoadToolDefFile(ToolDefinitionFile)\r
854 else:\r
855 EdkLogger.error("build", FILE_NOT_FOUND, ExtraData=ToolDefinitionFile)\r
856 else:\r
857 EdkLogger.error("build", FILE_NOT_FOUND, ExtraData=BuildConfigurationFile)\r
858\r
859 # if no ARCH given in command line, get it from target.txt\r
0d2711a6 860 if not self.ArchList:\r
52302d4d 861 self.ArchList = self.TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_TARGET_ARCH]\r
0d2711a6 862 self.ArchList = tuple(self.ArchList)\r
52302d4d
LG
863\r
864 # if no build target given in command line, get it from target.txt\r
0d2711a6 865 if not self.BuildTargetList:\r
52302d4d
LG
866 self.BuildTargetList = self.TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_TARGET]\r
867\r
868 # if no tool chain given in command line, get it from target.txt\r
0d2711a6 869 if not self.ToolChainList:\r
52302d4d
LG
870 self.ToolChainList = self.TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_TOOL_CHAIN_TAG]\r
871 if self.ToolChainList == None or len(self.ToolChainList) == 0:\r
872 EdkLogger.error("build", RESOURCE_NOT_AVAILABLE, ExtraData="No toolchain given. Don't know how to build.\n")\r
873\r
874 # check if the tool chains are defined or not\r
875 NewToolChainList = []\r
876 for ToolChain in self.ToolChainList:\r
877 if ToolChain not in self.ToolDef.ToolsDefTxtDatabase[TAB_TOD_DEFINES_TOOL_CHAIN_TAG]:\r
878 EdkLogger.warn("build", "Tool chain [%s] is not defined" % ToolChain)\r
879 else:\r
880 NewToolChainList.append(ToolChain)\r
881 # if no tool chain available, break the build\r
882 if len(NewToolChainList) == 0:\r
883 EdkLogger.error("build", RESOURCE_NOT_AVAILABLE,\r
884 ExtraData="[%s] not defined. No toolchain available for build!\n" % ", ".join(self.ToolChainList))\r
885 else:\r
886 self.ToolChainList = NewToolChainList\r
887\r
40b4e21d
YZ
888 ToolChainFamily = []\r
889 ToolDefinition = self.ToolDef.ToolsDefTxtDatabase\r
890 for Tool in self.ToolChainList:\r
891 if TAB_TOD_DEFINES_FAMILY not in ToolDefinition or Tool not in ToolDefinition[TAB_TOD_DEFINES_FAMILY] \\r
892 or not ToolDefinition[TAB_TOD_DEFINES_FAMILY][Tool]:\r
893 EdkLogger.warn("No tool chain family found in configuration for %s. Default to MSFT." % Tool)\r
894 ToolChainFamily.append("MSFT")\r
895 else:\r
896 ToolChainFamily.append(ToolDefinition[TAB_TOD_DEFINES_FAMILY][Tool])\r
897 self.ToolChainFamily = ToolChainFamily\r
898\r
52302d4d
LG
899 if self.ThreadNumber == None:\r
900 self.ThreadNumber = self.TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_MAX_CONCURRENT_THREAD_NUMBER]\r
901 if self.ThreadNumber == '':\r
902 self.ThreadNumber = 0\r
903 else:\r
904 self.ThreadNumber = int(self.ThreadNumber, 0)\r
905\r
906 if self.ThreadNumber == 0:\r
907 self.ThreadNumber = 1\r
908\r
909 if not self.PlatformFile:\r
910 PlatformFile = self.TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_ACTIVE_PLATFORM]\r
911 if not PlatformFile:\r
912 # Try to find one in current directory\r
913 WorkingDirectory = os.getcwd()\r
914 FileList = glob.glob(os.path.normpath(os.path.join(WorkingDirectory, '*.dsc')))\r
915 FileNum = len(FileList)\r
916 if FileNum >= 2:\r
917 EdkLogger.error("build", OPTION_MISSING,\r
918 ExtraData="There are %d DSC files in %s. Use '-p' to specify one.\n" % (FileNum, WorkingDirectory))\r
919 elif FileNum == 1:\r
920 PlatformFile = FileList[0]\r
921 else:\r
922 EdkLogger.error("build", RESOURCE_NOT_AVAILABLE,\r
923 ExtraData="No active platform specified in target.txt or command line! Nothing can be built.\n")\r
924\r
925 self.PlatformFile = PathClass(NormFile(PlatformFile, self.WorkspaceDir), self.WorkspaceDir)\r
52302d4d
LG
926\r
927 ## Initialize build configuration\r
928 #\r
929 # This method will parse DSC file and merge the configurations from\r
930 # command line and target.txt, then get the final build configurations.\r
931 #\r
932 def InitBuild(self):\r
0d2711a6 933 # parse target.txt, tools_def.txt, and platform file\r
4afd3d04 934 self.LoadConfiguration()\r
0d2711a6
LG
935\r
936 # Allow case-insensitive for those from command line or configuration file\r
937 ErrorCode, ErrorInfo = self.PlatformFile.Validate(".dsc", False)\r
52302d4d
LG
938 if ErrorCode != 0:\r
939 EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)\r
940\r
941 # create metafile database\r
f0dc69e6
YZ
942 if not self.Db_Flag:\r
943 self.Db.InitDatabase()\r
944\r
945 def InitPreBuild(self):\r
946 self.LoadConfiguration()\r
d429fcd0
YZ
947 ErrorCode, ErrorInfo = self.PlatformFile.Validate(".dsc", False)\r
948 if ErrorCode != 0:\r
949 EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)\r
f0dc69e6
YZ
950 if self.BuildTargetList:\r
951 GlobalData.gGlobalDefines['TARGET'] = self.BuildTargetList[0]\r
952 if self.ArchList:\r
953 GlobalData.gGlobalDefines['ARCH'] = self.ArchList[0]\r
954 if self.ToolChainList:\r
955 GlobalData.gGlobalDefines['TOOLCHAIN'] = self.ToolChainList[0]\r
956 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = self.ToolChainList[0]\r
40b4e21d
YZ
957 if self.ToolChainFamily:\r
958 GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[0]\r
f0dc69e6
YZ
959 if 'PREBUILD' in GlobalData.gCommandLineDefines.keys():\r
960 self.Prebuild = GlobalData.gCommandLineDefines.get('PREBUILD')\r
961 else:\r
962 self.Db.InitDatabase()\r
963 self.Db_Flag = True\r
964 Platform = self.Db._MapPlatform(str(self.PlatformFile))\r
965 self.Prebuild = str(Platform.Prebuild)\r
966 if self.Prebuild:\r
967 PrebuildList = self.Prebuild.split()\r
968 if not os.path.isabs(PrebuildList[0]):\r
969 PrebuildList[0] = mws.join(self.WorkspaceDir, PrebuildList[0])\r
970 if os.path.isfile(PrebuildList[0]):\r
971 self.PrebuildScript = PrebuildList[0]\r
972 self.Prebuild = ' '.join(PrebuildList)\r
973 self.Prebuild += self.PassCommandOption(self.BuildTargetList, self.ArchList, self.ToolChainList)\r
974 #self.LaunchPrebuild()\r
975 else:\r
976 EdkLogger.error("Prebuild", PREBUILD_ERROR, "the prebuild script %s is not exist.\n If you'd like to disable the Prebuild process, please use the format: -D PREBUILD=\"\" " %(PrebuildList[0]))\r
52302d4d 977\r
f0dc69e6
YZ
978 def InitPostBuild(self):\r
979 if 'POSTBUILD' in GlobalData.gCommandLineDefines.keys():\r
980 self.Postbuild = GlobalData.gCommandLineDefines.get('POSTBUILD')\r
981 else:\r
982 Platform = self.Db._MapPlatform(str(self.PlatformFile))\r
983 self.Postbuild = str(Platform.Postbuild)\r
984 if self.Postbuild:\r
985 PostbuildList = self.Postbuild.split()\r
986 if not os.path.isabs(PostbuildList[0]):\r
987 PostbuildList[0] = mws.join(self.WorkspaceDir, PostbuildList[0])\r
988 if os.path.isfile(PostbuildList[0]):\r
989 self.PostbuildScript = PostbuildList[0]\r
990 self.Postbuild = ' '.join(PostbuildList)\r
991 self.Postbuild += self.PassCommandOption(self.BuildTargetList, self.ArchList, self.ToolChainList)\r
f0dc69e6
YZ
992 else:\r
993 EdkLogger.error("Postbuild", POSTBUILD_ERROR, "the postbuild script %s is not exist.\n If you'd like to disable the Postbuild process, please use the format: -D POSTBUILD=\"\" " %(PostbuildList[0]))\r
994\r
995 def PassCommandOption(self, BuildTarget, TargetArch, ToolChain):\r
996 BuildStr = ''\r
997 if GlobalData.gCommand and isinstance(GlobalData.gCommand, list):\r
998 BuildStr += ' ' + ' '.join(GlobalData.gCommand)\r
999 TargetFlag = False\r
1000 ArchFlag = False\r
1001 ToolChainFlag = False\r
1002\r
1003 if GlobalData.gOptions and not GlobalData.gOptions.BuildTarget:\r
1004 TargetFlag = True\r
1005 if GlobalData.gOptions and not GlobalData.gOptions.TargetArch:\r
1006 ArchFlag = True\r
1007 if GlobalData.gOptions and not GlobalData.gOptions.ToolChain:\r
1008 ToolChainFlag = True\r
1009\r
1010 if TargetFlag and BuildTarget:\r
1011 if isinstance(BuildTarget, list) or isinstance(BuildTarget, tuple):\r
1012 BuildStr += ' -b ' + ' -b '.join(BuildTarget)\r
1013 elif isinstance(BuildTarget, str):\r
1014 BuildStr += ' -b ' + BuildTarget\r
1015 if ArchFlag and TargetArch:\r
1016 if isinstance(TargetArch, list) or isinstance(TargetArch, tuple):\r
1017 BuildStr += ' -a ' + ' -a '.join(TargetArch)\r
1018 elif isinstance(TargetArch, str):\r
1019 BuildStr += ' -a ' + TargetArch\r
1020 if ToolChainFlag and ToolChain:\r
1021 if isinstance(ToolChain, list) or isinstance(ToolChain, tuple):\r
1022 BuildStr += ' -t ' + ' -t '.join(ToolChain)\r
1023 elif isinstance(ToolChain, str):\r
1024 BuildStr += ' -t ' + ToolChain\r
1025\r
1026 return BuildStr\r
1027\r
1028 def LaunchPrebuild(self):\r
1029 if self.Prebuild:\r
1030 EdkLogger.info("\n- Prebuild Start -\n")\r
1031 self.LaunchPrebuildFlag = True\r
1032 PrebuildEnvFile = os.path.join(GlobalData.gConfDirectory,'.cache','.PrebuildEnv')\r
1033 if os.path.isfile(PrebuildEnvFile):\r
1034 os.remove(PrebuildEnvFile)\r
1035 if os.path.isfile(self.PlatformBuildPath):\r
1036 os.remove(self.PlatformBuildPath)\r
1037 if sys.platform == "win32":\r
1038 args = ' && '.join((self.Prebuild, 'set > ' + PrebuildEnvFile))\r
b926f2f2 1039 Process = Popen(args, stdout=PIPE, stderr=PIPE, shell=True)\r
f0dc69e6
YZ
1040 else:\r
1041 args = ' && '.join((self.Prebuild, 'env > ' + PrebuildEnvFile))\r
34816e7e 1042 Process = Popen(args, stdout=PIPE, stderr=PIPE, shell=True)\r
f0dc69e6
YZ
1043\r
1044 # launch two threads to read the STDOUT and STDERR\r
1045 EndOfProcedure = Event()\r
1046 EndOfProcedure.clear()\r
1047 if Process.stdout:\r
1048 StdOutThread = Thread(target=ReadMessage, args=(Process.stdout, EdkLogger.info, EndOfProcedure))\r
1049 StdOutThread.setName("STDOUT-Redirector")\r
1050 StdOutThread.setDaemon(False)\r
1051 StdOutThread.start()\r
1052\r
1053 if Process.stderr:\r
1054 StdErrThread = Thread(target=ReadMessage, args=(Process.stderr, EdkLogger.quiet, EndOfProcedure))\r
1055 StdErrThread.setName("STDERR-Redirector")\r
1056 StdErrThread.setDaemon(False)\r
1057 StdErrThread.start()\r
1058 # waiting for program exit\r
1059 Process.wait()\r
1060\r
1061 if Process.stdout:\r
1062 StdOutThread.join()\r
1063 if Process.stderr:\r
1064 StdErrThread.join()\r
1065 if Process.returncode != 0 :\r
1066 EdkLogger.error("Prebuild", PREBUILD_ERROR, 'Prebuild process is not success!')\r
1067\r
1068 if os.path.exists(PrebuildEnvFile):\r
1069 f = open(PrebuildEnvFile)\r
1070 envs = f.readlines()\r
1071 f.close()\r
1072 envs = itertools.imap(lambda l: l.split('=',1), envs)\r
1073 envs = itertools.ifilter(lambda l: len(l) == 2, envs)\r
1074 envs = itertools.imap(lambda l: [i.strip() for i in l], envs)\r
1075 os.environ.update(dict(envs))\r
1076 EdkLogger.info("\n- Prebuild Done -\n")\r
1077\r
91048b0d 1078 def LaunchPostbuild(self):\r
f0dc69e6
YZ
1079 if self.Postbuild:\r
1080 EdkLogger.info("\n- Postbuild Start -\n")\r
1081 if sys.platform == "win32":\r
b926f2f2 1082 Process = Popen(self.Postbuild, stdout=PIPE, stderr=PIPE, shell=True)\r
f0dc69e6 1083 else:\r
34816e7e 1084 Process = Popen(self.Postbuild, stdout=PIPE, stderr=PIPE, shell=True)\r
f0dc69e6
YZ
1085 # launch two threads to read the STDOUT and STDERR\r
1086 EndOfProcedure = Event()\r
1087 EndOfProcedure.clear()\r
1088 if Process.stdout:\r
1089 StdOutThread = Thread(target=ReadMessage, args=(Process.stdout, EdkLogger.info, EndOfProcedure))\r
1090 StdOutThread.setName("STDOUT-Redirector")\r
1091 StdOutThread.setDaemon(False)\r
1092 StdOutThread.start()\r
1093\r
1094 if Process.stderr:\r
1095 StdErrThread = Thread(target=ReadMessage, args=(Process.stderr, EdkLogger.quiet, EndOfProcedure))\r
1096 StdErrThread.setName("STDERR-Redirector")\r
1097 StdErrThread.setDaemon(False)\r
1098 StdErrThread.start()\r
1099 # waiting for program exit\r
1100 Process.wait()\r
1101\r
1102 if Process.stdout:\r
1103 StdOutThread.join()\r
1104 if Process.stderr:\r
1105 StdErrThread.join()\r
1106 if Process.returncode != 0 :\r
1107 EdkLogger.error("Postbuild", POSTBUILD_ERROR, 'Postbuild process is not success!')\r
1108 EdkLogger.info("\n- Postbuild Done -\n")\r
52302d4d
LG
1109 ## Build a module or platform\r
1110 #\r
08dd311f 1111 # Create autogen code and makefile for a module or platform, and the launch\r
52302d4d
LG
1112 # "make" command to build it\r
1113 #\r
1114 # @param Target The target of build command\r
1115 # @param Platform The platform file\r
1116 # @param Module The module file\r
1117 # @param BuildTarget The name of build target, one of "DEBUG", "RELEASE"\r
1118 # @param ToolChain The name of toolchain to build\r
1119 # @param Arch The arch of the module/platform\r
1120 # @param CreateDepModuleCodeFile Flag used to indicate creating code\r
1121 # for dependent modules/Libraries\r
1122 # @param CreateDepModuleMakeFile Flag used to indicate creating makefile\r
1123 # for dependent modules/Libraries\r
1124 #\r
03af2753 1125 def _BuildPa(self, Target, AutoGenObject, CreateDepsCodeFile=True, CreateDepsMakeFile=True, BuildModule=False):\r
52302d4d
LG
1126 if AutoGenObject == None:\r
1127 return False\r
1128\r
1129 # skip file generation for cleanxxx targets, run and fds target\r
1130 if Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:\r
1131 # for target which must generate AutoGen code and makefile\r
1132 if not self.SkipAutoGen or Target == 'genc':\r
1133 self.Progress.Start("Generating code")\r
1134 AutoGenObject.CreateCodeFile(CreateDepsCodeFile)\r
1135 self.Progress.Stop("done!")\r
1136 if Target == "genc":\r
1137 return True\r
1138\r
1139 if not self.SkipAutoGen or Target == 'genmake':\r
1140 self.Progress.Start("Generating makefile")\r
1141 AutoGenObject.CreateMakeFile(CreateDepsMakeFile)\r
1142 self.Progress.Stop("done!")\r
1143 if Target == "genmake":\r
1144 return True\r
1145 else:\r
1146 # always recreate top/platform makefile when clean, just in case of inconsistency\r
1147 AutoGenObject.CreateCodeFile(False)\r
1148 AutoGenObject.CreateMakeFile(False)\r
1149\r
1150 if EdkLogger.GetLevel() == EdkLogger.QUIET:\r
1151 EdkLogger.quiet("Building ... %s" % repr(AutoGenObject))\r
1152\r
1153 BuildCommand = AutoGenObject.BuildCommand\r
1154 if BuildCommand == None or len(BuildCommand) == 0:\r
0d2711a6
LG
1155 EdkLogger.error("build", OPTION_MISSING,\r
1156 "No build command found for this module. "\r
4afd3d04 1157 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %\r
0d2711a6
LG
1158 (AutoGenObject.BuildTarget, AutoGenObject.ToolChain, AutoGenObject.Arch),\r
1159 ExtraData=str(AutoGenObject))\r
52302d4d 1160\r
03af2753
HC
1161 makefile = GenMake.BuildFile(AutoGenObject)._FILE_NAME_[GenMake.gMakeType]\r
1162\r
03af2753
HC
1163 # run\r
1164 if Target == 'run':\r
997a5d1b 1165 RunDir = os.path.normpath(os.path.join(AutoGenObject.BuildDir, GlobalData.gGlobalDefines['ARCH']))\r
03af2753
HC
1166 Command = '.\SecMain'\r
1167 os.chdir(RunDir)\r
1168 LaunchCommand(Command, RunDir)\r
1169 return True\r
1170\r
1171 # build modules\r
1172 if BuildModule:\r
1173 BuildCommand = BuildCommand + [Target]\r
1174 LaunchCommand(BuildCommand, AutoGenObject.MakeFileDir)\r
a0a2cd1e 1175 self.CreateAsBuiltInf()\r
03af2753
HC
1176 return True\r
1177\r
1178 # build library\r
1179 if Target == 'libraries':\r
1180 for Lib in AutoGenObject.LibraryBuildDirectoryList:\r
1181 NewBuildCommand = BuildCommand + ['-f', os.path.normpath(os.path.join(Lib, makefile)), 'pbuild']\r
1182 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
1183 return True\r
1184\r
1185 # build module\r
1186 if Target == 'modules':\r
1187 for Lib in AutoGenObject.LibraryBuildDirectoryList:\r
1188 NewBuildCommand = BuildCommand + ['-f', os.path.normpath(os.path.join(Lib, makefile)), 'pbuild']\r
1189 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
1190 for Mod in AutoGenObject.ModuleBuildDirectoryList:\r
1191 NewBuildCommand = BuildCommand + ['-f', os.path.normpath(os.path.join(Mod, makefile)), 'pbuild']\r
1192 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
a0a2cd1e 1193 self.CreateAsBuiltInf()\r
03af2753
HC
1194 return True\r
1195\r
1196 # cleanlib\r
1197 if Target == 'cleanlib':\r
1198 for Lib in AutoGenObject.LibraryBuildDirectoryList:\r
1199 LibMakefile = os.path.normpath(os.path.join(Lib, makefile))\r
1200 if os.path.exists(LibMakefile):\r
1201 NewBuildCommand = BuildCommand + ['-f', LibMakefile, 'cleanall']\r
1202 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
1203 return True\r
1204\r
1205 # clean\r
1206 if Target == 'clean':\r
1207 for Mod in AutoGenObject.ModuleBuildDirectoryList:\r
1208 ModMakefile = os.path.normpath(os.path.join(Mod, makefile))\r
1209 if os.path.exists(ModMakefile):\r
1210 NewBuildCommand = BuildCommand + ['-f', ModMakefile, 'cleanall']\r
1211 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
1212 for Lib in AutoGenObject.LibraryBuildDirectoryList:\r
1213 LibMakefile = os.path.normpath(os.path.join(Lib, makefile))\r
1214 if os.path.exists(LibMakefile):\r
1215 NewBuildCommand = BuildCommand + ['-f', LibMakefile, 'cleanall']\r
1216 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
1217 return True\r
1218\r
1219 # cleanall\r
1220 if Target == 'cleanall':\r
1221 try:\r
1222 #os.rmdir(AutoGenObject.BuildDir)\r
1223 RemoveDirectory(AutoGenObject.BuildDir, True)\r
03af2753
HC
1224 except WindowsError, X:\r
1225 EdkLogger.error("build", FILE_DELETE_FAILURE, ExtraData=str(X))\r
1226 return True\r
1227\r
1228 ## Build a module or platform\r
1229 #\r
1230 # Create autogen code and makefile for a module or platform, and the launch\r
1231 # "make" command to build it\r
1232 #\r
1233 # @param Target The target of build command\r
1234 # @param Platform The platform file\r
1235 # @param Module The module file\r
1236 # @param BuildTarget The name of build target, one of "DEBUG", "RELEASE"\r
1237 # @param ToolChain The name of toolchain to build\r
1238 # @param Arch The arch of the module/platform\r
1239 # @param CreateDepModuleCodeFile Flag used to indicate creating code\r
1240 # for dependent modules/Libraries\r
1241 # @param CreateDepModuleMakeFile Flag used to indicate creating makefile\r
1242 # for dependent modules/Libraries\r
1243 #\r
1244 def _Build(self, Target, AutoGenObject, CreateDepsCodeFile=True, CreateDepsMakeFile=True, BuildModule=False):\r
1245 if AutoGenObject == None:\r
1246 return False\r
1247\r
1248 # skip file generation for cleanxxx targets, run and fds target\r
1249 if Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:\r
1250 # for target which must generate AutoGen code and makefile\r
1251 if not self.SkipAutoGen or Target == 'genc':\r
1252 self.Progress.Start("Generating code")\r
1253 AutoGenObject.CreateCodeFile(CreateDepsCodeFile)\r
1254 self.Progress.Stop("done!")\r
1255 if Target == "genc":\r
1256 return True\r
1257\r
1258 if not self.SkipAutoGen or Target == 'genmake':\r
1259 self.Progress.Start("Generating makefile")\r
1260 AutoGenObject.CreateMakeFile(CreateDepsMakeFile)\r
1261 #AutoGenObject.CreateAsBuiltInf()\r
1262 self.Progress.Stop("done!")\r
1263 if Target == "genmake":\r
1264 return True\r
1265 else:\r
1266 # always recreate top/platform makefile when clean, just in case of inconsistency\r
1267 AutoGenObject.CreateCodeFile(False)\r
1268 AutoGenObject.CreateMakeFile(False)\r
1269\r
1270 if EdkLogger.GetLevel() == EdkLogger.QUIET:\r
1271 EdkLogger.quiet("Building ... %s" % repr(AutoGenObject))\r
1272\r
1273 BuildCommand = AutoGenObject.BuildCommand\r
1274 if BuildCommand == None or len(BuildCommand) == 0:\r
1275 EdkLogger.error("build", OPTION_MISSING,\r
1276 "No build command found for this module. "\r
1277 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %\r
1278 (AutoGenObject.BuildTarget, AutoGenObject.ToolChain, AutoGenObject.Arch),\r
1279 ExtraData=str(AutoGenObject))\r
1280\r
b0e23cf3
YL
1281 # build modules\r
1282 if BuildModule:\r
1283 if Target != 'fds':\r
1284 BuildCommand = BuildCommand + [Target]\r
1285 LaunchCommand(BuildCommand, AutoGenObject.MakeFileDir)\r
1286 self.CreateAsBuiltInf()\r
1287 return True\r
1288\r
03af2753
HC
1289 # genfds\r
1290 if Target == 'fds':\r
1291 LaunchCommand(AutoGenObject.GenFdsCommand, AutoGenObject.MakeFileDir)\r
1292 return True\r
1293\r
1294 # run\r
1295 if Target == 'run':\r
997a5d1b 1296 RunDir = os.path.normpath(os.path.join(AutoGenObject.BuildDir, GlobalData.gGlobalDefines['ARCH']))\r
03af2753
HC
1297 Command = '.\SecMain'\r
1298 os.chdir(RunDir)\r
1299 LaunchCommand(Command, RunDir)\r
1300 return True\r
1301\r
03af2753
HC
1302 # build library\r
1303 if Target == 'libraries':\r
1304 pass\r
1305\r
1306 # not build modules\r
1307\r
1308\r
1309 # cleanall\r
52302d4d
LG
1310 if Target == 'cleanall':\r
1311 try:\r
1312 #os.rmdir(AutoGenObject.BuildDir)\r
1313 RemoveDirectory(AutoGenObject.BuildDir, True)\r
1314 except WindowsError, X:\r
1315 EdkLogger.error("build", FILE_DELETE_FAILURE, ExtraData=str(X))\r
1316 return True\r
1317\r
6780eef1 1318 ## Rebase module image and Get function address for the input module list.\r
52302d4d
LG
1319 #\r
1320 def _RebaseModule (self, MapBuffer, BaseAddress, ModuleList, AddrIsOffset = True, ModeIsSmm = False):\r
1321 if ModeIsSmm:\r
1322 AddrIsOffset = False\r
1323 InfFileNameList = ModuleList.keys()\r
1324 #InfFileNameList.sort()\r
1325 for InfFile in InfFileNameList:\r
da92f276
LG
1326 sys.stdout.write (".")\r
1327 sys.stdout.flush()\r
52302d4d
LG
1328 ModuleInfo = ModuleList[InfFile]\r
1329 ModuleName = ModuleInfo.BaseName\r
f3decdc3
LG
1330 ModuleOutputImage = ModuleInfo.Image.FileName\r
1331 ModuleDebugImage = os.path.join(ModuleInfo.DebugDir, ModuleInfo.BaseName + '.efi')\r
52302d4d
LG
1332 ## for SMM module in SMRAM, the SMRAM will be allocated from base to top.\r
1333 if not ModeIsSmm:\r
1334 BaseAddress = BaseAddress - ModuleInfo.Image.Size\r
1335 #\r
1336 # Update Image to new BaseAddress by GenFw tool\r
1337 #\r
f3decdc3 1338 LaunchCommand(["GenFw", "--rebase", str(BaseAddress), "-r", ModuleOutputImage], ModuleInfo.OutputDir)\r
47fea6af 1339 LaunchCommand(["GenFw", "--rebase", str(BaseAddress), "-r", ModuleDebugImage], ModuleInfo.DebugDir)\r
52302d4d
LG
1340 else:\r
1341 #\r
1342 # Set new address to the section header only for SMM driver.\r
1343 #\r
f3decdc3 1344 LaunchCommand(["GenFw", "--address", str(BaseAddress), "-r", ModuleOutputImage], ModuleInfo.OutputDir)\r
47fea6af 1345 LaunchCommand(["GenFw", "--address", str(BaseAddress), "-r", ModuleDebugImage], ModuleInfo.DebugDir)\r
52302d4d
LG
1346 #\r
1347 # Collect funtion address from Map file\r
1348 #\r
f3decdc3 1349 ImageMapTable = ModuleOutputImage.replace('.efi', '.map')\r
52302d4d
LG
1350 FunctionList = []\r
1351 if os.path.exists(ImageMapTable):\r
1352 OrigImageBaseAddress = 0\r
47fea6af 1353 ImageMap = open(ImageMapTable, 'r')\r
52302d4d
LG
1354 for LinStr in ImageMap:\r
1355 if len (LinStr.strip()) == 0:\r
1356 continue\r
1357 #\r
1358 # Get the preferred address set on link time.\r
1359 #\r
1360 if LinStr.find ('Preferred load address is') != -1:\r
1361 StrList = LinStr.split()\r
1362 OrigImageBaseAddress = int (StrList[len(StrList) - 1], 16)\r
1363\r
1364 StrList = LinStr.split()\r
1365 if len (StrList) > 4:\r
47fea6af 1366 if StrList[3] == 'f' or StrList[3] == 'F':\r
52302d4d
LG
1367 Name = StrList[1]\r
1368 RelativeAddress = int (StrList[2], 16) - OrigImageBaseAddress\r
1369 FunctionList.append ((Name, RelativeAddress))\r
1370 if ModuleInfo.Arch == 'IPF' and Name.endswith('_ModuleEntryPoint'):\r
1371 #\r
1372 # Get the real entry point address for IPF image.\r
1373 #\r
1374 ModuleInfo.Image.EntryPoint = RelativeAddress\r
1375 ImageMap.close()\r
1376 #\r
1377 # Add general information.\r
1378 #\r
1379 if ModeIsSmm:\r
1380 MapBuffer.write('\n\n%s (Fixed SMRAM Offset, BaseAddress=0x%010X, EntryPoint=0x%010X)\n' % (ModuleName, BaseAddress, BaseAddress + ModuleInfo.Image.EntryPoint))\r
1381 elif AddrIsOffset:\r
1382 MapBuffer.write('\n\n%s (Fixed Memory Offset, BaseAddress=-0x%010X, EntryPoint=-0x%010X)\n' % (ModuleName, 0 - BaseAddress, 0 - (BaseAddress + ModuleInfo.Image.EntryPoint)))\r
1383 else:\r
1384 MapBuffer.write('\n\n%s (Fixed Memory Address, BaseAddress=0x%010X, EntryPoint=0x%010X)\n' % (ModuleName, BaseAddress, BaseAddress + ModuleInfo.Image.EntryPoint))\r
1385 #\r
1386 # Add guid and general seciton section.\r
1387 #\r
1388 TextSectionAddress = 0\r
1389 DataSectionAddress = 0\r
1390 for SectionHeader in ModuleInfo.Image.SectionHeaderList:\r
1391 if SectionHeader[0] == '.text':\r
1392 TextSectionAddress = SectionHeader[1]\r
1393 elif SectionHeader[0] in ['.data', '.sdata']:\r
1394 DataSectionAddress = SectionHeader[1]\r
1395 if AddrIsOffset:\r
4afd3d04 1396 MapBuffer.write('(GUID=%s, .textbaseaddress=-0x%010X, .databaseaddress=-0x%010X)\n' % (ModuleInfo.Guid, 0 - (BaseAddress + TextSectionAddress), 0 - (BaseAddress + DataSectionAddress)))\r
52302d4d 1397 else:\r
4afd3d04 1398 MapBuffer.write('(GUID=%s, .textbaseaddress=0x%010X, .databaseaddress=0x%010X)\n' % (ModuleInfo.Guid, BaseAddress + TextSectionAddress, BaseAddress + DataSectionAddress))\r
f3decdc3
LG
1399 #\r
1400 # Add debug image full path.\r
1401 #\r
1402 MapBuffer.write('(IMAGE=%s)\n\n' % (ModuleDebugImage))\r
52302d4d
LG
1403 #\r
1404 # Add funtion address\r
1405 #\r
1406 for Function in FunctionList:\r
1407 if AddrIsOffset:\r
1408 MapBuffer.write(' -0x%010X %s\n' % (0 - (BaseAddress + Function[1]), Function[0]))\r
1409 else:\r
1410 MapBuffer.write(' 0x%010X %s\n' % (BaseAddress + Function[1], Function[0]))\r
1411 ImageMap.close()\r
1412\r
1413 #\r
1414 # for SMM module in SMRAM, the SMRAM will be allocated from base to top.\r
1415 #\r
1416 if ModeIsSmm:\r
1417 BaseAddress = BaseAddress + ModuleInfo.Image.Size\r
1418\r
1419 ## Collect MAP information of all FVs\r
1420 #\r
636f2be6 1421 def _CollectFvMapBuffer (self, MapBuffer, Wa, ModuleList):\r
0d2711a6 1422 if self.Fdf:\r
52302d4d 1423 # First get the XIP base address for FV map file.\r
636f2be6 1424 GuidPattern = re.compile("[-a-fA-F0-9]+")\r
f3decdc3 1425 GuidName = re.compile("\(GUID=[-a-fA-F0-9]+")\r
52302d4d
LG
1426 for FvName in Wa.FdfProfile.FvDict.keys():\r
1427 FvMapBuffer = os.path.join(Wa.FvDir, FvName + '.Fv.map')\r
1428 if not os.path.exists(FvMapBuffer):\r
1429 continue\r
1be2ed90 1430 FvMap = open(FvMapBuffer, 'r')\r
52302d4d
LG
1431 #skip FV size information\r
1432 FvMap.readline()\r
1433 FvMap.readline()\r
1434 FvMap.readline()\r
1435 FvMap.readline()\r
636f2be6
LG
1436 for Line in FvMap:\r
1437 MatchGuid = GuidPattern.match(Line)\r
1438 if MatchGuid != None:\r
1439 #\r
1440 # Replace GUID with module name\r
1441 #\r
1442 GuidString = MatchGuid.group()\r
1443 if GuidString.upper() in ModuleList:\r
1444 Line = Line.replace(GuidString, ModuleList[GuidString.upper()].Name)\r
1445 MapBuffer.write('%s' % (Line))\r
f3decdc3
LG
1446 #\r
1447 # Add the debug image full path.\r
1448 #\r
1449 MatchGuid = GuidName.match(Line)\r
1450 if MatchGuid != None:\r
1451 GuidString = MatchGuid.group().split("=")[1]\r
1452 if GuidString.upper() in ModuleList:\r
1453 MapBuffer.write('(IMAGE=%s)\n' % (os.path.join(ModuleList[GuidString.upper()].DebugDir, ModuleList[GuidString.upper()].Name + '.efi')))\r
1454\r
52302d4d
LG
1455 FvMap.close()\r
1456\r
1457 ## Collect MAP information of all modules\r
1458 #\r
1459 def _CollectModuleMapBuffer (self, MapBuffer, ModuleList):\r
da92f276
LG
1460 sys.stdout.write ("Generate Load Module At Fix Address Map")\r
1461 sys.stdout.flush()\r
52302d4d
LG
1462 PatchEfiImageList = []\r
1463 PeiModuleList = {}\r
1464 BtModuleList = {}\r
1465 RtModuleList = {}\r
1466 SmmModuleList = {}\r
1467 PeiSize = 0\r
1468 BtSize = 0\r
1469 RtSize = 0\r
1470 # reserve 4K size in SMRAM to make SMM module address not from 0.\r
1471 SmmSize = 0x1000\r
1472 IsIpfPlatform = False\r
1473 if 'IPF' in self.ArchList:\r
1474 IsIpfPlatform = True\r
636f2be6
LG
1475 for ModuleGuid in ModuleList:\r
1476 Module = ModuleList[ModuleGuid]\r
52302d4d 1477 GlobalData.gProcessingFile = "%s [%s, %s, %s]" % (Module.MetaFile, Module.Arch, Module.ToolChain, Module.BuildTarget)\r
4afd3d04 1478\r
52302d4d
LG
1479 OutputImageFile = ''\r
1480 for ResultFile in Module.CodaTargetList:\r
1481 if str(ResultFile.Target).endswith('.efi'):\r
1482 #\r
1483 # module list for PEI, DXE, RUNTIME and SMM\r
1484 #\r
1485 OutputImageFile = os.path.join(Module.OutputDir, Module.Name + '.efi')\r
1486 ImageClass = PeImageClass (OutputImageFile)\r
1487 if not ImageClass.IsValid:\r
1488 EdkLogger.error("build", FILE_PARSE_FAILURE, ExtraData=ImageClass.ErrorInfo)\r
f3decdc3 1489 ImageInfo = PeImageInfo(Module.Name, Module.Guid, Module.Arch, Module.OutputDir, Module.DebugDir, ImageClass)\r
47fea6af 1490 if Module.ModuleType in ['PEI_CORE', 'PEIM', 'COMBINED_PEIM_DRIVER', 'PIC_PEIM', 'RELOCATABLE_PEIM', 'DXE_CORE']:\r
52302d4d
LG
1491 PeiModuleList[Module.MetaFile] = ImageInfo\r
1492 PeiSize += ImageInfo.Image.Size\r
1493 elif Module.ModuleType in ['BS_DRIVER', 'DXE_DRIVER', 'UEFI_DRIVER']:\r
1494 BtModuleList[Module.MetaFile] = ImageInfo\r
1495 BtSize += ImageInfo.Image.Size\r
1496 elif Module.ModuleType in ['DXE_RUNTIME_DRIVER', 'RT_DRIVER', 'DXE_SAL_DRIVER', 'SAL_RT_DRIVER']:\r
1497 RtModuleList[Module.MetaFile] = ImageInfo\r
1498 #IPF runtime driver needs to be at 2 page alignment.\r
1499 if IsIpfPlatform and ImageInfo.Image.Size % 0x2000 != 0:\r
1500 ImageInfo.Image.Size = (ImageInfo.Image.Size / 0x2000 + 1) * 0x2000\r
1501 RtSize += ImageInfo.Image.Size\r
e574123c 1502 elif Module.ModuleType in ['SMM_CORE', 'DXE_SMM_DRIVER', 'MM_STANDALONE', 'MM_CORE_STANDALONE']:\r
52302d4d
LG
1503 SmmModuleList[Module.MetaFile] = ImageInfo\r
1504 SmmSize += ImageInfo.Image.Size\r
1505 if Module.ModuleType == 'DXE_SMM_DRIVER':\r
da92f276
LG
1506 PiSpecVersion = '0x00000000'\r
1507 if 'PI_SPECIFICATION_VERSION' in Module.Module.Specification:\r
1508 PiSpecVersion = Module.Module.Specification['PI_SPECIFICATION_VERSION']\r
52302d4d 1509 # for PI specification < PI1.1, DXE_SMM_DRIVER also runs as BOOT time driver.\r
da92f276 1510 if int(PiSpecVersion, 16) < 0x0001000A:\r
52302d4d
LG
1511 BtModuleList[Module.MetaFile] = ImageInfo\r
1512 BtSize += ImageInfo.Image.Size\r
1513 break\r
1514 #\r
1515 # EFI image is final target.\r
1516 # Check EFI image contains patchable FixAddress related PCDs.\r
1517 #\r
1518 if OutputImageFile != '':\r
1519 ModuleIsPatch = False\r
1520 for Pcd in Module.ModulePcdList:\r
1521 if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE and Pcd.TokenCName in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_LIST:\r
1522 ModuleIsPatch = True\r
1523 break\r
1524 if not ModuleIsPatch:\r
1525 for Pcd in Module.LibraryPcdList:\r
1526 if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE and Pcd.TokenCName in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_LIST:\r
1527 ModuleIsPatch = True\r
1528 break\r
4afd3d04 1529\r
52302d4d
LG
1530 if not ModuleIsPatch:\r
1531 continue\r
1532 #\r
1533 # Module includes the patchable load fix address PCDs.\r
4afd3d04 1534 # It will be fixed up later.\r
52302d4d
LG
1535 #\r
1536 PatchEfiImageList.append (OutputImageFile)\r
4afd3d04 1537\r
52302d4d
LG
1538 #\r
1539 # Get Top Memory address\r
1540 #\r
1541 ReservedRuntimeMemorySize = 0\r
1542 TopMemoryAddress = 0\r
1543 if self.LoadFixAddress == 0xFFFFFFFFFFFFFFFF:\r
1544 TopMemoryAddress = 0\r
1545 else:\r
1546 TopMemoryAddress = self.LoadFixAddress\r
1547 if TopMemoryAddress < RtSize + BtSize + PeiSize:\r
1548 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS is too low to load driver")\r
1549 # Make IPF runtime driver at 2 page alignment.\r
1550 if IsIpfPlatform:\r
1551 ReservedRuntimeMemorySize = TopMemoryAddress % 0x2000\r
1552 RtSize = RtSize + ReservedRuntimeMemorySize\r
1553\r
1554 #\r
1555 # Patch FixAddress related PCDs into EFI image\r
1556 #\r
4afd3d04 1557 for EfiImage in PatchEfiImageList:\r
52302d4d
LG
1558 EfiImageMap = EfiImage.replace('.efi', '.map')\r
1559 if not os.path.exists(EfiImageMap):\r
1560 continue\r
1561 #\r
1562 # Get PCD offset in EFI image by GenPatchPcdTable function\r
1563 #\r
4afd3d04 1564 PcdTable = parsePcdInfoFromMapFile(EfiImageMap, EfiImage)\r
52302d4d
LG
1565 #\r
1566 # Patch real PCD value by PatchPcdValue tool\r
1567 #\r
1568 for PcdInfo in PcdTable:\r
1569 ReturnValue = 0\r
1570 if PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE:\r
47fea6af 1571 ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE_DATA_TYPE, str (PeiSize / 0x1000))\r
52302d4d 1572 elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE:\r
47fea6af 1573 ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE_DATA_TYPE, str (BtSize / 0x1000))\r
52302d4d 1574 elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE:\r
47fea6af 1575 ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE_DATA_TYPE, str (RtSize / 0x1000))\r
52302d4d 1576 elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE and len (SmmModuleList) > 0:\r
47fea6af 1577 ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE_DATA_TYPE, str (SmmSize / 0x1000))\r
52302d4d
LG
1578 if ReturnValue != 0:\r
1579 EdkLogger.error("build", PARAMETER_INVALID, "Patch PCD value failed", ExtraData=ErrorInfo)\r
4afd3d04 1580\r
47fea6af
YZ
1581 MapBuffer.write('PEI_CODE_PAGE_NUMBER = 0x%x\n' % (PeiSize / 0x1000))\r
1582 MapBuffer.write('BOOT_CODE_PAGE_NUMBER = 0x%x\n' % (BtSize / 0x1000))\r
1583 MapBuffer.write('RUNTIME_CODE_PAGE_NUMBER = 0x%x\n' % (RtSize / 0x1000))\r
52302d4d 1584 if len (SmmModuleList) > 0:\r
47fea6af 1585 MapBuffer.write('SMM_CODE_PAGE_NUMBER = 0x%x\n' % (SmmSize / 0x1000))\r
4afd3d04
LG
1586\r
1587 PeiBaseAddr = TopMemoryAddress - RtSize - BtSize\r
52302d4d 1588 BtBaseAddr = TopMemoryAddress - RtSize\r
4afd3d04 1589 RtBaseAddr = TopMemoryAddress - ReservedRuntimeMemorySize\r
52302d4d
LG
1590\r
1591 self._RebaseModule (MapBuffer, PeiBaseAddr, PeiModuleList, TopMemoryAddress == 0)\r
1592 self._RebaseModule (MapBuffer, BtBaseAddr, BtModuleList, TopMemoryAddress == 0)\r
1593 self._RebaseModule (MapBuffer, RtBaseAddr, RtModuleList, TopMemoryAddress == 0)\r
47fea6af 1594 self._RebaseModule (MapBuffer, 0x1000, SmmModuleList, AddrIsOffset=False, ModeIsSmm=True)\r
52302d4d 1595 MapBuffer.write('\n\n')\r
da92f276
LG
1596 sys.stdout.write ("\n")\r
1597 sys.stdout.flush()\r
4afd3d04 1598\r
52302d4d
LG
1599 ## Save platform Map file\r
1600 #\r
1601 def _SaveMapFile (self, MapBuffer, Wa):\r
1602 #\r
1603 # Map file path is got.\r
1604 #\r
1605 MapFilePath = os.path.join(Wa.BuildDir, Wa.Name + '.map')\r
1606 #\r
1607 # Save address map into MAP file.\r
1608 #\r
40d841f6 1609 SaveFileOnChange(MapFilePath, MapBuffer.getvalue(), False)\r
da92f276
LG
1610 MapBuffer.close()\r
1611 if self.LoadFixAddress != 0:\r
47fea6af 1612 sys.stdout.write ("\nLoad Module At Fix Address Map file can be found at %s\n" % (MapFilePath))\r
da92f276 1613 sys.stdout.flush()\r
52302d4d
LG
1614\r
1615 ## Build active platform for different build targets and different tool chains\r
1616 #\r
1617 def _BuildPlatform(self):\r
f0dc69e6 1618 SaveFileOnChange(self.PlatformBuildPath, '# DO NOT EDIT \n# FILE auto-generated\n', False)\r
52302d4d 1619 for BuildTarget in self.BuildTargetList:\r
0d2711a6 1620 GlobalData.gGlobalDefines['TARGET'] = BuildTarget\r
40b4e21d 1621 index = 0\r
52302d4d 1622 for ToolChain in self.ToolChainList:\r
0d2711a6
LG
1623 GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain\r
1624 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain\r
40b4e21d
YZ
1625 GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[index]\r
1626 index += 1\r
52302d4d
LG
1627 Wa = WorkspaceAutoGen(\r
1628 self.WorkspaceDir,\r
0d2711a6 1629 self.PlatformFile,\r
52302d4d
LG
1630 BuildTarget,\r
1631 ToolChain,\r
1632 self.ArchList,\r
1633 self.BuildDatabase,\r
1634 self.TargetTxt,\r
1635 self.ToolDef,\r
1636 self.Fdf,\r
1637 self.FdList,\r
1638 self.FvList,\r
4234283c 1639 self.CapList,\r
f3decdc3 1640 self.SkuId,\r
9508d0fa
LG
1641 self.UniFlag,\r
1642 self.Progress\r
52302d4d 1643 )\r
0d2711a6
LG
1644 self.Fdf = Wa.FdfFile\r
1645 self.LoadFixAddress = Wa.Platform.LoadFixAddress\r
52302d4d
LG
1646 self.BuildReport.AddPlatformReport(Wa)\r
1647 self.Progress.Stop("done!")\r
03af2753
HC
1648 for Arch in Wa.ArchList:\r
1649 GlobalData.gGlobalDefines['ARCH'] = Arch\r
1650 Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)\r
a0a2cd1e
FB
1651 for Module in Pa.Platform.Modules:\r
1652 # Get ModuleAutoGen object to generate C code file and makefile\r
1653 Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)\r
1654 if Ma == None:\r
1655 continue\r
1656 self.BuildModules.append(Ma)\r
03af2753 1657 self._BuildPa(self.Target, Pa)\r
4afd3d04 1658\r
52302d4d 1659 # Create MAP file when Load Fix Address is enabled.\r
636f2be6 1660 if self.Target in ["", "all", "fds"]:\r
0d2711a6
LG
1661 for Arch in Wa.ArchList:\r
1662 GlobalData.gGlobalDefines['ARCH'] = Arch\r
52302d4d
LG
1663 #\r
1664 # Check whether the set fix address is above 4G for 32bit image.\r
1665 #\r
1666 if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:\r
0d2711a6 1667 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS can't be set to larger than or equal to 4G for the platform with IA32 or ARM arch modules")\r
52302d4d
LG
1668 #\r
1669 # Get Module List\r
1670 #\r
636f2be6 1671 ModuleList = {}\r
52302d4d
LG
1672 for Pa in Wa.AutoGenObjectList:\r
1673 for Ma in Pa.ModuleAutoGenList:\r
1674 if Ma == None:\r
1675 continue\r
1676 if not Ma.IsLibrary:\r
636f2be6 1677 ModuleList[Ma.Guid.upper()] = Ma\r
52302d4d
LG
1678\r
1679 MapBuffer = StringIO('')\r
636f2be6
LG
1680 if self.LoadFixAddress != 0:\r
1681 #\r
1682 # Rebase module to the preferred memory address before GenFds\r
1683 #\r
1684 self._CollectModuleMapBuffer(MapBuffer, ModuleList)\r
0d2711a6 1685 if self.Fdf:\r
b0e23cf3
YL
1686 #\r
1687 # create FDS again for the updated EFI image\r
1688 #\r
1689 self._Build("fds", Wa)\r
52302d4d
LG
1690 #\r
1691 # Create MAP file for all platform FVs after GenFds.\r
1692 #\r
636f2be6 1693 self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)\r
52302d4d
LG
1694 #\r
1695 # Save MAP buffer into MAP file.\r
1696 #\r
1697 self._SaveMapFile (MapBuffer, Wa)\r
1698\r
1699 ## Build active module for different build targets, different tool chains and different archs\r
1700 #\r
1701 def _BuildModule(self):\r
1702 for BuildTarget in self.BuildTargetList:\r
0d2711a6 1703 GlobalData.gGlobalDefines['TARGET'] = BuildTarget\r
40b4e21d 1704 index = 0\r
52302d4d 1705 for ToolChain in self.ToolChainList:\r
0d2711a6 1706 GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain\r
4afd3d04 1707 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain\r
40b4e21d
YZ
1708 GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[index]\r
1709 index += 1\r
52302d4d
LG
1710 #\r
1711 # module build needs platform build information, so get platform\r
1712 # AutoGen first\r
1713 #\r
1714 Wa = WorkspaceAutoGen(\r
1715 self.WorkspaceDir,\r
0d2711a6 1716 self.PlatformFile,\r
52302d4d
LG
1717 BuildTarget,\r
1718 ToolChain,\r
1719 self.ArchList,\r
1720 self.BuildDatabase,\r
1721 self.TargetTxt,\r
1722 self.ToolDef,\r
1723 self.Fdf,\r
1724 self.FdList,\r
1725 self.FvList,\r
4234283c 1726 self.CapList,\r
f3decdc3 1727 self.SkuId,\r
9508d0fa
LG
1728 self.UniFlag,\r
1729 self.Progress,\r
1730 self.ModuleFile\r
52302d4d 1731 )\r
0d2711a6
LG
1732 self.Fdf = Wa.FdfFile\r
1733 self.LoadFixAddress = Wa.Platform.LoadFixAddress\r
52302d4d
LG
1734 Wa.CreateMakeFile(False)\r
1735 self.Progress.Stop("done!")\r
1736 MaList = []\r
0d2711a6
LG
1737 for Arch in Wa.ArchList:\r
1738 GlobalData.gGlobalDefines['ARCH'] = Arch\r
16bad1fb
YZ
1739 Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)\r
1740 for Module in Pa.Platform.Modules:\r
1741 if self.ModuleFile.Dir == Module.Dir and self.ModuleFile.File == Module.File:\r
1742 Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)\r
1743 if Ma == None: continue\r
1744 MaList.append(Ma)\r
1745 self.BuildModules.append(Ma)\r
1746 if not Ma.IsBinaryModule:\r
1747 self._Build(self.Target, Ma, BuildModule=True)\r
d5d56f1b
LG
1748\r
1749 self.BuildReport.AddPlatformReport(Wa, MaList)\r
52302d4d
LG
1750 if MaList == []:\r
1751 EdkLogger.error(\r
1752 'build',\r
1753 BUILD_ERROR,\r
1754 "Module for [%s] is not a component of active platform."\\r
1755 " Please make sure that the ARCH and inf file path are"\\r
47fea6af 1756 " given in the same as in [%s]" % \\r
0d2711a6 1757 (', '.join(Wa.ArchList), self.PlatformFile),\r
52302d4d
LG
1758 ExtraData=self.ModuleFile\r
1759 )\r
1760 # Create MAP file when Load Fix Address is enabled.\r
0d2711a6
LG
1761 if self.Target == "fds" and self.Fdf:\r
1762 for Arch in Wa.ArchList:\r
52302d4d
LG
1763 #\r
1764 # Check whether the set fix address is above 4G for 32bit image.\r
1765 #\r
1766 if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:\r
1767 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS can't be set to larger than or equal to 4G for the platorm with IA32 or ARM arch modules")\r
1768 #\r
1769 # Get Module List\r
1770 #\r
636f2be6 1771 ModuleList = {}\r
52302d4d
LG
1772 for Pa in Wa.AutoGenObjectList:\r
1773 for Ma in Pa.ModuleAutoGenList:\r
1774 if Ma == None:\r
1775 continue\r
1776 if not Ma.IsLibrary:\r
636f2be6 1777 ModuleList[Ma.Guid.upper()] = Ma\r
52302d4d
LG
1778\r
1779 MapBuffer = StringIO('')\r
636f2be6
LG
1780 if self.LoadFixAddress != 0:\r
1781 #\r
1782 # Rebase module to the preferred memory address before GenFds\r
1783 #\r
1784 self._CollectModuleMapBuffer(MapBuffer, ModuleList)\r
b0e23cf3
YL
1785 #\r
1786 # create FDS again for the updated EFI image\r
1787 #\r
1788 self._Build("fds", Wa)\r
52302d4d
LG
1789 #\r
1790 # Create MAP file for all platform FVs after GenFds.\r
1791 #\r
636f2be6 1792 self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)\r
52302d4d
LG
1793 #\r
1794 # Save MAP buffer into MAP file.\r
1795 #\r
1796 self._SaveMapFile (MapBuffer, Wa)\r
1797\r
1798 ## Build a platform in multi-thread mode\r
1799 #\r
1800 def _MultiThreadBuildPlatform(self):\r
f0dc69e6 1801 SaveFileOnChange(self.PlatformBuildPath, '# DO NOT EDIT \n# FILE auto-generated\n', False)\r
52302d4d 1802 for BuildTarget in self.BuildTargetList:\r
0d2711a6 1803 GlobalData.gGlobalDefines['TARGET'] = BuildTarget\r
40b4e21d 1804 index = 0\r
52302d4d 1805 for ToolChain in self.ToolChainList:\r
0d2711a6 1806 GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain\r
4afd3d04 1807 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain\r
40b4e21d
YZ
1808 GlobalData.gGlobalDefines['FAMILY'] = self.ToolChainFamily[index]\r
1809 index += 1\r
52302d4d
LG
1810 Wa = WorkspaceAutoGen(\r
1811 self.WorkspaceDir,\r
0d2711a6 1812 self.PlatformFile,\r
52302d4d
LG
1813 BuildTarget,\r
1814 ToolChain,\r
1815 self.ArchList,\r
1816 self.BuildDatabase,\r
1817 self.TargetTxt,\r
1818 self.ToolDef,\r
1819 self.Fdf,\r
1820 self.FdList,\r
1821 self.FvList,\r
4234283c 1822 self.CapList,\r
f3decdc3 1823 self.SkuId,\r
9508d0fa
LG
1824 self.UniFlag,\r
1825 self.Progress\r
52302d4d 1826 )\r
0d2711a6
LG
1827 self.Fdf = Wa.FdfFile\r
1828 self.LoadFixAddress = Wa.Platform.LoadFixAddress\r
52302d4d
LG
1829 self.BuildReport.AddPlatformReport(Wa)\r
1830 Wa.CreateMakeFile(False)\r
1831\r
1832 # multi-thread exit flag\r
1833 ExitFlag = threading.Event()\r
1834 ExitFlag.clear()\r
0d2711a6
LG
1835 for Arch in Wa.ArchList:\r
1836 GlobalData.gGlobalDefines['ARCH'] = Arch\r
52302d4d
LG
1837 Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)\r
1838 if Pa == None:\r
1839 continue\r
a0a2cd1e
FB
1840 ModuleList = []\r
1841 for Inf in Pa.Platform.Modules:\r
1842 ModuleList.append(Inf)\r
1843 # Add the INF only list in FDF\r
1844 if GlobalData.gFdfParser != None:\r
1845 for InfName in GlobalData.gFdfParser.Profile.InfList:\r
1846 Inf = PathClass(NormPath(InfName), self.WorkspaceDir, Arch)\r
1847 if Inf in Pa.Platform.Modules:\r
1848 continue\r
1849 ModuleList.append(Inf)\r
1850 for Module in ModuleList:\r
52302d4d
LG
1851 # Get ModuleAutoGen object to generate C code file and makefile\r
1852 Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)\r
a0a2cd1e 1853 \r
52302d4d
LG
1854 if Ma == None:\r
1855 continue\r
1856 # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'\r
1857 if self.Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:\r
1858 # for target which must generate AutoGen code and makefile\r
1859 if not self.SkipAutoGen or self.Target == 'genc':\r
1860 Ma.CreateCodeFile(True)\r
1861 if self.Target == "genc":\r
1862 continue\r
1863\r
1864 if not self.SkipAutoGen or self.Target == 'genmake':\r
1865 Ma.CreateMakeFile(True)\r
1866 if self.Target == "genmake":\r
1867 continue\r
a0a2cd1e 1868 self.BuildModules.append(Ma)\r
e8a47801 1869 self.Progress.Stop("done!")\r
4afd3d04 1870\r
a0a2cd1e 1871 for Ma in self.BuildModules:\r
52302d4d 1872 # Generate build task for the module\r
a0a2cd1e
FB
1873 if not Ma.IsBinaryModule:\r
1874 Bt = BuildTask.New(ModuleMakeUnit(Ma, self.Target))\r
52302d4d
LG
1875 # Break build if any build thread has error\r
1876 if BuildTask.HasError():\r
1877 # we need a full version of makefile for platform\r
1878 ExitFlag.set()\r
1879 BuildTask.WaitForComplete()\r
1880 Pa.CreateMakeFile(False)\r
1881 EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)\r
1882 # Start task scheduler\r
1883 if not BuildTask.IsOnGoing():\r
1884 BuildTask.StartScheduler(self.ThreadNumber, ExitFlag)\r
1885\r
1886 # in case there's an interruption. we need a full version of makefile for platform\r
1887 Pa.CreateMakeFile(False)\r
1888 if BuildTask.HasError():\r
1889 EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)\r
1890\r
64b2609f
LG
1891 #\r
1892 # Save temp tables to a TmpTableDict.\r
1893 #\r
1894 for Key in Wa.BuildDatabase._CACHE_:\r
1895 if Wa.BuildDatabase._CACHE_[Key]._RawData and Wa.BuildDatabase._CACHE_[Key]._RawData._Table and Wa.BuildDatabase._CACHE_[Key]._RawData._Table.Table:\r
1896 if TemporaryTablePattern.match(Wa.BuildDatabase._CACHE_[Key]._RawData._Table.Table):\r
1897 TmpTableDict[Wa.BuildDatabase._CACHE_[Key]._RawData._Table.Table] = Wa.BuildDatabase._CACHE_[Key]._RawData._Table.Cur\r
1898 #\r
52302d4d
LG
1899 #\r
1900 # All modules have been put in build tasks queue. Tell task scheduler\r
1901 # to exit if all tasks are completed\r
1902 #\r
1903 ExitFlag.set()\r
1904 BuildTask.WaitForComplete()\r
a0a2cd1e 1905 self.CreateAsBuiltInf()\r
52302d4d
LG
1906\r
1907 #\r
1908 # Check for build error, and raise exception if one\r
1909 # has been signaled.\r
1910 #\r
1911 if BuildTask.HasError():\r
1912 EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)\r
1913\r
1914 # Create MAP file when Load Fix Address is enabled.\r
636f2be6 1915 if self.Target in ["", "all", "fds"]:\r
0d2711a6 1916 for Arch in Wa.ArchList:\r
52302d4d
LG
1917 #\r
1918 # Check whether the set fix address is above 4G for 32bit image.\r
1919 #\r
1920 if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:\r
1921 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS can't be set to larger than or equal to 4G for the platorm with IA32 or ARM arch modules")\r
1922 #\r
1923 # Get Module List\r
1924 #\r
636f2be6 1925 ModuleList = {}\r
52302d4d
LG
1926 for Pa in Wa.AutoGenObjectList:\r
1927 for Ma in Pa.ModuleAutoGenList:\r
1928 if Ma == None:\r
1929 continue\r
1930 if not Ma.IsLibrary:\r
636f2be6 1931 ModuleList[Ma.Guid.upper()] = Ma\r
52302d4d
LG
1932 #\r
1933 # Rebase module to the preferred memory address before GenFds\r
1934 #\r
1935 MapBuffer = StringIO('')\r
636f2be6
LG
1936 if self.LoadFixAddress != 0:\r
1937 self._CollectModuleMapBuffer(MapBuffer, ModuleList)\r
52302d4d 1938\r
0d2711a6 1939 if self.Fdf:\r
f3decdc3
LG
1940 #\r
1941 # Generate FD image if there's a FDF file found\r
1942 #\r
03af2753
HC
1943 LaunchCommand(Wa.GenFdsCommand, os.getcwd())\r
1944\r
52302d4d
LG
1945 #\r
1946 # Create MAP file for all platform FVs after GenFds.\r
1947 #\r
636f2be6 1948 self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)\r
52302d4d
LG
1949 #\r
1950 # Save MAP buffer into MAP file.\r
1951 #\r
1952 self._SaveMapFile(MapBuffer, Wa)\r
1953\r
1954 ## Generate GuidedSectionTools.txt in the FV directories.\r
1955 #\r
1956 def CreateGuidedSectionToolsFile(self):\r
0d2711a6
LG
1957 for BuildTarget in self.BuildTargetList:\r
1958 for ToolChain in self.ToolChainList:\r
1959 Wa = WorkspaceAutoGen(\r
1960 self.WorkspaceDir,\r
1961 self.PlatformFile,\r
1962 BuildTarget,\r
1963 ToolChain,\r
1964 self.ArchList,\r
1965 self.BuildDatabase,\r
1966 self.TargetTxt,\r
1967 self.ToolDef,\r
1968 self.Fdf,\r
1969 self.FdList,\r
1970 self.FvList,\r
1971 self.CapList,\r
1972 self.SkuId,\r
1973 self.UniFlag\r
1974 )\r
1975 FvDir = Wa.FvDir\r
1976 if not os.path.exists(FvDir):\r
1977 continue\r
1978\r
4afd3d04 1979 for Arch in self.ArchList:\r
52302d4d
LG
1980 # Build up the list of supported architectures for this build\r
1981 prefix = '%s_%s_%s_' % (BuildTarget, ToolChain, Arch)\r
4afd3d04 1982\r
52302d4d
LG
1983 # Look through the tool definitions for GUIDed tools\r
1984 guidAttribs = []\r
1985 for (attrib, value) in self.ToolDef.ToolsDefTxtDictionary.iteritems():\r
1986 if attrib.upper().endswith('_GUID'):\r
1987 split = attrib.split('_')\r
1988 thisPrefix = '_'.join(split[0:3]) + '_'\r
1989 if thisPrefix == prefix:\r
1990 guid = self.ToolDef.ToolsDefTxtDictionary[attrib]\r
1991 guid = guid.lower()\r
1992 toolName = split[3]\r
1993 path = '_'.join(split[0:4]) + '_PATH'\r
1994 path = self.ToolDef.ToolsDefTxtDictionary[path]\r
1995 path = self.GetFullPathOfTool(path)\r
1996 guidAttribs.append((guid, toolName, path))\r
4afd3d04 1997\r
52302d4d
LG
1998 # Write out GuidedSecTools.txt\r
1999 toolsFile = os.path.join(FvDir, 'GuidedSectionTools.txt')\r
2000 toolsFile = open(toolsFile, 'wt')\r
2001 for guidedSectionTool in guidAttribs:\r
2002 print >> toolsFile, ' '.join(guidedSectionTool)\r
2003 toolsFile.close()\r
2004\r
2005 ## Returns the full path of the tool.\r
2006 #\r
2007 def GetFullPathOfTool (self, tool):\r
2008 if os.path.exists(tool):\r
2009 return os.path.realpath(tool)\r
2010 else:\r
2011 # We need to search for the tool using the\r
2012 # PATH environment variable.\r
2013 for dirInPath in os.environ['PATH'].split(os.pathsep):\r
2014 foundPath = os.path.join(dirInPath, tool)\r
2015 if os.path.exists(foundPath):\r
2016 return os.path.realpath(foundPath)\r
2017\r
2018 # If the tool was not found in the path then we just return\r
2019 # the input tool.\r
2020 return tool\r
2021\r
2022 ## Launch the module or platform build\r
2023 #\r
2024 def Launch(self):\r
0d2711a6 2025 if not self.ModuleFile:\r
52302d4d
LG
2026 if not self.SpawnMode or self.Target not in ["", "all"]:\r
2027 self.SpawnMode = False\r
2028 self._BuildPlatform()\r
2029 else:\r
2030 self._MultiThreadBuildPlatform()\r
2031 self.CreateGuidedSectionToolsFile()\r
2032 else:\r
2033 self.SpawnMode = False\r
2034 self._BuildModule()\r
2035\r
bcbdc755
YL
2036 if self.Target == 'cleanall':\r
2037 self.Db.Close()\r
2038 RemoveDirectory(os.path.dirname(GlobalData.gDatabasePath), True)\r
2039\r
a0a2cd1e
FB
2040 def CreateAsBuiltInf(self):\r
2041 for Module in self.BuildModules:\r
2042 Module.CreateAsBuiltInf()\r
2043 self.BuildModules = []\r
52302d4d
LG
2044 ## Do some clean-up works when error occurred\r
2045 def Relinquish(self):\r
2046 OldLogLevel = EdkLogger.GetLevel()\r
2047 EdkLogger.SetLevel(EdkLogger.ERROR)\r
2048 #self.DumpBuildData()\r
2049 Utils.Progressor.Abort()\r
2050 if self.SpawnMode == True:\r
2051 BuildTask.Abort()\r
2052 EdkLogger.SetLevel(OldLogLevel)\r
2053\r
2054 def DumpBuildData(self):\r
97fa0ee9 2055 CacheDirectory = os.path.dirname(GlobalData.gDatabasePath)\r
52302d4d
LG
2056 Utils.CreateDirectory(CacheDirectory)\r
2057 Utils.DataDump(Utils.gFileTimeStampCache, os.path.join(CacheDirectory, "gFileTimeStampCache"))\r
2058 Utils.DataDump(Utils.gDependencyDatabase, os.path.join(CacheDirectory, "gDependencyDatabase"))\r
2059\r
2060 def RestoreBuildData(self):\r
97fa0ee9 2061 FilePath = os.path.join(os.path.dirname(GlobalData.gDatabasePath), "gFileTimeStampCache")\r
52302d4d
LG
2062 if Utils.gFileTimeStampCache == {} and os.path.isfile(FilePath):\r
2063 Utils.gFileTimeStampCache = Utils.DataRestore(FilePath)\r
2064 if Utils.gFileTimeStampCache == None:\r
2065 Utils.gFileTimeStampCache = {}\r
2066\r
97fa0ee9 2067 FilePath = os.path.join(os.path.dirname(GlobalData.gDatabasePath), "gDependencyDatabase")\r
52302d4d
LG
2068 if Utils.gDependencyDatabase == {} and os.path.isfile(FilePath):\r
2069 Utils.gDependencyDatabase = Utils.DataRestore(FilePath)\r
2070 if Utils.gDependencyDatabase == None:\r
2071 Utils.gDependencyDatabase = {}\r
2072\r
2073def ParseDefines(DefineList=[]):\r
2074 DefineDict = {}\r
2075 if DefineList != None:\r
2076 for Define in DefineList:\r
2077 DefineTokenList = Define.split("=", 1)\r
0d2711a6
LG
2078 if not GlobalData.gMacroNamePattern.match(DefineTokenList[0]):\r
2079 EdkLogger.error('build', FORMAT_INVALID,\r
2080 "The macro name must be in the pattern [A-Z][A-Z0-9_]*",\r
2081 ExtraData=DefineTokenList[0])\r
4afd3d04 2082\r
52302d4d 2083 if len(DefineTokenList) == 1:\r
0d2711a6 2084 DefineDict[DefineTokenList[0]] = "TRUE"\r
52302d4d
LG
2085 else:\r
2086 DefineDict[DefineTokenList[0]] = DefineTokenList[1].strip()\r
2087 return DefineDict\r
2088\r
2089gParamCheck = []\r
2090def SingleCheckCallback(option, opt_str, value, parser):\r
2091 if option not in gParamCheck:\r
2092 setattr(parser.values, option.dest, value)\r
2093 gParamCheck.append(option)\r
2094 else:\r
2095 parser.error("Option %s only allows one instance in command line!" % option)\r
2096\r
2097## Parse command line options\r
2098#\r
2099# Using standard Python module optparse to parse command line option of this tool.\r
2100#\r
2101# @retval Opt A optparse.Values object containing the parsed options\r
2102# @retval Args Target of build command\r
2103#\r
2104def MyOptionParser():\r
47fea6af
YZ
2105 Parser = OptionParser(description=__copyright__, version=__version__, prog="build.exe", usage="%prog [options] [all|fds|genc|genmake|clean|cleanall|cleanlib|modules|libraries|run]")\r
2106 Parser.add_option("-a", "--arch", action="append", type="choice", choices=['IA32', 'X64', 'IPF', 'EBC', 'ARM', 'AARCH64'], dest="TargetArch",\r
4afd3d04 2107 help="ARCHS is one of list: IA32, X64, IPF, ARM, AARCH64 or EBC, which overrides target.txt's TARGET_ARCH definition. To specify more archs, please repeat this option.")\r
52302d4d
LG
2108 Parser.add_option("-p", "--platform", action="callback", type="string", dest="PlatformFile", callback=SingleCheckCallback,\r
2109 help="Build the platform specified by the DSC file name argument, overriding target.txt's ACTIVE_PLATFORM definition.")\r
2110 Parser.add_option("-m", "--module", action="callback", type="string", dest="ModuleFile", callback=SingleCheckCallback,\r
2111 help="Build the module specified by the INF file name argument.")\r
64b2609f
LG
2112 Parser.add_option("-b", "--buildtarget", type="string", dest="BuildTarget", help="Using the TARGET to build the platform, overriding target.txt's TARGET definition.",\r
2113 action="append")\r
52302d4d
LG
2114 Parser.add_option("-t", "--tagname", action="append", type="string", dest="ToolChain",\r
2115 help="Using the Tool Chain Tagname to build the platform, overriding target.txt's TOOL_CHAIN_TAG definition.")\r
2116 Parser.add_option("-x", "--sku-id", action="callback", type="string", dest="SkuId", callback=SingleCheckCallback,\r
2117 help="Using this name of SKU ID to build the platform, overriding SKUID_IDENTIFIER in DSC file.")\r
2118\r
2119 Parser.add_option("-n", action="callback", type="int", dest="ThreadNumber", callback=SingleCheckCallback,\r
2120 help="Build the platform using multi-threaded compiler. The value overrides target.txt's MAX_CONCURRENT_THREAD_NUMBER. Less than 2 will disable multi-thread builds.")\r
2121\r
2122 Parser.add_option("-f", "--fdf", action="callback", type="string", dest="FdfFile", callback=SingleCheckCallback,\r
2123 help="The name of the FDF file to use, which overrides the setting in the DSC file.")\r
2124 Parser.add_option("-r", "--rom-image", action="append", type="string", dest="RomImage", default=[],\r
2125 help="The name of FD to be generated. The name must be from [FD] section in FDF file.")\r
2126 Parser.add_option("-i", "--fv-image", action="append", type="string", dest="FvImage", default=[],\r
2127 help="The name of FV to be generated. The name must be from [FV] section in FDF file.")\r
4234283c
LG
2128 Parser.add_option("-C", "--capsule-image", action="append", type="string", dest="CapName", default=[],\r
2129 help="The name of Capsule to be generated. The name must be from [Capsule] section in FDF file.")\r
52302d4d
LG
2130 Parser.add_option("-u", "--skip-autogen", action="store_true", dest="SkipAutoGen", help="Skip AutoGen step.")\r
2131 Parser.add_option("-e", "--re-parse", action="store_true", dest="Reparse", help="Re-parse all meta-data files.")\r
2132\r
0d2711a6 2133 Parser.add_option("-c", "--case-insensitive", action="store_true", dest="CaseInsensitive", default=False, help="Don't check case of file name.")\r
52302d4d
LG
2134\r
2135 Parser.add_option("-w", "--warning-as-error", action="store_true", dest="WarningAsError", help="Treat warning in tools as error.")\r
2136 Parser.add_option("-j", "--log", action="store", dest="LogFile", help="Put log in specified file as well as on console.")\r
2137\r
2138 Parser.add_option("-s", "--silent", action="store_true", type=None, dest="SilentMode",\r
2139 help="Make use of silent mode of (n)make.")\r
2140 Parser.add_option("-q", "--quiet", action="store_true", type=None, help="Disable all messages except FATAL ERRORS.")\r
2141 Parser.add_option("-v", "--verbose", action="store_true", type=None, help="Turn on verbose output with informational messages printed, "\\r
2142 "including library instances selected, final dependency expression, "\\r
2143 "and warning messages, etc.")\r
2144 Parser.add_option("-d", "--debug", action="store", type="int", help="Enable debug messages at specified level.")\r
2145 Parser.add_option("-D", "--define", action="append", type="string", dest="Macros", help="Macro: \"Name [= Value]\".")\r
2146\r
2147 Parser.add_option("-y", "--report-file", action="store", dest="ReportFile", help="Create/overwrite the report to the specified filename.")\r
eca5be7a
YZ
2148 Parser.add_option("-Y", "--report-type", action="append", type="choice", choices=['PCD','LIBRARY','FLASH','DEPEX','BUILD_FLAGS','FIXED_ADDRESS','HASH','EXECUTION_ORDER'], dest="ReportType", default=[],\r
2149 help="Flags that control the type of build report to generate. Must be one of: [PCD, LIBRARY, FLASH, DEPEX, BUILD_FLAGS, FIXED_ADDRESS, HASH, EXECUTION_ORDER]. "\\r
52302d4d 2150 "To specify more than one flag, repeat this option on the command line and the default flag set is [PCD, LIBRARY, FLASH, DEPEX, BUILD_FLAGS, FIXED_ADDRESS]")\r
f3decdc3
LG
2151 Parser.add_option("-F", "--flag", action="store", type="string", dest="Flag",\r
2152 help="Specify the specific option to parse EDK UNI file. Must be one of: [-c, -s]. -c is for EDK framework UNI file, and -s is for EDK UEFI UNI file. "\\r
2153 "This option can also be specified by setting *_*_*_BUILD_FLAGS in [BuildOptions] section of platform DSC. If they are both specified, this value "\\r
2154 "will override the setting in [BuildOptions] section of platform DSC.")\r
0d2711a6 2155 Parser.add_option("-N", "--no-cache", action="store_true", dest="DisableCache", default=False, help="Disable build cache mechanism")\r
97fa0ee9
YL
2156 Parser.add_option("--conf", action="store", type="string", dest="ConfDirectory", help="Specify the customized Conf directory.")\r
2157 Parser.add_option("--check-usage", action="store_true", dest="CheckUsage", default=False, help="Check usage content of entries listed in INF file.")\r
fae62ff2 2158 Parser.add_option("--ignore-sources", action="store_true", dest="IgnoreSources", default=False, help="Focus to a binary build and ignore all source files")\r
d7cd3356 2159 Parser.add_option("--pcd", action="append", dest="OptionPcd", help="Set PCD value by command line. Format: \"PcdName=Value\" ")\r
725cdb8f 2160 Parser.add_option("-l", "--cmd-len", action="store", type="int", dest="CommandLength", help="Specify the maximum line length of build command. Default is 4096.")\r
52302d4d 2161\r
47fea6af 2162 (Opt, Args) = Parser.parse_args()\r
52302d4d
LG
2163 return (Opt, Args)\r
2164\r
2165## Tool entrance method\r
2166#\r
2167# This method mainly dispatch specific methods per the command line options.\r
2168# If no error found, return zero value so the caller of this tool can know\r
2169# if it's executed successfully or not.\r
2170#\r
2171# @retval 0 Tool was successful\r
2172# @retval 1 Tool failed\r
2173#\r
2174def Main():\r
2175 StartTime = time.time()\r
2176\r
2177 # Initialize log system\r
2178 EdkLogger.Initialize()\r
f0dc69e6 2179 GlobalData.gCommand = sys.argv[1:]\r
52302d4d
LG
2180 #\r
2181 # Parse the options and args\r
2182 #\r
2183 (Option, Target) = MyOptionParser()\r
2184 GlobalData.gOptions = Option\r
2185 GlobalData.gCaseInsensitive = Option.CaseInsensitive\r
2186\r
2187 # Set log level\r
2188 if Option.verbose != None:\r
2189 EdkLogger.SetLevel(EdkLogger.VERBOSE)\r
2190 elif Option.quiet != None:\r
2191 EdkLogger.SetLevel(EdkLogger.QUIET)\r
2192 elif Option.debug != None:\r
2193 EdkLogger.SetLevel(Option.debug + 1)\r
2194 else:\r
2195 EdkLogger.SetLevel(EdkLogger.INFO)\r
2196\r
2197 if Option.LogFile != None:\r
2198 EdkLogger.SetLogFile(Option.LogFile)\r
2199\r
2200 if Option.WarningAsError == True:\r
2201 EdkLogger.SetWarningAsError()\r
2202\r
2203 if platform.platform().find("Windows") >= 0:\r
2204 GlobalData.gIsWindows = True\r
2205 else:\r
2206 GlobalData.gIsWindows = False\r
2207\r
6780eef1
LG
2208 EdkLogger.quiet("Build environment: %s" % platform.platform())\r
2209 EdkLogger.quiet(time.strftime("Build start time: %H:%M:%S, %b.%d %Y\n", time.localtime()));\r
52302d4d
LG
2210 ReturnCode = 0\r
2211 MyBuild = None\r
09ae0f11 2212 BuildError = True\r
52302d4d
LG
2213 try:\r
2214 if len(Target) == 0:\r
2215 Target = "all"\r
2216 elif len(Target) >= 2:\r
2217 EdkLogger.error("build", OPTION_NOT_SUPPORTED, "More than one targets are not supported.",\r
47fea6af 2218 ExtraData="Please select one of: %s" % (' '.join(gSupportedTarget)))\r
52302d4d
LG
2219 else:\r
2220 Target = Target[0].lower()\r
2221\r
2222 if Target not in gSupportedTarget:\r
2223 EdkLogger.error("build", OPTION_NOT_SUPPORTED, "Not supported target [%s]." % Target,\r
47fea6af 2224 ExtraData="Please select one of: %s" % (' '.join(gSupportedTarget)))\r
52302d4d 2225\r
52302d4d
LG
2226 #\r
2227 # Check environment variable: EDK_TOOLS_PATH, WORKSPACE, PATH\r
2228 #\r
2229 CheckEnvVariable()\r
0d2711a6
LG
2230 GlobalData.gCommandLineDefines.update(ParseDefines(Option.Macros))\r
2231\r
52302d4d
LG
2232 Workspace = os.getenv("WORKSPACE")\r
2233 #\r
2234 # Get files real name in workspace dir\r
2235 #\r
2236 GlobalData.gAllFiles = Utils.DirCache(Workspace)\r
2237\r
2238 WorkingDirectory = os.getcwd()\r
2239 if not Option.ModuleFile:\r
2240 FileList = glob.glob(os.path.normpath(os.path.join(WorkingDirectory, '*.inf')))\r
2241 FileNum = len(FileList)\r
2242 if FileNum >= 2:\r
2243 EdkLogger.error("build", OPTION_NOT_SUPPORTED, "There are %d INF files in %s." % (FileNum, WorkingDirectory),\r
2244 ExtraData="Please use '-m <INF_FILE_PATH>' switch to choose one.")\r
2245 elif FileNum == 1:\r
2246 Option.ModuleFile = NormFile(FileList[0], Workspace)\r
2247\r
2248 if Option.ModuleFile:\r
2249 if os.path.isabs (Option.ModuleFile):\r
2250 if os.path.normcase (os.path.normpath(Option.ModuleFile)).find (Workspace) == 0:\r
2251 Option.ModuleFile = NormFile(os.path.normpath(Option.ModuleFile), Workspace)\r
2252 Option.ModuleFile = PathClass(Option.ModuleFile, Workspace)\r
2253 ErrorCode, ErrorInfo = Option.ModuleFile.Validate(".inf", False)\r
2254 if ErrorCode != 0:\r
2255 EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)\r
2256\r
2257 if Option.PlatformFile != None:\r
2258 if os.path.isabs (Option.PlatformFile):\r
2259 if os.path.normcase (os.path.normpath(Option.PlatformFile)).find (Workspace) == 0:\r
2260 Option.PlatformFile = NormFile(os.path.normpath(Option.PlatformFile), Workspace)\r
2261 Option.PlatformFile = PathClass(Option.PlatformFile, Workspace)\r
52302d4d
LG
2262\r
2263 if Option.FdfFile != None:\r
2264 if os.path.isabs (Option.FdfFile):\r
2265 if os.path.normcase (os.path.normpath(Option.FdfFile)).find (Workspace) == 0:\r
2266 Option.FdfFile = NormFile(os.path.normpath(Option.FdfFile), Workspace)\r
2267 Option.FdfFile = PathClass(Option.FdfFile, Workspace)\r
2268 ErrorCode, ErrorInfo = Option.FdfFile.Validate(".fdf", False)\r
2269 if ErrorCode != 0:\r
2270 EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)\r
2271\r
f3decdc3
LG
2272 if Option.Flag != None and Option.Flag not in ['-c', '-s']:\r
2273 EdkLogger.error("build", OPTION_VALUE_INVALID, "UNI flag must be one of -c or -s")\r
2274\r
0d2711a6 2275 MyBuild = Build(Target, Workspace, Option)\r
64b2609f 2276 GlobalData.gCommandLineDefines['ARCH'] = ' '.join(MyBuild.ArchList)\r
f0dc69e6
YZ
2277 if not (MyBuild.LaunchPrebuildFlag and os.path.exists(MyBuild.PlatformBuildPath)):\r
2278 MyBuild.Launch()\r
64b2609f
LG
2279 # Drop temp tables to avoid database locked.\r
2280 for TmpTableName in TmpTableDict:\r
2281 SqlCommand = """drop table IF EXISTS %s""" % TmpTableName\r
2282 TmpTableDict[TmpTableName].execute(SqlCommand)\r
52302d4d 2283 #MyBuild.DumpBuildData()\r
09ae0f11
YL
2284 #\r
2285 # All job done, no error found and no exception raised\r
2286 #\r
2287 BuildError = False\r
52302d4d
LG
2288 except FatalError, X:\r
2289 if MyBuild != None:\r
2290 # for multi-thread build exits safely\r
2291 MyBuild.Relinquish()\r
2292 if Option != None and Option.debug != None:\r
2293 EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())\r
2294 ReturnCode = X.args[0]\r
2295 except Warning, X:\r
2296 # error from Fdf parser\r
2297 if MyBuild != None:\r
2298 # for multi-thread build exits safely\r
2299 MyBuild.Relinquish()\r
2300 if Option != None and Option.debug != None:\r
2301 EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())\r
2302 else:\r
47fea6af 2303 EdkLogger.error(X.ToolName, FORMAT_INVALID, File=X.FileName, Line=X.LineNumber, ExtraData=X.Message, RaiseError=False)\r
52302d4d
LG
2304 ReturnCode = FORMAT_INVALID\r
2305 except KeyboardInterrupt:\r
2306 ReturnCode = ABORT_ERROR\r
2307 if Option != None and Option.debug != None:\r
2308 EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())\r
2309 except:\r
2310 if MyBuild != None:\r
2311 # for multi-thread build exits safely\r
2312 MyBuild.Relinquish()\r
2313\r
2314 # try to get the meta-file from the object causing exception\r
2315 Tb = sys.exc_info()[-1]\r
2316 MetaFile = GlobalData.gProcessingFile\r
2317 while Tb != None:\r
2318 if 'self' in Tb.tb_frame.f_locals and hasattr(Tb.tb_frame.f_locals['self'], 'MetaFile'):\r
2319 MetaFile = Tb.tb_frame.f_locals['self'].MetaFile\r
2320 Tb = Tb.tb_next\r
2321 EdkLogger.error(\r
2322 "\nbuild",\r
2323 CODE_ERROR,\r
2324 "Unknown fatal error when processing [%s]" % MetaFile,\r
3a0f8bde 2325 ExtraData="\n(Please send email to edk2-devel@lists.01.org for help, attaching following call stack trace!)\n",\r
52302d4d
LG
2326 RaiseError=False\r
2327 )\r
d0acc87a 2328 EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())\r
52302d4d
LG
2329 ReturnCode = CODE_ERROR\r
2330 finally:\r
2331 Utils.Progressor.Abort()\r
97fa0ee9 2332 Utils.ClearDuplicatedInf()\r
52302d4d
LG
2333\r
2334 if ReturnCode == 0:\r
f0dc69e6 2335 try:\r
91048b0d 2336 MyBuild.LaunchPostbuild()\r
f0dc69e6
YZ
2337 Conclusion = "Done"\r
2338 except:\r
2339 Conclusion = "Failed"\r
52302d4d
LG
2340 elif ReturnCode == ABORT_ERROR:\r
2341 Conclusion = "Aborted"\r
2342 else:\r
2343 Conclusion = "Failed"\r
2344 FinishTime = time.time()\r
4234283c
LG
2345 BuildDuration = time.gmtime(int(round(FinishTime - StartTime)))\r
2346 BuildDurationStr = ""\r
2347 if BuildDuration.tm_yday > 1:\r
47fea6af 2348 BuildDurationStr = time.strftime("%H:%M:%S", BuildDuration) + ", %d day(s)" % (BuildDuration.tm_yday - 1)\r
4234283c
LG
2349 else:\r
2350 BuildDurationStr = time.strftime("%H:%M:%S", BuildDuration)\r
52302d4d 2351 if MyBuild != None:\r
09ae0f11
YL
2352 if not BuildError:\r
2353 MyBuild.BuildReport.GenerateReport(BuildDurationStr)\r
52302d4d
LG
2354 MyBuild.Db.Close()\r
2355 EdkLogger.SetLevel(EdkLogger.QUIET)\r
6780eef1
LG
2356 EdkLogger.quiet("\n- %s -" % Conclusion)\r
2357 EdkLogger.quiet(time.strftime("Build end time: %H:%M:%S, %b.%d %Y", time.localtime()))\r
4234283c 2358 EdkLogger.quiet("Build total time: %s\n" % BuildDurationStr)\r
52302d4d
LG
2359 return ReturnCode\r
2360\r
2361if __name__ == '__main__':\r
2362 r = Main()\r
2363 ## 0-127 is a safe return range, and 1 is a standard default error\r
2364 if r < 0 or r > 127: r = 1\r
2365 sys.exit(r)\r
2366\r