Changeset aac2949 in rtems-tools


Ignore:
Timestamp:
Oct 28, 2014, 8:14:02 AM (5 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.10, 4.11, master
Children:
fdb1fe6
Parents:
3fd45d3
Message:

linkers: Add kernel symbol support.

The rtems-sym tool has been changed from a basic map tool to now
provide an object file in the specific architecture containing
the symbols in the RTEMS kernel. It can still generate a map.

The object can be embedded or loaded. It cannot be both.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • linkers/rtems-syms.cpp

    r3fd45d3 raac2949  
    11/*
    2  * Copyright (c) 2011-2012, Chris Johns <chrisj@rtems.org>
     2 * Copyright (c) 2011-2014, Chris Johns <chrisj@rtems.org>
    33 *
    44 * Permission to use, copy, modify, and/or distribute this software for any
     
    2727#endif
    2828
     29#include <fstream>
     30#include <iomanip>
    2931#include <iostream>
    3032
     
    4143#include <rld-outputter.h>
    4244#include <rld-process.h>
    43 #include <rld-resolver.h>
     45#include <rld-symbols.h>
    4446
    4547#ifndef HAVE_KILL
    4648#define kill(p,s) raise(s)
    4749#endif
     50
     51/**
     52 * Header text.
     53 */
     54static const char* c_header[] =
     55{
     56  "/*",
     57  " * RTEMS Global Symbol Table",
     58  " *  Automatically generated so no point in hacking on it.",
     59  " */",
     60  "",
     61  "#if __bfin__ || __h8300__ || __v850__",
     62  " extern unsigned char _rtems_rtl_base_globals[];",
     63  " extern unsigned int _rtems_rtl_base_globals_size;",
     64  "#else",
     65  " extern unsigned char __rtems_rtl_base_globals[];",
     66  " extern unsigned int __rtems_rtl_base_globals_size;",
     67  "#endif",
     68  "",
     69  "asm(\"  .align   4\");",
     70  "asm(\"__rtems_rtl_base_globals:\");",
     71  0
     72};
     73
     74static const char* c_trailer[] =
     75{
     76  "asm(\"  .byte    0\");",
     77  "#if __mips__",
     78  " asm(\"  .align 0\");",
     79  "#else",
     80  " asm(\"  .balign 1\");",
     81  "#endif",
     82  "asm(\"  .ascii \\\"\\xde\\xad\\xbe\\xef\\\"\");",
     83  "asm(\"  .align   4\");",
     84  "asm(\"__rtems_rtl_base_globals_size:\");",
     85  "asm(\"  .long __rtems_rtl_base_globals_size - __rtems_rtl_base_globals\");",
     86  "",
     87  "void rtems_rtl_base_sym_global_add (const unsigned char* , unsigned int );",
     88  0
     89};
     90
     91static const char* c_rtl_call_body[] =
     92{
     93  "{",
     94  "#if __bfin__ || __h8300__ || __v850__",
     95  "  rtems_rtl_base_sym_global_add (_rtems_rtl_base_globals,",
     96  "                                 _rtems_rtl_base_globals_size);",
     97  "#else",
     98  "  rtems_rtl_base_sym_global_add (__rtems_rtl_base_globals,",
     99  "                                 __rtems_rtl_base_globals_size);",
     100  "#endif",
     101  "}",
     102  0
     103};
     104
     105/**
     106 * Paint the data to the temporary file.
     107 */
     108static void
     109temporary_file_paint (rld::process::tempfile& t, const char* lines[])
     110{
     111  for (int l = 0; lines[l]; ++l)
     112    t.write_line (lines[l]);
     113}
     114
     115/**
     116 * The constructor trailer.
     117 */
     118static void
     119c_constructor_trailer (rld::process::tempfile& c)
     120{
     121  temporary_file_paint (c, c_trailer);
     122  c.write_line ("static void init(void) __attribute__ ((constructor));");
     123  c.write_line ("static void init(void)");
     124  temporary_file_paint (c, c_rtl_call_body);
     125}
     126
     127/**
     128 * The embedded trailer.
     129 */
     130static void
     131c_embedded_trailer(rld::process::tempfile& c)
     132{
     133  temporary_file_paint (c, c_trailer);
     134  c.write_line ("void rtems_rtl_base_global_syms_init(void);");
     135  c.write_line ("void rtems_rtl_base_global_syms_init(void)");
     136  temporary_file_paint (c, c_rtl_call_body);
     137}
     138
     139/**
     140 * Generate the symbol map object file for loading or linking into
     141 * a running RTEMS machine.
     142 */
     143static void
     144generate_asm (rld::process::tempfile& c,
     145              rld::symbols::table&    symbols,
     146              bool                    embed)
     147{
     148  temporary_file_paint (c, c_header);
     149
     150  for (rld::symbols::symtab::const_iterator si = symbols.externals ().begin ();
     151       si != symbols.externals ().end ();
     152       ++si)
     153  {
     154    const rld::symbols::symbol& sym = *((*si).second);
     155
     156    if (!sym.name ().empty ())
     157    {
     158      c.write_line ("asm(\"  .asciz \\\"" + sym.name () + "\\\"\");");
     159
     160      if (embed)
     161      {
     162        c.write_line ("#if __mips__");
     163        c.write_line ("asm(\"  .align 0\");");
     164        c.write_line ("#else");
     165        c.write_line ("asm(\"  .balign 1\");");
     166        c.write_line ("#endif");
     167        c.write_line ("asm(\"  .long " + sym.name () + "\");");
     168      }
     169      else
     170      {
     171        std::stringstream oss;
     172        oss << std::hex << std::setfill ('0') << std::setw (8) << sym.value ();
     173        c.write_line ("asm(\"  .long 0x" + oss.str () + "\");");
     174      }
     175    }
     176  }
     177
     178  if (embed)
     179    c_embedded_trailer (c);
     180  else
     181    c_constructor_trailer (c);
     182}
     183
     184static void
     185generate_symmap (rld::process::tempfile& c,
     186                 const std::string&      output,
     187                 rld::symbols::table&    symbols,
     188                 bool                    embed)
     189{
     190  c.open (true);
     191
     192  if (rld::verbose ())
     193    std::cout << "symbol C file: " << c.name () << std::endl;
     194
     195  generate_asm (c, symbols, embed);
     196
     197  if (rld::verbose ())
     198    std::cout << "symbol O file: " << output << std::endl;
     199
     200  rld::process::arg_container args;
     201
     202  rld::cc::make_cc_command (args);
     203  rld::cc::append_flags (rld::cc::ft_cflags, args);
     204
     205  args.push_back ("-O2");
     206  args.push_back ("-g");
     207  args.push_back ("-c");
     208  args.push_back ("-o");
     209  args.push_back (output);
     210  args.push_back (c.name ());
     211
     212  rld::process::tempfile out;
     213  rld::process::tempfile err;
     214  rld::process::status   status;
     215
     216  status = rld::process::execute (rld::cc::get_cc (),
     217                                  args,
     218                                  out.name (),
     219                                  err.name ());
     220
     221  if ((status.type != rld::process::status::normal) ||
     222      (status.code != 0))
     223  {
     224    err.output (rld::cc::get_cc (), std::cout);
     225    throw rld::error ("Compiler error", "compiling wrapper");
     226  }
     227}
    48228
    49229/**
     
    56236  { "verbose",     no_argument,            NULL,           'v' },
    57237  { "warn",        no_argument,            NULL,           'w' },
    58   { "lib-path",    required_argument,      NULL,           'L' },
    59   { "lib",         required_argument,      NULL,           'l' },
    60   { "no-stdlibs",  no_argument,            NULL,           'n' },
     238  { "keep",        no_argument,            NULL,           'k' },
     239  { "embed",       no_argument,            NULL,           'e' },
     240  { "symc",        required_argument,      NULL,           'S' },
     241  { "output",      required_argument,      NULL,           'o' },
     242  { "map",         required_argument,      NULL,           'm' },
    61243  { "cc",          required_argument,      NULL,           'C' },
    62244  { "exec-prefix", required_argument,      NULL,           'E' },
    63   { "march",       required_argument,      NULL,           'a' },
    64   { "mcpu",        required_argument,      NULL,           'c' },
     245  { "cflags",      required_argument,      NULL,           'c' },
    65246  { NULL,          0,                      NULL,            0 }
    66247};
     
    69250usage (int exit_code)
    70251{
    71   std::cout << "rtems-syms [options] objects" << std::endl
     252  std::cout << "rtems-syms [options] kernel" << std::endl
    72253            << "Options and arguments:" << std::endl
    73254            << " -h        : help (also --help)" << std::endl
     
    76257            << "             to increase verbosity (also --verbose)" << std::endl
    77258            << " -w        : generate warnings (also --warn)" << std::endl
    78             << " -L path   : path to a library, add multiple for more than" << std::endl
    79             << "             one path (also --lib-path)" << std::endl
    80             << " -l lib    : add lib to the libraries searched, add multiple" << std::endl
    81             << "             for more than one library (also --lib)" << std::endl
    82             << " -S        : search standard libraries (also --stdlibs)" << std::endl
     259            << " -k        : keep temporary files (also --keep)" << std::endl
     260            << " -e        : embedded symbol table (also --embed)" << std::endl
     261            << " -S        : symbol's C file (also --symc)" << std::endl
     262            << " -o file   : output object file (also --output)" << std::endl
     263            << " -m file   : output a map file (also --map)" << std::endl
    83264            << " -C file   : execute file as the target C compiler (also --cc)" << std::endl
    84265            << " -E prefix : the RTEMS tool prefix (also --exec-prefix)" << std::endl
     
    130311  try
    131312  {
    132     rld::files::cache   cache;
    133     rld::path::paths    libpaths;
    134     rld::path::paths    libs;
    135     rld::path::paths    objects;
    136     rld::path::paths    libraries;
     313    rld::files::cache   kernel;
    137314    rld::symbols::table symbols;
    138     std::string         base_name;
    139     std::string         cc_name;
    140     bool                standard_libs = false;
    141 #if HAVE_WARNINGS
     315    std::string         kernel_name;
     316    std::string         output;
     317    std::string         map;
     318    std::string         cc;
     319    std::string         symc;
     320    bool                embed = false;
    142321    bool                warnings = false;
    143 #endif
    144 
    145     libpaths.push_back (".");
     322
     323    rld::set_cmdline (argc, argv);
    146324
    147325    while (true)
    148326    {
    149       int opt = ::getopt_long (argc, argv, "hvwVSE:L:l:c:C:", rld_opts, NULL);
     327      int opt = ::getopt_long (argc, argv, "hvVwS:o:m:E:c:C:", rld_opts, NULL);
    150328      if (opt < 0)
    151329        break;
     
    164342
    165343        case 'w':
    166 #if HAVE_WARNINGS
    167344          warnings = true;
    168 #endif
    169           break;
    170 
    171         case 'l':
    172           /*
    173            * The order is important. It is the search order.
    174            */
    175           libs.push_back (optarg);
    176           break;
    177 
    178         case 'L':
    179           if ((optarg[::strlen (optarg) - 1] == '/') ||
    180               (optarg[::strlen (optarg) - 1] == '\\'))
    181             optarg[::strlen (optarg) - 1] = '\0';
    182           libpaths.push_back (optarg);
    183           break;
    184 
    185         case 'S':
    186           standard_libs = true;
     345          break;
     346
     347        case 'k':
     348          rld::process::set_keep_temporary_files ();
     349          break;
     350
     351        case 'e':
     352          embed = true;
     353          break;
     354
     355        case 'o':
     356          output = optarg;
     357          break;
     358
     359        case 'm':
     360          map = optarg;
    187361          break;
    188362
     
    203377          break;
    204378
     379        case 'S':
     380          symc = optarg;
     381          break;
     382
    205383        case '?':
    206384          usage (3);
     
    213391    }
    214392
     393    /*
     394     * Set the program name.
     395     */
     396    rld::set_progname (argv[0]);
     397
    215398    argc -= optind;
    216399    argv += optind;
    217400
    218     std::cout << "RTEMS Symbols " << rld::version () << std::endl;
     401    if (rld::verbose ())
     402      std::cout << "RTEMS Kernel Symbols " << rld::version () << std::endl;
    219403
    220404    /*
     
    222406     */
    223407    if (argc == 0)
    224       throw rld::error ("no object files", "options");
     408      throw rld::error ("no kernel file", "options");
     409    if (argc != 1)
     410      throw rld::error ("only one kernel file", "options");
     411    if (output.empty ())
     412      throw rld::error ("no output file", "options");
     413
     414    kernel_name = *argv;
     415
     416    if (rld::verbose ())
     417      std::cout << "kernel: " << kernel_name << std::endl;
    225418
    226419    /*
    227      * Load the remaining command line arguments into the cache as object
    228      * files.
    229      */
    230     while (argc--)
    231       objects.push_back (*argv++);
    232 
    233     /*
    234      * Add the object files to the cache.
    235      */
    236     cache.add (objects);
    237 
    238     /*
    239      * Open the cache.
    240      */
    241     cache.open ();
    242 
    243     /*
    244      * If the full path to CC is not provided and the exec-prefix is not set by
    245      * the command line see if it can be detected from the object file
    246      * types. This must be after we have added the object files because they
    247      * are used when detecting.
    248      */
    249     if (!rld::cc::is_cc_set () && !rld::cc::is_exec_prefix_set ())
    250       rld::cc::set_exec_prefix (rld::elf::machine_type ());
    251 
    252     /*
    253      * Get the standard library paths
    254      */
    255     if (standard_libs)
    256       rld::cc::get_standard_libpaths (libpaths);
    257 
    258     /*
    259      * Get the command line libraries.
    260      */
    261     rld::files::find_libraries (libraries, libpaths, libs);
    262 
    263     /*
    264      * Are we to load standard libraries ?
    265      */
    266     if (standard_libs)
    267       rld::cc::get_standard_libs (libraries, libpaths);
    268 
    269     /*
    270      * Load the library to the cache.
    271      */
    272     cache.add_libraries (libraries);
    273 
    274     /*
    275      * Begin the archive session. This opens the archives and leaves them open
    276      * while we the symbol table is being used. The symbols reference object
    277      * files and the object files may reference archives and it is assumed they
    278      * are open and available. It is also assumed the number of library
    279      * archives being managed is less than the maximum file handles this
    280      * process can have open at any one time. If this is not the case this
    281      * approach would need to be reconsidered and the overhead of opening and
    282      * closing archives added.
     420     * Load the symbols from the kernel.
    283421     */
    284422    try
    285423    {
     424      kernel.open ();
     425      kernel.add (kernel_name);
     426      kernel.load_symbols (symbols, true);
     427
    286428      /*
    287        * Load the symbol table.
     429       * If the full path to CC is not provided and the exec-prefix is not set
     430       * by the command line see if it can be detected from the object file
     431       * types. This must be after we have added the object files because they
     432       * are used when detecting.
    288433       */
    289       cache.load_symbols (symbols);
    290 
    291       rld::map (cache, symbols);
     434      if (!cc.empty ())
     435        rld::cc::set_cc (cc);
     436      if (!rld::cc::is_cc_set () && !rld::cc::is_exec_prefix_set ())
     437        rld::cc::set_exec_prefix (rld::elf::machine_type ());
     438
     439      rld::process::tempfile c (".c");
     440
     441      if (!symc.empty ())
     442      {
     443        c.override (symc);
     444        c.keep ();
     445      }
     446
     447      /*
     448       * Generate and compile the symbol map.
     449       */
     450      generate_symmap (c, output, symbols, embed);
     451
     452      /*
     453       * Create a map file is asked to.
     454       */
     455      if (!map.empty ())
     456      {
     457        std::ofstream mout;
     458        mout.open (map);
     459        if (!mout.is_open ())
     460          throw rld::error ("map file open failed", "map");
     461        mout << "RTEMS Kernel Symbols Map" << std::endl
     462             << " kernel: " << kernel_name << std::endl
     463             << std::endl;
     464        rld::symbols::output (mout, symbols);
     465        mout.close ();
     466      }
     467
     468      kernel.close ();
    292469    }
    293470    catch (...)
    294471    {
    295       cache.archives_end ();
     472      kernel.close ();
    296473      throw;
    297474    }
    298475
    299     cache.archives_end ();
     476    kernel.close ();
    300477  }
    301478  catch (rld::error re)
Note: See TracChangeset for help on using the changeset viewer.