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