source: examples-v2/rtems_waf/rtems.py @ acbe98f

4.11
Last change on this file since acbe98f was acbe98f, checked in by Gedare Bloom <gedare@…>, on Nov 25, 2013 at 9:50:48 PM

rtems.py: add tweak for gc-sections link flag

  • Property mode set to 100644
File size: 22.1 KB
Line 
1#
2# Copyright 2012, 2013 Chris Johns (chrisj@rtems.org)
3#
4# Redistribution and use in source and binary forms, with or without
5# modification, are permitted provided that the following conditions are met:
6
7# 1. Redistributions of source code must retain the above copyright notice, this
8# list of conditions and the following disclaimer.
9
10# 2. Redistributions in binary form must reproduce the above copyright notice,
11# this list of conditions and the following disclaimer in the documentation
12# and/or other materials provided with the distribution.
13
14# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
15# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
18# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
20# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
21# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
22# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24
25#
26# RTEMS support for applications.
27#
28
29import copy
30import os
31import os.path
32import pkgconfig
33import re
34import subprocess
35
36default_version = '4.11'
37default_label = 'rtems-' + default_version
38default_path = '/opt/' + default_label
39default_postfix = 'rtems' + default_version
40
41rtems_filters = None
42
43def options(opt):
44    opt.add_option('--rtems',
45                   default = default_path,
46                   dest = 'rtems_path',
47                   help = 'Path to an installed RTEMS.')
48    opt.add_option('--rtems-tools',
49                   default = None,
50                   dest = 'rtems_tools',
51                   help = 'Path to RTEMS tools.')
52    opt.add_option('--rtems-version',
53                   default = default_version,
54                   dest = 'rtems_version',
55                   help = 'RTEMS version (default ' + default_version + ').')
56    opt.add_option('--rtems-archs',
57                   default = 'all',
58                   dest = 'rtems_archs',
59                   help = 'List of RTEMS architectures to build.')
60    opt.add_option('--rtems-bsps',
61                   default = 'all',
62                   dest = 'rtems_bsps',
63                   help = 'List of BSPs to build.')
64    opt.add_option('--show-commands',
65                   action = 'store_true',
66                   default = False,
67                   dest = 'show_commands',
68                   help = 'Print the commands as strings.')
69
70def init(ctx, filters = None):
71    global rtems_filters
72
73    try:
74        import waflib.Options
75        import waflib.ConfigSet
76
77        #
78        # Load the configuation set from the lock file.
79        #
80        env = waflib.ConfigSet.ConfigSet()
81        env.load(waflib.Options.lockfile)
82
83        #
84        # Set the RTEMS filter to the context.
85        #
86        rtems_filters = filters
87
88        #
89        # Check the tools, architectures and bsps.
90        #
91        rtems_path, rtems_tools, archs, arch_bsps = check_options(ctx,
92                                                                  env.options['rtems_tools'],
93                                                                  env.options['rtems_path'],
94                                                                  env.options['rtems_version'],
95                                                                  env.options['rtems_archs'],
96                                                                  env.options['rtems_bsps'])
97
98        #
99        # Update the contextes for all the bsps.
100        #
101        from waflib.Build import BuildContext, CleanContext, \
102            InstallContext, UninstallContext
103        for x in arch_bsps:
104            for y in (BuildContext, CleanContext, InstallContext, UninstallContext):
105                name = y.__name__.replace('Context','').lower()
106                class context(y):
107                    cmd = name + '-' + x
108                    variant = x
109
110        #
111        # Add the various commands.
112        #
113        for cmd in ['build', 'clean', 'install']:
114            if cmd in waflib.Options.commands:
115                waflib.Options.commands.remove(cmd)
116                for x in arch_bsps:
117                    waflib.Options.commands.insert(0, cmd + '-' + x)
118    except:
119        pass
120
121def configure(conf):
122    #
123    # Handle the show commands option.
124    #
125    if conf.options.show_commands:
126        show_commands = 'yes'
127    else:
128        show_commands = 'no'
129
130    rtems_path, rtems_tools, archs, arch_bsps = check_options(conf,
131                                                              conf.options.rtems_tools,
132                                                              conf.options.rtems_path,
133                                                              conf.options.rtems_version,
134                                                              conf.options.rtems_archs,
135                                                              conf.options.rtems_bsps)
136
137    _log_header(conf)
138
139    conf.msg('Architectures', ', '.join(archs), 'YELLOW')
140
141    tools = {}
142    env = conf.env.derive()
143
144    for ab in arch_bsps:
145        conf.setenv(ab, env)
146
147        conf.msg('Board Support Package', ab, 'YELLOW')
148
149        arch = _arch_from_arch_bsp(ab)
150
151        conf.env.RTEMS_PATH = conf.options.rtems_path
152        conf.env.RTEMS_VERSION = conf.options.rtems_version
153        conf.env.RTEMS_ARCH_BSP = ab
154        conf.env.RTEMS_ARCH = arch.split('-')[0]
155        conf.env.RTEMS_ARCH_RTEMS = arch
156        conf.env.RTEMS_BSP = _bsp_from_arch_bsp(ab)
157
158        tools = _find_tools(conf, arch, [rtems_path] + rtems_tools, tools)
159        for t in tools[arch]:
160            conf.env[t] = tools[arch][t]
161
162        conf.load('gcc')
163        conf.load('g++')
164        conf.load('gas')
165
166        flags = _load_flags(conf, ab, conf.options.rtems_path)
167
168        cflags = _filter_flags('cflags', flags['CFLAGS'],
169                               arch, conf.options.rtems_path)
170        ldflags = _filter_flags('ldflags', flags['LDFLAGS'],
171                               arch, conf.options.rtems_path)
172
173        conf.env.CFLAGS    = cflags['cflags']
174        conf.env.CXXFLAGS  = conf.env.CFLAGS
175        conf.env.ASFLAGS   = cflags['cflags']
176        conf.env.WFLAGS    = cflags['warnings']
177        conf.env.RFLAGS    = cflags['specs']
178        conf.env.MFLAGS    = cflags['machines']
179        conf.env.IFLAGS    = cflags['includes']
180        conf.env.LINKFLAGS = cflags['cflags'] + ldflags['ldflags']
181        conf.env.LIB       = flags['LIB']
182
183        #
184        # Add tweaks.
185        #
186        tweaks(conf, ab)
187
188        conf.env.SHOW_COMMANDS = show_commands
189
190        conf.setenv('', env)
191
192    conf.env.RTEMS_TOOLS = rtems_tools
193    conf.env.ARCHS = archs
194    conf.env.ARCH_BSPS = arch_bsps
195
196    conf.env.SHOW_COMMANDS = show_commands
197
198def build(bld):
199    if bld.env.SHOW_COMMANDS == 'yes':
200        output_command_line()
201
202def tweaks(conf, arch_bsp):
203    #
204    # Hack to work around NIOS2 naming.
205    #
206    if conf.env.RTEMS_ARCH in ['nios2']:
207        conf.env.OBJCOPY_FLAGS = ['-O', 'elf32-littlenios2']
208    elif conf.env.RTEMS_ARCH in ['arm']:
209        conf.env.OBJCOPY_FLAGS = ['-I', 'binary', '-O', 'elf32-littlearm']
210    else:
211        conf.env.OBJCOPY_FLAGS = ['-O', 'elf32-' + conf.env.RTEMS_ARCH]
212
213    #
214    # Check for a i386 PC bsp.
215    #
216    if re.match('i386-.*-pc[3456]86', arch_bsp) is not None:
217        conf.env.LINKFLAGS += ['-Wl,-Ttext,0x00100000']
218
219    if '-ffunction-sections' in conf.env.CFLAGS:
220      conf.env.LINKFLAGS += ['-Wl,--gc-sections']
221
222def check_options(ctx, rtems_tools, rtems_path, rtems_version, rtems_archs, rtems_bsps):
223    #
224    # Check the paths are valid.
225    #
226    if not os.path.exists(rtems_path):
227        ctx.fatal('RTEMS path not found.')
228    if os.path.exists(os.path.join(rtems_path, 'lib', 'pkgconfig')):
229        rtems_config = None
230    elif os.path.exists(os.path.join(rtems_path, 'rtems-config')):
231        rtems_config = os.path.join(rtems_path, 'rtems-config')
232    else:
233        ctx.fatal('RTEMS path is not valid. No lib/pkgconfig or rtems-config found.')
234    if os.path.exists(os.path.join(rtems_path, 'bin')):
235        rtems_bin = os.path.join(rtems_path, 'bin')
236    else:
237        ctx.fatal('RTEMS path is not valid. No bin directory found.')
238
239    #
240    # We can more than one path to tools. This happens when testing different
241    # versions.
242    #
243    if rtems_tools is not None:
244        rt = rtems_tools.split(',')
245        tools = []
246        for path in rt:
247            if not os.path.exists(path):
248                ctx.fatal('RTEMS tools path not found: ' + path)
249            if not os.path.exists(os.path.join(path, 'bin')):
250                ctx.fatal('RTEMS tools path does not contain a \'bin\' directory: ' + path)
251            tools += [os.path.join(path, 'bin')]
252    else:
253        tools = None
254
255    #
256    # Filter the tools.
257    #
258    tools = filter(ctx, 'tools', tools)
259
260    #
261    # Match the archs requested against the ones found. If the user
262    # wants all (default) set all used.
263    #
264    if rtems_archs == 'all':
265        archs = _find_installed_archs(rtems_config, rtems_path, rtems_version)
266    else:
267        archs = _check_archs(rtems_config, rtems_archs, rtems_path, rtems_version)
268
269    #
270    # Filter the architectures.
271    #
272    archs = filter(ctx, 'archs', archs)
273
274    #
275    # We some.
276    #
277    if len(archs) == 0:
278        ctx.fatal('Could not find any architectures')
279
280    #
281    # Get the list of valid BSPs. This process filters the architectures
282    # to those referenced by the BSPs.
283    #
284    if rtems_bsps == 'all':
285        arch_bsps = _find_installed_arch_bsps(rtems_config, rtems_path, archs, rtems_version)
286    else:
287        arch_bsps = _check_arch_bsps(rtems_bsps, rtems_config, rtems_path, archs, rtems_version)
288
289    if len(arch_bsps) == 0:
290        ctx.fatal('No valid arch/bsps found')
291
292    #
293    # Filter the bsps.
294    #
295    arch_bsps = filter(ctx, 'bsps', arch_bsps)
296
297    return rtems_bin, tools, archs, arch_bsps
298
299def arch(arch_bsp):
300    """ Given an arch/bsp return the architecture."""
301    return _arch_from_arch_bsp(arch_bsp).split('-')[0]
302
303def bsp(arch_bsp):
304    """ Given an arch/bsp return the BSP."""
305    return _bsp_from_arch_bsp(arch_bsp)
306
307def arch_bsps(ctx):
308    """ Return the list of arch/bsps we are building."""
309    return ctx.env.ARCH_BSPS
310
311def arch_bsp_env(ctx, arch_bsp):
312    return ctx.env_of_name(arch_bsp).derive()
313
314def filter(ctx, filter, items):
315    if rtems_filters is None:
316        return items
317    if type(rtems_filters) is not dict:
318        ctx.fatal("Invalid RTEMS filter type, ie { 'tools': { 'in': [], 'out': [] }, 'arch': {}, 'bsps': {} }")
319    if filter not in rtems_filters:
320        return items
321    items_in = []
322    items_out = []
323    if 'in' in rtems_filters[filter]:
324        items_in = copy.copy(rtems_filters[filter]['in'])
325    if 'out' in rtems_filters[filter]:
326        items_out = copy.copy(rtems_filters[filter]['out'])
327    filtered_items = []
328    for i in items:
329        item = i
330        ab = '%s/%s' % (arch(item), bsp(item))
331        for inre in items_in:
332            if re.compile(inre).match(ab):
333                items_in.remove(inre)
334                filtered_items += [item]
335                item = None
336                break
337        if item is not None:
338            for outre in items_out:
339                if re.compile(outre).match(ab):
340                    item = None
341                    break
342        if item is not None:
343            filtered_items += [item]
344    if len(items_in) != 0:
345        ctx.fatal('Following %s not found: %s' % (filter, ', '.join(items_in)))
346    return sorted(filtered_items)
347
348def arch_rtems_version(arch):
349    """ Return the RTEMS architecture path, ie sparc-rtems4.11."""
350    return '%s-%s' % (arch, default_postfix)
351
352def arch_bsp_path(arch_bsp):
353    """ Return the BSP path."""
354    return '%s/%s' % (arch_rtems_version(arch(arch_bsp)), bsp(arch_bsp))
355
356def arch_bsp_include_path(arch_bsp):
357    """ Return the BSP include path."""
358    return '%s/lib/include' % (arch_bsp_path(arch_bsp))
359
360def arch_bsp_lib_path(arch_bsp):
361    """ Return the BSP library path. """
362    return '%s/lib' % (arch_bsp_path(arch_bsp))
363
364def library_path(library, cc, cflags):
365    cmd = cc + cflags + ['-print-file-name=%s' % library]
366    a = subprocess.check_output(cmd)
367    lib = os.path.abspath(a.strip())
368    if os.path.exists(lib):
369        return os.path.dirname(lib)
370    return None
371
372def clone_tasks(bld):
373    if bld.cmd == 'build':
374        for obj in bld.all_task_gen[:]:
375            for x in arch_bsp:
376                cloned_obj = obj.clone(x)
377                kind = Options.options.build_kind
378                if kind.find(x) < 0:
379                    cloned_obj.posted = True
380            obj.posted = True
381
382#
383# From the demos. Use this to get the command to cut+paste to play.
384#
385def output_command_line():
386    # first, display strings, people like them
387    from waflib import Utils, Logs
388    from waflib.Context import Context
389    def exec_command(self, cmd, **kw):
390        subprocess = Utils.subprocess
391        kw['shell'] = isinstance(cmd, str)
392        if isinstance(cmd, str):
393            Logs.info('%s' % cmd)
394        else:
395            Logs.info('%s' % ' '.join(cmd)) # here is the change
396        Logs.debug('runner_env: kw=%s' % kw)
397        try:
398            if self.logger:
399                self.logger.info(cmd)
400                kw['stdout'] = kw['stderr'] = subprocess.PIPE
401                p = subprocess.Popen(cmd, **kw)
402                (out, err) = p.communicate()
403                if out:
404                    self.logger.debug('out: %s' % out.decode(sys.stdout.encoding or 'iso8859-1'))
405                if err:
406                    self.logger.error('err: %s' % err.decode(sys.stdout.encoding or 'iso8859-1'))
407                return p.returncode
408            else:
409                p = subprocess.Popen(cmd, **kw)
410                return p.wait()
411        except OSError:
412            return -1
413    Context.exec_command = exec_command
414
415    # Change the outputs for tasks too
416    from waflib.Task import Task
417    def display(self):
418        return '' # no output on empty strings
419
420    Task.__str__ = display
421
422def _find_tools(conf, arch, paths, tools):
423    if arch not in tools:
424        arch_tools = {}
425        arch_tools['CC']          = conf.find_program([arch + '-gcc'], path_list = paths)
426        arch_tools['CXX']         = conf.find_program([arch + '-g++'], path_list = paths)
427        arch_tools['AS']          = conf.find_program([arch + '-gcc'], path_list = paths)
428        arch_tools['LD']          = conf.find_program([arch + '-ld'],  path_list = paths)
429        arch_tools['AR']          = conf.find_program([arch + '-ar'],  path_list = paths)
430        arch_tools['LINK_CC']     = arch_tools['CC']
431        arch_tools['LINK_CXX']    = arch_tools['CXX']
432        arch_tools['AR']          = conf.find_program([arch + '-ar'], path_list = paths)
433        arch_tools['LD']          = conf.find_program([arch + '-ld'], path_list = paths)
434        arch_tools['NM']          = conf.find_program([arch + '-nm'], path_list = paths)
435        arch_tools['OBJDUMP']     = conf.find_program([arch + '-objdump'], path_list = paths)
436        arch_tools['OBJCOPY']     = conf.find_program([arch + '-objcopy'], path_list = paths)
437        arch_tools['READELF']     = conf.find_program([arch + '-readelf'], path_list = paths)
438        arch_tools['STRIP']       = conf.find_program([arch + '-strip'], path_list = paths)
439        arch_tools['RTEMS_LD']    = conf.find_program(['rtems-ld'], path_list = paths, mandatory = False)
440        arch_tools['RTEMS_BIN2C'] = conf.find_program(['rtems-bin2c'], path_list = paths, mandatory = False)
441        arch_tools['TAR']         = conf.find_program(['tar'], mandatory = False)
442        tools[arch] = arch_tools
443    return tools
444
445def _find_installed_archs(config, path, version):
446    archs = []
447    if config is None:
448        for d in os.listdir(path):
449            if d.endswith('-rtems' + version):
450                archs += [d]
451    else:
452        a = subprocess.check_output([config, '--list-format', '"%(arch)s"'])
453        a = a[:-1].replace('"', '')
454        archs = set(a.split())
455        archs = ['%s-rtems4.11' % (x) for x in archs]
456    archs.sort()
457    return archs
458
459def _check_archs(config, req, path, version):
460    installed = _find_installed_archs(config, path, version)
461    archs = []
462    for a in req.split(','):
463        arch = a + '-rtems' + version
464        if arch in installed:
465            archs += [arch]
466    archs.sort()
467    return archs
468
469def _find_installed_arch_bsps(config, path, archs, version):
470    arch_bsps = []
471    if config is None:
472        for f in os.listdir(_pkgconfig_path(path)):
473            if f.endswith('.pc'):
474                if _arch_from_arch_bsp(f[:-3]) in archs:
475                    arch_bsps += [f[:-3]]
476    else:
477        ab = subprocess.check_output([config, '--list-format'])
478        ab = ab[:-1].replace('"', '')
479        ab = ab.replace('/', '-rtems%s-' % (version))
480        arch_bsps = [x for x in set(ab.split())]
481    arch_bsps.sort()
482    return arch_bsps
483
484def _check_arch_bsps(req, config, path, archs, version):
485    archs_bsps = []
486    for ab in req.split(','):
487        abl = ab.split('/')
488        if len(abl) != 2:
489            return []
490        found = False
491        for arch in archs:
492            a = '%s-rtems%s' % (abl[0], version)
493            if a == arch:
494                found = True
495                break
496        if not found:
497            return []
498        archs_bsps += ['%s-%s' % (a, abl[1])]
499    if len(archs_bsps) == 0:
500        return []
501    installed = _find_installed_arch_bsps(config, path, archs, version)
502    bsps = []
503    for b in archs_bsps:
504        if b in installed:
505            bsps += [b]
506    bsps.sort()
507    return bsps
508
509def _arch_from_arch_bsp(arch_bsp):
510    return '-'.join(arch_bsp.split('-')[:2])
511
512def _bsp_from_arch_bsp(arch_bsp):
513    return '-'.join(arch_bsp.split('-')[2:])
514
515def _pkgconfig_path(path):
516    return os.path.join(path, 'lib', 'pkgconfig')
517
518def _load_flags(conf, arch_bsp, path):
519    if not os.path.exists(path):
520        ctx.fatal('RTEMS path not found.')
521    if os.path.exists(_pkgconfig_path(path)):
522        pc = os.path.join(_pkgconfig_path(path), arch_bsp + '.pc')
523        conf.to_log('Opening and load pkgconfig: ' + pc)
524        pkg = pkgconfig.package(pc)
525        config = None
526    elif os.path.exists(os.path.join(path, 'rtems-config')):
527        config = os.path.join(path, 'rtems-config')
528        pkg = None
529    flags = {}
530    _log_header(conf)
531    flags['CFLAGS'] = _load_flags_set('CFLAGS', arch_bsp, conf, config, pkg)
532    flags['LDFLAGS'] = _load_flags_set('LDFLAGS', arch_bsp, conf, config, pkg)
533    flags['LIB'] = _load_flags_set('LIB', arch_bsp, conf, config, pkg)
534    return flags
535
536def _load_flags_set(flags, arch_bsp, conf, config, pkg):
537    conf.to_log('%s ->' % flags)
538    if pkg is not None:
539        flagstr = ''
540        try:
541            flagstr = pkg.get(flags)
542        except pkgconfig.error as e:
543            conf.to_log('pkconfig warning: ' + e.msg)
544        conf.to_log('  ' + flagstr)
545    else:
546        flags_map = { 'CFLAGS': '--cflags',
547                      'LDFLAGS': '--ldflags',
548                      'LIB': '--libs' }
549        ab = arch_bsp.split('-')
550        #conf.check_cfg(path = config,
551        #               package = '',
552        #               uselib_store = 'rtems',
553        #               args = '--bsp %s/%s %s' % (ab[0], ab[2], flags_map[flags]))
554        #print conf.env
555        #print '%r' % conf
556        #flagstr = '-l -c'
557        flagstr = subprocess.check_output([config, '--bsp', '%s/%s' % (ab[0], ab[2]), flags_map[flags]])
558        #print flags, ">>>>", flagstr
559        if flags == 'CFLAGS':
560            flagstr += ' -DWAF_BUILD=1'
561        if flags == 'LIB':
562            flagstr = 'rtemscpu rtemsbsp c rtemscpu rtemsbsp'
563    return flagstr.split()
564
565def _filter_flags(label, flags, arch, rtems_path):
566
567    flag_groups = \
568        [ { 'key': 'warnings', 'path': False, 'flags': { '-W': 1 }, 'cflags': False, 'lflags': False },
569          { 'key': 'includes', 'path': True,  'flags': { '-I': 1, '-isystem': 2, '-sysroot': 2 } },
570          { 'key': 'machines', 'path': True,  'flags': { '-O': 1, '-m': 1, '-f': 1 } },
571          { 'key': 'specs',    'path': True,  'flags': { '-q': 1, '-B': 2, '--specs': 2 } } ]
572
573    flags = _strip_cflags(flags)
574
575    _flags = { label: [] }
576    for fg in flag_groups:
577        _flags[fg['key']] = []
578
579    iflags = iter(flags)
580    for opt in iflags:
581        in_label = True
582        opts = []
583        for fg in flag_groups:
584            key = fg['key']
585            for flag in fg['flags']:
586                if opt.startswith(flag):
587                    opt_count = fg['flags'][flag]
588                    if opt_count > 1:
589                        if opt != flag:
590                            opt_count -= 1
591                            if fg['path'] and arch in opt:
592                                opt = '%s%s/%s' % (flag, rtems_path,
593                                                   opt[opt.find(arch):])
594                    opts += [opt]
595                    for c in range(1, opt_count):
596                        opt = next(iflags)
597                        if fg['path'] and arch in opt:
598                            opt = '%s%s/%s' % (f, rtems_path,
599                                               opt[opt.find(arch):])
600                        opts += [opt]
601                    _flags[key] += opts
602                    if label in fg and not fg[label]:
603                        in_label = False
604                    break
605            if in_label:
606                _flags[label] += opts
607    return _flags
608
609def _strip_cflags(cflags):
610    _cflags = []
611    for o in cflags:
612        if o.startswith('-O'):
613            pass
614        elif o.startswith('-g'):
615            pass
616        else:
617            _cflags += [o]
618    return _cflags
619
620def _log_header(conf):
621    conf.to_log('-----------------------------------------')
622
623from waflib import TaskGen
624from waflib.Tools.ccroot import link_task, USELIB_VARS
625USELIB_VARS['rap'] = set(['RTEMS_LINKFLAGS'])
626@TaskGen.extension('.c')
627class rap(link_task):
628        "Link object files into a RTEMS application"
629        run_str = '${RTEMS_LD} ${RTEMS_LINKFLAGS} --cc ${CC} ${SRC} -o ${TGT[0].abspath()} ${STLIB_MARKER} ${STLIBPATH_ST:STLIBPATH} ${STLIB_ST:STLIB} ${LIBPATH_ST:LIBPATH} ${LIB_ST:LIB}'
630        ext_out = ['.rap']
631        vars    = ['RTEMS_LINKFLAGS', 'LINKDEPS']
632        inst_to = '${BINDIR}'
Note: See TracBrowser for help on using the repository browser.