source: rtems-libbsd/builder.py @ cf9836e

55-freebsd-126-freebsd-12freebsd-9.3
Last change on this file since cf9836e was c689915, checked in by Sebastian Huber <sebastian.huber@…>, on 11/12/15 at 12:12:22

Use optimization level -O2
  • Property mode set to 100755
File size: 19.0 KB
Line 
1#
2#  Copyright (c) 2015 Chris Johns <chrisj@rtems.org>. All rights reserved.
3#
4#  Copyright (c) 2009-2015 embedded brains GmbH.  All rights reserved.
5#
6#   embedded brains GmbH
7#   Dornierstr. 4
8#   82178 Puchheim
9#   Germany
10#   <info@embedded-brains.de>
11#
12#  Copyright (c) 2012 OAR Corporation. All rights reserved.
13#
14#  Redistribution and use in source and binary forms, with or without
15#  modification, are permitted provided that the following conditions
16#  are met:
17#  1. Redistributions of source code must retain the above copyright
18#     notice, this list of conditions and the following disclaimer.
19#  2. Redistributions in binary form must reproduce the above copyright
20#     notice, this list of conditions and the following disclaimer in the
21#     documentation and/or other materials provided with the distribution.
22#
23#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24#  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25#  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26#  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27#  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28#  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
29#  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30#  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31#  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32#  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
33#  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34
35# FreeBSD: http://svn.freebsd.org/base/releng/8.2/sys (revision 222485)
36
37import shutil
38import os
39import re
40import sys
41import getopt
42import filecmp
43import difflib
44
45#
46# Global controls.
47#
48RTEMS_DIR = "."
49FreeBSD_DIR = "freebsd-org"
50isVerbose = False
51isDryRun = False
52isDiffMode = False
53filesProcessed = 0
54
55class error(Exception):
56    """Base class for exceptions."""
57    def __init(self, msg):
58        self.msg = 'error: %s' % (msg)
59    def set_output(self, msg):
60        self.msg = msg
61    def __str__(self):
62        return self.msg
63
64def common_flags():
65    return ['-O2',
66            '-g',
67            '-fno-strict-aliasing',
68            '-ffreestanding',
69            '-fno-common']
70
71def common_warnings():
72    return ['-Wall',
73            '-Wno-format']
74
75def common_no_warnings():
76    return ['-w']
77
78def includes():
79    return ['-Irtemsbsd/include',
80            '-Ifreebsd/sys',
81            '-Ifreebsd/sys/contrib/altq',
82            '-Ifreebsd/sys/contrib/pf',
83            '-Ifreebsd/include',
84            '-Ifreebsd/lib/libc/include',
85            '-Ifreebsd/lib/libc/isc/include',
86            '-Ifreebsd/lib/libc/resolv',
87            '-Ifreebsd/lib/libutil',
88            '-Ifreebsd/lib/libkvm',
89            '-Ifreebsd/lib/libmemstat',
90            '-Ifreebsd/lib/libipsec',
91            '-Ifreebsd/contrib/libpcap',
92            '-Irtemsbsd/sys',
93            '-ImDNSResponder/mDNSCore',
94            '-ImDNSResponder/mDNSShared',
95            '-ImDNSResponder/mDNSPosix',
96            '-Itestsuite/include']
97
98def cpu_includes():
99    return ['-Irtemsbsd/@CPU@/include',
100            '-Ifreebsd/sys/@CPU@/include']
101
102def cflags():
103    return ['-std=gnu11']
104
105def cxxflags():
106    return ['-std=gnu++11']
107
108def header_paths():
109    #         local path                      wildcard             dest path
110    return [('rtemsbsd/include',              '*.h',               ''),
111            ('rtemsbsd/mghttpd',              'mongoose.h',        'mghttpd'),
112            ('freebsd/include',               '*.h',               ''),
113            ('freebsd/sys/contrib/altq/altq', '*.h',               'altq'),
114            ('freebsd/sys/bsm',               '*.h',               'bsm'),
115            ('freebsd/sys/cam',               '*.h',               'cam'),
116            ('freebsd/sys/net',               '*.h',               'net'),
117            ('freebsd/sys/net80211',          '*.h',               'net80211'),
118            ('freebsd/sys/netatalk',          '*.h',               'netatalk'),
119            ('freebsd/sys/netinet',           '*.h',               'netinet'),
120            ('freebsd/sys/netinet6',          '*.h',               'netinet6'),
121            ('freebsd/sys/netipsec',          '*.h',               'netipsec'),
122            ('freebsd/sys/sys',               '*.h',               'sys'),
123            ('freebsd/sys/vm',                '*.h',               'vm'),
124            ('freebsd/sys/dev/mii',           '*.h',               'dev/mii'),
125            ('mDNSResponder/mDNSCore',        'mDNSDebug.h',       ''),
126            ('mDNSResponder/mDNSCore',        'mDNSEmbeddedAPI.h', ''),
127            ('mDNSResponder/mDNSShared',      'dns_sd.h',          ''),
128            ('mDNSResponder/mDNSPosix',       'mDNSPosix.h',       '')]
129
130# compare and process file only if different
131#  + copy or diff depending on execution mode
132def processIfDifferent(new, old, src):
133
134    global filesProcessed
135    global isVerbose, isDryRun, isEarlyExit
136
137    if not os.path.exists(old) or \
138       filecmp.cmp(new, old, shallow = False) == False:
139        filesProcessed += 1
140        if isDiffMode == False:
141            if isVerbose == True:
142                print "Move " + src + " to " + old
143            if isDryRun == False:
144                shutil.move(new, old)
145        else:
146            if isVerbose == True:
147                print "Diff %s => %s" % (src, new)
148            old_contents = open(old).readlines()
149            new_contents = open(new).readlines()
150            for line in \
151                difflib.unified_diff(old_contents, new_contents,
152                                     fromfile = src, tofile = new, n = 5):
153                sys.stdout.write(line)
154
155# Move target dependent files under a machine directory
156def mapCPUDependentPath(path):
157  return path.replace("include/", "include/machine/")
158
159def fixIncludes(data):
160    data = re.sub('#include <sys/lock.h>', '#include <rtems/bsd/sys/lock.h>', data)
161    data = re.sub('#include <sys/time.h>', '#include <rtems/bsd/sys/time.h>', data)
162    data = re.sub('#include <sys/cpuset.h>', '#include <rtems/bsd/sys/cpuset.h>', data)
163    data = re.sub('#include <sys/errno.h>', '#include <rtems/bsd/sys/errno.h>', data)
164    data = re.sub('#include <sys/param.h>', '#include <rtems/bsd/sys/param.h>', data)
165    data = re.sub('#include <sys/types.h>', '#include <rtems/bsd/sys/types.h>', data)
166    data = re.sub('#include <sys/resource.h>', '#include <rtems/bsd/sys/resource.h>', data)
167    data = re.sub('#include <sys/unistd.h>', '#include <rtems/bsd/sys/unistd.h>', data)
168    data = re.sub('#include <sys/_types.h>', '#include <rtems/bsd/sys/_types.h>', data)
169    return data
170
171# revert fixing the include paths inside a C or .h file
172def revertFixIncludes(data):
173    data = re.sub('#include <rtems/bsd/', '#include <', data)
174    data = re.sub('#include <util.h>', '#include <rtems/bsd/util.h>', data)
175    data = re.sub('#include <bsd.h>', '#include <rtems/bsd/bsd.h>', data)
176    data = re.sub('#include <zerocopy.h>', '#include <rtems/bsd/zerocopy.h>', data)
177    return data
178
179# fix include paths inside a C or .h file
180def fixLocalIncludes(data):
181    data = re.sub('#include "opt_([^"]*)"', '#include <rtems/bsd/local/opt_\\1>', data)
182    data = re.sub('#include "([^"]*)_if.h"', '#include <rtems/bsd/local/\\1_if.h>', data)
183    data = re.sub('#include "miidevs([^"]*)"', '#include <rtems/bsd/local/miidevs\\1>', data)
184    data = re.sub('#include "usbdevs([^"]*)"', '#include <rtems/bsd/local/usbdevs\\1>', data)
185    return data
186
187# revert fixing the include paths inside a C or .h file
188def revertFixLocalIncludes(data):
189    data = re.sub('#include <rtems/bsd/local/([^>]*)>', '#include "\\1"', data)
190    return data
191
192def assertHeaderFile(path):
193    if path[-2] != '.' or path[-1] != 'h':
194        print "*** " + path + " does not end in .h"
195        print "*** Move it to a C source file list"
196        sys.exit(2)
197
198def assertSourceFile(path):
199    if path[-2] != '.' or (path[-1] != 'c' and path[-1] != 'S'):
200        print "*** " + path + " does not end in .c"
201        print "*** Move it to a header file list"
202        sys.exit(2)
203
204class Converter(object):
205    def convert(self, src):
206        return open(src).read()
207
208    def isConvertible(self):
209        return True
210
211class NoConverter(Converter):
212    def convert(self, src):
213        raise
214
215    def isConvertible(self):
216        return False
217
218class EmptyConverter(Converter):
219    def convert(self, src):
220        return '/* EMPTY */\n'
221
222class FromFreeBSDToRTEMSHeaderConverter(Converter):
223    def convert(self, src):
224        data = super(FromFreeBSDToRTEMSHeaderConverter, self).convert(src)
225        data = fixLocalIncludes(data)
226        data = fixIncludes(data)
227        return data
228
229class FromFreeBSDToRTEMSUserSpaceHeaderConverter(Converter):
230    def convert(self, src):
231        data = super(FromFreeBSDToRTEMSUserSpaceHeaderConverter, self).convert(src)
232        data = fixIncludes(data)
233        return data
234
235class FromFreeBSDToRTEMSSourceConverter(Converter):
236    def convert(self, src):
237        data = super(FromFreeBSDToRTEMSSourceConverter, self).convert(src)
238        data = fixLocalIncludes(data)
239        data = fixIncludes(data)
240        data = '#include <machine/rtems-bsd-kernel-space.h>\n\n' + data
241        return data
242
243class FromFreeBSDToRTEMSUserSpaceSourceConverter(Converter):
244    def convert(self, src):
245        data = super(FromFreeBSDToRTEMSUserSpaceSourceConverter, self).convert(src)
246        data = fixIncludes(data)
247        data = '#include <machine/rtems-bsd-user-space.h>\n\n' + data
248        return data
249
250class FromRTEMSToFreeBSDHeaderConverter(Converter):
251    def convert(self, src):
252        data = super(FromRTEMSToFreeBSDHeaderConverter, self).convert(src)
253        data = revertFixLocalIncludes(data)
254        data = revertFixIncludes(data)
255        return data
256
257class FromRTEMSToFreeBSDSourceConverter(Converter):
258    def convert(self, src):
259        data = super(FromRTEMSToFreeBSDSourceConverter, self).convert(src)
260        data = re.sub('#include <machine/rtems-bsd-kernel-space.h>\n\n', '', data)
261        data = re.sub('#include <machine/rtems-bsd-user-space.h>\n\n', '', data)
262        data = revertFixLocalIncludes(data)
263        data = revertFixIncludes(data)
264        return data
265
266class PathComposer(object):
267    def composeFreeBSDPath(self, path):
268        return path
269
270    def composeRTEMSPath(self, path, prefix):
271        path = prefix + path
272        return path
273
274class FreeBSDPathComposer(PathComposer):
275    def composeFreeBSDPath(self, path):
276        return FreeBSD_DIR + '/' + path
277
278    def composeRTEMSPath(self, path, prefix):
279        return prefix + 'freebsd/' + path
280
281class RTEMSPathComposer(PathComposer):
282    def composeFreeBSDPath(self, path):
283        return path
284
285    def composeRTEMSPath(self, path, prefix):
286        path = prefix + 'rtemsbsd/' + path
287        return path
288
289class CPUDependentPathComposer(FreeBSDPathComposer):
290    def composeRTEMSPath(self, path, prefix):
291        path = super(CPUDependentPathComposer, self).composeRTEMSPath(path, prefix)
292        path = mapCPUDependentPath(path)
293        return path
294
295class TargetSourceCPUDependentPathComposer(CPUDependentPathComposer):
296    def __init__(self, targetCPU, sourceCPU):
297        self.targetCPU = targetCPU
298        self.sourceCPU = sourceCPU
299
300    def composeRTEMSPath(self, path, prefix):
301        path = super(TargetSourceCPUDependentPathComposer, self).composeRTEMSPath(path, prefix)
302        path = path.replace(self.sourceCPU, self.targetCPU)
303        return path
304
305class BuildSystemFragmentComposer(object):
306    def __init__(self, includes = None):
307        if type(includes) is not list:
308            self.includes = [includes]
309        else:
310            self.includes = includes
311
312    def compose(self, path):
313        return ''
314
315class File(object):
316    def __init__(self, path, pathComposer,
317                 fromFreeBSDToRTEMSConverter, fromRTEMSToFreeBSDConverter, buildSystemComposer):
318        self.path = path
319        self.pathComposer = pathComposer
320        self.fromFreeBSDToRTEMSConverter = fromFreeBSDToRTEMSConverter
321        self.fromRTEMSToFreeBSDConverter = fromRTEMSToFreeBSDConverter
322        self.buildSystemComposer = buildSystemComposer
323
324    def copy(self, dst, src, converter = None):
325        import tempfile
326        if converter is not None and converter.isConvertible():
327            try:
328                if isDryRun == False:
329                    os.makedirs(os.path.dirname(dst))
330            except OSError:
331                pass
332            data = converter.convert(src)
333            try:
334                out = tempfile.NamedTemporaryFile(delete = False)
335                out.write(data)
336                out.close()
337                processIfDifferent(out.name, dst, src)
338            finally:
339                try:
340                    os.remove(out.name)
341                except:
342                    pass
343
344    def copyFromFreeBSDToRTEMS(self):
345        src = self.pathComposer.composeFreeBSDPath(self.path)
346        dst = self.pathComposer.composeRTEMSPath(self.path, RTEMS_DIR + '/')
347        self.copy(dst, src, self.fromFreeBSDToRTEMSConverter)
348
349    def copyFromRTEMSToFreeBSD(self):
350        src = self.pathComposer.composeRTEMSPath(self.path, RTEMS_DIR + '/')
351        dst = self.pathComposer.composeFreeBSDPath(self.path)
352        self.copy(dst, src, self.fromRTEMSToFreeBSDConverter)
353
354    def getFragment(self):
355        return self.buildSystemComposer.compose(self.pathComposer.composeRTEMSPath(self.path, ''))
356
357# Module - logical group of related files we can perform actions on
358class Module:
359    def __init__(self, name):
360        self.name = name
361        self.conditionalOn = "none"
362        self.files = []
363        self.cpuDependentSourceFiles = {}
364        self.dependencies = []
365
366    def initCPUDependencies(self, cpu):
367        if cpu not in self.cpuDependentSourceFiles:
368            self.cpuDependentSourceFiles[cpu] = []
369
370    def copyFromFreeBSDToRTEMS(self):
371        for f in self.files:
372            f.copyFromFreeBSDToRTEMS()
373        for cpu, files in self.cpuDependentSourceFiles.items():
374            for f in files:
375                f.copyFromFreeBSDToRTEMS()
376
377    def copyFromRTEMSToFreeBSD(self):
378        for f in self.files:
379            f.copyFromRTEMSToFreeBSD()
380        for cpu, files in self.cpuDependentSourceFiles.items():
381            for f in files:
382                f.copyFromRTEMSToFreeBSD()
383
384    def addFiles(self, newFiles, buildSystemComposer = BuildSystemFragmentComposer()):
385        files = []
386        for newFile in newFiles:
387            assertFile(newFile)
388            files += [File(newFile, composers, buildSystemComposer)]
389        return files
390
391    def addFile(self, f):
392        self.files += [f]
393
394    def addFiles(self, newFiles,
395                 pathComposer, fromFreeBSDToRTEMSConverter, fromRTEMSToFreeBSDConverter,
396                 assertFile, buildSystemComposer = BuildSystemFragmentComposer()):
397        files = []
398        for newFile in newFiles:
399            assertFile(newFile)
400            files += [File(newFile, pathComposer, fromFreeBSDToRTEMSConverter,
401                           fromRTEMSToFreeBSDConverter, buildSystemComposer)]
402        return files
403
404    def addKernelSpaceHeaderFiles(self, files):
405        self.files += self.addFiles(files,
406                                    FreeBSDPathComposer(), FromFreeBSDToRTEMSHeaderConverter(),
407                                    FromRTEMSToFreeBSDHeaderConverter(), assertHeaderFile)
408
409    def addUserSpaceHeaderFiles(self, files):
410        self.files += self.addFiles(files,
411                                    FreeBSDPathComposer(), FromFreeBSDToRTEMSUserSpaceHeaderConverter(),
412                                    FromRTEMSToFreeBSDHeaderConverter(), assertHeaderFile)
413
414    def addRTEMSHeaderFiles(self, files):
415        self.files += self.addFiles(files, RTEMSPathComposer(),
416                                    NoConverter(), NoConverter(), assertHeaderFile)
417
418    def addCPUDependentHeaderFiles(self, files):
419        self.files += self.addFiles(files,
420                                    CPUDependentPathComposer(), FromFreeBSDToRTEMSHeaderConverter(),
421                                    FromRTEMSToFreeBSDHeaderConverter(), assertHeaderFile)
422
423    def addTargetSourceCPUDependentHeaderFiles(self, targetCPUs, sourceCPU, files):
424        for cpu in targetCPUs:
425            self.files += self.addFiles(files,
426                                        TargetSourceCPUDependentPathComposer(cpu, sourceCPU),
427                                        FromFreeBSDToRTEMSHeaderConverter(),
428                                        NoConverter(), assertHeaderFile)
429
430    def addSourceFiles(self, files, sourceFileFragmentComposer):
431        self.files += self.addFiles(files,
432                                    PathComposer(), NoConverter(), NoConverter(), assertSourceFile,
433                                    sourceFileFragmentComposer)
434
435    def addKernelSpaceSourceFiles(self, files, sourceFileFragmentComposer):
436        self.files += self.addFiles(files,
437                                    FreeBSDPathComposer(), FromFreeBSDToRTEMSSourceConverter(),
438                                    FromRTEMSToFreeBSDSourceConverter(), assertSourceFile,
439                                    sourceFileFragmentComposer)
440
441    def addUserSpaceSourceFiles(self, files, sourceFileFragmentComposer):
442        self.files += self.addFiles(files,
443                                    FreeBSDPathComposer(),
444                                    FromFreeBSDToRTEMSUserSpaceSourceConverter(),
445                                    FromRTEMSToFreeBSDSourceConverter(), assertSourceFile,
446                                    sourceFileFragmentComposer)
447
448    def addRTEMSSourceFiles(self, files, sourceFileFragmentComposer):
449        self.files += self.addFiles(files,
450                                    RTEMSPathComposer(), NoConverter(), NoConverter(),
451                                    assertSourceFile, sourceFileFragmentComposer)
452
453    def addCPUDependentSourceFiles(self, cpus, files, sourceFileFragmentComposer):
454        for cpu in cpus:
455            self.initCPUDependencies(cpu)
456            self.cpuDependentSourceFiles[cpu] += \
457                self.addFiles(files,
458                              CPUDependentPathComposer(), FromFreeBSDToRTEMSSourceConverter(),
459                              FromRTEMSToFreeBSDSourceConverter(), assertSourceFile,
460                              sourceFileFragmentComposer)
461
462    def addTest(self, testFragementComposer):
463        self.files += [File(testFragementComposer.testName,
464                            PathComposer(), NoConverter(), NoConverter(),
465                            testFragementComposer)]
466
467    def addDependency(self, dep):
468        self.dependencies += [dep]
469
470class ModuleManager:
471    def __init__(self):
472        self.modules = {}
473        self.generator = {}
474        self.setGenerators()
475
476    def __getitem__(self, key):
477        if key not in self.modules:
478            raise KeyError('module %s not found' % (key))
479        return self.modules[key]
480
481    def getModules(self):
482        return sorted(self.modules.keys())
483
484    def addModule(self, module):
485        self.modules[module.name] = module
486
487    def copyFromFreeBSDToRTEMS(self):
488        for m in sorted(self.modules):
489            self.modules[m].copyFromFreeBSDToRTEMS()
490
491    def copyFromRTEMSToFreeBSD(self):
492        for m in sorted(self.modules):
493            self.modules[m].copyFromRTEMSToFreeBSD()
Note: See TracBrowser for help on using the repository browser.