Changeset fdb1fe6 in rtems-tools


Ignore:
Timestamp:
Oct 30, 2014, 6:55:18 AM (5 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.10, 4.11, master
Children:
2015c85
Parents:
aac2949
Message:

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.

Files:
7 edited

Legend:

Unmodified
Added
Removed
  • linkers/rtems-syms.cpp

    raac2949 rfdb1fe6  
    5656  "/*",
    5757  " * RTEMS Global Symbol Table",
    58   " *  Automatically generated so no point in hacking on it.",
     58  " *  Automatically generated. Do not edit..",
    5959  " */",
    6060  "",
    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",
     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\\\"\");",
    6867  "",
    6968  "asm(\"  .align   4\");",
    70   "asm(\"__rtems_rtl_base_globals:\");",
    71   0
    72 };
    73 
    74 static const char* c_trailer[] =
    75 {
    76   "asm(\"  .byte    0\");",
     69  "asm(\"  .local   rtems__rtl_base_globals\");",
     70  "asm(\"rtems__rtl_base_globals:\");",
    7771  "#if __mips__",
    7872  " asm(\"  .align 0\");",
     
    8074  " asm(\"  .balign 1\");",
    8175  "#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 );",
    8876  0
    8977};
    9078
     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
    9199static const char* c_rtl_call_body[] =
    92100{
    93101  "{",
    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",
     102  "  rtems_rtl_base_sym_global_add ((const unsigned char*) &rtems__rtl_base_globals,",
     103  "                                 rtems__rtl_base_globals_size);",
    101104  "}",
    102105  0
     
    119122c_constructor_trailer (rld::process::tempfile& c)
    120123{
    121   temporary_file_paint (c, c_trailer);
    122124  c.write_line ("static void init(void) __attribute__ ((constructor));");
    123125  c.write_line ("static void init(void)");
     
    129131 */
    130132static void
    131 c_embedded_trailer(rld::process::tempfile& c)
    132 {
    133   temporary_file_paint (c, c_trailer);
     133c_embedded_trailer (rld::process::tempfile& c)
     134{
    134135  c.write_line ("void rtems_rtl_base_global_syms_init(void);");
    135136  c.write_line ("void rtems_rtl_base_global_syms_init(void)");
     
    142143 */
    143144static void
    144 generate_asm (rld::process::tempfile& c,
    145               rld::symbols::table&    symbols,
    146               bool                    embed)
     145generate_c (rld::process::tempfile& c,
     146              rld::symbols::table&  symbols,
     147              bool                  embed)
    147148{
    148149  temporary_file_paint (c, c_header);
    149150
    150   for (rld::symbols::symtab::const_iterator si = symbols.externals ().begin ();
    151        si != symbols.externals ().end ();
     151  for (rld::symbols::symtab::const_iterator si = symbols.globals ().begin ();
     152       si != symbols.globals ().end ();
    152153       ++si)
    153154  {
    154155    const rld::symbols::symbol& sym = *((*si).second);
    155156
    156     if (!sym.name ().empty ())
     157    c.write_line ("asm(\"  .asciz \\\"" + sym.name () + "\\\"\");");
     158
     159    if (embed)
    157160    {
    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       }
     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 () + "\");");
    175168    }
    176169  }
     170
     171  temporary_file_paint (c, c_trailer);
    177172
    178173  if (embed)
     
    193188    std::cout << "symbol C file: " << c.name () << std::endl;
    194189
    195   generate_asm (c, symbols, embed);
     190  generate_c (c, symbols, embed);
    196191
    197192  if (rld::verbose ())
     
    204199
    205200  args.push_back ("-O2");
    206   args.push_back ("-g");
    207201  args.push_back ("-c");
    208202  args.push_back ("-o");
     
    218212                                  out.name (),
    219213                                  err.name ());
     214
    220215
    221216  if ((status.type != rld::process::status::normal) ||
     
    325320    while (true)
    326321    {
    327       int opt = ::getopt_long (argc, argv, "hvVwS:o:m:E:c:C:", rld_opts, NULL);
     322      int opt = ::getopt_long (argc, argv, "hvVwkef:S:o:m:E:c:C:", rld_opts, NULL);
    328323      if (opt < 0)
    329324        break;
     
    409404    if (argc != 1)
    410405      throw rld::error ("only one kernel file", "options");
    411     if (output.empty ())
    412       throw rld::error ("no output file", "options");
     406    if (output.empty () && map.empty ())
     407      throw rld::error ("no output or map", "options");
    413408
    414409    kernel_name = *argv;
     
    422417    try
    423418    {
     419      /*
     420       * Load the kernel ELF file symbol table.
     421       */
    424422      kernel.open ();
    425423      kernel.add (kernel_name);
     
    437435        rld::cc::set_exec_prefix (rld::elf::machine_type ());
    438436
    439       rld::process::tempfile c (".c");
    440 
    441       if (!symc.empty ())
    442       {
    443         c.override (symc);
    444         c.keep ();
    445       }
    446 
    447437      /*
    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.
     438       * Create a map file if asked too.
    454439       */
    455440      if (!map.empty ())
     
    464449        rld::symbols::output (mout, symbols);
    465450        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);
    466470      }
    467471
  • rtemstoolkit/rld-files.cpp

    raac2949 rfdb1fe6  
    10411041      rld::symbols::pointers syms;
    10421042
    1043       elf ().get_symbols (syms, false, local, false, true);
     1043      if (local)
     1044      {
     1045        elf ().get_symbols (syms, false, true, false, false);
     1046
     1047        if (rld::verbose () >= RLD_VERBOSE_TRACE_SYMS)
     1048          std::cout << "object:load-sym: local: total "
     1049                    << syms.size () << std::endl;
     1050
     1051        for (symbols::pointers::iterator si = syms.begin ();
     1052             si != syms.end ();
     1053             ++si)
     1054        {
     1055          symbols::symbol& sym = *(*si);
     1056
     1057          if (rld::verbose () >= RLD_VERBOSE_TRACE_SYMS)
     1058            std::cout << "object:load-sym: local: " << sym << std::endl;
     1059
     1060          sym.set_object (*this);
     1061          symbols.add_local (sym);
     1062        }
     1063      }
     1064
     1065      elf ().get_symbols (syms, false, false, true, false);
    10441066
    10451067      if (rld::verbose () >= RLD_VERBOSE_TRACE_SYMS)
    1046         std::cout << "object:load-sym: exported: total "
     1068        std::cout << "object:load-sym: weak: total "
    10471069                  << syms.size () << std::endl;
    10481070
     
    10541076
    10551077        if (rld::verbose () >= RLD_VERBOSE_TRACE_SYMS)
    1056           std::cout << "object:load-sym: exported: " << sym << std::endl;
     1078          std::cout << "object:load-sym: weak: " << sym << std::endl;
    10571079
    10581080        sym.set_object (*this);
    1059         symbols.add_external (sym);
     1081        symbols.add_weak (sym);
    10601082        externals.push_back (&sym);
    10611083      }
    10621084
    1063       elf ().get_symbols (syms, false, false, true, false);
     1085      elf ().get_symbols (syms, false, false, false, true);
    10641086
    10651087      if (rld::verbose () >= RLD_VERBOSE_TRACE_SYMS)
    1066         std::cout << "object:load-sym: weak: total "
     1088        std::cout << "object:load-sym: global: total "
    10671089                  << syms.size () << std::endl;
    10681090
     
    10741096
    10751097        if (rld::verbose () >= RLD_VERBOSE_TRACE_SYMS)
    1076           std::cout << "object:load-sym: weak: " << sym << std::endl;
     1098          std::cout << "object:load-sym: global: " << sym << std::endl;
    10771099
    10781100        sym.set_object (*this);
    1079         symbols.add_weak (sym);
     1101        symbols.add_global (sym);
    10801102        externals.push_back (&sym);
    10811103      }
  • rtemstoolkit/rld-process.cpp

    raac2949 rfdb1fe6  
    272272          if (level < (sizeof (buf) - 1))
    273273          {
    274             memset (buf + level, 0, sizeof (buf) - level);
     274            ::memset (buf + level, 0, sizeof (buf) - level);
    275275            int read = ::read (fd, buf + level, sizeof (buf) - level - 1);
    276276            if (read < 0)
     
    286286            int   len = level;
    287287            if (lf)
     288            {
    288289              len = lf - &buf[0] + 1;
    289             if (lf || !reading)
    290             {
    291               line.append (buf, len);
    292               level -= len;
    293             }
     290              reading = false;
     291            }
     292            line.append (buf, len);
     293            level -= len;
    294294            if (level)
    295295              ::memmove (buf, &buf[len], level + 1);
    296             reading = false;
    297296          }
    298297        }
     
    355354          read_line (line);
    356355          ++lc;
    357           if (line.empty ())
     356          if (line.empty () && (level == 0))
    358357            break;
    359358          if (!prefix.empty ())
  • rtemstoolkit/rld-resolver.cpp

    raac2949 rfdb1fe6  
    109109          continue;
    110110
    111         symbols::symbol* es = base_symbols.find_external (urs.name ());
     111        symbols::symbol* es = base_symbols.find_global (urs.name ());
    112112        bool             base = true;
    113113
     
    121121        if (!es)
    122122        {
    123           es = symbols.find_external (urs.name ());
     123          es = symbols.find_global (urs.name ());
    124124          if (!es)
    125125          {
  • rtemstoolkit/rld-symbols.cpp

    raac2949 rfdb1fe6  
    133133    }
    134134
     135    bool
     136    symbol::is_local () const
     137    {
     138      return binding () == STB_LOCAL;
     139    }
     140
     141    bool
     142    symbol::is_weak () const
     143    {
     144      return binding () == STB_WEAK;
     145    }
     146
     147    bool
     148    symbol::is_global () const
     149    {
     150      return binding () == STB_GLOBAL;
     151    }
     152
    135153    int
    136154    symbol::type () const
     
    276294
    277295    void
    278     table::add_external (symbol& sym)
    279     {
    280       _externals[sym.name ()] = &sym;
     296    table::add_global (symbol& sym)
     297    {
     298      globals_[sym.name ()] = &sym;
    281299    }
    282300
     
    284302    table::add_weak (symbol& sym)
    285303    {
    286       _weaks[sym.name ()] = &sym;
     304      weaks_[sym.name ()] = &sym;
     305    }
     306
     307    void
     308    table::add_local (symbol& sym)
     309    {
     310      locals_[sym.name ()] = &sym;
    287311    }
    288312
    289313    symbol*
    290     table::find_external (const std::string& name)
    291     {
    292       symtab::iterator sti = _externals.find (name);
    293       if (sti == _externals.end ())
     314    table::find_global (const std::string& name)
     315    {
     316      symtab::iterator sti = globals_.find (name);
     317      if (sti == globals_.end ())
    294318        return 0;
    295319      return (*sti).second;
     
    299323    table::find_weak (const std::string& name)
    300324    {
    301       symtab::iterator sti = _weaks.find (name);
    302       if (sti == _weaks.end ())
     325      symtab::iterator sti = weaks_.find (name);
     326      if (sti == weaks_.end ())
    303327        return 0;
    304328      return (*sti).second;
    305329    }
    306330
     331    symbol*
     332    table::find_local (const std::string& name)
     333    {
     334      symtab::iterator sti = locals_.find (name);
     335      if (sti == locals_.end ())
     336        return 0;
     337      return (*sti).second;
     338    }
     339
    307340    size_t
    308341    table::size () const
    309342    {
    310       return _externals.size () + _weaks.size ();
     343      return globals_.size () + weaks_.size () + locals_.size ();
    311344    }
    312345
    313346    const symtab&
    314     table::externals () const
    315     {
    316       return _externals;
     347    table::globals () const
     348    {
     349      return globals_;
    317350    }
    318351
     
    320353    table::weaks () const
    321354    {
    322       return _weaks;
     355      return weaks_;
     356    }
     357
     358    const symtab&
     359    table::locals () const
     360    {
     361      return locals_;
    323362    }
    324363
     
    330369           ++sbi)
    331370      {
    332         table_.add_external (*sbi);
     371        table_.add_global (*sbi);
    333372      }
    334373    }
     
    365404    output (std::ostream& out, const table& symbols)
    366405    {
    367       out << "Externals:" << std::endl;
    368       output (out, symbols.externals ());
     406      out << "Globals:" << std::endl;
     407      output (out, symbols.globals ());
    369408      out << "Weaks:" << std::endl;
    370409      output (out, symbols.weaks ());
     410      out << "Locals:" << std::endl;
     411      output (out, symbols.locals ());
    371412    }
    372413
  • rtemstoolkit/rld-symbols.h

    raac2949 rfdb1fe6  
    102102
    103103      /**
     104       * Is the symbol binding is local ?
     105       */
     106      bool is_local () const;
     107
     108      /**
     109       * Is the symbol binding weak ?
     110       */
     111      bool is_weak () const;
     112
     113      /**
     114       * Is the symbol binding global ?
     115       */
     116      bool is_global () const;
     117
     118      /**
    104119       * The symbol's type.
    105120       */
     
    191206
    192207    /**
    193      * A symbols contains a symbol table of externals and weak symbols.
     208     * A symbols contains a symbol table of global, weak and local symbols.
    194209     */
    195210    class table
     
    207222
    208223      /**
    209        * Add an external symbol.
    210        */
    211       void add_external (symbol& sym);
     224       * Add a global symbol.
     225       */
     226      void add_global (symbol& sym);
    212227
    213228      /**
     
    217232
    218233      /**
    219        * Find an external symbol.
    220        */
    221       symbol* find_external (const std::string& name);
     234       * Add a local symbol.
     235       */
     236      void add_local (symbol& sym);
     237
     238      /**
     239       * Find a global symbol.
     240       */
     241      symbol* find_global (const std::string& name);
    222242
    223243      /**
     
    227247
    228248      /**
     249       * Find an local symbol.
     250       */
     251      symbol* find_local (const std::string& name);
     252
     253      /**
    229254       * Return the size of the symbols loaded.
    230255       */
     
    232257
    233258      /**
    234        * Return the externals symbol table.
    235        */
    236       const symtab& externals () const;
     259       * Return the globals symbol table.
     260       */
     261      const symtab& globals () const;
    237262
    238263      /**
     
    241266      const symtab& weaks () const;
    242267
     268      /**
     269       * Return the locals symbol table.
     270       */
     271      const symtab& locals () const;
     272
    243273    private:
    244274
     
    249279
    250280      /**
    251        * A table of external symbols.
    252        */
    253       symtab _externals;
     281       * A table of global symbols.
     282       */
     283      symtab globals_;
    254284
    255285      /**
    256286       * A table of weak symbols.
    257287       */
    258       symtab _weaks;
     288      symtab weaks_;
     289
     290      /**
     291       * A table of local symbols.
     292       */
     293      symtab locals_;
    259294    };
    260295
  • rtemstoolkit/rtems-utils.h

    raac2949 rfdb1fe6  
    2323 */
    2424
    25 #if !defined (_MEMORY_DUMP_H_)
    26 #define _MEMORY_DUMP_H_
     25#if !defined (_RTEMS_UTILS_H_)
     26#define _RTEMS_UTILS_H_
    2727
    2828#include <stdint.h>
Note: See TracChangeset for help on using the changeset viewer.