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