source: rtems-tools/linkers/rtems-syms.cpp @ fdb1fe6

4.104.11
Last change on this file since fdb1fe6 was fdb1fe6, checked in by Chris Johns <chrisj@…>, on Oct 30, 2014 at 6:55:18 AM

linkers: Add base image symbol to ELF object file generation.

This change adds support to the rtems-syms code to generate a suitable
ELF object you can link to the base image kernel in the embed mode or
you can load with the run-time load mode.

The change fixes a bug in the framework where local ELF symbols
were being placed in the external symbol table. The external
symbol table has been removed and a global, weak and local set
of tables is now provided as this is more aligned with the ELF
format.

  • Property mode set to 100644
File size: 13.2 KB
Line 
1/*
2 * Copyright (c) 2011-2014, Chris Johns <chrisj@rtems.org>
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16/**
17 * @file
18 *
19 * @ingroup rtems_rld
20 *
21 * @brief RTEMS Symbols Main manages opions, sequence of operations and exceptions.
22 *
23 */
24
25#if HAVE_CONFIG_H
26#include "config.h"
27#endif
28
29#include <fstream>
30#include <iomanip>
31#include <iostream>
32
33#include <cxxabi.h>
34#include <signal.h>
35#include <stdlib.h>
36#include <string.h>
37#include <unistd.h>
38
39#include <getopt.h>
40
41#include <rld.h>
42#include <rld-cc.h>
43#include <rld-outputter.h>
44#include <rld-process.h>
45#include <rld-symbols.h>
46
47#ifndef HAVE_KILL
48#define kill(p,s) raise(s)
49#endif
50
51/**
52 * Header text.
53 */
54static const char* c_header[] =
55{
56  "/*",
57  " * RTEMS Global Symbol Table",
58  " *  Automatically generated. Do not edit..",
59  " */",
60  "",
61  "extern const unsigned char rtems__rtl_base_globals[];",
62  "extern const unsigned int rtems__rtl_base_globals_size;",
63  "",
64  "void rtems_rtl_base_sym_global_add (const unsigned char* , unsigned int );",
65  "",
66  "asm(\".section \\\".rodata\\\"\");",
67  "",
68  "asm(\"  .align   4\");",
69  "asm(\"  .local   rtems__rtl_base_globals\");",
70  "asm(\"rtems__rtl_base_globals:\");",
71  "#if __mips__",
72  " asm(\"  .align 0\");",
73  "#else",
74  " asm(\"  .balign 1\");",
75  "#endif",
76  0
77};
78
79static const char* c_trailer[] =
80{
81  "asm(\"  .byte    0\");",
82  "asm(\"  .ascii   \\\"\\xde\\xad\\xbe\\xef\\\"\");",
83  "asm(\"  .type    rtems__rtl_base_globals, #object\");",
84  "asm(\"  .size    rtems__rtl_base_globals, . - rtems__rtl_base_globals\");",
85  "",
86  "/*",
87  " * Symbol table size.",
88  " */",
89  "asm(\"  .align   4\");",
90  "asm(\"  .local   rtems__rtl_base_globals_size\");",
91  "asm(\"  .type    rtems__rtl_base_globals_size, #object\");",
92  "asm(\"  .size    rtems__rtl_base_globals_size, 4\");",
93  "asm(\"rtems__rtl_base_globals_size:\");",
94  "asm(\"  .long rtems__rtl_base_globals_size - rtems__rtl_base_globals\");",
95  "",
96  0
97};
98
99static const char* c_rtl_call_body[] =
100{
101  "{",
102  "  rtems_rtl_base_sym_global_add ((const unsigned char*) &rtems__rtl_base_globals,",
103  "                                 rtems__rtl_base_globals_size);",
104  "}",
105  0
106};
107
108/**
109 * Paint the data to the temporary file.
110 */
111static void
112temporary_file_paint (rld::process::tempfile& t, const char* lines[])
113{
114  for (int l = 0; lines[l]; ++l)
115    t.write_line (lines[l]);
116}
117
118/**
119 * The constructor trailer.
120 */
121static void
122c_constructor_trailer (rld::process::tempfile& c)
123{
124  c.write_line ("static void init(void) __attribute__ ((constructor));");
125  c.write_line ("static void init(void)");
126  temporary_file_paint (c, c_rtl_call_body);
127}
128
129/**
130 * The embedded trailer.
131 */
132static void
133c_embedded_trailer (rld::process::tempfile& c)
134{
135  c.write_line ("void rtems_rtl_base_global_syms_init(void);");
136  c.write_line ("void rtems_rtl_base_global_syms_init(void)");
137  temporary_file_paint (c, c_rtl_call_body);
138}
139
140/**
141 * Generate the symbol map object file for loading or linking into
142 * a running RTEMS machine.
143 */
144static void
145generate_c (rld::process::tempfile& c,
146              rld::symbols::table&  symbols,
147              bool                  embed)
148{
149  temporary_file_paint (c, c_header);
150
151  for (rld::symbols::symtab::const_iterator si = symbols.globals ().begin ();
152       si != symbols.globals ().end ();
153       ++si)
154  {
155    const rld::symbols::symbol& sym = *((*si).second);
156
157    c.write_line ("asm(\"  .asciz \\\"" + sym.name () + "\\\"\");");
158
159    if (embed)
160    {
161      c.write_line ("asm(\"  .long " + sym.name () + "\");");
162    }
163    else
164    {
165      std::stringstream oss;
166      oss << std::hex << std::setfill ('0') << std::setw (8) << sym.value ();
167      c.write_line ("asm(\"  .long 0x" + oss.str () + "\");");
168    }
169  }
170
171  temporary_file_paint (c, c_trailer);
172
173  if (embed)
174    c_embedded_trailer (c);
175  else
176    c_constructor_trailer (c);
177}
178
179static void
180generate_symmap (rld::process::tempfile& c,
181                 const std::string&      output,
182                 rld::symbols::table&    symbols,
183                 bool                    embed)
184{
185  c.open (true);
186
187  if (rld::verbose ())
188    std::cout << "symbol C file: " << c.name () << std::endl;
189
190  generate_c (c, symbols, embed);
191
192  if (rld::verbose ())
193    std::cout << "symbol O file: " << output << std::endl;
194
195  rld::process::arg_container args;
196
197  rld::cc::make_cc_command (args);
198  rld::cc::append_flags (rld::cc::ft_cflags, args);
199
200  args.push_back ("-O2");
201  args.push_back ("-c");
202  args.push_back ("-o");
203  args.push_back (output);
204  args.push_back (c.name ());
205
206  rld::process::tempfile out;
207  rld::process::tempfile err;
208  rld::process::status   status;
209
210  status = rld::process::execute (rld::cc::get_cc (),
211                                  args,
212                                  out.name (),
213                                  err.name ());
214
215
216  if ((status.type != rld::process::status::normal) ||
217      (status.code != 0))
218  {
219    err.output (rld::cc::get_cc (), std::cout);
220    throw rld::error ("Compiler error", "compiling wrapper");
221  }
222}
223
224/**
225 * RTEMS Linker options. This needs to be rewritten to be like cc where only a
226 * single '-' and long options is present.
227 */
228static struct option rld_opts[] = {
229  { "help",        no_argument,            NULL,           'h' },
230  { "version",     no_argument,            NULL,           'V' },
231  { "verbose",     no_argument,            NULL,           'v' },
232  { "warn",        no_argument,            NULL,           'w' },
233  { "keep",        no_argument,            NULL,           'k' },
234  { "embed",       no_argument,            NULL,           'e' },
235  { "symc",        required_argument,      NULL,           'S' },
236  { "output",      required_argument,      NULL,           'o' },
237  { "map",         required_argument,      NULL,           'm' },
238  { "cc",          required_argument,      NULL,           'C' },
239  { "exec-prefix", required_argument,      NULL,           'E' },
240  { "cflags",      required_argument,      NULL,           'c' },
241  { NULL,          0,                      NULL,            0 }
242};
243
244void
245usage (int exit_code)
246{
247  std::cout << "rtems-syms [options] kernel" << std::endl
248            << "Options and arguments:" << std::endl
249            << " -h        : help (also --help)" << std::endl
250            << " -V        : print linker version number and exit (also --version)" << std::endl
251            << " -v        : verbose (trace import parts), can supply multiple times" << std::endl
252            << "             to increase verbosity (also --verbose)" << std::endl
253            << " -w        : generate warnings (also --warn)" << std::endl
254            << " -k        : keep temporary files (also --keep)" << std::endl
255            << " -e        : embedded symbol table (also --embed)" << std::endl
256            << " -S        : symbol's C file (also --symc)" << std::endl
257            << " -o file   : output object file (also --output)" << std::endl
258            << " -m file   : output a map file (also --map)" << std::endl
259            << " -C file   : execute file as the target C compiler (also --cc)" << std::endl
260            << " -E prefix : the RTEMS tool prefix (also --exec-prefix)" << std::endl
261            << " -c cflags : C compiler flags (also --cflags)" << std::endl;
262  ::exit (exit_code);
263}
264
265static void
266fatal_signal (int signum)
267{
268  signal (signum, SIG_DFL);
269
270  rld::process::temporaries_clean_up ();
271
272  /*
273   * Get the same signal again, this time not handled, so its normal effect
274   * occurs.
275   */
276  kill (getpid (), signum);
277}
278
279static void
280setup_signals (void)
281{
282  if (signal (SIGINT, SIG_IGN) != SIG_IGN)
283    signal (SIGINT, fatal_signal);
284#ifdef SIGHUP
285  if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
286    signal (SIGHUP, fatal_signal);
287#endif
288  if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
289    signal (SIGTERM, fatal_signal);
290#ifdef SIGPIPE
291  if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
292    signal (SIGPIPE, fatal_signal);
293#endif
294#ifdef SIGCHLD
295  signal (SIGCHLD, SIG_DFL);
296#endif
297}
298
299int
300main (int argc, char* argv[])
301{
302  int ec = 0;
303
304  setup_signals ();
305
306  try
307  {
308    rld::files::cache   kernel;
309    rld::symbols::table symbols;
310    std::string         kernel_name;
311    std::string         output;
312    std::string         map;
313    std::string         cc;
314    std::string         symc;
315    bool                embed = false;
316    bool                warnings = false;
317
318    rld::set_cmdline (argc, argv);
319
320    while (true)
321    {
322      int opt = ::getopt_long (argc, argv, "hvVwkef:S:o:m:E:c:C:", rld_opts, NULL);
323      if (opt < 0)
324        break;
325
326      switch (opt)
327      {
328        case 'V':
329          std::cout << "rtems-syms (RTEMS Symbols) " << rld::version ()
330                    << std::endl;
331          ::exit (0);
332          break;
333
334        case 'v':
335          rld::verbose_inc ();
336          break;
337
338        case 'w':
339          warnings = true;
340          break;
341
342        case 'k':
343          rld::process::set_keep_temporary_files ();
344          break;
345
346        case 'e':
347          embed = true;
348          break;
349
350        case 'o':
351          output = optarg;
352          break;
353
354        case 'm':
355          map = optarg;
356          break;
357
358        case 'C':
359          if (rld::cc::is_exec_prefix_set ())
360            std::cerr << "warning: exec-prefix ignored when CC provided" << std::endl;
361          rld::cc::set_cc (optarg);
362          break;
363
364        case 'E':
365          if (rld::cc::is_cc_set ())
366            std::cerr << "warning: exec-prefix ignored when CC provided" << std::endl;
367          rld::cc::set_exec_prefix (optarg);
368          break;
369
370        case 'c':
371          rld::cc::set_flags (optarg, rld::cc::ft_cflags);
372          break;
373
374        case 'S':
375          symc = optarg;
376          break;
377
378        case '?':
379          usage (3);
380          break;
381
382        case 'h':
383          usage (0);
384          break;
385      }
386    }
387
388    /*
389     * Set the program name.
390     */
391    rld::set_progname (argv[0]);
392
393    argc -= optind;
394    argv += optind;
395
396    if (rld::verbose ())
397      std::cout << "RTEMS Kernel Symbols " << rld::version () << std::endl;
398
399    /*
400     * If there are no object files there is nothing to link.
401     */
402    if (argc == 0)
403      throw rld::error ("no kernel file", "options");
404    if (argc != 1)
405      throw rld::error ("only one kernel file", "options");
406    if (output.empty () && map.empty ())
407      throw rld::error ("no output or map", "options");
408
409    kernel_name = *argv;
410
411    if (rld::verbose ())
412      std::cout << "kernel: " << kernel_name << std::endl;
413
414    /*
415     * Load the symbols from the kernel.
416     */
417    try
418    {
419      /*
420       * Load the kernel ELF file symbol table.
421       */
422      kernel.open ();
423      kernel.add (kernel_name);
424      kernel.load_symbols (symbols, true);
425
426      /*
427       * If the full path to CC is not provided and the exec-prefix is not set
428       * by the command line see if it can be detected from the object file
429       * types. This must be after we have added the object files because they
430       * are used when detecting.
431       */
432      if (!cc.empty ())
433        rld::cc::set_cc (cc);
434      if (!rld::cc::is_cc_set () && !rld::cc::is_exec_prefix_set ())
435        rld::cc::set_exec_prefix (rld::elf::machine_type ());
436
437      /*
438       * Create a map file if asked too.
439       */
440      if (!map.empty ())
441      {
442        std::ofstream mout;
443        mout.open (map);
444        if (!mout.is_open ())
445          throw rld::error ("map file open failed", "map");
446        mout << "RTEMS Kernel Symbols Map" << std::endl
447             << " kernel: " << kernel_name << std::endl
448             << std::endl;
449        rld::symbols::output (mout, symbols);
450        mout.close ();
451      }
452
453      /*
454       * Create an output file if asked too.
455       */
456      if (!output.empty ())
457      {
458        rld::process::tempfile c (".c");
459
460        if (!symc.empty ())
461        {
462          c.override (symc);
463          c.keep ();
464        }
465
466        /*
467         * Generate and compile the symbol map.
468         */
469        generate_symmap (c, output, symbols, embed);
470      }
471
472      kernel.close ();
473    }
474    catch (...)
475    {
476      kernel.close ();
477      throw;
478    }
479
480    kernel.close ();
481  }
482  catch (rld::error re)
483  {
484    std::cerr << "error: "
485              << re.where << ": " << re.what
486              << std::endl;
487    ec = 10;
488  }
489  catch (std::exception e)
490  {
491    int   status;
492    char* realname;
493    realname = abi::__cxa_demangle (e.what(), 0, 0, &status);
494    std::cerr << "error: exception: " << realname << " [";
495    ::free (realname);
496    const std::type_info &ti = typeid (e);
497    realname = abi::__cxa_demangle (ti.name(), 0, 0, &status);
498    std::cerr << realname << "] " << e.what () << std::endl;
499    ::free (realname);
500    ec = 11;
501  }
502  catch (...)
503  {
504    /*
505     * Helps to know if this happens.
506     */
507    std::cout << "error: unhandled exception" << std::endl;
508    ec = 12;
509  }
510
511  return ec;
512}
Note: See TracBrowser for help on using the repository browser.