]> 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
BaseTools/VolInfo: generate HASH value for each PE image
[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
923 if self.BuildTargetList:\r
924 GlobalData.gGlobalDefines['TARGET'] = self.BuildTargetList[0]\r
925 if self.ArchList:\r
926 GlobalData.gGlobalDefines['ARCH'] = self.ArchList[0]\r
927 if self.ToolChainList:\r
928 GlobalData.gGlobalDefines['TOOLCHAIN'] = self.ToolChainList[0]\r
929 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = self.ToolChainList[0]\r
930 if 'PREBUILD' in GlobalData.gCommandLineDefines.keys():\r
931 self.Prebuild = GlobalData.gCommandLineDefines.get('PREBUILD')\r
932 else:\r
933 self.Db.InitDatabase()\r
934 self.Db_Flag = True\r
935 Platform = self.Db._MapPlatform(str(self.PlatformFile))\r
936 self.Prebuild = str(Platform.Prebuild)\r
937 if self.Prebuild:\r
938 PrebuildList = self.Prebuild.split()\r
939 if not os.path.isabs(PrebuildList[0]):\r
940 PrebuildList[0] = mws.join(self.WorkspaceDir, PrebuildList[0])\r
941 if os.path.isfile(PrebuildList[0]):\r
942 self.PrebuildScript = PrebuildList[0]\r
943 self.Prebuild = ' '.join(PrebuildList)\r
944 self.Prebuild += self.PassCommandOption(self.BuildTargetList, self.ArchList, self.ToolChainList)\r
945 #self.LaunchPrebuild()\r
946 else:\r
947 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 948\r
f0dc69e6
YZ		 949 def InitPostBuild(self):\r
950 if 'POSTBUILD' in GlobalData.gCommandLineDefines.keys():\r
951 self.Postbuild = GlobalData.gCommandLineDefines.get('POSTBUILD')\r
952 else:\r
953 Platform = self.Db._MapPlatform(str(self.PlatformFile))\r
954 self.Postbuild = str(Platform.Postbuild)\r
955 if self.Postbuild:\r
956 PostbuildList = self.Postbuild.split()\r
957 if not os.path.isabs(PostbuildList[0]):\r
958 PostbuildList[0] = mws.join(self.WorkspaceDir, PostbuildList[0])\r
959 if os.path.isfile(PostbuildList[0]):\r
960 self.PostbuildScript = PostbuildList[0]\r
961 self.Postbuild = ' '.join(PostbuildList)\r
962 self.Postbuild += self.PassCommandOption(self.BuildTargetList, self.ArchList, self.ToolChainList)\r
963 #self.LanuchPostbuild()\r
964 else:\r
965 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
966\r
967 def PassCommandOption(self, BuildTarget, TargetArch, ToolChain):\r
968 BuildStr = ''\r
969 if GlobalData.gCommand and isinstance(GlobalData.gCommand, list):\r
970 BuildStr += ' ' + ' '.join(GlobalData.gCommand)\r
971 TargetFlag = False\r
972 ArchFlag = False\r
973 ToolChainFlag = False\r
974\r
975 if GlobalData.gOptions and not GlobalData.gOptions.BuildTarget:\r
976 TargetFlag = True\r
977 if GlobalData.gOptions and not GlobalData.gOptions.TargetArch:\r
978 ArchFlag = True\r
979 if GlobalData.gOptions and not GlobalData.gOptions.ToolChain:\r
980 ToolChainFlag = True\r
981\r
982 if TargetFlag and BuildTarget:\r
983 if isinstance(BuildTarget, list) or isinstance(BuildTarget, tuple):\r
984 BuildStr += ' -b ' + ' -b '.join(BuildTarget)\r
985 elif isinstance(BuildTarget, str):\r
986 BuildStr += ' -b ' + BuildTarget\r
987 if ArchFlag and TargetArch:\r
988 if isinstance(TargetArch, list) or isinstance(TargetArch, tuple):\r
989 BuildStr += ' -a ' + ' -a '.join(TargetArch)\r
990 elif isinstance(TargetArch, str):\r
991 BuildStr += ' -a ' + TargetArch\r
992 if ToolChainFlag and ToolChain:\r
993 if isinstance(ToolChain, list) or isinstance(ToolChain, tuple):\r
994 BuildStr += ' -t ' + ' -t '.join(ToolChain)\r
995 elif isinstance(ToolChain, str):\r
996 BuildStr += ' -t ' + ToolChain\r
997\r
998 return BuildStr\r
999\r
1000 def LaunchPrebuild(self):\r
1001 if self.Prebuild:\r
1002 EdkLogger.info("\n- Prebuild Start -\n")\r
1003 self.LaunchPrebuildFlag = True\r
1004 PrebuildEnvFile = os.path.join(GlobalData.gConfDirectory,'.cache','.PrebuildEnv')\r
1005 if os.path.isfile(PrebuildEnvFile):\r
1006 os.remove(PrebuildEnvFile)\r
1007 if os.path.isfile(self.PlatformBuildPath):\r
1008 os.remove(self.PlatformBuildPath)\r
1009 if sys.platform == "win32":\r
1010 args = ' && '.join((self.Prebuild, 'set > ' + PrebuildEnvFile))\r
1011 Process = Popen(args, stdout=PIPE, stderr=PIPE)\r
1012 else:\r
1013 args = ' && '.join((self.Prebuild, 'env > ' + PrebuildEnvFile))\r
1014 Process = Popen(args, stdout=PIPE, stderr=PIPE, shell=True, executable="/bin/bash")\r
1015\r
1016 # launch two threads to read the STDOUT and STDERR\r
1017 EndOfProcedure = Event()\r
1018 EndOfProcedure.clear()\r
1019 if Process.stdout:\r
1020 StdOutThread = Thread(target=ReadMessage, args=(Process.stdout, EdkLogger.info, EndOfProcedure))\r
1021 StdOutThread.setName("STDOUT-Redirector")\r
1022 StdOutThread.setDaemon(False)\r
1023 StdOutThread.start()\r
1024\r
1025 if Process.stderr:\r
1026 StdErrThread = Thread(target=ReadMessage, args=(Process.stderr, EdkLogger.quiet, EndOfProcedure))\r
1027 StdErrThread.setName("STDERR-Redirector")\r
1028 StdErrThread.setDaemon(False)\r
1029 StdErrThread.start()\r
1030 # waiting for program exit\r
1031 Process.wait()\r
1032\r
1033 if Process.stdout:\r
1034 StdOutThread.join()\r
1035 if Process.stderr:\r
1036 StdErrThread.join()\r
1037 if Process.returncode != 0 :\r
1038 EdkLogger.error("Prebuild", PREBUILD_ERROR, 'Prebuild process is not success!')\r
1039\r
1040 if os.path.exists(PrebuildEnvFile):\r
1041 f = open(PrebuildEnvFile)\r
1042 envs = f.readlines()\r
1043 f.close()\r
1044 envs = itertools.imap(lambda l: l.split('=',1), envs)\r
1045 envs = itertools.ifilter(lambda l: len(l) == 2, envs)\r
1046 envs = itertools.imap(lambda l: [i.strip() for i in l], envs)\r
1047 os.environ.update(dict(envs))\r
1048 EdkLogger.info("\n- Prebuild Done -\n")\r
1049\r
1050 def LanuchPostbuild(self):\r
1051 if self.Postbuild:\r
1052 EdkLogger.info("\n- Postbuild Start -\n")\r
1053 if sys.platform == "win32":\r
1054 Process = Popen(self.Postbuild, stdout=PIPE, stderr=PIPE)\r
1055 else:\r
1056 Process = Popen(self.Postbuild, stdout=PIPE, stderr=PIPE, shell=True, executable="/bin/bash")\r
1057 # launch two threads to read the STDOUT and STDERR\r
1058 EndOfProcedure = Event()\r
1059 EndOfProcedure.clear()\r
1060 if Process.stdout:\r
1061 StdOutThread = Thread(target=ReadMessage, args=(Process.stdout, EdkLogger.info, EndOfProcedure))\r
1062 StdOutThread.setName("STDOUT-Redirector")\r
1063 StdOutThread.setDaemon(False)\r
1064 StdOutThread.start()\r
1065\r
1066 if Process.stderr:\r
1067 StdErrThread = Thread(target=ReadMessage, args=(Process.stderr, EdkLogger.quiet, EndOfProcedure))\r
1068 StdErrThread.setName("STDERR-Redirector")\r
1069 StdErrThread.setDaemon(False)\r
1070 StdErrThread.start()\r
1071 # waiting for program exit\r
1072 Process.wait()\r
1073\r
1074 if Process.stdout:\r
1075 StdOutThread.join()\r
1076 if Process.stderr:\r
1077 StdErrThread.join()\r
1078 if Process.returncode != 0 :\r
1079 EdkLogger.error("Postbuild", POSTBUILD_ERROR, 'Postbuild process is not success!')\r
1080 EdkLogger.info("\n- Postbuild Done -\n")\r
52302d4d
LG		 1081 ## Build a module or platform\r
1082 #\r
08dd311f 1083 # Create autogen code and makefile for a module or platform, and the launch\r
52302d4d
LG		 1084 # "make" command to build it\r
1085 #\r
1086 # @param Target The target of build command\r
1087 # @param Platform The platform file\r
1088 # @param Module The module file\r
1089 # @param BuildTarget The name of build target, one of "DEBUG", "RELEASE"\r
1090 # @param ToolChain The name of toolchain to build\r
1091 # @param Arch The arch of the module/platform\r
1092 # @param CreateDepModuleCodeFile Flag used to indicate creating code\r
1093 # for dependent modules/Libraries\r
1094 # @param CreateDepModuleMakeFile Flag used to indicate creating makefile\r
1095 # for dependent modules/Libraries\r
1096 #\r
03af2753 1097 def _BuildPa(self, Target, AutoGenObject, CreateDepsCodeFile=True, CreateDepsMakeFile=True, BuildModule=False):\r
52302d4d
LG		 1098 if AutoGenObject == None:\r
1099 return False\r
1100\r
1101 # skip file generation for cleanxxx targets, run and fds target\r
1102 if Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:\r
1103 # for target which must generate AutoGen code and makefile\r
1104 if not self.SkipAutoGen or Target == 'genc':\r
1105 self.Progress.Start("Generating code")\r
1106 AutoGenObject.CreateCodeFile(CreateDepsCodeFile)\r
1107 self.Progress.Stop("done!")\r
1108 if Target == "genc":\r
1109 return True\r
1110\r
1111 if not self.SkipAutoGen or Target == 'genmake':\r
1112 self.Progress.Start("Generating makefile")\r
1113 AutoGenObject.CreateMakeFile(CreateDepsMakeFile)\r
1114 self.Progress.Stop("done!")\r
1115 if Target == "genmake":\r
1116 return True\r
1117 else:\r
1118 # always recreate top/platform makefile when clean, just in case of inconsistency\r
1119 AutoGenObject.CreateCodeFile(False)\r
1120 AutoGenObject.CreateMakeFile(False)\r
1121\r
1122 if EdkLogger.GetLevel() == EdkLogger.QUIET:\r
1123 EdkLogger.quiet("Building ... %s" % repr(AutoGenObject))\r
1124\r
1125 BuildCommand = AutoGenObject.BuildCommand\r
1126 if BuildCommand == None or len(BuildCommand) == 0:\r
0d2711a6
LG		 1127 EdkLogger.error("build", OPTION_MISSING,\r
1128 "No build command found for this module. "\r
4afd3d04 1129 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %\r
0d2711a6
LG		 1130 (AutoGenObject.BuildTarget, AutoGenObject.ToolChain, AutoGenObject.Arch),\r
1131 ExtraData=str(AutoGenObject))\r
52302d4d 1132\r
03af2753
HC		 1133 makefile = GenMake.BuildFile(AutoGenObject)._FILE_NAME_[GenMake.gMakeType]\r
1134\r
03af2753
HC		 1135 # run\r
1136 if Target == 'run':\r
997a5d1b 1137 RunDir = os.path.normpath(os.path.join(AutoGenObject.BuildDir, GlobalData.gGlobalDefines['ARCH']))\r
03af2753
HC		 1138 Command = '.\SecMain'\r
1139 os.chdir(RunDir)\r
1140 LaunchCommand(Command, RunDir)\r
1141 return True\r
1142\r
1143 # build modules\r
1144 if BuildModule:\r
1145 BuildCommand = BuildCommand + [Target]\r
1146 LaunchCommand(BuildCommand, AutoGenObject.MakeFileDir)\r
a0a2cd1e 1147 self.CreateAsBuiltInf()\r
03af2753
HC		 1148 return True\r
1149\r
1150 # build library\r
1151 if Target == 'libraries':\r
1152 for Lib in AutoGenObject.LibraryBuildDirectoryList:\r
1153 NewBuildCommand = BuildCommand + ['-f', os.path.normpath(os.path.join(Lib, makefile)), 'pbuild']\r
1154 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
1155 return True\r
1156\r
1157 # build module\r
1158 if Target == 'modules':\r
1159 for Lib in AutoGenObject.LibraryBuildDirectoryList:\r
1160 NewBuildCommand = BuildCommand + ['-f', os.path.normpath(os.path.join(Lib, makefile)), 'pbuild']\r
1161 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
1162 for Mod in AutoGenObject.ModuleBuildDirectoryList:\r
1163 NewBuildCommand = BuildCommand + ['-f', os.path.normpath(os.path.join(Mod, makefile)), 'pbuild']\r
1164 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
a0a2cd1e 1165 self.CreateAsBuiltInf()\r
03af2753
HC		 1166 return True\r
1167\r
1168 # cleanlib\r
1169 if Target == 'cleanlib':\r
1170 for Lib in AutoGenObject.LibraryBuildDirectoryList:\r
1171 LibMakefile = os.path.normpath(os.path.join(Lib, makefile))\r
1172 if os.path.exists(LibMakefile):\r
1173 NewBuildCommand = BuildCommand + ['-f', LibMakefile, 'cleanall']\r
1174 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
1175 return True\r
1176\r
1177 # clean\r
1178 if Target == 'clean':\r
1179 for Mod in AutoGenObject.ModuleBuildDirectoryList:\r
1180 ModMakefile = os.path.normpath(os.path.join(Mod, makefile))\r
1181 if os.path.exists(ModMakefile):\r
1182 NewBuildCommand = BuildCommand + ['-f', ModMakefile, 'cleanall']\r
1183 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
1184 for Lib in AutoGenObject.LibraryBuildDirectoryList:\r
1185 LibMakefile = os.path.normpath(os.path.join(Lib, makefile))\r
1186 if os.path.exists(LibMakefile):\r
1187 NewBuildCommand = BuildCommand + ['-f', LibMakefile, 'cleanall']\r
1188 LaunchCommand(NewBuildCommand, AutoGenObject.MakeFileDir)\r
1189 return True\r
1190\r
1191 # cleanall\r
1192 if Target == 'cleanall':\r
1193 try:\r
1194 #os.rmdir(AutoGenObject.BuildDir)\r
1195 RemoveDirectory(AutoGenObject.BuildDir, True)\r
03af2753
HC		 1196 except WindowsError, X:\r
1197 EdkLogger.error("build", FILE_DELETE_FAILURE, ExtraData=str(X))\r
1198 return True\r
1199\r
1200 ## Build a module or platform\r
1201 #\r
1202 # Create autogen code and makefile for a module or platform, and the launch\r
1203 # "make" command to build it\r
1204 #\r
1205 # @param Target The target of build command\r
1206 # @param Platform The platform file\r
1207 # @param Module The module file\r
1208 # @param BuildTarget The name of build target, one of "DEBUG", "RELEASE"\r
1209 # @param ToolChain The name of toolchain to build\r
1210 # @param Arch The arch of the module/platform\r
1211 # @param CreateDepModuleCodeFile Flag used to indicate creating code\r
1212 # for dependent modules/Libraries\r
1213 # @param CreateDepModuleMakeFile Flag used to indicate creating makefile\r
1214 # for dependent modules/Libraries\r
1215 #\r
1216 def _Build(self, Target, AutoGenObject, CreateDepsCodeFile=True, CreateDepsMakeFile=True, BuildModule=False):\r
1217 if AutoGenObject == None:\r
1218 return False\r
1219\r
1220 # skip file generation for cleanxxx targets, run and fds target\r
1221 if Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:\r
1222 # for target which must generate AutoGen code and makefile\r
1223 if not self.SkipAutoGen or Target == 'genc':\r
1224 self.Progress.Start("Generating code")\r
1225 AutoGenObject.CreateCodeFile(CreateDepsCodeFile)\r
1226 self.Progress.Stop("done!")\r
1227 if Target == "genc":\r
1228 return True\r
1229\r
1230 if not self.SkipAutoGen or Target == 'genmake':\r
1231 self.Progress.Start("Generating makefile")\r
1232 AutoGenObject.CreateMakeFile(CreateDepsMakeFile)\r
1233 #AutoGenObject.CreateAsBuiltInf()\r
1234 self.Progress.Stop("done!")\r
1235 if Target == "genmake":\r
1236 return True\r
1237 else:\r
1238 # always recreate top/platform makefile when clean, just in case of inconsistency\r
1239 AutoGenObject.CreateCodeFile(False)\r
1240 AutoGenObject.CreateMakeFile(False)\r
1241\r
1242 if EdkLogger.GetLevel() == EdkLogger.QUIET:\r
1243 EdkLogger.quiet("Building ... %s" % repr(AutoGenObject))\r
1244\r
1245 BuildCommand = AutoGenObject.BuildCommand\r
1246 if BuildCommand == None or len(BuildCommand) == 0:\r
1247 EdkLogger.error("build", OPTION_MISSING,\r
1248 "No build command found for this module. "\r
1249 "Please check your setting of %s_%s_%s_MAKE_PATH in Conf/tools_def.txt file." %\r
1250 (AutoGenObject.BuildTarget, AutoGenObject.ToolChain, AutoGenObject.Arch),\r
1251 ExtraData=str(AutoGenObject))\r
1252\r
b0e23cf3
YL		 1253 # build modules\r
1254 if BuildModule:\r
1255 if Target != 'fds':\r
1256 BuildCommand = BuildCommand + [Target]\r
1257 LaunchCommand(BuildCommand, AutoGenObject.MakeFileDir)\r
1258 self.CreateAsBuiltInf()\r
1259 return True\r
1260\r
03af2753
HC		 1261 # genfds\r
1262 if Target == 'fds':\r
1263 LaunchCommand(AutoGenObject.GenFdsCommand, AutoGenObject.MakeFileDir)\r
1264 return True\r
1265\r
1266 # run\r
1267 if Target == 'run':\r
997a5d1b 1268 RunDir = os.path.normpath(os.path.join(AutoGenObject.BuildDir, GlobalData.gGlobalDefines['ARCH']))\r
03af2753
HC		 1269 Command = '.\SecMain'\r
1270 os.chdir(RunDir)\r
1271 LaunchCommand(Command, RunDir)\r
1272 return True\r
1273\r
03af2753
HC		 1274 # build library\r
1275 if Target == 'libraries':\r
1276 pass\r
1277\r
1278 # not build modules\r
1279\r
1280\r
1281 # cleanall\r
52302d4d
LG		 1282 if Target == 'cleanall':\r
1283 try:\r
1284 #os.rmdir(AutoGenObject.BuildDir)\r
1285 RemoveDirectory(AutoGenObject.BuildDir, True)\r
1286 except WindowsError, X:\r
1287 EdkLogger.error("build", FILE_DELETE_FAILURE, ExtraData=str(X))\r
1288 return True\r
1289\r
6780eef1 1290 ## Rebase module image and Get function address for the input module list.\r
52302d4d
LG		 1291 #\r
1292 def _RebaseModule (self, MapBuffer, BaseAddress, ModuleList, AddrIsOffset = True, ModeIsSmm = False):\r
1293 if ModeIsSmm:\r
1294 AddrIsOffset = False\r
1295 InfFileNameList = ModuleList.keys()\r
1296 #InfFileNameList.sort()\r
1297 for InfFile in InfFileNameList:\r
da92f276
LG		 1298 sys.stdout.write (".")\r
1299 sys.stdout.flush()\r
52302d4d
LG		 1300 ModuleInfo = ModuleList[InfFile]\r
1301 ModuleName = ModuleInfo.BaseName\r
f3decdc3
LG		 1302 ModuleOutputImage = ModuleInfo.Image.FileName\r
1303 ModuleDebugImage = os.path.join(ModuleInfo.DebugDir, ModuleInfo.BaseName + '.efi')\r
52302d4d
LG		 1304 ## for SMM module in SMRAM, the SMRAM will be allocated from base to top.\r
1305 if not ModeIsSmm:\r
1306 BaseAddress = BaseAddress - ModuleInfo.Image.Size\r
1307 #\r
1308 # Update Image to new BaseAddress by GenFw tool\r
1309 #\r
f3decdc3 1310 LaunchCommand(["GenFw", "--rebase", str(BaseAddress), "-r", ModuleOutputImage], ModuleInfo.OutputDir)\r
47fea6af 1311 LaunchCommand(["GenFw", "--rebase", str(BaseAddress), "-r", ModuleDebugImage], ModuleInfo.DebugDir)\r
52302d4d
LG		 1312 else:\r
1313 #\r
1314 # Set new address to the section header only for SMM driver.\r
1315 #\r
f3decdc3 1316 LaunchCommand(["GenFw", "--address", str(BaseAddress), "-r", ModuleOutputImage], ModuleInfo.OutputDir)\r
47fea6af 1317 LaunchCommand(["GenFw", "--address", str(BaseAddress), "-r", ModuleDebugImage], ModuleInfo.DebugDir)\r
52302d4d
LG		 1318 #\r
1319 # Collect funtion address from Map file\r
1320 #\r
f3decdc3 1321 ImageMapTable = ModuleOutputImage.replace('.efi', '.map')\r
52302d4d
LG		 1322 FunctionList = []\r
1323 if os.path.exists(ImageMapTable):\r
1324 OrigImageBaseAddress = 0\r
47fea6af 1325 ImageMap = open(ImageMapTable, 'r')\r
52302d4d
LG		 1326 for LinStr in ImageMap:\r
1327 if len (LinStr.strip()) == 0:\r
1328 continue\r
1329 #\r
1330 # Get the preferred address set on link time.\r
1331 #\r
1332 if LinStr.find ('Preferred load address is') != -1:\r
1333 StrList = LinStr.split()\r
1334 OrigImageBaseAddress = int (StrList[len(StrList) - 1], 16)\r
1335\r
1336 StrList = LinStr.split()\r
1337 if len (StrList) > 4:\r
47fea6af 1338 if StrList[3] == 'f' or StrList[3] == 'F':\r
52302d4d
LG		 1339 Name = StrList[1]\r
1340 RelativeAddress = int (StrList[2], 16) - OrigImageBaseAddress\r
1341 FunctionList.append ((Name, RelativeAddress))\r
1342 if ModuleInfo.Arch == 'IPF' and Name.endswith('_ModuleEntryPoint'):\r
1343 #\r
1344 # Get the real entry point address for IPF image.\r
1345 #\r
1346 ModuleInfo.Image.EntryPoint = RelativeAddress\r
1347 ImageMap.close()\r
1348 #\r
1349 # Add general information.\r
1350 #\r
1351 if ModeIsSmm:\r
1352 MapBuffer.write('\n\n%s (Fixed SMRAM Offset, BaseAddress=0x%010X, EntryPoint=0x%010X)\n' % (ModuleName, BaseAddress, BaseAddress + ModuleInfo.Image.EntryPoint))\r
1353 elif AddrIsOffset:\r
1354 MapBuffer.write('\n\n%s (Fixed Memory Offset, BaseAddress=-0x%010X, EntryPoint=-0x%010X)\n' % (ModuleName, 0 - BaseAddress, 0 - (BaseAddress + ModuleInfo.Image.EntryPoint)))\r
1355 else:\r
1356 MapBuffer.write('\n\n%s (Fixed Memory Address, BaseAddress=0x%010X, EntryPoint=0x%010X)\n' % (ModuleName, BaseAddress, BaseAddress + ModuleInfo.Image.EntryPoint))\r
1357 #\r
1358 # Add guid and general seciton section.\r
1359 #\r
1360 TextSectionAddress = 0\r
1361 DataSectionAddress = 0\r
1362 for SectionHeader in ModuleInfo.Image.SectionHeaderList:\r
1363 if SectionHeader[0] == '.text':\r
1364 TextSectionAddress = SectionHeader[1]\r
1365 elif SectionHeader[0] in ['.data', '.sdata']:\r
1366 DataSectionAddress = SectionHeader[1]\r
1367 if AddrIsOffset:\r
4afd3d04 1368 MapBuffer.write('(GUID=%s, .textbaseaddress=-0x%010X, .databaseaddress=-0x%010X)\n' % (ModuleInfo.Guid, 0 - (BaseAddress + TextSectionAddress), 0 - (BaseAddress + DataSectionAddress)))\r
52302d4d 1369 else:\r
4afd3d04 1370 MapBuffer.write('(GUID=%s, .textbaseaddress=0x%010X, .databaseaddress=0x%010X)\n' % (ModuleInfo.Guid, BaseAddress + TextSectionAddress, BaseAddress + DataSectionAddress))\r
f3decdc3
LG		 1371 #\r
1372 # Add debug image full path.\r
1373 #\r
1374 MapBuffer.write('(IMAGE=%s)\n\n' % (ModuleDebugImage))\r
52302d4d
LG		 1375 #\r
1376 # Add funtion address\r
1377 #\r
1378 for Function in FunctionList:\r
1379 if AddrIsOffset:\r
1380 MapBuffer.write(' -0x%010X %s\n' % (0 - (BaseAddress + Function[1]), Function[0]))\r
1381 else:\r
1382 MapBuffer.write(' 0x%010X %s\n' % (BaseAddress + Function[1], Function[0]))\r
1383 ImageMap.close()\r
1384\r
1385 #\r
1386 # for SMM module in SMRAM, the SMRAM will be allocated from base to top.\r
1387 #\r
1388 if ModeIsSmm:\r
1389 BaseAddress = BaseAddress + ModuleInfo.Image.Size\r
1390\r
1391 ## Collect MAP information of all FVs\r
1392 #\r
636f2be6 1393 def _CollectFvMapBuffer (self, MapBuffer, Wa, ModuleList):\r
0d2711a6 1394 if self.Fdf:\r
52302d4d 1395 # First get the XIP base address for FV map file.\r
636f2be6 1396 GuidPattern = re.compile("[-a-fA-F0-9]+")\r
f3decdc3 1397 GuidName = re.compile("\(GUID=[-a-fA-F0-9]+")\r
52302d4d
LG		 1398 for FvName in Wa.FdfProfile.FvDict.keys():\r
1399 FvMapBuffer = os.path.join(Wa.FvDir, FvName + '.Fv.map')\r
1400 if not os.path.exists(FvMapBuffer):\r
1401 continue\r
1be2ed90 1402 FvMap = open(FvMapBuffer, 'r')\r
52302d4d
LG		 1403 #skip FV size information\r
1404 FvMap.readline()\r
1405 FvMap.readline()\r
1406 FvMap.readline()\r
1407 FvMap.readline()\r
636f2be6
LG		 1408 for Line in FvMap:\r
1409 MatchGuid = GuidPattern.match(Line)\r
1410 if MatchGuid != None:\r
1411 #\r
1412 # Replace GUID with module name\r
1413 #\r
1414 GuidString = MatchGuid.group()\r
1415 if GuidString.upper() in ModuleList:\r
1416 Line = Line.replace(GuidString, ModuleList[GuidString.upper()].Name)\r
1417 MapBuffer.write('%s' % (Line))\r
f3decdc3
LG		 1418 #\r
1419 # Add the debug image full path.\r
1420 #\r
1421 MatchGuid = GuidName.match(Line)\r
1422 if MatchGuid != None:\r
1423 GuidString = MatchGuid.group().split("=")[1]\r
1424 if GuidString.upper() in ModuleList:\r
1425 MapBuffer.write('(IMAGE=%s)\n' % (os.path.join(ModuleList[GuidString.upper()].DebugDir, ModuleList[GuidString.upper()].Name + '.efi')))\r
1426\r
52302d4d
LG		 1427 FvMap.close()\r
1428\r
1429 ## Collect MAP information of all modules\r
1430 #\r
1431 def _CollectModuleMapBuffer (self, MapBuffer, ModuleList):\r
da92f276
LG		 1432 sys.stdout.write ("Generate Load Module At Fix Address Map")\r
1433 sys.stdout.flush()\r
52302d4d
LG		 1434 PatchEfiImageList = []\r
1435 PeiModuleList = {}\r
1436 BtModuleList = {}\r
1437 RtModuleList = {}\r
1438 SmmModuleList = {}\r
1439 PeiSize = 0\r
1440 BtSize = 0\r
1441 RtSize = 0\r
1442 # reserve 4K size in SMRAM to make SMM module address not from 0.\r
1443 SmmSize = 0x1000\r
1444 IsIpfPlatform = False\r
1445 if 'IPF' in self.ArchList:\r
1446 IsIpfPlatform = True\r
636f2be6
LG		 1447 for ModuleGuid in ModuleList:\r
1448 Module = ModuleList[ModuleGuid]\r
52302d4d 1449 GlobalData.gProcessingFile = "%s [%s, %s, %s]" % (Module.MetaFile, Module.Arch, Module.ToolChain, Module.BuildTarget)\r
4afd3d04 1450\r
52302d4d
LG		 1451 OutputImageFile = ''\r
1452 for ResultFile in Module.CodaTargetList:\r
1453 if str(ResultFile.Target).endswith('.efi'):\r
1454 #\r
1455 # module list for PEI, DXE, RUNTIME and SMM\r
1456 #\r
1457 OutputImageFile = os.path.join(Module.OutputDir, Module.Name + '.efi')\r
1458 ImageClass = PeImageClass (OutputImageFile)\r
1459 if not ImageClass.IsValid:\r
1460 EdkLogger.error("build", FILE_PARSE_FAILURE, ExtraData=ImageClass.ErrorInfo)\r
f3decdc3 1461 ImageInfo = PeImageInfo(Module.Name, Module.Guid, Module.Arch, Module.OutputDir, Module.DebugDir, ImageClass)\r
47fea6af 1462 if Module.ModuleType in ['PEI_CORE', 'PEIM', 'COMBINED_PEIM_DRIVER', 'PIC_PEIM', 'RELOCATABLE_PEIM', 'DXE_CORE']:\r
52302d4d
LG		 1463 PeiModuleList[Module.MetaFile] = ImageInfo\r
1464 PeiSize += ImageInfo.Image.Size\r
1465 elif Module.ModuleType in ['BS_DRIVER', 'DXE_DRIVER', 'UEFI_DRIVER']:\r
1466 BtModuleList[Module.MetaFile] = ImageInfo\r
1467 BtSize += ImageInfo.Image.Size\r
1468 elif Module.ModuleType in ['DXE_RUNTIME_DRIVER', 'RT_DRIVER', 'DXE_SAL_DRIVER', 'SAL_RT_DRIVER']:\r
1469 RtModuleList[Module.MetaFile] = ImageInfo\r
1470 #IPF runtime driver needs to be at 2 page alignment.\r
1471 if IsIpfPlatform and ImageInfo.Image.Size % 0x2000 != 0:\r
1472 ImageInfo.Image.Size = (ImageInfo.Image.Size / 0x2000 + 1) * 0x2000\r
1473 RtSize += ImageInfo.Image.Size\r
1474 elif Module.ModuleType in ['SMM_CORE', 'DXE_SMM_DRIVER']:\r
1475 SmmModuleList[Module.MetaFile] = ImageInfo\r
1476 SmmSize += ImageInfo.Image.Size\r
1477 if Module.ModuleType == 'DXE_SMM_DRIVER':\r
da92f276
LG		 1478 PiSpecVersion = '0x00000000'\r
1479 if 'PI_SPECIFICATION_VERSION' in Module.Module.Specification:\r
1480 PiSpecVersion = Module.Module.Specification['PI_SPECIFICATION_VERSION']\r
52302d4d 1481 # for PI specification < PI1.1, DXE_SMM_DRIVER also runs as BOOT time driver.\r
da92f276 1482 if int(PiSpecVersion, 16) < 0x0001000A:\r
52302d4d
LG		 1483 BtModuleList[Module.MetaFile] = ImageInfo\r
1484 BtSize += ImageInfo.Image.Size\r
1485 break\r
1486 #\r
1487 # EFI image is final target.\r
1488 # Check EFI image contains patchable FixAddress related PCDs.\r
1489 #\r
1490 if OutputImageFile != '':\r
1491 ModuleIsPatch = False\r
1492 for Pcd in Module.ModulePcdList:\r
1493 if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE and Pcd.TokenCName in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_LIST:\r
1494 ModuleIsPatch = True\r
1495 break\r
1496 if not ModuleIsPatch:\r
1497 for Pcd in Module.LibraryPcdList:\r
1498 if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE and Pcd.TokenCName in TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_LIST:\r
1499 ModuleIsPatch = True\r
1500 break\r
4afd3d04 1501\r
52302d4d
LG		 1502 if not ModuleIsPatch:\r
1503 continue\r
1504 #\r
1505 # Module includes the patchable load fix address PCDs.\r
4afd3d04 1506 # It will be fixed up later.\r
52302d4d
LG		 1507 #\r
1508 PatchEfiImageList.append (OutputImageFile)\r
4afd3d04 1509\r
52302d4d
LG		 1510 #\r
1511 # Get Top Memory address\r
1512 #\r
1513 ReservedRuntimeMemorySize = 0\r
1514 TopMemoryAddress = 0\r
1515 if self.LoadFixAddress == 0xFFFFFFFFFFFFFFFF:\r
1516 TopMemoryAddress = 0\r
1517 else:\r
1518 TopMemoryAddress = self.LoadFixAddress\r
1519 if TopMemoryAddress < RtSize + BtSize + PeiSize:\r
1520 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS is too low to load driver")\r
1521 # Make IPF runtime driver at 2 page alignment.\r
1522 if IsIpfPlatform:\r
1523 ReservedRuntimeMemorySize = TopMemoryAddress % 0x2000\r
1524 RtSize = RtSize + ReservedRuntimeMemorySize\r
1525\r
1526 #\r
1527 # Patch FixAddress related PCDs into EFI image\r
1528 #\r
4afd3d04 1529 for EfiImage in PatchEfiImageList:\r
52302d4d
LG		 1530 EfiImageMap = EfiImage.replace('.efi', '.map')\r
1531 if not os.path.exists(EfiImageMap):\r
1532 continue\r
1533 #\r
1534 # Get PCD offset in EFI image by GenPatchPcdTable function\r
1535 #\r
4afd3d04 1536 PcdTable = parsePcdInfoFromMapFile(EfiImageMap, EfiImage)\r
52302d4d
LG		 1537 #\r
1538 # Patch real PCD value by PatchPcdValue tool\r
1539 #\r
1540 for PcdInfo in PcdTable:\r
1541 ReturnValue = 0\r
1542 if PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE:\r
47fea6af 1543 ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_PEI_PAGE_SIZE_DATA_TYPE, str (PeiSize / 0x1000))\r
52302d4d 1544 elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE:\r
47fea6af 1545 ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_DXE_PAGE_SIZE_DATA_TYPE, str (BtSize / 0x1000))\r
52302d4d 1546 elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE:\r
47fea6af 1547 ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_RUNTIME_PAGE_SIZE_DATA_TYPE, str (RtSize / 0x1000))\r
52302d4d 1548 elif PcdInfo[0] == TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE and len (SmmModuleList) > 0:\r
47fea6af 1549 ReturnValue, ErrorInfo = PatchBinaryFile (EfiImage, PcdInfo[1], TAB_PCDS_PATCHABLE_LOAD_FIX_ADDRESS_SMM_PAGE_SIZE_DATA_TYPE, str (SmmSize / 0x1000))\r
52302d4d
LG		 1550 if ReturnValue != 0:\r
1551 EdkLogger.error("build", PARAMETER_INVALID, "Patch PCD value failed", ExtraData=ErrorInfo)\r
4afd3d04 1552\r
47fea6af
YZ		 1553 MapBuffer.write('PEI_CODE_PAGE_NUMBER = 0x%x\n' % (PeiSize / 0x1000))\r
1554 MapBuffer.write('BOOT_CODE_PAGE_NUMBER = 0x%x\n' % (BtSize / 0x1000))\r
1555 MapBuffer.write('RUNTIME_CODE_PAGE_NUMBER = 0x%x\n' % (RtSize / 0x1000))\r
52302d4d 1556 if len (SmmModuleList) > 0:\r
47fea6af 1557 MapBuffer.write('SMM_CODE_PAGE_NUMBER = 0x%x\n' % (SmmSize / 0x1000))\r
4afd3d04
LG		 1558\r
1559 PeiBaseAddr = TopMemoryAddress - RtSize - BtSize\r
52302d4d 1560 BtBaseAddr = TopMemoryAddress - RtSize\r
4afd3d04 1561 RtBaseAddr = TopMemoryAddress - ReservedRuntimeMemorySize\r
52302d4d
LG		 1562\r
1563 self._RebaseModule (MapBuffer, PeiBaseAddr, PeiModuleList, TopMemoryAddress == 0)\r
1564 self._RebaseModule (MapBuffer, BtBaseAddr, BtModuleList, TopMemoryAddress == 0)\r
1565 self._RebaseModule (MapBuffer, RtBaseAddr, RtModuleList, TopMemoryAddress == 0)\r
47fea6af 1566 self._RebaseModule (MapBuffer, 0x1000, SmmModuleList, AddrIsOffset=False, ModeIsSmm=True)\r
52302d4d 1567 MapBuffer.write('\n\n')\r
da92f276
LG		 1568 sys.stdout.write ("\n")\r
1569 sys.stdout.flush()\r
4afd3d04 1570\r
52302d4d
LG		 1571 ## Save platform Map file\r
1572 #\r
1573 def _SaveMapFile (self, MapBuffer, Wa):\r
1574 #\r
1575 # Map file path is got.\r
1576 #\r
1577 MapFilePath = os.path.join(Wa.BuildDir, Wa.Name + '.map')\r
1578 #\r
1579 # Save address map into MAP file.\r
1580 #\r
40d841f6 1581 SaveFileOnChange(MapFilePath, MapBuffer.getvalue(), False)\r
da92f276
LG		 1582 MapBuffer.close()\r
1583 if self.LoadFixAddress != 0:\r
47fea6af 1584 sys.stdout.write ("\nLoad Module At Fix Address Map file can be found at %s\n" % (MapFilePath))\r
da92f276 1585 sys.stdout.flush()\r
52302d4d
LG		 1586\r
1587 ## Build active platform for different build targets and different tool chains\r
1588 #\r
1589 def _BuildPlatform(self):\r
f0dc69e6 1590 SaveFileOnChange(self.PlatformBuildPath, '# DO NOT EDIT \n# FILE auto-generated\n', False)\r
52302d4d 1591 for BuildTarget in self.BuildTargetList:\r
0d2711a6 1592 GlobalData.gGlobalDefines['TARGET'] = BuildTarget\r
52302d4d 1593 for ToolChain in self.ToolChainList:\r
0d2711a6
LG		 1594 GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain\r
1595 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain\r
52302d4d
LG		 1596 Wa = WorkspaceAutoGen(\r
1597 self.WorkspaceDir,\r
0d2711a6 1598 self.PlatformFile,\r
52302d4d
LG		 1599 BuildTarget,\r
1600 ToolChain,\r
1601 self.ArchList,\r
1602 self.BuildDatabase,\r
1603 self.TargetTxt,\r
1604 self.ToolDef,\r
1605 self.Fdf,\r
1606 self.FdList,\r
1607 self.FvList,\r
4234283c 1608 self.CapList,\r
f3decdc3 1609 self.SkuId,\r
9508d0fa
LG		 1610 self.UniFlag,\r
1611 self.Progress\r
52302d4d 1612 )\r
0d2711a6
LG		 1613 self.Fdf = Wa.FdfFile\r
1614 self.LoadFixAddress = Wa.Platform.LoadFixAddress\r
52302d4d
LG		 1615 self.BuildReport.AddPlatformReport(Wa)\r
1616 self.Progress.Stop("done!")\r
03af2753
HC		 1617 for Arch in Wa.ArchList:\r
1618 GlobalData.gGlobalDefines['ARCH'] = Arch\r
1619 Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)\r
a0a2cd1e
FB		 1620 for Module in Pa.Platform.Modules:\r
1621 # Get ModuleAutoGen object to generate C code file and makefile\r
1622 Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)\r
1623 if Ma == None:\r
1624 continue\r
1625 self.BuildModules.append(Ma)\r
03af2753 1626 self._BuildPa(self.Target, Pa)\r
4afd3d04 1627\r
52302d4d 1628 # Create MAP file when Load Fix Address is enabled.\r
636f2be6 1629 if self.Target in ["", "all", "fds"]:\r
0d2711a6
LG		 1630 for Arch in Wa.ArchList:\r
1631 GlobalData.gGlobalDefines['ARCH'] = Arch\r
52302d4d
LG		 1632 #\r
1633 # Check whether the set fix address is above 4G for 32bit image.\r
1634 #\r
1635 if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:\r
0d2711a6 1636 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		 1637 #\r
1638 # Get Module List\r
1639 #\r
636f2be6 1640 ModuleList = {}\r
52302d4d
LG		 1641 for Pa in Wa.AutoGenObjectList:\r
1642 for Ma in Pa.ModuleAutoGenList:\r
1643 if Ma == None:\r
1644 continue\r
1645 if not Ma.IsLibrary:\r
636f2be6 1646 ModuleList[Ma.Guid.upper()] = Ma\r
52302d4d
LG		 1647\r
1648 MapBuffer = StringIO('')\r
636f2be6
LG		 1649 if self.LoadFixAddress != 0:\r
1650 #\r
1651 # Rebase module to the preferred memory address before GenFds\r
1652 #\r
1653 self._CollectModuleMapBuffer(MapBuffer, ModuleList)\r
0d2711a6 1654 if self.Fdf:\r
b0e23cf3
YL		 1655 #\r
1656 # create FDS again for the updated EFI image\r
1657 #\r
1658 self._Build("fds", Wa)\r
52302d4d
LG		 1659 #\r
1660 # Create MAP file for all platform FVs after GenFds.\r
1661 #\r
636f2be6 1662 self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)\r
52302d4d
LG		 1663 #\r
1664 # Save MAP buffer into MAP file.\r
1665 #\r
1666 self._SaveMapFile (MapBuffer, Wa)\r
1667\r
1668 ## Build active module for different build targets, different tool chains and different archs\r
1669 #\r
1670 def _BuildModule(self):\r
1671 for BuildTarget in self.BuildTargetList:\r
0d2711a6 1672 GlobalData.gGlobalDefines['TARGET'] = BuildTarget\r
52302d4d 1673 for ToolChain in self.ToolChainList:\r
0d2711a6 1674 GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain\r
4afd3d04 1675 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain\r
52302d4d
LG		 1676 #\r
1677 # module build needs platform build information, so get platform\r
1678 # AutoGen first\r
1679 #\r
1680 Wa = WorkspaceAutoGen(\r
1681 self.WorkspaceDir,\r
0d2711a6 1682 self.PlatformFile,\r
52302d4d
LG		 1683 BuildTarget,\r
1684 ToolChain,\r
1685 self.ArchList,\r
1686 self.BuildDatabase,\r
1687 self.TargetTxt,\r
1688 self.ToolDef,\r
1689 self.Fdf,\r
1690 self.FdList,\r
1691 self.FvList,\r
4234283c 1692 self.CapList,\r
f3decdc3 1693 self.SkuId,\r
9508d0fa
LG		 1694 self.UniFlag,\r
1695 self.Progress,\r
1696 self.ModuleFile\r
52302d4d 1697 )\r
0d2711a6
LG		 1698 self.Fdf = Wa.FdfFile\r
1699 self.LoadFixAddress = Wa.Platform.LoadFixAddress\r
52302d4d
LG		 1700 Wa.CreateMakeFile(False)\r
1701 self.Progress.Stop("done!")\r
1702 MaList = []\r
0d2711a6
LG		 1703 for Arch in Wa.ArchList:\r
1704 GlobalData.gGlobalDefines['ARCH'] = Arch\r
52302d4d
LG		 1705 Ma = ModuleAutoGen(Wa, self.ModuleFile, BuildTarget, ToolChain, Arch, self.PlatformFile)\r
1706 if Ma == None: continue\r
1707 MaList.append(Ma)\r
a0a2cd1e 1708 self.BuildModules.append(Ma)\r
03af2753
HC		 1709 if not Ma.IsBinaryModule:\r
1710 self._Build(self.Target, Ma, BuildModule=True)\r
d5d56f1b
LG		 1711\r
1712 self.BuildReport.AddPlatformReport(Wa, MaList)\r
52302d4d
LG		 1713 if MaList == []:\r
1714 EdkLogger.error(\r
1715 'build',\r
1716 BUILD_ERROR,\r
1717 "Module for [%s] is not a component of active platform."\\r
1718 " Please make sure that the ARCH and inf file path are"\\r
47fea6af 1719 " given in the same as in [%s]" % \\r
0d2711a6 1720 (', '.join(Wa.ArchList), self.PlatformFile),\r
52302d4d
LG		 1721 ExtraData=self.ModuleFile\r
1722 )\r
1723 # Create MAP file when Load Fix Address is enabled.\r
0d2711a6
LG		 1724 if self.Target == "fds" and self.Fdf:\r
1725 for Arch in Wa.ArchList:\r
52302d4d
LG		 1726 #\r
1727 # Check whether the set fix address is above 4G for 32bit image.\r
1728 #\r
1729 if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:\r
1730 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
1731 #\r
1732 # Get Module List\r
1733 #\r
636f2be6 1734 ModuleList = {}\r
52302d4d
LG		 1735 for Pa in Wa.AutoGenObjectList:\r
1736 for Ma in Pa.ModuleAutoGenList:\r
1737 if Ma == None:\r
1738 continue\r
1739 if not Ma.IsLibrary:\r
636f2be6 1740 ModuleList[Ma.Guid.upper()] = Ma\r
52302d4d
LG		 1741\r
1742 MapBuffer = StringIO('')\r
636f2be6
LG		 1743 if self.LoadFixAddress != 0:\r
1744 #\r
1745 # Rebase module to the preferred memory address before GenFds\r
1746 #\r
1747 self._CollectModuleMapBuffer(MapBuffer, ModuleList)\r
b0e23cf3
YL		 1748 #\r
1749 # create FDS again for the updated EFI image\r
1750 #\r
1751 self._Build("fds", Wa)\r
52302d4d
LG		 1752 #\r
1753 # Create MAP file for all platform FVs after GenFds.\r
1754 #\r
636f2be6 1755 self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)\r
52302d4d
LG		 1756 #\r
1757 # Save MAP buffer into MAP file.\r
1758 #\r
1759 self._SaveMapFile (MapBuffer, Wa)\r
1760\r
1761 ## Build a platform in multi-thread mode\r
1762 #\r
1763 def _MultiThreadBuildPlatform(self):\r
f0dc69e6 1764 SaveFileOnChange(self.PlatformBuildPath, '# DO NOT EDIT \n# FILE auto-generated\n', False)\r
52302d4d 1765 for BuildTarget in self.BuildTargetList:\r
0d2711a6 1766 GlobalData.gGlobalDefines['TARGET'] = BuildTarget\r
52302d4d 1767 for ToolChain in self.ToolChainList:\r
0d2711a6 1768 GlobalData.gGlobalDefines['TOOLCHAIN'] = ToolChain\r
4afd3d04 1769 GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = ToolChain\r
52302d4d
LG		 1770 Wa = WorkspaceAutoGen(\r
1771 self.WorkspaceDir,\r
0d2711a6 1772 self.PlatformFile,\r
52302d4d
LG		 1773 BuildTarget,\r
1774 ToolChain,\r
1775 self.ArchList,\r
1776 self.BuildDatabase,\r
1777 self.TargetTxt,\r
1778 self.ToolDef,\r
1779 self.Fdf,\r
1780 self.FdList,\r
1781 self.FvList,\r
4234283c 1782 self.CapList,\r
f3decdc3 1783 self.SkuId,\r
9508d0fa
LG		 1784 self.UniFlag,\r
1785 self.Progress\r
52302d4d 1786 )\r
0d2711a6
LG		 1787 self.Fdf = Wa.FdfFile\r
1788 self.LoadFixAddress = Wa.Platform.LoadFixAddress\r
52302d4d
LG		 1789 self.BuildReport.AddPlatformReport(Wa)\r
1790 Wa.CreateMakeFile(False)\r
1791\r
1792 # multi-thread exit flag\r
1793 ExitFlag = threading.Event()\r
1794 ExitFlag.clear()\r
0d2711a6
LG		 1795 for Arch in Wa.ArchList:\r
1796 GlobalData.gGlobalDefines['ARCH'] = Arch\r
52302d4d
LG		 1797 Pa = PlatformAutoGen(Wa, self.PlatformFile, BuildTarget, ToolChain, Arch)\r
1798 if Pa == None:\r
1799 continue\r
a0a2cd1e
FB		 1800 ModuleList = []\r
1801 for Inf in Pa.Platform.Modules:\r
1802 ModuleList.append(Inf)\r
1803 # Add the INF only list in FDF\r
1804 if GlobalData.gFdfParser != None:\r
1805 for InfName in GlobalData.gFdfParser.Profile.InfList:\r
1806 Inf = PathClass(NormPath(InfName), self.WorkspaceDir, Arch)\r
1807 if Inf in Pa.Platform.Modules:\r
1808 continue\r
1809 ModuleList.append(Inf)\r
1810 for Module in ModuleList:\r
52302d4d
LG		 1811 # Get ModuleAutoGen object to generate C code file and makefile\r
1812 Ma = ModuleAutoGen(Wa, Module, BuildTarget, ToolChain, Arch, self.PlatformFile)\r
a0a2cd1e 1813 \r
52302d4d
LG		 1814 if Ma == None:\r
1815 continue\r
1816 # Not to auto-gen for targets 'clean', 'cleanlib', 'cleanall', 'run', 'fds'\r
1817 if self.Target not in ['clean', 'cleanlib', 'cleanall', 'run', 'fds']:\r
1818 # for target which must generate AutoGen code and makefile\r
1819 if not self.SkipAutoGen or self.Target == 'genc':\r
1820 Ma.CreateCodeFile(True)\r
1821 if self.Target == "genc":\r
1822 continue\r
1823\r
1824 if not self.SkipAutoGen or self.Target == 'genmake':\r
1825 Ma.CreateMakeFile(True)\r
1826 if self.Target == "genmake":\r
1827 continue\r
a0a2cd1e 1828 self.BuildModules.append(Ma)\r
e8a47801 1829 self.Progress.Stop("done!")\r
4afd3d04 1830\r
a0a2cd1e 1831 for Ma in self.BuildModules:\r
52302d4d 1832 # Generate build task for the module\r
a0a2cd1e
FB		 1833 if not Ma.IsBinaryModule:\r
1834 Bt = BuildTask.New(ModuleMakeUnit(Ma, self.Target))\r
52302d4d
LG		 1835 # Break build if any build thread has error\r
1836 if BuildTask.HasError():\r
1837 # we need a full version of makefile for platform\r
1838 ExitFlag.set()\r
1839 BuildTask.WaitForComplete()\r
1840 Pa.CreateMakeFile(False)\r
1841 EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)\r
1842 # Start task scheduler\r
1843 if not BuildTask.IsOnGoing():\r
1844 BuildTask.StartScheduler(self.ThreadNumber, ExitFlag)\r
1845\r
1846 # in case there's an interruption. we need a full version of makefile for platform\r
1847 Pa.CreateMakeFile(False)\r
1848 if BuildTask.HasError():\r
1849 EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)\r
1850\r
64b2609f
LG		 1851 #\r
1852 # Save temp tables to a TmpTableDict.\r
1853 #\r
1854 for Key in Wa.BuildDatabase._CACHE_:\r
1855 if Wa.BuildDatabase._CACHE_[Key]._RawData and Wa.BuildDatabase._CACHE_[Key]._RawData._Table and Wa.BuildDatabase._CACHE_[Key]._RawData._Table.Table:\r
1856 if TemporaryTablePattern.match(Wa.BuildDatabase._CACHE_[Key]._RawData._Table.Table):\r
1857 TmpTableDict[Wa.BuildDatabase._CACHE_[Key]._RawData._Table.Table] = Wa.BuildDatabase._CACHE_[Key]._RawData._Table.Cur\r
1858 #\r
52302d4d
LG		 1859 #\r
1860 # All modules have been put in build tasks queue. Tell task scheduler\r
1861 # to exit if all tasks are completed\r
1862 #\r
1863 ExitFlag.set()\r
1864 BuildTask.WaitForComplete()\r
a0a2cd1e 1865 self.CreateAsBuiltInf()\r
52302d4d
LG		 1866\r
1867 #\r
1868 # Check for build error, and raise exception if one\r
1869 # has been signaled.\r
1870 #\r
1871 if BuildTask.HasError():\r
1872 EdkLogger.error("build", BUILD_ERROR, "Failed to build module", ExtraData=GlobalData.gBuildingModule)\r
1873\r
1874 # Create MAP file when Load Fix Address is enabled.\r
636f2be6 1875 if self.Target in ["", "all", "fds"]:\r
0d2711a6 1876 for Arch in Wa.ArchList:\r
52302d4d
LG		 1877 #\r
1878 # Check whether the set fix address is above 4G for 32bit image.\r
1879 #\r
1880 if (Arch == 'IA32' or Arch == 'ARM') and self.LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self.LoadFixAddress >= 0x100000000:\r
1881 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
1882 #\r
1883 # Get Module List\r
1884 #\r
636f2be6 1885 ModuleList = {}\r
52302d4d
LG		 1886 for Pa in Wa.AutoGenObjectList:\r
1887 for Ma in Pa.ModuleAutoGenList:\r
1888 if Ma == None:\r
1889 continue\r
1890 if not Ma.IsLibrary:\r
636f2be6 1891 ModuleList[Ma.Guid.upper()] = Ma\r
52302d4d
LG		 1892 #\r
1893 # Rebase module to the preferred memory address before GenFds\r
1894 #\r
1895 MapBuffer = StringIO('')\r
636f2be6
LG		 1896 if self.LoadFixAddress != 0:\r
1897 self._CollectModuleMapBuffer(MapBuffer, ModuleList)\r
52302d4d 1898\r
0d2711a6 1899 if self.Fdf:\r
f3decdc3
LG		 1900 #\r
1901 # Generate FD image if there's a FDF file found\r
1902 #\r
03af2753
HC		 1903 LaunchCommand(Wa.GenFdsCommand, os.getcwd())\r
1904\r
52302d4d
LG		 1905 #\r
1906 # Create MAP file for all platform FVs after GenFds.\r
1907 #\r
636f2be6 1908 self._CollectFvMapBuffer(MapBuffer, Wa, ModuleList)\r
52302d4d
LG		 1909 #\r
1910 # Save MAP buffer into MAP file.\r
1911 #\r
1912 self._SaveMapFile(MapBuffer, Wa)\r
1913\r
1914 ## Generate GuidedSectionTools.txt in the FV directories.\r
1915 #\r
1916 def CreateGuidedSectionToolsFile(self):\r
0d2711a6
LG		 1917 for BuildTarget in self.BuildTargetList:\r
1918 for ToolChain in self.ToolChainList:\r
1919 Wa = WorkspaceAutoGen(\r
1920 self.WorkspaceDir,\r
1921 self.PlatformFile,\r
1922 BuildTarget,\r
1923 ToolChain,\r
1924 self.ArchList,\r
1925 self.BuildDatabase,\r
1926 self.TargetTxt,\r
1927 self.ToolDef,\r
1928 self.Fdf,\r
1929 self.FdList,\r
1930 self.FvList,\r
1931 self.CapList,\r
1932 self.SkuId,\r
1933 self.UniFlag\r
1934 )\r
1935 FvDir = Wa.FvDir\r
1936 if not os.path.exists(FvDir):\r
1937 continue\r
1938\r
4afd3d04 1939 for Arch in self.ArchList:\r
52302d4d
LG		 1940 # Build up the list of supported architectures for this build\r
1941 prefix = '%s_%s_%s_' % (BuildTarget, ToolChain, Arch)\r
4afd3d04 1942\r
52302d4d
LG		 1943 # Look through the tool definitions for GUIDed tools\r
1944 guidAttribs = []\r
1945 for (attrib, value) in self.ToolDef.ToolsDefTxtDictionary.iteritems():\r
1946 if attrib.upper().endswith('_GUID'):\r
1947 split = attrib.split('_')\r
1948 thisPrefix = '_'.join(split[0:3]) + '_'\r
1949 if thisPrefix == prefix:\r
1950 guid = self.ToolDef.ToolsDefTxtDictionary[attrib]\r
1951 guid = guid.lower()\r
1952 toolName = split[3]\r
1953 path = '_'.join(split[0:4]) + '_PATH'\r
1954 path = self.ToolDef.ToolsDefTxtDictionary[path]\r
1955 path = self.GetFullPathOfTool(path)\r
1956 guidAttribs.append((guid, toolName, path))\r
4afd3d04 1957\r
52302d4d
LG		 1958 # Write out GuidedSecTools.txt\r
1959 toolsFile = os.path.join(FvDir, 'GuidedSectionTools.txt')\r
1960 toolsFile = open(toolsFile, 'wt')\r
1961 for guidedSectionTool in guidAttribs:\r
1962 print >> toolsFile, ' '.join(guidedSectionTool)\r
1963 toolsFile.close()\r
1964\r
1965 ## Returns the full path of the tool.\r
1966 #\r
1967 def GetFullPathOfTool (self, tool):\r
1968 if os.path.exists(tool):\r
1969 return os.path.realpath(tool)\r
1970 else:\r
1971 # We need to search for the tool using the\r
1972 # PATH environment variable.\r
1973 for dirInPath in os.environ['PATH'].split(os.pathsep):\r
1974 foundPath = os.path.join(dirInPath, tool)\r
1975 if os.path.exists(foundPath):\r
1976 return os.path.realpath(foundPath)\r
1977\r
1978 # If the tool was not found in the path then we just return\r
1979 # the input tool.\r
1980 return tool\r
1981\r
1982 ## Launch the module or platform build\r
1983 #\r
1984 def Launch(self):\r
0d2711a6 1985 if not self.ModuleFile:\r
52302d4d
LG		 1986 if not self.SpawnMode or self.Target not in ["", "all"]:\r
1987 self.SpawnMode = False\r
1988 self._BuildPlatform()\r
1989 else:\r
1990 self._MultiThreadBuildPlatform()\r
1991 self.CreateGuidedSectionToolsFile()\r
1992 else:\r
1993 self.SpawnMode = False\r
1994 self._BuildModule()\r
1995\r
bcbdc755
YL		 1996 if self.Target == 'cleanall':\r
1997 self.Db.Close()\r
1998 RemoveDirectory(os.path.dirname(GlobalData.gDatabasePath), True)\r
1999\r
a0a2cd1e
FB		 2000 def CreateAsBuiltInf(self):\r
2001 for Module in self.BuildModules:\r
2002 Module.CreateAsBuiltInf()\r
2003 self.BuildModules = []\r
52302d4d
LG		 2004 ## Do some clean-up works when error occurred\r
2005 def Relinquish(self):\r
2006 OldLogLevel = EdkLogger.GetLevel()\r
2007 EdkLogger.SetLevel(EdkLogger.ERROR)\r
2008 #self.DumpBuildData()\r
2009 Utils.Progressor.Abort()\r
2010 if self.SpawnMode == True:\r
2011 BuildTask.Abort()\r
2012 EdkLogger.SetLevel(OldLogLevel)\r
2013\r
2014 def DumpBuildData(self):\r
97fa0ee9 2015 CacheDirectory = os.path.dirname(GlobalData.gDatabasePath)\r
52302d4d
LG		 2016 Utils.CreateDirectory(CacheDirectory)\r
2017 Utils.DataDump(Utils.gFileTimeStampCache, os.path.join(CacheDirectory, "gFileTimeStampCache"))\r
2018 Utils.DataDump(Utils.gDependencyDatabase, os.path.join(CacheDirectory, "gDependencyDatabase"))\r
2019\r
2020 def RestoreBuildData(self):\r
97fa0ee9 2021 FilePath = os.path.join(os.path.dirname(GlobalData.gDatabasePath), "gFileTimeStampCache")\r
52302d4d
LG		 2022 if Utils.gFileTimeStampCache == {} and os.path.isfile(FilePath):\r
2023 Utils.gFileTimeStampCache = Utils.DataRestore(FilePath)\r
2024 if Utils.gFileTimeStampCache == None:\r
2025 Utils.gFileTimeStampCache = {}\r
2026\r
97fa0ee9 2027 FilePath = os.path.join(os.path.dirname(GlobalData.gDatabasePath), "gDependencyDatabase")\r
52302d4d
LG		 2028 if Utils.gDependencyDatabase == {} and os.path.isfile(FilePath):\r
2029 Utils.gDependencyDatabase = Utils.DataRestore(FilePath)\r
2030 if Utils.gDependencyDatabase == None:\r
2031 Utils.gDependencyDatabase = {}\r
2032\r
2033def ParseDefines(DefineList=[]):\r
2034 DefineDict = {}\r
2035 if DefineList != None:\r
2036 for Define in DefineList:\r
2037 DefineTokenList = Define.split("=", 1)\r
0d2711a6
LG		 2038 if not GlobalData.gMacroNamePattern.match(DefineTokenList[0]):\r
2039 EdkLogger.error('build', FORMAT_INVALID,\r
2040 "The macro name must be in the pattern [A-Z][A-Z0-9_]*",\r
2041 ExtraData=DefineTokenList[0])\r
4afd3d04 2042\r
52302d4d 2043 if len(DefineTokenList) == 1:\r
0d2711a6 2044 DefineDict[DefineTokenList[0]] = "TRUE"\r
52302d4d
LG		 2045 else:\r
2046 DefineDict[DefineTokenList[0]] = DefineTokenList[1].strip()\r
2047 return DefineDict\r
2048\r
2049gParamCheck = []\r
2050def SingleCheckCallback(option, opt_str, value, parser):\r
2051 if option not in gParamCheck:\r
2052 setattr(parser.values, option.dest, value)\r
2053 gParamCheck.append(option)\r
2054 else:\r
2055 parser.error("Option %s only allows one instance in command line!" % option)\r
2056\r
2057## Parse command line options\r
2058#\r
2059# Using standard Python module optparse to parse command line option of this tool.\r
2060#\r
2061# @retval Opt A optparse.Values object containing the parsed options\r
2062# @retval Args Target of build command\r
2063#\r
2064def MyOptionParser():\r
47fea6af
YZ		 2065 Parser = OptionParser(description=__copyright__, version=__version__, prog="build.exe", usage="%prog [options] [all|fds|genc|genmake|clean|cleanall|cleanlib|modules|libraries|run]")\r
2066 Parser.add_option("-a", "--arch", action="append", type="choice", choices=['IA32', 'X64', 'IPF', 'EBC', 'ARM', 'AARCH64'], dest="TargetArch",\r
4afd3d04 2067 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		 2068 Parser.add_option("-p", "--platform", action="callback", type="string", dest="PlatformFile", callback=SingleCheckCallback,\r
2069 help="Build the platform specified by the DSC file name argument, overriding target.txt's ACTIVE_PLATFORM definition.")\r
2070 Parser.add_option("-m", "--module", action="callback", type="string", dest="ModuleFile", callback=SingleCheckCallback,\r
2071 help="Build the module specified by the INF file name argument.")\r
64b2609f
LG		 2072 Parser.add_option("-b", "--buildtarget", type="string", dest="BuildTarget", help="Using the TARGET to build the platform, overriding target.txt's TARGET definition.",\r
2073 action="append")\r
52302d4d
LG		 2074 Parser.add_option("-t", "--tagname", action="append", type="string", dest="ToolChain",\r
2075 help="Using the Tool Chain Tagname to build the platform, overriding target.txt's TOOL_CHAIN_TAG definition.")\r
2076 Parser.add_option("-x", "--sku-id", action="callback", type="string", dest="SkuId", callback=SingleCheckCallback,\r
2077 help="Using this name of SKU ID to build the platform, overriding SKUID_IDENTIFIER in DSC file.")\r
2078\r
2079 Parser.add_option("-n", action="callback", type="int", dest="ThreadNumber", callback=SingleCheckCallback,\r
2080 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
2081\r
2082 Parser.add_option("-f", "--fdf", action="callback", type="string", dest="FdfFile", callback=SingleCheckCallback,\r
2083 help="The name of the FDF file to use, which overrides the setting in the DSC file.")\r
2084 Parser.add_option("-r", "--rom-image", action="append", type="string", dest="RomImage", default=[],\r
2085 help="The name of FD to be generated. The name must be from [FD] section in FDF file.")\r
2086 Parser.add_option("-i", "--fv-image", action="append", type="string", dest="FvImage", default=[],\r
2087 help="The name of FV to be generated. The name must be from [FV] section in FDF file.")\r
4234283c
LG		 2088 Parser.add_option("-C", "--capsule-image", action="append", type="string", dest="CapName", default=[],\r
2089 help="The name of Capsule to be generated. The name must be from [Capsule] section in FDF file.")\r
52302d4d
LG		 2090 Parser.add_option("-u", "--skip-autogen", action="store_true", dest="SkipAutoGen", help="Skip AutoGen step.")\r
2091 Parser.add_option("-e", "--re-parse", action="store_true", dest="Reparse", help="Re-parse all meta-data files.")\r
2092\r
0d2711a6 2093 Parser.add_option("-c", "--case-insensitive", action="store_true", dest="CaseInsensitive", default=False, help="Don't check case of file name.")\r
52302d4d
LG		 2094\r
2095 Parser.add_option("-w", "--warning-as-error", action="store_true", dest="WarningAsError", help="Treat warning in tools as error.")\r
2096 Parser.add_option("-j", "--log", action="store", dest="LogFile", help="Put log in specified file as well as on console.")\r
2097\r
2098 Parser.add_option("-s", "--silent", action="store_true", type=None, dest="SilentMode",\r
2099 help="Make use of silent mode of (n)make.")\r
2100 Parser.add_option("-q", "--quiet", action="store_true", type=None, help="Disable all messages except FATAL ERRORS.")\r
2101 Parser.add_option("-v", "--verbose", action="store_true", type=None, help="Turn on verbose output with informational messages printed, "\\r
2102 "including library instances selected, final dependency expression, "\\r
2103 "and warning messages, etc.")\r
2104 Parser.add_option("-d", "--debug", action="store", type="int", help="Enable debug messages at specified level.")\r
2105 Parser.add_option("-D", "--define", action="append", type="string", dest="Macros", help="Macro: \"Name [= Value]\".")\r
2106\r
2107 Parser.add_option("-y", "--report-file", action="store", dest="ReportFile", help="Create/overwrite the report to the specified filename.")\r
47fea6af 2108 Parser.add_option("-Y", "--report-type", action="append", type="choice", choices=['PCD', 'LIBRARY', 'FLASH', 'DEPEX', 'BUILD_FLAGS', 'FIXED_ADDRESS', 'EXECUTION_ORDER'], dest="ReportType", default=[],\r
52302d4d
LG		 2109 help="Flags that control the type of build report to generate. Must be one of: [PCD, LIBRARY, FLASH, DEPEX, BUILD_FLAGS, FIXED_ADDRESS, EXECUTION_ORDER]. "\\r
2110 "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		 2111 Parser.add_option("-F", "--flag", action="store", type="string", dest="Flag",\r
2112 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
2113 "This option can also be specified by setting *_*_*_BUILD_FLAGS in [BuildOptions] section of platform DSC. If they are both specified, this value "\\r
2114 "will override the setting in [BuildOptions] section of platform DSC.")\r
0d2711a6 2115 Parser.add_option("-N", "--no-cache", action="store_true", dest="DisableCache", default=False, help="Disable build cache mechanism")\r
97fa0ee9
YL		 2116 Parser.add_option("--conf", action="store", type="string", dest="ConfDirectory", help="Specify the customized Conf directory.")\r
2117 Parser.add_option("--check-usage", action="store_true", dest="CheckUsage", default=False, help="Check usage content of entries listed in INF file.")\r
fae62ff2 2118 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 2119 Parser.add_option("--pcd", action="append", dest="OptionPcd", help="Set PCD value by command line. Format: \"PcdName=Value\" ")\r
725cdb8f 2120 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 2121\r
47fea6af 2122 (Opt, Args) = Parser.parse_args()\r
52302d4d
LG		 2123 return (Opt, Args)\r
2124\r
2125## Tool entrance method\r
2126#\r
2127# This method mainly dispatch specific methods per the command line options.\r
2128# If no error found, return zero value so the caller of this tool can know\r
2129# if it's executed successfully or not.\r
2130#\r
2131# @retval 0 Tool was successful\r
2132# @retval 1 Tool failed\r
2133#\r
2134def Main():\r
2135 StartTime = time.time()\r
2136\r
2137 # Initialize log system\r
2138 EdkLogger.Initialize()\r
f0dc69e6 2139 GlobalData.gCommand = sys.argv[1:]\r
52302d4d
LG		 2140 #\r
2141 # Parse the options and args\r
2142 #\r
2143 (Option, Target) = MyOptionParser()\r
2144 GlobalData.gOptions = Option\r
2145 GlobalData.gCaseInsensitive = Option.CaseInsensitive\r
2146\r
2147 # Set log level\r
2148 if Option.verbose != None:\r
2149 EdkLogger.SetLevel(EdkLogger.VERBOSE)\r
2150 elif Option.quiet != None:\r
2151 EdkLogger.SetLevel(EdkLogger.QUIET)\r
2152 elif Option.debug != None:\r
2153 EdkLogger.SetLevel(Option.debug + 1)\r
2154 else:\r
2155 EdkLogger.SetLevel(EdkLogger.INFO)\r
2156\r
2157 if Option.LogFile != None:\r
2158 EdkLogger.SetLogFile(Option.LogFile)\r
2159\r
2160 if Option.WarningAsError == True:\r
2161 EdkLogger.SetWarningAsError()\r
2162\r
2163 if platform.platform().find("Windows") >= 0:\r
2164 GlobalData.gIsWindows = True\r
2165 else:\r
2166 GlobalData.gIsWindows = False\r
2167\r
6780eef1
LG		 2168 EdkLogger.quiet("Build environment: %s" % platform.platform())\r
2169 EdkLogger.quiet(time.strftime("Build start time: %H:%M:%S, %b.%d %Y\n", time.localtime()));\r
52302d4d
LG		 2170 ReturnCode = 0\r
2171 MyBuild = None\r
09ae0f11 2172 BuildError = True\r
52302d4d
LG		 2173 try:\r
2174 if len(Target) == 0:\r
2175 Target = "all"\r
2176 elif len(Target) >= 2:\r
2177 EdkLogger.error("build", OPTION_NOT_SUPPORTED, "More than one targets are not supported.",\r
47fea6af 2178 ExtraData="Please select one of: %s" % (' '.join(gSupportedTarget)))\r
52302d4d
LG		 2179 else:\r
2180 Target = Target[0].lower()\r
2181\r
2182 if Target not in gSupportedTarget:\r
2183 EdkLogger.error("build", OPTION_NOT_SUPPORTED, "Not supported target [%s]." % Target,\r
47fea6af 2184 ExtraData="Please select one of: %s" % (' '.join(gSupportedTarget)))\r
52302d4d 2185\r
52302d4d
LG		 2186 #\r
2187 # Check environment variable: EDK_TOOLS_PATH, WORKSPACE, PATH\r
2188 #\r
2189 CheckEnvVariable()\r
0d2711a6
LG		 2190 GlobalData.gCommandLineDefines.update(ParseDefines(Option.Macros))\r
2191\r
52302d4d
LG		 2192 Workspace = os.getenv("WORKSPACE")\r
2193 #\r
2194 # Get files real name in workspace dir\r
2195 #\r
2196 GlobalData.gAllFiles = Utils.DirCache(Workspace)\r
2197\r
2198 WorkingDirectory = os.getcwd()\r
2199 if not Option.ModuleFile:\r
2200 FileList = glob.glob(os.path.normpath(os.path.join(WorkingDirectory, '*.inf')))\r
2201 FileNum = len(FileList)\r
2202 if FileNum >= 2:\r
2203 EdkLogger.error("build", OPTION_NOT_SUPPORTED, "There are %d INF files in %s." % (FileNum, WorkingDirectory),\r
2204 ExtraData="Please use '-m <INF_FILE_PATH>' switch to choose one.")\r
2205 elif FileNum == 1:\r
2206 Option.ModuleFile = NormFile(FileList[0], Workspace)\r
2207\r
2208 if Option.ModuleFile:\r
2209 if os.path.isabs (Option.ModuleFile):\r
2210 if os.path.normcase (os.path.normpath(Option.ModuleFile)).find (Workspace) == 0:\r
2211 Option.ModuleFile = NormFile(os.path.normpath(Option.ModuleFile), Workspace)\r
2212 Option.ModuleFile = PathClass(Option.ModuleFile, Workspace)\r
2213 ErrorCode, ErrorInfo = Option.ModuleFile.Validate(".inf", False)\r
2214 if ErrorCode != 0:\r
2215 EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)\r
2216\r
2217 if Option.PlatformFile != None:\r
2218 if os.path.isabs (Option.PlatformFile):\r
2219 if os.path.normcase (os.path.normpath(Option.PlatformFile)).find (Workspace) == 0:\r
2220 Option.PlatformFile = NormFile(os.path.normpath(Option.PlatformFile), Workspace)\r
2221 Option.PlatformFile = PathClass(Option.PlatformFile, Workspace)\r
52302d4d
LG		 2222\r
2223 if Option.FdfFile != None:\r
2224 if os.path.isabs (Option.FdfFile):\r
2225 if os.path.normcase (os.path.normpath(Option.FdfFile)).find (Workspace) == 0:\r
2226 Option.FdfFile = NormFile(os.path.normpath(Option.FdfFile), Workspace)\r
2227 Option.FdfFile = PathClass(Option.FdfFile, Workspace)\r
2228 ErrorCode, ErrorInfo = Option.FdfFile.Validate(".fdf", False)\r
2229 if ErrorCode != 0:\r
2230 EdkLogger.error("build", ErrorCode, ExtraData=ErrorInfo)\r
2231\r
f3decdc3
LG		 2232 if Option.Flag != None and Option.Flag not in ['-c', '-s']:\r
2233 EdkLogger.error("build", OPTION_VALUE_INVALID, "UNI flag must be one of -c or -s")\r
2234\r
0d2711a6 2235 MyBuild = Build(Target, Workspace, Option)\r
64b2609f 2236 GlobalData.gCommandLineDefines['ARCH'] = ' '.join(MyBuild.ArchList)\r
f0dc69e6
YZ		 2237 if not (MyBuild.LaunchPrebuildFlag and os.path.exists(MyBuild.PlatformBuildPath)):\r
2238 MyBuild.Launch()\r
64b2609f
LG		 2239 # Drop temp tables to avoid database locked.\r
2240 for TmpTableName in TmpTableDict:\r
2241 SqlCommand = """drop table IF EXISTS %s""" % TmpTableName\r
2242 TmpTableDict[TmpTableName].execute(SqlCommand)\r
52302d4d 2243 #MyBuild.DumpBuildData()\r
09ae0f11
YL		 2244 #\r
2245 # All job done, no error found and no exception raised\r
2246 #\r
2247 BuildError = False\r
52302d4d
LG		 2248 except FatalError, X:\r
2249 if MyBuild != None:\r
2250 # for multi-thread build exits safely\r
2251 MyBuild.Relinquish()\r
2252 if Option != None and Option.debug != None:\r
2253 EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())\r
2254 ReturnCode = X.args[0]\r
2255 except Warning, X:\r
2256 # error from Fdf parser\r
2257 if MyBuild != None:\r
2258 # for multi-thread build exits safely\r
2259 MyBuild.Relinquish()\r
2260 if Option != None and Option.debug != None:\r
2261 EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())\r
2262 else:\r
47fea6af 2263 EdkLogger.error(X.ToolName, FORMAT_INVALID, File=X.FileName, Line=X.LineNumber, ExtraData=X.Message, RaiseError=False)\r
52302d4d
LG		 2264 ReturnCode = FORMAT_INVALID\r
2265 except KeyboardInterrupt:\r
2266 ReturnCode = ABORT_ERROR\r
2267 if Option != None and Option.debug != None:\r
2268 EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())\r
2269 except:\r
2270 if MyBuild != None:\r
2271 # for multi-thread build exits safely\r
2272 MyBuild.Relinquish()\r
2273\r
2274 # try to get the meta-file from the object causing exception\r
2275 Tb = sys.exc_info()[-1]\r
2276 MetaFile = GlobalData.gProcessingFile\r
2277 while Tb != None:\r
2278 if 'self' in Tb.tb_frame.f_locals and hasattr(Tb.tb_frame.f_locals['self'], 'MetaFile'):\r
2279 MetaFile = Tb.tb_frame.f_locals['self'].MetaFile\r
2280 Tb = Tb.tb_next\r
2281 EdkLogger.error(\r
2282 "\nbuild",\r
2283 CODE_ERROR,\r
2284 "Unknown fatal error when processing [%s]" % MetaFile,\r
3a0f8bde 2285 ExtraData="\n(Please send email to edk2-devel@lists.01.org for help, attaching following call stack trace!)\n",\r
52302d4d
LG		 2286 RaiseError=False\r
2287 )\r
d0acc87a 2288 EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc())\r
52302d4d
LG		 2289 ReturnCode = CODE_ERROR\r
2290 finally:\r
2291 Utils.Progressor.Abort()\r
97fa0ee9 2292 Utils.ClearDuplicatedInf()\r
52302d4d
LG		 2293\r
2294 if ReturnCode == 0:\r
f0dc69e6
YZ		 2295 try:\r
2296 MyBuild.LanuchPostbuild()\r
2297 Conclusion = "Done"\r
2298 except:\r
2299 Conclusion = "Failed"\r
52302d4d
LG		 2300 elif ReturnCode == ABORT_ERROR:\r
2301 Conclusion = "Aborted"\r
2302 else:\r
2303 Conclusion = "Failed"\r
2304 FinishTime = time.time()\r
4234283c
LG		 2305 BuildDuration = time.gmtime(int(round(FinishTime - StartTime)))\r
2306 BuildDurationStr = ""\r
2307 if BuildDuration.tm_yday > 1:\r
47fea6af 2308 BuildDurationStr = time.strftime("%H:%M:%S", BuildDuration) + ", %d day(s)" % (BuildDuration.tm_yday - 1)\r
4234283c
LG		 2309 else:\r
2310 BuildDurationStr = time.strftime("%H:%M:%S", BuildDuration)\r
52302d4d 2311 if MyBuild != None:\r
09ae0f11
YL		 2312 if not BuildError:\r
2313 MyBuild.BuildReport.GenerateReport(BuildDurationStr)\r
52302d4d
LG		 2314 MyBuild.Db.Close()\r
2315 EdkLogger.SetLevel(EdkLogger.QUIET)\r
6780eef1
LG		 2316 EdkLogger.quiet("\n- %s -" % Conclusion)\r
2317 EdkLogger.quiet(time.strftime("Build end time: %H:%M:%S, %b.%d %Y", time.localtime()))\r
4234283c 2318 EdkLogger.quiet("Build total time: %s\n" % BuildDurationStr)\r
52302d4d
LG		 2319 return ReturnCode\r
2320\r
2321if __name__ == '__main__':\r
2322 r = Main()\r
2323 ## 0-127 is a safe return range, and 1 is a standard default error\r
2324 if r < 0 or r > 127: r = 1\r
2325 sys.exit(r)\r
2326\r
EFI Development Kit II mirror for PVE