]> git.karo-electronics.de Git - karo-tx-uboot.git/blob - tools/buildman/toolchain.py
update to 2015.04-rc1
[karo-tx-uboot.git] / tools / buildman / toolchain.py
1 # Copyright (c) 2012 The Chromium OS Authors.
2 #
3 # SPDX-License-Identifier:      GPL-2.0+
4 #
5
6 import re
7 import glob
8 from HTMLParser import HTMLParser
9 import os
10 import sys
11 import tempfile
12 import urllib2
13
14 import bsettings
15 import command
16
17 # Simple class to collect links from a page
18 class MyHTMLParser(HTMLParser):
19     def __init__(self, arch):
20         """Create a new parser
21
22         After the parser runs, self.links will be set to a list of the links
23         to .xz archives found in the page, and self.arch_link will be set to
24         the one for the given architecture (or None if not found).
25
26         Args:
27             arch: Architecture to search for
28         """
29         HTMLParser.__init__(self)
30         self.arch_link = None
31         self.links = []
32         self._match = '_%s-' % arch
33
34     def handle_starttag(self, tag, attrs):
35         if tag == 'a':
36             for tag, value in attrs:
37                 if tag == 'href':
38                     if value and value.endswith('.xz'):
39                         self.links.append(value)
40                         if self._match in value:
41                             self.arch_link = value
42
43
44 class Toolchain:
45     """A single toolchain
46
47     Public members:
48         gcc: Full path to C compiler
49         path: Directory path containing C compiler
50         cross: Cross compile string, e.g. 'arm-linux-'
51         arch: Architecture of toolchain as determined from the first
52                 component of the filename. E.g. arm-linux-gcc becomes arm
53     """
54     def __init__(self, fname, test, verbose=False):
55         """Create a new toolchain object.
56
57         Args:
58             fname: Filename of the gcc component
59             test: True to run the toolchain to test it
60         """
61         self.gcc = fname
62         self.path = os.path.dirname(fname)
63
64         # Find the CROSS_COMPILE prefix to use for U-Boot. For example,
65         # 'arm-linux-gnueabihf-gcc' turns into 'arm-linux-gnueabihf-'.
66         basename = os.path.basename(fname)
67         pos = basename.rfind('-')
68         self.cross = basename[:pos + 1] if pos != -1 else ''
69
70         # The architecture is the first part of the name
71         pos = self.cross.find('-')
72         self.arch = self.cross[:pos] if pos != -1 else 'sandbox'
73
74         env = self.MakeEnvironment(False)
75
76         # As a basic sanity check, run the C compiler with --version
77         cmd = [fname, '--version']
78         if test:
79             result = command.RunPipe([cmd], capture=True, env=env,
80                                      raise_on_error=False)
81             self.ok = result.return_code == 0
82             if verbose:
83                 print 'Tool chain test: ',
84                 if self.ok:
85                     print 'OK'
86                 else:
87                     print 'BAD'
88                     print 'Command: ', cmd
89                     print result.stdout
90                     print result.stderr
91         else:
92             self.ok = True
93         self.priority = self.GetPriority(fname)
94
95     def GetPriority(self, fname):
96         """Return the priority of the toolchain.
97
98         Toolchains are ranked according to their suitability by their
99         filename prefix.
100
101         Args:
102             fname: Filename of toolchain
103         Returns:
104             Priority of toolchain, 0=highest, 20=lowest.
105         """
106         priority_list = ['-elf', '-unknown-linux-gnu', '-linux',
107             '-none-linux-gnueabi', '-uclinux', '-none-eabi',
108             '-gentoo-linux-gnu', '-linux-gnueabi', '-le-linux', '-uclinux']
109         for prio in range(len(priority_list)):
110             if priority_list[prio] in fname:
111                 return prio
112         return prio
113
114     def MakeEnvironment(self, full_path):
115         """Returns an environment for using the toolchain.
116
117         Thie takes the current environment and adds CROSS_COMPILE so that
118         the tool chain will operate correctly.
119
120         Args:
121             full_path: Return the full path in CROSS_COMPILE and don't set
122                 PATH
123         """
124         env = dict(os.environ)
125         if full_path:
126             env['CROSS_COMPILE'] = os.path.join(self.path, self.cross)
127         else:
128             env['CROSS_COMPILE'] = self.cross
129             env['PATH'] = self.path + ':' + env['PATH']
130
131         return env
132
133
134 class Toolchains:
135     """Manage a list of toolchains for building U-Boot
136
137     We select one toolchain for each architecture type
138
139     Public members:
140         toolchains: Dict of Toolchain objects, keyed by architecture name
141         paths: List of paths to check for toolchains (may contain wildcards)
142     """
143
144     def __init__(self):
145         self.toolchains = {}
146         self.paths = []
147         self._make_flags = dict(bsettings.GetItems('make-flags'))
148
149     def GetPathList(self):
150         """Get a list of available toolchain paths
151
152         Returns:
153             List of strings, each a path to a toolchain mentioned in the
154             [toolchain] section of the settings file.
155         """
156         toolchains = bsettings.GetItems('toolchain')
157         if not toolchains:
158             print ("Warning: No tool chains - please add a [toolchain] section"
159                  " to your buildman config file %s. See README for details" %
160                  bsettings.config_fname)
161
162         paths = []
163         for name, value in toolchains:
164             if '*' in value:
165                 paths += glob.glob(value)
166             else:
167                 paths.append(value)
168         return paths
169
170     def GetSettings(self):
171       self.paths += self.GetPathList()
172
173     def Add(self, fname, test=True, verbose=False):
174         """Add a toolchain to our list
175
176         We select the given toolchain as our preferred one for its
177         architecture if it is a higher priority than the others.
178
179         Args:
180             fname: Filename of toolchain's gcc driver
181             test: True to run the toolchain to test it
182         """
183         toolchain = Toolchain(fname, test, verbose)
184         add_it = toolchain.ok
185         if toolchain.arch in self.toolchains:
186             add_it = (toolchain.priority <
187                         self.toolchains[toolchain.arch].priority)
188         if add_it:
189             self.toolchains[toolchain.arch] = toolchain
190
191     def ScanPath(self, path, verbose):
192         """Scan a path for a valid toolchain
193
194         Args:
195             path: Path to scan
196             verbose: True to print out progress information
197         Returns:
198             Filename of C compiler if found, else None
199         """
200         for subdir in ['.', 'bin', 'usr/bin']:
201             dirname = os.path.join(path, subdir)
202             if verbose: print "      - looking in '%s'" % dirname
203             for fname in glob.glob(dirname + '/*gcc'):
204                 if verbose: print "         - found '%s'" % fname
205                 return fname
206         return None
207
208
209     def Scan(self, verbose):
210         """Scan for available toolchains and select the best for each arch.
211
212         We look for all the toolchains we can file, figure out the
213         architecture for each, and whether it works. Then we select the
214         highest priority toolchain for each arch.
215
216         Args:
217             verbose: True to print out progress information
218         """
219         if verbose: print 'Scanning for tool chains'
220         for path in self.paths:
221             if verbose: print "   - scanning path '%s'" % path
222             fname = self.ScanPath(path, verbose)
223             if fname:
224                 self.Add(fname, True, verbose)
225
226     def List(self):
227         """List out the selected toolchains for each architecture"""
228         print 'List of available toolchains (%d):' % len(self.toolchains)
229         if len(self.toolchains):
230             for key, value in sorted(self.toolchains.iteritems()):
231                 print '%-10s: %s' % (key, value.gcc)
232         else:
233             print 'None'
234
235     def Select(self, arch):
236         """Returns the toolchain for a given architecture
237
238         Args:
239             args: Name of architecture (e.g. 'arm', 'ppc_8xx')
240
241         returns:
242             toolchain object, or None if none found
243         """
244         for tag, value in bsettings.GetItems('toolchain-alias'):
245             if arch == tag:
246                 for alias in value.split():
247                     if alias in self.toolchains:
248                         return self.toolchains[alias]
249
250         if not arch in self.toolchains:
251             raise ValueError, ("No tool chain found for arch '%s'" % arch)
252         return self.toolchains[arch]
253
254     def ResolveReferences(self, var_dict, args):
255         """Resolve variable references in a string
256
257         This converts ${blah} within the string to the value of blah.
258         This function works recursively.
259
260         Args:
261             var_dict: Dictionary containing variables and their values
262             args: String containing make arguments
263         Returns:
264             Resolved string
265
266         >>> bsettings.Setup()
267         >>> tcs = Toolchains()
268         >>> tcs.Add('fred', False)
269         >>> var_dict = {'oblique' : 'OBLIQUE', 'first' : 'fi${second}rst', \
270                         'second' : '2nd'}
271         >>> tcs.ResolveReferences(var_dict, 'this=${oblique}_set')
272         'this=OBLIQUE_set'
273         >>> tcs.ResolveReferences(var_dict, 'this=${oblique}_set${first}nd')
274         'this=OBLIQUE_setfi2ndrstnd'
275         """
276         re_var = re.compile('(\$\{[-_a-z0-9A-Z]{1,}\})')
277
278         while True:
279             m = re_var.search(args)
280             if not m:
281                 break
282             lookup = m.group(0)[2:-1]
283             value = var_dict.get(lookup, '')
284             args = args[:m.start(0)] + value + args[m.end(0):]
285         return args
286
287     def GetMakeArguments(self, board):
288         """Returns 'make' arguments for a given board
289
290         The flags are in a section called 'make-flags'. Flags are named
291         after the target they represent, for example snapper9260=TESTING=1
292         will pass TESTING=1 to make when building the snapper9260 board.
293
294         References to other boards can be added in the string also. For
295         example:
296
297         [make-flags]
298         at91-boards=ENABLE_AT91_TEST=1
299         snapper9260=${at91-boards} BUILD_TAG=442
300         snapper9g45=${at91-boards} BUILD_TAG=443
301
302         This will return 'ENABLE_AT91_TEST=1 BUILD_TAG=442' for snapper9260
303         and 'ENABLE_AT91_TEST=1 BUILD_TAG=443' for snapper9g45.
304
305         A special 'target' variable is set to the board target.
306
307         Args:
308             board: Board object for the board to check.
309         Returns:
310             'make' flags for that board, or '' if none
311         """
312         self._make_flags['target'] = board.target
313         arg_str = self.ResolveReferences(self._make_flags,
314                            self._make_flags.get(board.target, ''))
315         args = arg_str.split(' ')
316         i = 0
317         while i < len(args):
318             if not args[i]:
319                 del args[i]
320             else:
321                 i += 1
322         return args
323
324     def LocateArchUrl(self, fetch_arch):
325         """Find a toolchain available online
326
327         Look in standard places for available toolchains. At present the
328         only standard place is at kernel.org.
329
330         Args:
331             arch: Architecture to look for, or 'list' for all
332         Returns:
333             If fetch_arch is 'list', a tuple:
334                 Machine architecture (e.g. x86_64)
335                 List of toolchains
336             else
337                 URL containing this toolchain, if avaialble, else None
338         """
339         arch = command.OutputOneLine('uname', '-m')
340         base = 'https://www.kernel.org/pub/tools/crosstool/files/bin'
341         versions = ['4.6.3', '4.6.2', '4.5.1', '4.2.4']
342         links = []
343         for version in versions:
344             url = '%s/%s/%s/' % (base, arch, version)
345             print 'Checking: %s' % url
346             response = urllib2.urlopen(url)
347             html = response.read()
348             parser = MyHTMLParser(fetch_arch)
349             parser.feed(html)
350             if fetch_arch == 'list':
351                 links += parser.links
352             elif parser.arch_link:
353                 return url + parser.arch_link
354         if fetch_arch == 'list':
355             return arch, links
356         return None
357
358     def Download(self, url):
359         """Download a file to a temporary directory
360
361         Args:
362             url: URL to download
363         Returns:
364             Tuple:
365                 Temporary directory name
366                 Full path to the downloaded archive file in that directory,
367                     or None if there was an error while downloading
368         """
369         print "Downloading: %s" % url
370         leaf = url.split('/')[-1]
371         tmpdir = tempfile.mkdtemp('.buildman')
372         response = urllib2.urlopen(url)
373         fname = os.path.join(tmpdir, leaf)
374         fd = open(fname, 'wb')
375         meta = response.info()
376         size = int(meta.getheaders("Content-Length")[0])
377         done = 0
378         block_size = 1 << 16
379         status = ''
380
381         # Read the file in chunks and show progress as we go
382         while True:
383             buffer = response.read(block_size)
384             if not buffer:
385                 print chr(8) * (len(status) + 1), '\r',
386                 break
387
388             done += len(buffer)
389             fd.write(buffer)
390             status = r"%10d MiB  [%3d%%]" % (done / 1024 / 1024,
391                                              done * 100 / size)
392             status = status + chr(8) * (len(status) + 1)
393             print status,
394             sys.stdout.flush()
395         fd.close()
396         if done != size:
397             print 'Error, failed to download'
398             os.remove(fname)
399             fname = None
400         return tmpdir, fname
401
402     def Unpack(self, fname, dest):
403         """Unpack a tar file
404
405         Args:
406             fname: Filename to unpack
407             dest: Destination directory
408         Returns:
409             Directory name of the first entry in the archive, without the
410             trailing /
411         """
412         stdout = command.Output('tar', 'xvfJ', fname, '-C', dest)
413         return stdout.splitlines()[0][:-1]
414
415     def TestSettingsHasPath(self, path):
416         """Check if builmand will find this toolchain
417
418         Returns:
419             True if the path is in settings, False if not
420         """
421         paths = self.GetPathList()
422         return path in paths
423
424     def ListArchs(self):
425         """List architectures with available toolchains to download"""
426         host_arch, archives = self.LocateArchUrl('list')
427         re_arch = re.compile('[-a-z0-9.]*_([^-]*)-.*')
428         arch_set = set()
429         for archive in archives:
430             # Remove the host architecture from the start
431             arch = re_arch.match(archive[len(host_arch):])
432             if arch:
433                 arch_set.add(arch.group(1))
434         return sorted(arch_set)
435
436     def FetchAndInstall(self, arch):
437         """Fetch and install a new toolchain
438
439         arch:
440             Architecture to fetch, or 'list' to list
441         """
442         # Fist get the URL for this architecture
443         url = self.LocateArchUrl(arch)
444         if not url:
445             print ("Cannot find toolchain for arch '%s' - use 'list' to list" %
446                    arch)
447             return 2
448         home = os.environ['HOME']
449         dest = os.path.join(home, '.buildman-toolchains')
450         if not os.path.exists(dest):
451             os.mkdir(dest)
452
453         # Download the tar file for this toolchain and unpack it
454         tmpdir, tarfile = self.Download(url)
455         if not tarfile:
456             return 1
457         print 'Unpacking to: %s' % dest,
458         sys.stdout.flush()
459         path = self.Unpack(tarfile, dest)
460         os.remove(tarfile)
461         os.rmdir(tmpdir)
462         print
463
464         # Check that the toolchain works
465         print 'Testing'
466         dirpath = os.path.join(dest, path)
467         compiler_fname = self.ScanPath(dirpath, True)
468         if not compiler_fname:
469             print 'Could not locate C compiler - fetch failed.'
470             return 1
471         toolchain = Toolchain(compiler_fname, True, True)
472
473         # Make sure that it will be found by buildman
474         if not self.TestSettingsHasPath(dirpath):
475             print ("Adding 'download' to config file '%s'" %
476                    bsettings.config_fname)
477             tools_dir = os.path.dirname(dirpath)
478             bsettings.SetItem('toolchain', 'download', '%s/*' % tools_dir)
479         return 0