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