Changeset 977c3de in rtems-tools


Ignore:
Timestamp:
Nov 17, 2012, 6:34:33 AM (7 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.10, 4.11, master
Children:
065ac15
Parents:
0b65a28
Message:

Refactor the ELF support to allow ELF write suppport.

The refactoring allows better reuse of the ELF support and cleans up
some hacks from the generic file and archive handling improving the
separation of the file handling from the file format, ie ELF. The
handling of ELF object files and ELF object files inside archives
is cleaner.

The refactor cleaned up the symbol handling where the symbols now
reside in the ELF file object and references are take in symbol
pointer containers and symbol table containers.

The main purpose of the refactor is to allow support for creating
and writing ELF files.

Also added an rtems-syms command where special symbol support
can be added.

Location:
linkers
Files:
1 added
11 edited
1 moved

Legend:

Unmodified
Added
Removed
  • linkers/rld-elf-types.h

    r0b65a28 r977c3de  
    11/*
    2  * Copyright (c) 2011, Chris Johns <chrisj@rtems.org> 
     2 * Copyright (c) 2011, Chris Johns <chrisj@rtems.org>
    33 *
    44 * Permission to use, copy, modify, and/or distribute this software for any
    55 * purpose with or without fee is hereby granted, provided that the above
    66 * copyright notice and this permission notice appear in all copies.
    7  * 
     7 *
    88 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    99 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
     
    3737     * Hide the types from libelf we use.
    3838     */
    39     typedef ::GElf_Word elf_word;
    40     typedef ::GElf_Addr elf_addr;
    41     typedef ::GElf_Sym  elf_sym;
    42     typedef ::Elf_Kind  elf_kind;
    43     typedef ::Elf_Scn   elf_scn;
    44     typedef ::GElf_Shdr elf_shdr;
    45     typedef ::GElf_Ehdr elf_ehdr;
    46     typedef ::Elf_Data  elf_data;
    47     typedef ::Elf       elf;
     39    typedef ::GElf_Word  elf_word;
     40    typedef ::GElf_Xword elf_xword;
     41    typedef ::GElf_Addr  elf_addr;
     42    typedef ::GElf_Off   elf_off;
     43    typedef ::GElf_Sym   elf_sym;
     44    typedef ::Elf_Kind   elf_kind;
     45    typedef ::Elf_Scn    elf_scn;
     46    typedef ::GElf_Ehdr  elf_ehdr;
     47    typedef ::GElf_Shdr  elf_shdr;
     48    typedef ::GElf_Phdr  elf_phdr;
     49    typedef ::Elf_Data   elf_data;
     50    typedef ::Elf        elf;
    4851  }
    4952}
  • linkers/rld-elf.cpp

    r0b65a28 r977c3de  
    11/*
    2  * Copyright (c) 2011, Chris Johns <chrisj@rtems.org>
     2 * Copyright (c) 2011-2012, Chris Johns <chrisj@rtems.org>
    33 *
    44 * Permission to use, copy, modify, and/or distribute this software for any
    55 * purpose with or without fee is hereby granted, provided that the above
    66 * copyright notice and this permission notice appear in all copies.
    7  * 
     7 *
    88 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    99 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
     
    3131  namespace elf
    3232  {
    33     void error (const std::string& where)
    34     {
    35       throw rld::error (::elf_errmsg (-1), "elf:" + where);
     33    /**
     34     * Throw an ELF error.
     35     *
     36     * @param where Where the error is raised.
     37     */
     38    void libelf_error (const std::string& where)
     39    {
     40      throw rld::error (::elf_errmsg (-1), "libelf:" + where);
    3641    }
    3742
     
    4045     * header of and all header must match. We cannot mix object module types.
    4146     */
    42     static int elf_object_class = ELFCLASSNONE;
    43     static int elf_object_data = ELFDATANONE;
    44     static int elf_object_machinetype = EM_NONE;
     47    static unsigned int elf_object_class = ELFCLASSNONE;
     48    static unsigned int elf_object_data = ELFDATANONE;
     49    static unsigned int elf_object_machinetype = EM_NONE;
    4550
    4651    /**
     
    5560      {
    5661        if (::elf_version (EV_CURRENT) == EV_NONE)
    57           error ("initialisation");
     62          libelf_error ("initialisation");
    5863        libelf_initialised = true;
    5964      }
    6065    }
    6166
    62     /**
    63      * Return the RTEMS target type given the ELF machine type.
    64      */
     67    section::section (file& file_, int index_)
     68      : file_ (&file_),
     69        index_ (index_),
     70        scn (0),
     71        data_ (0)
     72    {
     73      memset (&shdr, 0, sizeof (shdr));
     74
     75      scn = ::elf_getscn (file_.get_elf (), index_);
     76      if (!scn)
     77        libelf_error ("elf_getscn: " + file_.name ());
     78
     79      if (!::gelf_getshdr (scn, &shdr))
     80        libelf_error ("gelf_getshdr: " + file_.name ());
     81
     82      if (shdr.sh_type != SHT_NULL)
     83      {
     84        name_ = file_.get_string (shdr.sh_name);
     85        data_ = ::elf_getdata (scn, NULL);
     86        if (!data_)
     87          libelf_error ("elf_getdata: " + name_ + '(' + file_.name () + ')');
     88      }
     89    }
     90
     91    section::section (const section& orig)
     92      : file_ (orig.file_),
     93        index_ (orig.index_),
     94        name_ (orig.name_),
     95        scn (orig.scn),
     96        shdr (orig.shdr),
     97        data_ (orig.data_)
     98    {
     99    }
     100
     101    section::section ()
     102      : file_ (0),
     103        index_ (-1),
     104        scn (0),
     105        data_ (0)
     106    {
     107      memset (&shdr, 0, sizeof (shdr));
     108    }
     109
     110    int
     111    section::index () const
     112    {
     113      check ();
     114      return index_;
     115    }
     116
     117    const std::string&
     118    section::name () const
     119    {
     120      check ();
     121      return name_;
     122    }
     123
     124    elf_data*
     125    section::data ()
     126    {
     127      check ();
     128      return data_;
     129    }
     130
     131    elf_word
     132    section::type () const
     133    {
     134      check ();
     135      return shdr.sh_type;
     136    }
     137
     138    elf_xword
     139    section::flags () const
     140    {
     141      check ();
     142      return shdr.sh_flags;
     143    }
     144
     145    elf_addr
     146    section::address () const
     147    {
     148      check ();
     149      return shdr.sh_addr;
     150    }
     151
     152    elf_xword
     153    section::alignment () const
     154    {
     155      check ();
     156      return shdr.sh_addralign;
     157    }
     158
     159    elf_off
     160    section::offset () const
     161    {
     162      check ();
     163      return shdr.sh_offset;
     164    }
     165
     166    elf_word
     167    section::link () const
     168    {
     169      check ();
     170      return shdr.sh_link;
     171    }
     172
     173    elf_word
     174    section::info () const
     175    {
     176      check ();
     177      return shdr.sh_info;
     178    }
     179
     180    elf_xword
     181    section::size () const
     182    {
     183      check ();
     184      return shdr.sh_size;
     185    }
     186
     187    elf_xword
     188    section::entry_size () const
     189    {
     190      check ();
     191      return shdr.sh_entsize;
     192    }
     193
     194    int
     195    section::entries () const
     196    {
     197      return size () / entry_size ();
     198    }
     199
     200    void
     201    section::check () const
     202    {
     203      if (!file_ || (index_ < 0))
     204        throw rld::error ("Invalid section.", "section:check:");
     205    }
     206
     207    file::file ()
     208      : fd_ (-1),
     209        archive (false),
     210        writable (false),
     211        elf_ (0),
     212        oclass (0),
     213        ident_str (0),
     214        ident_size (0)
     215    {
     216      memset (&ehdr, 0, sizeof (ehdr));
     217      memset (&phdr, 0, sizeof (phdr));
     218    }
     219
     220    file::~file ()
     221    {
     222      end ();
     223    }
     224
     225    void
     226    file::begin (const std::string& name__, int fd__, const bool writable_)
     227    {
     228      begin (name__, fd__, writable_, 0, 0);
     229    }
     230
     231    void
     232    file::begin (const std::string& name__, file& archive_, off_t offset)
     233    {
     234      archive_.check ("begin:archive");
     235
     236      if (archive_.writable)
     237        throw rld::error ("archive is writable", "elf:file:begin");
     238
     239      begin (name__, archive_.fd_, false, &archive_, offset);
     240    }
     241
     242    #define rld_archive_fhdr_size (60)
     243
     244    void
     245    file::begin (const std::string& name__,
     246                 int                fd__,
     247                 const bool         writable_,
     248                 file*              archive_,
     249                 off_t              offset_)
     250    {
     251      if (fd__ < 0)
     252        throw rld::error ("no file descriptor", "elf:file:begin");
     253
     254      /*
     255       * Begin's are not nesting.
     256       */
     257      if (elf_ || (fd_ >= 0))
     258        throw rld::error ("already called", "elf:file:begin");
     259
     260      /*
     261       * Cannot write directly into archive. Create a file then archive it.
     262       */
     263      if (archive_ && writable_)
     264        throw rld::error ("cannot write into archives directly",
     265                          "elf:file:begin");
     266
     267      libelf_initialise ();
     268
     269      /*
     270       * Is this image part of an archive ?
     271       */
     272      if (archive_)
     273      {
     274        ssize_t offset = offset_ - rld_archive_fhdr_size;
     275        if (::elf_rand (archive_->elf_, offset) != offset)
     276          libelf_error ("rand: " + archive_->name_);
     277      }
     278
     279      /*
     280       * Note, the elf passed is either the archive or NULL.
     281       */
     282      elf* elf__ = ::elf_begin (fd__,
     283                                writable_ ? ELF_C_WRITE : ELF_C_READ,
     284                                archive_ ? archive_->elf_ : 0);
     285      if (!elf__)
     286        libelf_error ("begin: " + name__);
     287
     288      if (rld::verbose () >= RLD_VERBOSE_FULL_DEBUG)
     289        std::cout << "elf::begin: " << elf__ << ' ' << name__ << std::endl;
     290
     291      elf_kind ek = ::elf_kind (elf__);
     292
     293      /*
     294       * If this is inside an archive it must be an ELF file.
     295       */
     296
     297      if (archive_ && (ek != ELF_K_ELF))
     298        throw rld::error ("File format in archive not ELF", "elf:file:begin: " + name__);
     299      else
     300      {
     301        if (ek == ELF_K_AR)
     302          archive = true;
     303        else if (ek == ELF_K_ELF)
     304          archive = false;
     305        else
     306          throw rld::error ("File format not ELF or archive",
     307                            "elf:file:begin: " + name__);
     308      }
     309
     310      if (!writable_)
     311      {
     312        /*
     313         * If an ELF file make sure they all match. On the first file that
     314         * begins an ELF session record its settings.
     315         */
     316        if (ek == ELF_K_ELF)
     317        {
     318          oclass = ::gelf_getclass (elf__);
     319          ident_str = elf_getident (elf__, &ident_size);
     320        }
     321      }
     322
     323      fd_ = fd__;
     324      name_ = name__;
     325      writable = writable_;
     326      elf_ = elf__;
     327
     328      if (!archive)
     329        load_header ();
     330    }
     331
     332    void
     333    file::end ()
     334    {
     335      if (elf_)
     336      {
     337        if (rld::verbose () >= RLD_VERBOSE_FULL_DEBUG)
     338          std::cout << "libelf::end: " << elf_
     339                    << ' ' << name_ << std::endl;
     340        ::elf_end (elf_);
     341      }
     342
     343      fd_ = -1;
     344      name_.clear ();
     345      archive = false;
     346      elf_ = 0;
     347      oclass = 0;
     348      ident_str = 0;
     349      ident_size = 0;
     350      memset (&ehdr, 0, sizeof (ehdr));
     351      memset (&phdr, 0, sizeof (phdr));
     352      stab.clear ();
     353      secs.clear ();
     354    }
     355
     356    void
     357    file::load_header ()
     358    {
     359      check ("get_header");
     360
     361      if (::gelf_getehdr (elf_, &ehdr) == NULL)
     362        error ("get-header");
     363    }
     364
     365    unsigned int
     366    file::machinetype () const
     367    {
     368      check ("machinetype");
     369      return ehdr.e_machine;
     370    }
     371
     372    unsigned int
     373    file::type () const
     374    {
     375      check ("type");
     376      return ehdr.e_type;
     377    }
     378
     379    unsigned int
     380    file::object_class () const
     381    {
     382      check ("object_class");
     383      return oclass;
     384    }
     385
     386    unsigned int
     387    file::data_type () const
     388    {
     389      check ("data_type");
     390      if (!ident_str)
     391        throw rld::error ("No ELF ident str", "elf:file:data_type: " + name_);
     392      return ident_str[EI_DATA];
     393    }
     394
     395    bool
     396    file::is_archive () const
     397    {
     398      check ("is_archive");
     399      return archive;
     400    }
     401
     402    bool
     403    file::is_executable () const
     404    {
     405      check ("is_executable");
     406      return ehdr.e_type != ET_REL;
     407    }
     408
     409    bool
     410    file::is_relocatable() const
     411    {
     412      check ("is_relocatable");
     413      return ehdr.e_type == ET_REL;
     414    }
     415
     416    int
     417    file::section_count () const
     418    {
     419      check ("section_count");
     420      return ehdr.e_shnum;
     421    }
     422
     423    void
     424    file::load_sections ()
     425    {
     426      if (secs.empty ())
     427      {
     428        check ("load_sections_headers");
     429        for (int sn = 0; sn < section_count (); ++sn)
     430          secs.push_back (section (*this, sn));
     431      }
     432    }
     433
     434    void
     435    file::get_sections (sections& filtered_secs, unsigned int type)
     436    {
     437      load_sections ();
     438      filtered_secs.clear ();
     439      for (sections::iterator si = secs.begin ();
     440           si != secs.end ();
     441           ++si)
     442      {
     443        if ((type == 0) || ((*si).type () == type))
     444          filtered_secs.push_back (*si);
     445      }
     446    }
     447
     448    void
     449    file::load_symbols ()
     450    {
     451      if (symbols.empty ())
     452      {
     453        sections symbol_secs;
     454
     455        get_sections (symbol_secs, SHT_SYMTAB);
     456
     457        for (sections::iterator si = symbol_secs.begin ();
     458             si != symbol_secs.end ();
     459             ++si)
     460        {
     461          section& sec = *si;
     462          int      syms = sec.entries ();
     463
     464          for (int s = 0; s < syms; ++s)
     465          {
     466            elf_sym esym;
     467
     468            if (!::gelf_getsym (sec.data (), s, &esym))
     469             error ("gelf_getsym");
     470
     471            std::string name = get_string (sec.link (), esym.st_name);
     472
     473            if (!name.empty ())
     474            {
     475              symbols::symbol sym (name, esym);
     476
     477              if (rld::verbose () >= RLD_VERBOSE_TRACE)
     478              {
     479                std::cout << "elf::symbol: ";
     480                sym.output (std::cout);
     481                std::cout << std::endl;
     482              }
     483
     484              symbols.push_back (sym);
     485            }
     486          }
     487        }
     488      }
     489    }
     490
     491    void
     492    file::get_symbols (symbols::pointers& filtered_syms,
     493                       bool               unresolved,
     494                       bool               local,
     495                       bool               weak,
     496                       bool               global)
     497    {
     498      if (rld::verbose () >= RLD_VERBOSE_DETAILS)
     499        std::cout << "elf:get-syms: unresolved:" << unresolved
     500                  << " local:" << local
     501                  << " weak:" << weak
     502                  << " global:" << global
     503                  << " " << name_
     504                  << std::endl;
     505
     506      load_symbols ();
     507
     508      filtered_syms.clear ();
     509
     510      for (symbols::bucket::iterator si = symbols.begin ();
     511           si != symbols.end ();
     512           ++si)
     513      {
     514        symbols::symbol& sym = *si;
     515
     516        int stype = sym.type ();
     517        int sbind = sym.binding ();
     518
     519        /*
     520         * If wanting unresolved symbols and the type is no-type and the
     521         * section is undefined, or, the type is no-type or object or function
     522         * and the bind is local and we want local symbols, or the bind is weak
     523         * and we want weak symbols, or the bind is global and we want global
     524         * symbols then add the filtered symbols container.
     525         */
     526        bool add = false;
     527
     528        if ((stype == STT_NOTYPE) && (sym.index () == SHN_UNDEF))
     529        {
     530          if (unresolved)
     531            add = true;
     532        }
     533        else if (!unresolved)
     534        {
     535          if (((stype == STT_NOTYPE) ||
     536               (stype == STT_OBJECT) ||
     537               (stype == STT_FUNC)) &&
     538              ((local && (sbind == STB_LOCAL)) ||
     539                  (weak && (sbind == STB_WEAK)) ||
     540               (global && (sbind == STB_GLOBAL))))
     541            add = true;
     542        }
     543
     544        if (add)
     545          filtered_syms.push_back (&sym);
     546      }
     547    }
     548
     549    int
     550    file::strings_section () const
     551    {
     552      check ("strings_sections");
     553      return ehdr.e_shstrndx;
     554    }
     555
     556    std::string
     557    file::get_string (int section, size_t offset)
     558    {
     559      check ("get_string");
     560      char* s = ::elf_strptr (elf_, section, offset);
     561      if (!s)
     562        error ("elf_strptr");
     563      return s;
     564    }
     565
     566    std::string
     567    file::get_string (size_t offset)
     568    {
     569      check ("get_string");
     570      char* s = ::elf_strptr (elf_, strings_section (), offset);
     571      if (!s)
     572        error ("elf_strptr");
     573      return s;
     574    }
     575
     576#if 0
     577    void
     578    file::set_header (xxx)
     579    {
     580      elf_ehdr* ehdr_ = ::gelf_newehdr (elf_);
     581
     582      if (ehdr == NULL)
     583        error ("set-header");
     584
     585      ehdr->xx = xx;
     586
     587      ::gelf_flagphdr (elf_, ELF_C_SET , ELF_F_DIRTY);
     588    }
     589#endif
     590
     591    elf*
     592    file::get_elf ()
     593    {
     594      return elf_;
     595    }
     596
     597    const std::string&
     598    file::name () const
     599    {
     600      return name_;
     601    }
     602
     603    bool
     604    file::is_writable () const
     605    {
     606      return writable;
     607    }
     608
     609    void
     610    file::check (const char* where) const
     611    {
     612      if (!elf_ || (fd_ < 0))
     613      {
     614        std::string w = where;
     615        throw rld::error ("no elf file or header", "elf:file:" + w);
     616      }
     617    }
     618
     619    void
     620    file::check_writable (const char* where) const
     621    {
     622      check (where);
     623      if (!writable)
     624      {
     625        std::string w = where;
     626        throw rld::error ("not writable", "elf:file:" + w);
     627      }
     628    }
     629
     630    void
     631    file::error (const char* where) const
     632    {
     633      std::string w = where;
     634      libelf_error (w + ": " + name_);
     635    }
     636
    65637    const std::string
    66     machine_type ()
     638    machine_type (unsigned int machinetype)
    67639    {
    68640      struct types_and_labels
    69641      {
    70         const char* name;        //< The RTEMS label.
    71         int        machinetype; //< The machine type.
     642        const char*  name;        //< The RTEMS label.
     643        unsigned int machinetype; //< The machine type.
    72644      };
    73645      types_and_labels types_to_labels[] =
     
    93665      while (types_to_labels[m].machinetype != EM_NONE)
    94666      {
    95         if (elf_object_machinetype == types_to_labels[m].machinetype)
     667        if (machinetype == types_to_labels[m].machinetype)
    96668          return types_to_labels[m].name;
    97669        ++m;
     
    103675    }
    104676
    105     section::section (int          index,
    106                       std::string& name,
    107                       elf_scn*     scn,
    108                       elf_shdr&    shdr)
    109       : index (index),
    110         name (name),
    111         scn (scn),
    112         shdr (shdr)
    113     {
    114       data = ::elf_getdata (scn, NULL);
    115       if (!data)
    116         error ("elf_getdata");
    117     }
    118 
    119     section::section ()
    120       : index (-1),
    121         scn (0),
    122         data (0)
    123     {
    124       memset (&shdr, 0, sizeof (shdr));
    125     }
    126 
    127     #define rld_archive_fhdr_size (60)
    128 
    129     void
    130     begin (rld::files::image& image)
    131     {
    132       libelf_initialise ();
    133 
    134       /*
    135        * Begin's are not nesting.
    136        */
    137       Elf* elf = image.elf ();
    138       if (elf)
    139           error ("begin: already done: " + image.name ().full ());
    140 
    141       /*
    142        * Is this image part of an archive ?
    143        */
    144       elf = image.elf (true);
    145       if (elf)
    146       {
    147         ssize_t offset = image.name ().offset () - rld_archive_fhdr_size;
    148 
    149         if (rld::verbose () >= RLD_VERBOSE_FULL_DEBUG)
    150           std::cout << "elf::rand: " << elf << " offset:" << offset
    151                     << ' ' << image.name ().full () << std::endl;
    152 
    153         if (::elf_rand (elf, offset) != offset)
    154           error ("begin:" + image.name ().full ());
    155       }
    156 
    157       /*
    158        * Note, the elf passed is either the archive or NULL.
    159        */
    160       elf = ::elf_begin (image.fd (), ELF_C_READ, elf);
    161       if (!elf)
    162         error ("begin:" + image.name ().full ());
    163 
    164       if (rld::verbose () >= RLD_VERBOSE_FULL_DEBUG)
    165         std::cout << "elf::begin: " << elf
    166                   << ' ' << image.name ().full () << std::endl;
    167 
    168       image.set_elf (elf);
    169 
    170       elf_kind ek = ::elf_kind (elf);
    171       if (image.name ().is_archive ())
    172       {
    173         if (ek != ELF_K_AR)
    174           throw rld::error ("File not an ar archive", "libelf:" + image.name ().full ());
    175       }
    176       else if (ek != ELF_K_ELF)
    177         throw rld::error ("File format not ELF", "libelf:" + image.name ().full ());
    178 
    179       /*
    180        * If an ELF file make sure they all match. On the first file that begins
    181        * an ELF session record its settings.
    182        */
    183       if (ek == ELF_K_ELF)
    184       {
    185         int cl = ::gelf_getclass (elf);
    186 
    187         if (elf_object_class == ELFCLASSNONE)
    188           elf_object_class = cl;
    189         else if (cl != elf_object_class)
    190           throw rld::error ("Mixed classes not allowed (32bit/64bit).",
    191                             "begin:" + image.name ().full ());
    192      
    193         char* ident = elf_getident (elf, NULL);
    194 
    195         if (elf_object_data == ELFDATANONE)
    196           elf_object_data = ident[EI_DATA];
    197         else if (elf_object_data != ident[EI_DATA])
    198           throw rld::error ("Mixed data types not allowed (LSB/MSB).",
    199                             "begin:" + image.name ().full ());
    200       }
    201     }
    202 
    203     void
    204     end (rld::files::image& image)
    205     {
    206       ::Elf* elf = image.elf ();
    207       if (elf)
    208       {
    209         if (rld::verbose () >= RLD_VERBOSE_FULL_DEBUG)
    210           std::cout << "elf::end: " << elf
    211                     << ' ' << image.name ().full () << std::endl;
    212         ::elf_end (elf);
    213       }
    214       image.set_elf (0);
    215     }
    216 
    217     void
    218     get_header (rld::files::image& image, elf_ehdr& ehdr)
    219     {
    220       if (::gelf_getehdr (image.elf (), &ehdr) == NULL)
    221         error ("get-header:" + image.name ().full ());
    222      
    223       if ((ehdr.e_type != ET_EXEC) && (ehdr.e_type != ET_REL))
    224         throw rld::error ("Invalid ELF type (only ET_EXEC/ET_REL supported).",
    225                           "get-header:" + image.name ().full ());
    226 
     677    const std::string machine_type ()
     678    {
     679      return machine_type (elf_object_machinetype);
     680    }
     681
     682    void
     683    check_file(const file& file)
     684    {
    227685      if (elf_object_machinetype == EM_NONE)
    228         elf_object_machinetype = ehdr.e_machine;
    229       else if (elf_object_machinetype != ehdr.e_machine)
     686        elf_object_machinetype = file.machinetype ();
     687      else if (file.machinetype () != elf_object_machinetype)
    230688      {
    231689        std::ostringstream oss;
    232         oss << "get-header:" << image.name ().full ()
    233             << ": " << elf_object_machinetype << '/' << ehdr.e_machine;
     690        oss << "elf:check_file:" << file.name ()
     691            << ": " << elf_object_machinetype << '/' << file.machinetype ();
    234692        throw rld::error ("Mixed machine types not supported.", oss.str ());
    235693      }
    236     }
    237 
    238     void
    239     get_section_headers (rld::files::object& object,
    240                          sections&           secs,
    241                          unsigned int        type)
    242     {
    243       for (int sn = 0; sn < object.sections (); ++sn)
    244       {
    245         ::Elf_Scn* scn = ::elf_getscn (object.elf (), sn);
    246         if (!scn)
    247           error ("elf_getscn:" + object.name ().full ());
    248         ::GElf_Shdr shdr;
    249         if (!::gelf_getshdr (scn, &shdr))
    250           error ("gelf_getshdr:" + object.name ().full ());
    251         if (shdr.sh_type == type)
    252         {
    253           std::string name = get_string (object,
    254                                          object.section_strings (),
    255                                          shdr.sh_name);
    256           secs.push_back (section (sn, name, scn, shdr));
    257         }
    258       }
    259     }
    260 
    261     void
    262     load_symbol_table (rld::symbols::table& exported,
    263                        rld::files::object&  object,
    264                        section&             sec,
    265                        bool                 local,
    266                        bool                 weak,
    267                        bool                 global)
    268     {
    269       int count = sec.shdr.sh_size / sec.shdr.sh_entsize;
    270       for (int s = 0; s < count; ++s)
    271       {
    272         GElf_Sym esym;
    273         if (!::gelf_getsym (sec.data, s, &esym))
    274           error ("gelf_getsym");
    275         std::string name = get_string (object, sec.shdr.sh_link, esym.st_name);
    276         if (!name.empty ())
    277         {
    278           int stype = GELF_ST_TYPE (esym.st_info);
    279           int sbind = GELF_ST_BIND (esym.st_info);
    280           if (rld::verbose () >= RLD_VERBOSE_TRACE)
    281           {
    282             rld::symbols::symbol sym (name, esym);
    283             std::cout << "elf::symbol: ";
    284             sym.output (std::cout);
    285             std::cout << std::endl;
    286           }
    287           if ((stype == STT_NOTYPE) && (esym.st_shndx == SHN_UNDEF))
    288             object.unresolved_symbols ()[name] = rld::symbols::symbol (name, esym);
    289           else if (((stype == STT_NOTYPE) ||
    290                     (stype == STT_OBJECT) ||
    291                     (stype == STT_FUNC)) &&
    292                    ((local && (sbind == STB_LOCAL)) ||
    293                     (weak && (sbind == STB_WEAK)) ||
    294                     (global && (sbind == STB_GLOBAL))))
    295           {
    296             exported[name] = rld::symbols::symbol (name, object, esym);;
    297             object.external_symbols ().push_back (&exported[name]);
    298           }
    299         }
    300       }
    301     }
    302 
     694
     695      if (elf_object_class == ELFCLASSNONE)
     696        elf_object_class = file.object_class ();
     697      else if (file.object_class () != elf_object_class)
     698        throw rld::error ("Mixed classes not allowed (32bit/64bit).",
     699                          "elf:check_file: " + file.name ());
     700
     701      if (elf_object_data == ELFDATANONE)
     702        elf_object_data = file.data_type ();
     703      else if (elf_object_data != file.data_type ())
     704        throw rld::error ("Mixed data types not allowed (LSB/MSB).",
     705                          "elf:check_file: " + file.name ());
     706    }
     707
     708#if 0
    303709    void
    304710    load_symbols (rld::symbols::table& symbols,
    305                   rld::files::object&  object, 
     711                  rld::files::object&  object,
    306712                  bool                 local,
    307713                  bool                 weak,
     
    315721        load_symbol_table (symbols, object, *si, local, weak, global);
    316722    }
    317 
    318     std::string
    319     get_string (rld::files::object& object,
    320                 int                 section,
    321                 size_t              offset)
    322     {
    323       char* s = ::elf_strptr (object.elf (), section, offset);
    324       if (!s)
    325         error ("elf_strptr");
    326       return s;
    327     }
     723#endif
    328724
    329725  }
  • linkers/rld-elf.h

    r0b65a28 r977c3de  
    11/*
    2  * Copyright (c) 2011, Chris Johns <chrisj@rtems.org> 
     2 * Copyright (c) 2011, Chris Johns <chrisj@rtems.org>
    33 *
    44 * Permission to use, copy, modify, and/or distribute this software for any
    55 * purpose with or without fee is hereby granted, provided that the above
    66 * copyright notice and this permission notice appear in all copies.
    7  * 
     7 *
    88 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    99 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
     
    3535  {
    3636    /**
    37      * Sections.
    38      */
    39     struct section
     37     * Forward decl.
     38     */
     39    class file;
     40
     41    /**
     42     * An ELF Section.
     43     */
     44    class section
    4045    {
    41       int         index; //< The section header index.
    42       std::string name;  //< The section's name.
    43       elf_scn*    scn;   //< ELF private section data.
    44       elf_shdr    shdr;  //< The section header.
    45       elf_data*   data;  //< The section's data.
    46      
    47       /**
    48        * Construct the section and get the data value.
    49        */
    50       section (int          index,
    51                std::string& name,
    52                elf_scn*     scn,
    53                elf_shdr&    sdhr);
     46    public:
     47      /**
     48       * Construct the section getting the details.
     49       *
     50       * @param elf The ELF file this section is part of.
     51       * @param index The sections index in the ELF file.
     52       */
     53      section (file& file_, int index);
     54
     55      /**
     56       * Copy constructor.
     57       */
     58      section (const section& orig);
    5459
    5560      /**
     
    5762       */
    5863      section ();
     64
     65      /**
     66       * The section's index in the ELF file.
     67       *
     68       * @return int The section number.
     69       */
     70      int index () const;
     71
     72      /**
     73       * The name of the section.
     74       *
     75       * @return const std::string& The section's name.
     76       */
     77      const std::string& name () const;
     78
     79      /**
     80       * The section's data.
     81       */
     82      elf_data* data ();
     83
     84      /**
     85       * Get the type of the section.
     86       */
     87      elf_word type () const;
     88
     89      /**
     90       * The section flags.
     91       */
     92      elf_xword flags () const;
     93
     94      /**
     95       * In-memory address of the section.
     96       */
     97      elf_addr address () const;
     98
     99      /**
     100       * Alignment constraint.
     101       */
     102      elf_xword alignment () const;
     103
     104      /**
     105       * The file offset of the section.
     106       */
     107      elf_off offset () const;
     108
     109      /**
     110       * The header table link.
     111       */
     112      elf_word link () const;
     113
     114      /**
     115       * Extra information.
     116       */
     117      elf_word info () const;
     118
     119      /**
     120       * Size of the section.
     121       */
     122      elf_xword size () const;
     123
     124      /**
     125       * Size of the entries in the section.
     126       */
     127      elf_xword entry_size () const;
     128
     129      /**
     130       * Number of entries.
     131       */
     132      int entries () const;
     133
     134    private:
     135
     136      /**
     137       * Check the section is acrtual valid.
     138       */
     139      void check () const;
     140
     141      file*       file_;  //< The ELF file.
     142      int         index_; //< The section header index.
     143      std::string name_;  //< The section's name.
     144      elf_scn*    scn;    //< ELF private section data.
     145      elf_shdr    shdr;   //< The section header.
     146      elf_data*   data_;  //< The section's data.
    59147    };
    60148
    61149    /**
    62      * Container of section headers.
     150     * Container of ELF sections.
    63151     */
    64152    typedef std::list < section > sections;
    65153
    66154    /**
    67      * Get the machine type detected in the object files as their headers are read.
     155     * An ELF file.
     156     */
     157    class file
     158    {
     159    public:
     160      /**
     161       * Construct an ELF file.
     162       */
     163      file ();
     164
     165      /**
     166       * Destruct the ELF file object.
     167       */
     168      ~file ();
     169
     170      /**
     171       * Begin using the ELF file.
     172       *
     173       * @param name The full name of the file.
     174       * @param fd The file descriptor to read or write the file.
     175       * @param writable The file is writeable. The default is false.
     176       */
     177      void begin (const std::string& name, int fd, const bool writable = false);
     178
     179      /**
     180       * Begin using the ELF file in an archive.
     181       *
     182       * @param name The full name of the file.
     183       * @param archive The file that is the archive.
     184       * @param offset The offset of the ELF file in the archive.
     185       */
     186      void begin (const std::string& name, file& archive, off_t offset);
     187
     188      /**
     189       * End using the ELF file.
     190       */
     191      void end ();
     192
     193      /**
     194       * Load the header. Done automatically.
     195       */
     196      void load_header ();
     197
     198      /**
     199       * Get the machine type.
     200       */
     201      unsigned int machinetype () const;
     202
     203      /**
     204       * Get the type of ELF file.
     205       */
     206      unsigned int type () const;
     207
     208      /**
     209       * Get the class of the object file.
     210       */
     211      unsigned int object_class () const;
     212
     213      /**
     214       * Get the data type, ie LSB or MSB.
     215       */
     216      unsigned int data_type () const;
     217
     218      /**
     219       * Is the file an archive format file ?
     220       */
     221      bool is_archive () const;
     222
     223      /**
     224       * Is the file an executable ?
     225       */
     226      bool is_executable () const;
     227
     228      /**
     229       * Is the file relocatable ?
     230       */
     231      bool is_relocatable() const;
     232
     233      /**
     234       * The number of sections in the file.
     235       */
     236      int section_count () const;
     237
     238      /**
     239       * Load the sections.
     240       */
     241      void load_sections ();
     242
     243      /**
     244       * Get a filtered container of the sections. The key is the section
     245       * type. If the sections are not loaded they are loaded. If the type is 0
     246       * all sections are returned.
     247       *
     248       * @param filtered_secs The container the copy of the filtered sections
     249       *                      are placed in.
     250       * @param type The type of sections to filter on. If 0 all sections are
     251       *             matched.
     252       */
     253      void get_sections (sections& filtered_secs, unsigned int type);
     254
     255      /**
     256       * Return the index of the string section.
     257       */
     258      int strings_section () const;
     259
     260      /**
     261       * Get the string from the specified section at the requested offset.
     262       *
     263       * @param section The section to search for the string.
     264       * @param offset The offset in the string section.
     265       * @return std::string The string.
     266       */
     267      std::string get_string (int section, size_t offset);
     268
     269      /**
     270       * Get the string from the ELF header declared string section at the
     271       * requested offset.
     272       *
     273       * @param offset The offset in the string section.
     274       * @return std::string The string.
     275       */
     276      std::string get_string (size_t offset);
     277
     278      /**
     279       * Load the symbols.
     280       */
     281      void load_symbols ();
     282
     283      /**
     284       * Get a filtered container of symbols given the various types. If the
     285       * symbols are not loaded they are loaded.
     286       *
     287       * @param filter_syms The filtered symbols found in the file. This is a
     288       *                    container of pointers.
     289       * @param local Return local symbols.
     290       * @param weak Return weak symbols.
     291       * @param global Return global symbols.
     292       * @param unresolved Return unresolved symbols.
     293       */
     294      void get_symbols (rld::symbols::pointers& filtered_syms,
     295                        bool                    unresolved = false,
     296                        bool                    local = false,
     297                        bool                    weak = true,
     298                        bool                    global = true);
     299
     300      /**
     301       * Get the ELF reference.
     302       */
     303      elf* get_elf ();
     304
     305      /**
     306       * Get the name of the file.
     307       */
     308      const std::string& name () const;
     309
     310      /**
     311       * Is the file writable ?
     312       */
     313      bool is_writable () const;
     314
     315    private:
     316
     317      /**
     318       * Begin using the ELF file.
     319       *
     320       * @param name The full name of the file.
     321       * @param fd The file descriptor to read or write the file.
     322       * @param writable The file is writeable. It cannot be part of an archive.
     323       * @param archive The archive's ELF handle or 0 if not an archive.
     324       * @param offset The offset of the ELF file in the archive if elf is non-zero.
     325       */
     326      void begin (const std::string& name,
     327                  int                fd,
     328                  const bool         writable,
     329                  file*              archive,
     330                  off_t              offset);
     331
     332      /**
     333       * Check if the file is usable. Throw an exception if not.
     334       *
     335       * @param where Where the check is performed.
     336       */
     337      void check (const char* where) const;
     338
     339      /**
     340       * Check if the file is usable and writable. Throw an exception if not.
     341       *
     342       * @param where Where the check is performed.
     343       */
     344      void check_writable (const char* where) const;
     345
     346      /**
     347       * Generate libelf error.
     348       *
     349       * @param where Where the error is generated.
     350       */
     351      void error (const char* where) const;
     352
     353      int                  fd_;        //< The file handle.
     354      std::string          name_;      //< The name of the file.
     355      bool                 archive;    //< The ELF file is part of an archive.
     356      bool                 writable;   //< The file is writeable.
     357      elf*                 elf_;       //< The ELF handle.
     358      unsigned int         mtype;      //< The machine type.
     359      unsigned int         oclass;     //< The object class.
     360      const char*          ident_str;  //< The ELF file's ident string.
     361      size_t               ident_size; //< The size of the ident.
     362      elf_ehdr             ehdr;       //< The ELF header.
     363      elf_phdr             phdr;       //< The ELF program header.
     364      std::string          stab;       //< The string table.
     365      sections             secs;       //< The sections.
     366      rld::symbols::bucket symbols;    //< The symbols. All tables point here.
     367    };
     368
     369    /**
     370     * Return the machine type label given the machine type.
     371     *
     372     * @param machinetype The ELF machine type.
     373     */
     374    const std::string machine_type (unsigned int machinetype);
     375
     376    /**
     377     * Return the global machine type set by the check_file call.
    68378     */
    69379    const std::string machine_type ();
    70380
    71381    /**
    72      * Begin a libelf session with the image.
    73      */
    74     void begin (rld::files::image& image);
    75 
    76     /**
    77      * End the libelf session with the image.
    78      */
    79     void end (rld::files::image& image);
    80 
    81     /**
    82      * Get the ELF header.
    83      */
    84     void get_header (rld::files::image& image, elf_ehdr& ehdr);
    85 
    86     /**
    87      * Get the section headers for an object file.
    88      */
    89     void get_section_headers (rld::files::object& object,
    90                               sections&           secs,
    91                               unsigned int        type = SHT_NULL);
    92  
    93     /**
    94      * Load the symbol table with the symbols.
    95      */
    96     void load_symbol_table (rld::symbols::table& exported,
    97                             rld::files::object&  object,
    98                             section&             sec,
    99                             bool                 local = false,
    100                             bool                 weak = true,
    101                             bool                 global = true);
    102    
    103     /**
    104      * Load the symbol table with an object's symbols.
    105      */
    106     void load_symbols (rld::symbols::table& symbols,
    107                        rld::files::object&  object,
    108                        bool                 local = false,
    109                        bool                 weak = true,
    110                        bool                 global = true);
    111 
    112     /**
    113      * Get a string.
    114      */
    115     std::string get_string (rld::files::object& object,
    116                             int                 section,
    117                             size_t              offset);
     382     * Check the file against the global machine type, object class and data
     383     * type. If this is the first file checked it becomes the default all
     384     * others are checked against. This is a simple way to make sure all files
     385     * are the same type.
     386     *
     387     * @param file The check to check.
     388     */
     389    void check_file(const file& file);
     390
    118391  }
    119392}
  • linkers/rld-files.cpp

    r0b65a28 r977c3de  
    11/*
    2  * Copyright (c) 2011, Chris Johns <chrisj@rtems.org> 
     2 * Copyright (c) 2011, Chris Johns <chrisj@rtems.org>
    33 *
    44 * Permission to use, copy, modify, and/or distribute this software for any
    55 * purpose with or without fee is hereby granted, provided that the above
    66 * copyright notice and this permission notice appear in all copies.
    7  * 
     7 *
    88 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    99 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
     
    4646    {
    4747      uint64_t value = 0;
    48      
     48
    4949      while (len && (*string != ' '))
    5050      {
     
    105105      else if ((path_[path_.size () - 1] == RLD_PATH_SEPARATOR) &&
    106106               (file_[0] == RLD_PATH_SEPARATOR))
    107         joined = path_ + &file_[1];       
     107        joined = path_ + &file_[1];
    108108      else
    109109        joined = path_ + file_;
     
    148148                off_t              offset,
    149149                size_t             size)
    150       : aname_ (aname), 
     150      : aname_ (aname),
    151151        oname_ (oname),
    152152        offset_ (offset),
     
    247247      return oname_;
    248248    }
    249    
    250     const std::string 
     249
     250    const std::string
    251251    file::full () const
    252252    {
     
    298298      : name_ (name),
    299299        references_ (0),
    300         fd_ (-1),
    301         elf_ (0)
     300        fd_ (-1)
    302301    {
    303302    }
     
    307306        references_ (0),
    308307        fd_ (-1),
    309         elf_ (0),
    310         symbol_refs (0)
     308        symbol_refs (0),
     309        writeable (false)
    311310    {
    312311    }
     
    315314      : references_ (0),
    316315        fd_ (-1),
    317         elf_ (0),
    318316        symbol_refs (0)
    319317    {
     
    336334
    337335    void
    338     image::open (bool writable)
     336    image::open (bool writeable_)
    339337    {
    340338      const std::string path = name_.path ();
    341339
    342340      if (path.empty ())
    343         throw rld::error ("No file name", "open" + path);
     341        throw rld::error ("No file name", "open:" + path);
    344342
    345343      if (rld::verbose () >= RLD_VERBOSE_DETAILS)
    346344        std::cout << "image::open: " << name (). full ()
     345                  << " writable:" << (char*) (writeable_ ? "yes" : "no")
    347346                  << " refs:" << references_ + 1 << std::endl;
    348347
    349348      if (fd_ < 0)
    350349      {
    351         if (writable)
     350        writeable = writeable_;
     351
     352        if (writeable)
    352353          fd_ = ::open (path.c_str (), OPEN_FLAGS | O_RDWR | O_CREAT | O_TRUNC, CREATE_MODE);
    353354        else
     
    356357          throw rld::error (::strerror (errno), "open:" + path);
    357358      }
     359      else
     360      {
     361        if (writeable_ != writeable)
     362          throw rld::error ("Cannot change write status", "open:" + path);
     363      }
    358364
    359365      ++references_;
     
    386392      return rsize;
    387393    }
    388  
     394
    389395    ssize_t
    390396    image::write (const void* buffer, size_t size)
     
    395401      return wsize;
    396402    }
    397  
     403
    398404    void
    399405    image::seek (off_t offset)
     
    402408        throw rld::error (strerror (errno), "lseek:" + name ().path ());
    403409    }
    404  
     410
    405411    bool
    406412    image::seek_read (off_t offset, uint8_t* buffer, size_t size)
     
    409415      return size == (size_t) read (buffer, size);
    410416    }
    411  
     417
    412418    bool
    413419    image::seek_write (off_t offset, const void* buffer, size_t size)
     
    416422      return size == (size_t) write (buffer, size);
    417423    }
    418  
     424
    419425    const file&
    420426    image::name () const
     
    424430
    425431    int
    426     image::references () const 
     432    image::references () const
    427433    {
    428434      return references_;
     
    430436
    431437    size_t
    432     image::size () const 
     438    image::size () const
    433439    {
    434440      return name ().size ();
     
    436442
    437443    int
    438     image::fd () const 
     444    image::fd () const
    439445    {
    440446      return fd_;
    441447    }
    442448
    443     rld::elf::elf*
    444     image::elf (bool )
     449    rld::elf::file&
     450    image::elf ()
    445451    {
    446452      return elf_;
     
    448454
    449455    void
    450     image::set_elf (rld::elf::elf* elf)
    451     {
    452       elf_ = elf;
    453     }
    454 
    455     void
    456456    image::symbol_referenced ()
    457457    {
    458458      ++symbol_refs;
    459459    }
    460    
     460
    461461    int
    462462    image::symbol_references () const
     
    475475        while (size)
    476476        {
     477          /*
     478           * @fixme the reading and writing are not POSIX; sigints could split them.
     479           */
     480
    477481          size_t l = size < COPY_FILE_BUFFER_SIZE ? size : COPY_FILE_BUFFER_SIZE;
    478482          ssize_t r = ::read (in.fd (), buffer, l);
     
    546550    }
    547551
     552    void
     553    archive::begin ()
     554    {
     555      elf ().begin (name ().full (), fd ());
     556
     557      /*
     558       * Make sure it is an archive.
     559       */
     560      if (!elf ().is_archive ())
     561        throw rld::error ("Not an archive.",
     562                          "archive-begin:" + name ().full ());
     563    }
     564
     565    void
     566    archive::end ()
     567    {
     568      elf ().end ();
     569    }
     570
    548571    bool
    549572    archive::is (const std::string& path) const
     
    581604         * The archive file headers are always aligned to an even address.
    582605         */
    583         size = 
    584           (scan_decimal (&header[rld_archive_size], 
     606        size =
     607          (scan_decimal (&header[rld_archive_size],
    585608                         rld_archive_size_size) + 1) & ~1;
    586609
     
    626649                while (extended_file_names == 0)
    627650                {
    628                   size_t esize = 
     651                  size_t esize =
    629652                    (scan_decimal (&header[rld_archive_size],
    630653                                   rld_archive_size_size) + 1) & ~1;
    631654                  off += esize + rld_archive_fhdr_size;
    632                    
     655
    633656                  if (!read_header (off, &header[0]))
    634657                    throw rld::error ("No GNU extended file name section found",
    635658                                      "get-names:" + name ().path ());
    636              
     659
    637660                  if ((header[0] == '/') && (header[1] == '/'))
    638661                  {
     
    694717        throw rld::error ("Invalid header magic numbers at " +
    695718                          rld::to_string (offset), "read-header:" + name ().path ());
    696      
     719
    697720      return true;
    698721    }
     
    726749
    727750        memset (header, ' ', sizeof (header));
    728        
     751
    729752        size_t len = name.length ();
    730753        if (len > rld_archive_fname_size)
     
    757780         */
    758781        std::string extended_file_names;
    759        
     782
    760783        for (object_list::iterator oi = objects.begin ();
    761784             oi != objects.end ();
     
    819842        throw;
    820843      }
    821      
     844
    822845      close ();
    823846    }
     
    878901    {
    879902      /*
    880        * Begin an ELF session and get the ELF header.
     903       * Begin a session.
    881904       */
    882       rld::elf::begin (*this);
    883       rld::elf::get_header (*this, ehdr);
     905      if (archive_)
     906        elf ().begin (name ().full (), archive_->elf(), name ().offset ());
     907      else
     908        elf ().begin (name ().full (), fd ());
     909
     910      /*
     911       * Cannot be an archive.
     912       */
     913      if (elf ().is_archive ())
     914        throw rld::error ("Is an archive not an object file.",
     915                          "object-begin:" + name ().full ());
     916
     917      /*
     918       * We only support executable or relocatable ELF files.
     919       */
     920      if (!elf ().is_executable () && !elf ().is_relocatable ())
     921        throw rld::error ("Invalid ELF type (only ET_EXEC/ET_REL supported).",
     922                          "object-begin:" + name ().full ());
     923
     924      elf::check_file (elf ());
    884925    }
    885926
     
    887928    object::end ()
    888929    {
    889       rld::elf::end (*this);
     930      elf ().end ();
    890931    }
    891932
     
    895936      if (rld::verbose () >= RLD_VERBOSE_DETAILS)
    896937        std::cout << "object:load-sym: " << name ().full () << std::endl;
    897       rld::elf::load_symbols (symbols, *this, local);
    898     }
    899 
    900     std::string
    901     object::get_string (int section, size_t offset)
    902     {
    903       return rld::elf::get_string (*this, section, offset);
    904     }
    905    
     938
     939      rld::symbols::pointers syms;
     940
     941      elf ().get_symbols (syms, false, local);
     942
     943      if (rld::verbose () >= RLD_VERBOSE_DETAILS)
     944        std::cout << "object:load-sym: exported: total "
     945                  << syms.size () << std::endl;
     946
     947      for (symbols::pointers::iterator si = syms.begin ();
     948           si != syms.end ();
     949           ++si)
     950      {
     951        symbols::symbol& sym = *(*si);
     952
     953        if (rld::verbose () >= RLD_VERBOSE_DETAILS)
     954        {
     955          std::cout << "object:load-sym: exported: ";
     956          sym.output (std::cout);
     957          std::cout << std::endl;
     958        }
     959
     960        sym.set_object (*this);
     961        symbols[sym.name ()] = &sym;
     962        externals.push_back (&sym);
     963      }
     964
     965      elf ().get_symbols (syms, true);
     966
     967      if (rld::verbose () >= RLD_VERBOSE_DETAILS)
     968        std::cout << "object:load-sym: unresolved: total "
     969                  << syms.size () << std::endl;
     970
     971      for (symbols::pointers::iterator si = syms.begin ();
     972           si != syms.end ();
     973           ++si)
     974      {
     975        symbols::symbol& sym = *(*si);
     976
     977        if (rld::verbose () >= RLD_VERBOSE_DETAILS)
     978        {
     979          std::cout << "object:load-sym: unresolved: ";
     980          sym.output (std::cout);
     981          std::cout << std::endl;
     982        }
     983
     984        unresolved[sym.name ()] = &sym;
     985      }
     986    }
     987
    906988    int
    907     object::references () const 
     989    object::references () const
    908990    {
    909991      if (archive_)
     
    913995
    914996    size_t
    915     object::size () const 
     997    object::size () const
    916998    {
    917999      if (archive_)
     
    9211003
    9221004    int
    923     object::fd () const 
     1005    object::fd () const
    9241006    {
    9251007      if (archive_)
     
    9281010    }
    9291011
    930     rld::elf::elf*
    931     object::elf (bool archive__)
    932     {
    933       if (archive__ && archive_)
    934         return archive_->elf ();
    935       return image::elf ();
    936     }
    937 
    9381012    void
    9391013    object::symbol_referenced ()
     
    9431017        archive_->symbol_referenced ();
    9441018    }
    945    
     1019
    9461020    archive*
    9471021    object::get_archive ()
     
    9501024    }
    9511025
     1026#if 0
    9521027    int
    9531028    object::sections () const
     
    9611036      return ehdr.e_shstrndx;
    9621037    }
     1038#endif
    9631039
    9641040    rld::symbols::table&
     
    9681044    }
    9691045
    970     rld::symbols::list&
     1046    rld::symbols::pointers&
    9711047    object::external_symbols ()
    9721048    {
     
    10481124            std::cout << "cache:archive-begin: " << path << std::endl;
    10491125          ar->open ();
    1050           rld::elf::begin (*ar);
     1126          ar->begin ();
    10511127        }
    10521128      }
     
    10641140          if (rld::verbose () >= RLD_VERBOSE_TRACE)
    10651141            std::cout << "cache:archive-end: " << path << std::endl;
    1066           rld::elf::end (*ar);
     1142          ar->end ();
    10671143          ar->close ();
    10681144        }
     
    10831159        archive_end (((*ai).second)->path ());
    10841160    }
    1085    
     1161
    10861162    void
    10871163    cache::collect_object_files ()
     
    11741250      return archives_;
    11751251    }
    1176  
     1252
    11771253    objects&
    11781254    cache::get_objects ()
  • linkers/rld-files.h

    r0b65a28 r977c3de  
    11/*
    2  * Copyright (c) 2011, Chris Johns <chrisj@rtems.org> 
     2 * Copyright (c) 2011, Chris Johns <chrisj@rtems.org>
    33 *
    44 * Permission to use, copy, modify, and/or distribute this software for any
    55 * purpose with or without fee is hereby granted, provided that the above
    66 * copyright notice and this permission notice appear in all copies.
    7  * 
     7 *
    88 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    99 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
     
    2727 * created when the archive or object file was opened.
    2828 *
    29  * 
     29 *
    3030 */
    3131
     
    6868     */
    6969    typedef std::list < object* > object_list;
    70    
     70
    7171    /**
    7272     * Split a path from a string with a delimiter to the path container. Add
     
    7979     * Make a path by joining the parts with required separator.
    8080     */
    81     void path_join (const std::string& path_, 
    82                     const std::string& file_, 
     81    void path_join (const std::string& path_,
     82                    const std::string& file_,
    8383                    std::string& joined);
    8484
     
    9292     */
    9393    bool check_directory (const std::string& path);
    94    
     94
    9595    /**
    9696     * Find the file given a container of paths and file names.
     
    100100     * @param search_paths The container of paths to search.
    101101     */
    102     void find_file (std::string&       path, 
     102    void find_file (std::string&       path,
    103103                    const std::string& name,
    104104                    paths&             search_paths);
     
    324324
    325325      /**
    326        * The libelf reference. The ELF image could be in an archive container
    327        * so set container to true to get the archive's reference.
    328        */
    329       virtual rld::elf::elf* elf (bool archive = false);
    330 
    331       /**
    332        * Set the libelf reference.
    333        */
    334       void set_elf (rld::elf::elf* elf);
     326       * The ELF reference.
     327       */
     328      elf::file& elf ();
    335329
    336330      /**
     
    354348
    355349      /**
    356        * Is the archive open ?
    357        *
    358        * @retval true The archive is open.
    359        * @retval false The archive is not open.
     350       * Is the image open ?
     351       *
     352       * @retval true The image is open.
     353       * @retval false The image is not open.
    360354       */
    361355      bool is_open () const {
     
    363357      }
    364358
     359      /**
     360       * Is the image writable ?
     361       *
     362       * @retval true The image is writeable.
     363       * @retval false The image is not writeable.
     364       */
     365      bool is_writeable () const {
     366        return writeable;
     367      }
     368
    365369    private:
     370
    366371      file      name_;       //< The name of the file.
    367372      int       references_; //< The number of handles open.
    368373      int       fd_;         //< The file descriptor of the archive.
    369       elf::elf* elf_;        //< The libelf reference.
     374      elf::file elf_;        //< The libelf reference.
    370375      int       symbol_refs; //< The number of symbols references made.
     376      bool      writeable;   //< The image is writable.
    371377    };
    372378
     
    397403
    398404      /**
     405       * Begin the ELF session.
     406       */
     407      void begin ();
     408
     409      /**
     410       * End the ELF session.
     411       */
     412      void end ();
     413
     414      /**
    399415       * Match the archive name.
    400416       *
     
    414430       */
    415431      void load_objects (objects& objs);
    416      
     432
    417433      /**
    418434       * Get the name.
     
    432448
    433449    private:
     450
    434451      /**
    435452       * Read header.
     
    442459      void add_object (objects&    objs,
    443460                       const char* name,
    444                        off_t       offset, 
     461                       off_t       offset,
    445462                       size_t      size);
    446463
     
    529546       * Get the string from the string table.
    530547       */
    531       std::string get_string (int section, size_t offset);
     548//      std::string get_string (int section, size_t offset);
    532549
    533550      /**
     
    545562       */
    546563      virtual int fd () const;
    547 
    548       /**
    549        * The libelf reference. The ELF image could be in an archive container
    550        * so set container to true to get the archive's reference.
    551        */
    552       virtual elf::elf* elf (bool archive = false);
    553564
    554565      /**
     
    563574      archive* get_archive ();
    564575
     576#if 0
    565577      /**
    566578       * Number of sections in the object file.
     
    572584       */
    573585      int section_strings () const;
     586#endif
    574587
    575588      /**
     
    581594       * Return the list external symbols.
    582595       */
    583       rld::symbols::list& external_symbols ();
     596      rld::symbols::pointers& external_symbols ();
    584597
    585598    private:
    586       archive*            archive_;   //< Points to the archive if part of an
    587                                       //  archive.
    588       elf::elf_ehdr       ehdr;       //< The ELF header.
    589       rld::symbols::table unresolved; //< This object's unresolved symbols.
    590       rld::symbols::list  externals;  //< This object's external symbols.
     599      archive*               archive_;   //< Points to the archive if part of
     600                                         //  an archive.
     601      rld::symbols::table    unresolved; //< This object's unresolved symbols.
     602      rld::symbols::pointers externals;  //< This object's external symbols.
    591603
    592604      /**
     
    645657
    646658      /**
    647        * Being an ELF session on an archive.
     659       * Being a session on an archive.
    648660       */
    649661      void archive_begin (const std::string& path);
    650662
    651663      /**
    652        * End an ELF session on an archive.
     664       * End a session on an archive.
    653665       */
    654666      void archive_end (const std::string& path);
    655667
    656668      /**
    657        * Being ELF sessions on all archives.
     669       * Being sessions on all archives.
    658670       */
    659671      void archives_begin ();
    660672
    661673      /**
    662        * End the archive elf sessions.
     674       * End the archive sessions.
    663675       */
    664676      void archives_end ();
     
    668680       */
    669681      void collect_object_files ();
    670      
     682
    671683      /**
    672684       * Collect the object file names by verifing the paths to the files are
     
    674686       */
    675687      void collect_object_files (const std::string& path);
    676      
     688
    677689      /**
    678690       * Load the symbols into the symbol table.
     
    692704       */
    693705      archives& get_archives ();
    694  
     706
    695707      /**
    696708       * Get the objects inlcuding those in archives.
    697709       */
    698710      objects& get_objects ();
    699  
     711
    700712      /**
    701713       * Get the added objects. Does not include the ones in th archives.
  • linkers/rld-outputter.cpp

    r0b65a28 r977c3de  
    6969             ++ursi)
    7070        {
    71           rld::symbols::symbol& urs = (*ursi).second;
     71          rld::symbols::symbol& urs = *((*ursi).second);
    7272
    7373          ++count;
     
    9898           ++oi)
    9999        objects.push_back (*oi);
     100
     101      objects.unique ();
    100102
    101103      rld::files::archive arch (name);
     
    129131
    130132      out.close ();
    131 
    132 #if 0
    133       rld::files::object_list objects;
    134       cache.get_objects (objects);
    135 
    136       for (rld::files::object_list::iterator oi = objects.begin ();
    137            oi != objects.end ();
    138            ++oi)
    139       {
    140         rld::files::object& obj = *(*oi);
    141 
    142         if (rld::verbose () >= RLD_VERBOSE_INFO)
    143           std::cout << " o: " << obj.name ().full () << std::endl;
    144 
    145         out << "o:" << obj.name ().basename () << std::endl;
    146       }
    147 
    148       for (rld::files::object_list::iterator oi = dependents.begin ();
    149            oi != dependents.end ();
    150            ++oi)
    151       {
    152         rld::files::object&  obj = *(*oi);
    153         rld::symbols::table& unresolved = obj.unresolved_symbols ();
    154 
    155         if (rld::verbose () >= RLD_VERBOSE_INFO)
    156           std::cout << " d: " << obj.name ().full () << std::endl;
    157 
    158         out << "d:" << obj.name ().basename () << std::endl;
    159 
    160         int count = 0;
    161         for (rld::symbols::table::iterator ursi = unresolved.begin ();
    162              ursi != unresolved.begin ();
    163              ++ursi)
    164         {
    165           ++count;
    166           rld::symbols::symbol& urs = (*ursi).second;
    167           out << " u:" << count << ':' << urs.name () << std::endl;
    168         }
    169       }
    170 #endif
    171133    }
    172134  }
  • linkers/rld-resolver.cpp

    r0b65a28 r977c3de  
    5555       * symbol. Record each object file that is found and when all unresolved
    5656       * symbols in this object file have been found iterate over the found
    57        * object files resolving them. The 'usr' is the unresolved symbol and
     57       * object files resolving them. The 'urs' is the unresolved symbol and
    5858       * 'es' is the exported symbol.
    5959       */
     
    6767                  << ", unresolved: "
    6868                  << unresolved.size ()
    69                   << ((*unresolved.begin ()).second.object () ? " (resolved)" : "")
     69                  << (((*unresolved.begin ()).second)->object () ? " (resolved)" : "")
    7070                  << std::endl;
    7171
     
    7373
    7474      for (rld::symbols::table::iterator ursi = unresolved.begin ();
    75            (ursi != unresolved.end ()) && !(*ursi).second.object ();
     75           (ursi != unresolved.end ()) && !((*ursi).second)->object ();
    7676           ++ursi)
    7777      {
    78         rld::symbols::symbol&         urs = (*ursi).second;
     78        rld::symbols::symbol&         urs = *((*ursi).second);
    7979        rld::symbols::table::iterator esi = base_symbols.find (urs.name ());
    8080        bool                          base = true;
     81
     82        if (rld::verbose () >= RLD_VERBOSE_INFO)
     83        {
     84          std::cout << "resolver:resolve  : "
     85                    << std::setw (nesting + 1) << ' '
     86                    << urs.name () << std::endl;
     87        }
    8188
    8289        if (esi == base_symbols.end ())
     
    8996        }
    9097
    91         rld::symbols::symbol& es = (*esi).second;
     98        rld::symbols::symbol& es = *((*esi).second);
    9299
    93100        if (rld::verbose () >= RLD_VERBOSE_INFO)
  • linkers/rld-symbols.cpp

    r0b65a28 r977c3de  
    11/*
    2  * Copyright (c) 2011, Chris Johns <chrisj@rtems.org> 
     2 * Copyright (c) 2011, Chris Johns <chrisj@rtems.org>
    33 *
    44 * Permission to use, copy, modify, and/or distribute this software for any
    55 * purpose with or without fee is hereby granted, provided that the above
    66 * copyright notice and this permission notice appear in all copies.
    7  * 
     7 *
    88 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    99 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
     
    5858
    5959    symbol::symbol (const std::string&  name,
    60                     rld::files::object& object,
     60                    files::object&      object,
    6161                    const elf::elf_sym& esym)
    6262      : name_ (name),
     
    105105    }
    106106
    107     const std::string& 
     107    const std::string&
    108108    symbol::name () const
    109109    {
     
    111111    }
    112112
    113     const std::string& 
     113    const std::string&
    114114    symbol::demangled () const
    115115    {
     
    123123    }
    124124
     125    int
     126    symbol::type () const
     127    {
     128      return GELF_ST_TYPE (esym_.st_info);
     129    }
     130
     131    int
     132    symbol::binding () const
     133    {
     134      return GELF_ST_BIND (esym_.st_info);
     135    }
     136
     137    int
     138    symbol::index () const
     139    {
     140      return esym_.st_shndx;
     141    }
     142
    125143    rld::files::object*
    126144    symbol::object () const
     
    128146      return object_;
    129147    }
    130    
     148
    131149    void
    132150    symbol::set_object (rld::files::object& obj)
     
    135153    }
    136154
    137     const elf::elf_sym& 
     155    const elf::elf_sym&
    138156    symbol::esym () const
    139157    {
     
    141159    }
    142160
    143     void 
     161    void
    144162    symbol::referenced ()
    145163    {
     
    149167    }
    150168
    151     bool 
     169    bool
    152170    symbol::operator< (const symbol& rhs) const
    153171    {
     
    208226      }
    209227
    210       out << binding 
     228      out << binding
    211229          << ' ' << type
    212           << " 0x" << std::setw (8) << std::setfill ('0') << std::hex 
    213           << es.st_value 
     230          << " 0x" << std::setw (8) << std::setfill ('0') << std::hex
     231          << es.st_value
    214232          << std::dec << std::setfill (' ')
    215233          << ' ' << std::setw (7)  << es.st_size
    216234          << ' ';
    217      
     235
    218236      if (is_cplusplus ())
    219237        out << demangled ();
     
    225243    }
    226244
     245    void
     246    load (bucket& bucket_, table& table_)
     247    {
     248      for (bucket::iterator sbi = bucket_.begin ();
     249           sbi != bucket_.end ();
     250           ++sbi)
     251      {
     252        symbol& sym = *sbi;
     253        table_[sym.name ()] = &sym;
     254      }
     255    }
     256
    227257    size_t
    228     referenced (list& symbols)
     258    referenced (pointers& symbols)
    229259    {
    230260      size_t used = 0;
    231       for (rld::symbols::list::iterator sli = symbols.begin ();
     261      for (pointers::iterator sli = symbols.begin ();
    232262           sli != symbols.end ();
    233263           ++sli)
    234264      {
    235         rld::symbols::symbol& sym = *(*sli);
     265        symbol& sym = *(*sli);
    236266        if (sym.references ())
    237267          ++used;
     
    250280           ++si)
    251281      {
    252         const symbol& sym = (*si).second;
     282        const symbol& sym = *((*si).second);
    253283        out << std::setw (5) << index << ' ' << sym << std::endl;
    254284        ++index;
  • linkers/rld-symbols.h

    r0b65a28 r977c3de  
    11/*
    2  * Copyright (c) 2011, Chris Johns <chrisj@rtems.org> 
     2 * Copyright (c) 2011, Chris Johns <chrisj@rtems.org>
    33 *
    44 * Permission to use, copy, modify, and/or distribute this software for any
    55 * purpose with or without fee is hereby granted, provided that the above
    66 * copyright notice and this permission notice appear in all copies.
    7  * 
     7 *
    88 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    99 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
     
    5959       * Construct an exported symbol with a object file.
    6060       */
    61       symbol (const std::string&  name, 
    62               rld::files::object& object,
     61      symbol (const std::string&  name,
     62              files::object&      object,
    6363              const elf::elf_sym& esym);
    6464
     
    6767       */
    6868      symbol (const std::string& name, const elf::elf_sym& esym);
    69      
     69
    7070      /**
    7171       * Construct a linker symbol that is internally created.
     
    7373      symbol (const std::string&  name,
    7474              const elf::elf_addr value);
    75      
     75
    7676      /**
    7777       * Construct a linker symbol that is internally created.
    7878       */
    79       symbol (const char*        name,
    80               rld::elf::elf_addr value = 0);
    81      
     79      symbol (const char*   name,
     80              elf::elf_addr value = 0);
     81
    8282      /**
    8383       * The symbol's name.
     
    9696
    9797      /**
     98       * The symbol's type.
     99       */
     100      int type () const;
     101
     102      /**
     103       * The symbol's binding, ie local, weak, or global.
     104       */
     105      int binding () const;
     106
     107      /**
     108       * The synbol's section index.
     109       */
     110      int index () const;
     111
     112      /**
    98113       * The symbol's object file name.
    99114       */
    100       rld::files::object* object () const;
     115      files::object* object () const;
    101116
    102117      /**
     
    104119       * symbols.
    105120       */
    106       void set_object (rld::files::object& obj);
     121      void set_object (files::object& obj);
    107122
    108123      /**
    109124       * The ELF symbol.
    110125       */
    111       const ::GElf_Sym& esym () const;
     126      const elf::elf_sym& esym () const;
    112127
    113128      /**
     
    134149
    135150    private:
    136       std::string         name_;       //< The name of the symbol.
    137       std::string         demangled_;  //< If a C++ symbol the demangled name.
    138       rld::files::object* object_;     //< The object file containing the
    139                                        // symbol.
    140       ::GElf_Sym          esym_;       //< The ELF symbol.
    141       int                 references_; //< The number of times if it referenced.
     151
     152      std::string    name_;       //< The name of the symbol.
     153      std::string    demangled_;  //< If a C++ symbol the demangled name.
     154      files::object* object_;     //< The object file containing the symbol.
     155      elf::elf_sym   esym_;       //< The ELF symbol.
     156      int            references_; //< The number of times if it referenced.
    142157    };
    143158
    144159    /**
    145      * List of symbol references.
    146      */
    147     typedef std::list < symbol* > list;
    148 
    149     /**
    150      * A symbols table is a map container of symbols.
    151      */
    152     typedef std::map < std::string, symbol > table;
    153 
    154     /**
    155      * Given a list of symbols return how many are referenced.
    156      */
    157     size_t referenced (list& symbols);
     160     * Container of symbols. A bucket of symbols.
     161     */
     162    typedef std::list < symbol > bucket;
     163
     164    /**
     165     * References to symbols. Should always point to symbols held in a bucket.
     166     */
     167    typedef std::list < symbol* > pointers;
     168
     169    /**
     170     * A symbols table is a map container of symbols. Should always point to
     171     * symbols held in a bucket.
     172     */
     173    typedef std::map < std::string, symbol* > table;
     174
     175    /**
     176     * Load a table from a buckey.
     177     */
     178    void load (bucket& bucket_, table& table_);
     179
     180    /**
     181     * Given a container of symbols return how many are referenced.
     182     */
     183    size_t referenced (pointers& symbols);
    158184
    159185    /**
     
    167193 * Output stream operator.
    168194 */
    169 static inline std::ostream& operator<< (std::ostream& out, const rld::symbols::symbol& sym) {
     195static inline std::ostream& operator<< (std::ostream&               out,
     196                                        const rld::symbols::symbol& sym) {
    170197  sym.output (out);
    171198  return out;
  • linkers/rld.cpp

    r0b65a28 r977c3de  
    11/*
    2  * Copyright (c) 2011, Chris Johns <chrisj@rtems.org> 
     2 * Copyright (c) 2011, Chris Johns <chrisj@rtems.org>
    33 *
    44 * Permission to use, copy, modify, and/or distribute this software for any
    55 * purpose with or without fee is hereby granted, provided that the above
    66 * copyright notice and this permission notice appear in all copies.
    7  * 
     7 *
    88 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    99 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
     
    6565   */
    6666  static std::string output;
    67  
     67
    6868  void
    6969  verbose_inc ()
     
    117117    std::cout << "Object files     : " << cache.object_count () << std::endl;
    118118    std::cout << "Exported symbols : " << symbols.size () << std::endl;
    119    
     119
    120120    std::cout << "Archives:" << std::endl;
    121121    cache.output_archive_files (std::cout);
     
    137137         ++oli)
    138138    {
    139       rld::files::object& object = *(*oli);
    140       rld::symbols::list& externals = object.external_symbols ();
    141      
     139      rld::files::object&     object = *(*oli);
     140      rld::symbols::pointers& externals = object.external_symbols ();
     141
    142142      if (rld::symbols::referenced (externals) != externals.size ())
    143143      {
     
    150150        std::cout << ' ' << object.name ().basename () << std::endl;
    151151
    152         for (rld::symbols::list::iterator sli = externals.begin ();
     152        for (rld::symbols::pointers::iterator sli = externals.begin ();
    153153             sli != externals.end ();
    154154             ++sli)
  • linkers/rtems-ld.cpp

    r0b65a28 r977c3de  
    156156  try
    157157  {
    158     rld::files::cache   cache;
    159     rld::files::cache   base;
    160     rld::files::paths   libpaths;
    161     rld::files::paths   libs;
    162     rld::files::paths   objects;
    163     rld::files::paths   libraries;
    164     rld::symbols::table base_symbols;
    165     rld::symbols::table symbols;
    166     rld::symbols::table undefined;
    167     std::string         entry;
    168     std::string         output = "a.out";
    169     std::string         base_name;
    170     std::string         cc_name;
    171     bool                script = false;
    172     bool                standard_libs = true;
    173     bool                exec_prefix_set = false;
    174     bool                map = false;
    175     bool                warnings = false;
     158    rld::files::cache    cache;
     159    rld::files::cache    base;
     160    rld::files::paths    libpaths;
     161    rld::files::paths    libs;
     162    rld::files::paths    objects;
     163    rld::files::paths    libraries;
     164    rld::symbols::bucket defines;
     165    rld::symbols::bucket undefines;
     166    rld::symbols::table  base_symbols;
     167    rld::symbols::table  symbols;
     168    rld::symbols::table  undefined;
     169    std::string          entry;
     170    std::string          output = "a.out";
     171    std::string          base_name;
     172    std::string          cc_name;
     173    bool                 script = false;
     174    bool                 standard_libs = true;
     175    bool                 exec_prefix_set = false;
     176    bool                 map = false;
     177    bool                 warnings = false;
    176178
    177179    libpaths.push_back (".");
     
    255257
    256258        case 'd':
    257           symbols[optarg] = rld::symbols::symbol (optarg);
     259          defines.push_back (rld::symbols::symbol (optarg));
    258260          break;
    259261
    260262        case 'u':
    261           undefined[optarg] = rld::symbols::symbol (optarg);
     263          undefines.push_back (rld::symbols::symbol (optarg));
    262264          break;
    263265
     
    294296    while (argc--)
    295297      objects.push_back (*argv++);
     298
     299    /*
     300     * Load the symbol table with the defined symbols from the defines bucket.
     301     */
     302    rld::symbols::load (defines, symbols);
     303
     304    /*
     305     * Load the undefined table with the undefined symbols from the undefines
     306     * bucket.
     307     */
     308    rld::symbols::load (undefines, undefined);
    296309
    297310    /*
     
    398411    char* realname;
    399412    realname = abi::__cxa_demangle (e.what(), 0, 0, &status);
    400     std::cerr << "error: std::exception: " << realname << " [";
     413    std::cerr << "error: exception: " << realname << " [";
    401414    ::free (realname);
    402415    const std::type_info &ti = typeid (e);
  • linkers/wscript

    r0b65a28 r977c3de  
    6161    #
    6262    bld.warningflags = ['-Wall', '-Wextra', '-pedantic']
    63     bld.optflags = ['-O2']
     63    bld.optflags = [] #['-O2']
    6464    bld.cflags = ['-pipe', '-g'] + bld.optflags
    6565    bld.cxxflags = ['-pipe', '-g'] + bld.optflags
     
    8080
    8181    #
     82    # RLD source.
     83    #
     84    rld_source = ['rld-elf.cpp',
     85                  'rld-files.cpp',
     86                  'rld-cc.cpp',
     87                  'rld-outputter.cpp',
     88                  'rld-process.cpp',
     89                  'rld-resolver.cpp',
     90                  'rld-symbols.cpp',
     91                  'rld.cpp']
     92
     93    #
    8294    # Build the linker.
    8395    #
    8496    bld.program(target = 'rtems-ld',
    85                 source = ['main.cpp',
    86                           'pkgconfig.cpp',
    87                           'rld-elf.cpp',
    88                           'rld-files.cpp',
    89                           'rld-cc.cpp',
    90                           'rld-outputter.cpp',
    91                           'rld-process.cpp',
    92                           'rld-resolver.cpp',
    93                           'rld-symbols.cpp',
    94                           'rld.cpp'],
     97                source = ['rtems-ld.cpp',
     98                          'pkgconfig.cpp'] + rld_source,
     99                defines = ['HAVE_CONFIG_H=1', 'RTEMS_VERSION=' + bld.env.RTEMS_VERSION],
     100                includes = ['.'] + bld.includes,
     101                cflags = bld.cflags + bld.warningflags,
     102                cxxflags = bld.cxxflags + bld.warningflags,
     103                linkflags = bld.linkflags,
     104                use = modules)
     105
     106    #
     107    # Build the symbols.
     108    #
     109    bld.program(target = 'rtems-syms',
     110                source = ['rtems-syms.cpp'] + rld_source,
    95111                defines = ['HAVE_CONFIG_H=1', 'RTEMS_VERSION=' + bld.env.RTEMS_VERSION],
    96112                includes = ['.'] + bld.includes,
Note: See TracChangeset for help on using the changeset viewer.