Changeset b36c5209 in rtems


Ignore:
Timestamp:
May 3, 2019, 12:15:20 AM (2 weeks ago)
Author:
Chris Johns <chrisj@…>
Branches:
master
Children:
8bd4f61c
Parents:
be50969
Message:

libdl: Do not access the ELF file while the allocator is locked.

  • Load symbols before allocation.
  • Parse reloc records and place any reloc recs in a cache to use while the allocator is locked.
  • Relocate symbols after section allocation.
  • Split section loading into allocation/locating and loading.
  • Update all arch back-ends with a new reloc interface to control tramp handling.
  • Add -a and -t to the object list shell command.

Closes #3741

Files:
1 added
25 edited

Legend:

Unmodified
Added
Removed
  • cpukit/include/rtems/rtl/rtl-obj.h

    rbe50969 rb36c5209  
    208208  void*               const_base;   /**< The base address of the const section
    209209                                     *   in memory. */
    210   size_t              const_size;    /**< The size of the const section. */
     210  size_t              const_size;   /**< The size of the const section. */
    211211  void*               eh_base;      /**< The base address of the eh section in
    212212                                     *   memory. */
     
    228228  void*               trampoline;   /**< Trampoline memory. Used for fixups or
    229229                                     *   veneers */
    230   size_t              tramp_size;   /**< Size of the tramopline memory. */
     230  size_t              tramp_size;   /**< Size of a tramopline slot. */
     231  size_t              tramps_size;  /**< Size of the trampoline memory. */
    231232  void*               tramp_brk;    /**< Trampoline memory allocator. MD
    232233                                     *   relocators can take memory from the
    233234                                     *   break upto the size. */
     235  size_t              tramp_relocs; /**< Number of slots reserved for
     236                                     *   relocs. The remainder are for
     237                                     *   unresolved symbols. */
    234238  struct link_map*    linkmap;      /**< For GDB. */
    235239  void*               loader;       /**< The file details specific to a
     
    371375 * @retval bool Returns @true if the space is available.
    372376 */
    373 static inline bool rtems_rtl_obj_has_ramp_space (const rtems_rtl_obj* obj,
    374                                                  const size_t         size)
     377static inline bool rtems_rtl_obj_has_tramp_space (const rtems_rtl_obj* obj,
     378                                                  const size_t         size)
    375379{
    376380  return (obj->trampoline != NULL &&
    377           ((obj->tramp_brk - obj->trampoline) + size) <= obj->tramp_size);
     381          ((obj->tramp_brk - obj->trampoline) + size) <= obj->tramps_size);
     382}
     383
     384/**
     385 * Trampoline slots.
     386 *
     387 * @param obj The object file's descriptor.
     388 * @retval size_t The number of trampoline slots.
     389 */
     390static inline size_t rtems_rtl_obj_trampoline_slots (const rtems_rtl_obj* obj)
     391{
     392  return obj->trampoline == NULL || obj->tramp_size == 0 ?
     393    0 : obj->tramps_size / obj->tramp_size;
     394}
     395
     396/**
     397 * Number of trampolines.
     398 *
     399 * @param obj The object file's descriptor.
     400 * @retval size_t The number of trampolines.
     401 */
     402static inline size_t rtems_rtl_obj_trampolines (const rtems_rtl_obj* obj)
     403{
     404  return obj->trampoline == NULL || obj->tramp_size == 0 ?
     405    0 : (obj->tramp_brk - obj->trampoline) / obj->tramp_size;
    378406}
    379407
  • cpukit/include/rtems/rtl/rtl-unresolved.h

    rbe50969 rb36c5209  
    11/*
    2  *  COPYRIGHT (c) 2012, 2018 Chris Johns <chrisj@rtems.org>
     2 *  COPYRIGHT (c) 2012, 2019 Chris Johns <chrisj@rtems.org>
    33 *
    44 *  The license and distribution terms for this file may be
     
    7474  rtems_rtl_unresolved_empty = 0,  /**< The records is empty. Must always be 0 */
    7575  rtems_rtl_unresolved_symbol = 1, /**< The record is a symbol. */
    76   rtems_rtl_unresolved_reloc = 2   /**< The record is a relocation record. */
     76  rtems_rtl_unresolved_reloc = 2,  /**< The record is a relocation record. */
     77  rtems_rtl_trampoline_reloc = 3   /**< The record is a trampoline relocation record. */
    7778} rtems_rtl_unresolved_rtype;
    7879
     
    102103/**
    103104 * Unresolved externals symbols require the relocation records to be held
    104  * and references.
     105 * and referenced.
    105106 */
    106107typedef struct rtems_rtl_unresolv_reloc
     
    114115
    115116/**
     117 * Trampolines require the relocation records to be held
     118 */
     119typedef struct rtems_rtl_tramp_reloc
     120{
     121  rtems_rtl_obj* obj;      /**< The relocation's object file. */
     122  uint16_t       flags;    /**< Format specific flags. */
     123  uint16_t       sect;     /**< The target section. */
     124  rtems_rtl_word symvalue; /**< The symbol's value. */
     125  rtems_rtl_word rel[3];   /**< Relocation record. */
     126} rtems_rtl_tramp_reloc;
     127
     128/**
    116129 * Unresolved externals records.
    117130 */
     
    122135  {
    123136    rtems_rtl_unresolv_symbol name;   /**< The symbol, or */
    124     rtems_rtl_unresolv_reloc  reloc;  /**< the relocation record. */
     137    rtems_rtl_unresolv_reloc  reloc;  /**< The relocation record. */
     138    rtems_rtl_tramp_reloc     tramp;  /**< The trampoline relocation record. */
    125139  } rec;
    126140} rtems_rtl_unresolv_rec;
  • cpukit/include/rtems/rtl/rtl.h

    rbe50969 rb36c5209  
    7373 * The number of relocation record per block in the unresolved table.
    7474 */
    75 #define RTEMS_RTL_UNRESOLVED_BLOCK_SIZE (64)
     75#define RTEMS_RTL_UNRESOLVED_BLOCK_SIZE (256)
    7676
    7777/**
  • cpukit/libdl/rtl-allocator.c

    rbe50969 rb36c5209  
    148148
    149149  if (rtems_rtl_trace (RTEMS_RTL_TRACE_ALLOCATOR))
    150     printf ("rtl: alloc: wr-enable: addr=%p\n", address);
     150    printf ("rtl: alloc: wr-disable: addr=%p\n", address);
    151151
    152152  if (rtl != NULL && address != NULL)
  • cpukit/libdl/rtl-elf.c

    rbe50969 rb36c5209  
    11/*
    2  *  COPYRIGHT (c) 2012-2018 Chris Johns <chrisj@rtems.org>
     2 *  COPYRIGHT (c) 2012-2019 Chris Johns <chrisj@rtems.org>
    33 *
    44 *  The license and distribution terms for this file may be
     
    3232#include "rtl-error.h"
    3333#include <rtems/rtl/rtl-trace.h>
     34#include "rtl-trampoline.h"
    3435#include "rtl-unwind.h"
    3536#include <rtems/rtl/rtl-unresolved.h>
    3637
    3738/**
    38  * The offsets in the unresolved array.
     39 * The offsets in the reloc words.
    3940 */
    4041#define REL_R_OFFSET (0)
     
    167168{
    168169  rtems_rtl_elf_reloc_data* rd = (rtems_rtl_elf_reloc_data*) data;
    169 
    170   /*
    171    * The symbol has to have been resolved to parse the reloc record. Unresolved
    172    * symbols are handled in the relocator but we need to count them here so a
    173    * trampoline is accounted for. We have to assume the unresolved may be out of
    174    * of range.
    175    */
    176   if (!resolved)
    177   {
    178     ++rd->unresolved;
     170  rtems_rtl_word            rel_words[3];
     171  rtems_rtl_elf_rel_status  rs;
     172
     173  /*
     174   * Check the reloc record to see if a trampoline is needed.
     175   */
     176  if (is_rela)
     177  {
     178    const Elf_Rela* rela = (const Elf_Rela*) relbuf;
     179    if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
     180      printf ("rtl: rela tramp: sym: %c:%s(%d)=%08jx type:%d off:%08jx addend:%d\n",
     181              ELF_ST_BIND (sym->st_info) == STB_GLOBAL ||
     182              ELF_ST_BIND (sym->st_info) == STB_WEAK ? 'G' : 'L',
     183              symname, (int) ELF_R_SYM (rela->r_info),
     184              (uintmax_t) symvalue, (int) ELF_R_TYPE (rela->r_info),
     185              (uintmax_t) rela->r_offset, (int) rela->r_addend);
     186    rs = rtems_rtl_elf_relocate_rela_tramp (obj, rela, targetsect,
     187                                            symname, sym->st_info, symvalue);
     188    rel_words[REL_R_OFFSET] = rela->r_offset;
     189    rel_words[REL_R_INFO] = rela->r_info;
     190    rel_words[REL_R_ADDEND] = rela->r_addend;
    179191  }
    180192  else
    181193  {
     194    const Elf_Rel* rel = (const Elf_Rel*) relbuf;
     195    if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
     196      printf ("rtl: rel tramp: sym: %c:%s(%d)=%08jx type:%d off:%08jx\n",
     197              ELF_ST_BIND (sym->st_info) == STB_GLOBAL ||
     198              ELF_ST_BIND (sym->st_info) == STB_WEAK ? 'G' : 'L',
     199              symname, (int) ELF_R_SYM (rel->r_info),
     200              (uintmax_t) symvalue, (int) ELF_R_TYPE (rel->r_info),
     201              (uintmax_t) rel->r_offset);
     202    rs = rtems_rtl_elf_relocate_rel_tramp (obj, rel, targetsect,
     203                                           symname, sym->st_info, symvalue);
     204    rel_words[REL_R_OFFSET] = rel->r_offset;
     205    rel_words[REL_R_INFO] = rel->r_info;
     206    rel_words[REL_R_ADDEND] = 0;
     207  }
     208
     209  if (rs == rtems_rtl_elf_rel_failure)
     210    return false;
     211
     212  if (rs == rtems_rtl_elf_rel_tramp_cache || rs == rtems_rtl_elf_rel_tramp_add)
     213  {
     214    uint32_t flags = (is_rela ? 1 : 0) | (resolved ? 0 : 1 << 1) | (sym->st_info << 8);
     215    if (!rtems_rtl_trampoline_add (obj, flags,
     216                                   targetsect->section, symvalue, rel_words))
     217      return false;
     218  }
     219
     220  /*
     221   * Handle any dependencies if there is a valid symbol.
     222   */
     223  if (symname != NULL)
     224  {
    182225    /*
    183      * Check the reloc record to see if a trampoline is needed.
     226     * Find the symbol's object file. It cannot be NULL so ignore that result
     227     * if returned, it means something is corrupted. We are in an iterator.
    184228     */
    185     if (is_rela)
    186     {
    187       const Elf_Rela* rela = (const Elf_Rela*) relbuf;
    188       if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
    189         printf ("rtl: rela tramp: sym:%s(%d)=%08jx type:%d off:%08jx addend:%d\n",
    190                 symname, (int) ELF_R_SYM (rela->r_info),
    191                 (uintmax_t) symvalue, (int) ELF_R_TYPE (rela->r_info),
    192                 (uintmax_t) rela->r_offset, (int) rela->r_addend);
    193       if (!rtems_rtl_elf_relocate_rela_tramp (obj, rela, targetsect,
    194                                               symname, sym->st_info, symvalue))
    195         return false;
    196     }
    197     else
    198     {
    199       const Elf_Rel* rel = (const Elf_Rel*) relbuf;
    200       if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
    201         printf ("rtl: rel tramp: sym:%s(%d)=%08jx type:%d off:%08jx\n",
    202                 symname, (int) ELF_R_SYM (rel->r_info),
    203                 (uintmax_t) symvalue, (int) ELF_R_TYPE (rel->r_info),
    204                 (uintmax_t) rel->r_offset);
    205       if (!rtems_rtl_elf_relocate_rel_tramp (obj, rel, targetsect,
    206                                              symname, sym->st_info, symvalue))
    207         return false;
    208     }
    209 
    210     if (symname != NULL)
     229    rtems_rtl_obj*  sobj = rtems_rtl_find_obj_with_symbol (symbol);
     230    if (sobj != NULL)
    211231    {
    212232      /*
    213        * Find the symbol's object file. It cannot be NULL so ignore that result
    214        * if returned, it means something is corrupted. We are in an iterator.
     233       * A dependency is not the base kernel image or itself. Tag the object as
     234       * having been visited so we count it only once.
    215235       */
    216       rtems_rtl_obj*  sobj = rtems_rtl_find_obj_with_symbol (symbol);
    217       if (sobj != NULL)
    218       {
    219         /*
    220          * A dependency is not the base kernel image or itself. Tag the object as
    221          * having been visited so we count it only once.
    222          */
    223         if (sobj != rtems_rtl_baseimage () && obj != sobj &&
    224             (sobj->flags & RTEMS_RTL_OBJ_RELOC_TAG) == 0)
    225         {
    226           sobj->flags |= RTEMS_RTL_OBJ_RELOC_TAG;
    227           ++rd->dependents;
    228         }
     236      if (sobj != rtems_rtl_baseimage () && obj != sobj &&
     237          (sobj->flags & RTEMS_RTL_OBJ_RELOC_TAG) == 0)
     238      {
     239        sobj->flags |= RTEMS_RTL_OBJ_RELOC_TAG;
     240        ++rd->dependents;
    229241      }
    230242    }
     
    279291  else
    280292  {
    281     rtems_rtl_obj* sobj;
     293    rtems_rtl_obj*           sobj;
     294    rtems_rtl_elf_rel_status rs;
    282295
    283296    if (is_rela)
     
    288301                (uintmax_t) symvalue, (int) ELF_R_TYPE (rela->r_info),
    289302                (uintmax_t) rela->r_offset, (int) rela->r_addend);
    290       if (!rtems_rtl_elf_relocate_rela (obj, rela, targetsect,
    291                                         symname, sym->st_info, symvalue))
     303      rs = rtems_rtl_elf_relocate_rela (obj, rela, targetsect,
     304                                        symname, sym->st_info, symvalue);
     305      if (rs != rtems_rtl_elf_rel_no_error)
    292306        return false;
    293307    }
     
    299313                (uintmax_t) symvalue, (int) ELF_R_TYPE (rel->r_info),
    300314                (uintmax_t) rel->r_offset);
    301       if (!rtems_rtl_elf_relocate_rel (obj, rel, targetsect,
    302                                        symname, sym->st_info, symvalue))
     315      rs = rtems_rtl_elf_relocate_rel (obj, rel, targetsect,
     316                                       symname, sym->st_info, symvalue);
     317      if (rs != rtems_rtl_elf_rel_no_error)
    303318        return false;
    304319    }
     
    420435     * Only need the name of the symbol if global or a common symbol.
    421436     */
    422     if (ELF_ST_TYPE (sym.st_info) == STT_NOTYPE ||
     437    if (ELF_ST_TYPE (sym.st_info) == STT_OBJECT ||
     438        ELF_ST_TYPE (sym.st_info) == STT_COMMON ||
     439        ELF_ST_TYPE (sym.st_info) == STT_FUNC ||
     440        ELF_ST_TYPE (sym.st_info) == STT_NOTYPE ||
    423441        ELF_ST_TYPE (sym.st_info) == STT_TLS ||
    424442        sym.st_shndx == SHN_COMMON)
     
    492510                                   rtems_rtl_obj_sym*        sym)
    493511{
    494   rtems_rtl_obj_sect* sect;
    495   bool                is_rela;
    496   Elf_Word            symvalue;
    497   rtems_rtl_obj*      sobj;
     512  rtems_rtl_obj_sect*      sect;
     513  bool                     is_rela;
     514  Elf_Word                 symvalue;
     515  rtems_rtl_obj*           sobj;
     516  rtems_rtl_elf_rel_status rs;
    498517
    499518  is_rela = reloc->flags & 1;
     
    517536                  (int) ELF_R_SYM (rela.r_info), (int) ELF_R_TYPE (rela.r_info),
    518537                  (uintmax_t) rela.r_offset, (int) rela.r_addend);
    519     if (!rtems_rtl_elf_relocate_rela (reloc->obj, &rela, sect,
    520                                       sym->name, sym->data, symvalue))
     538    rs = rtems_rtl_elf_relocate_rela (reloc->obj, &rela, sect,
     539                                      sym->name, sym->data, symvalue);
     540    if (rs != rtems_rtl_elf_rel_no_error)
    521541      return false;
    522542  }
     
    530550              (int) ELF_R_SYM (rel.r_info), (int) ELF_R_TYPE (rel.r_info),
    531551              (uintmax_t) rel.r_offset);
    532     if (!rtems_rtl_elf_relocate_rel (reloc->obj, &rel, sect,
    533                                      sym->name, sym->data, symvalue))
     552    rs = rtems_rtl_elf_relocate_rel (reloc->obj, &rel, sect,
     553                                     sym->name, sym->data, symvalue);
     554    if (rs != rtems_rtl_elf_rel_no_error)
    534555      return false;
    535556  }
     
    622643}
    623644
     645/**
     646 * Struct to handle trampoline reloc recs in the unresolved table.
     647 */
     648typedef struct rtems_rtl_tramp_data
     649{
     650  bool           failure;
     651  rtems_rtl_obj* obj;
     652  size_t         count;
     653  size_t         total;
     654} rtems_rtl_tramp_data;
     655
     656static bool
     657rtems_rtl_elf_tramp_resolve_reloc (rtems_rtl_unresolv_rec* rec,
     658                                   void*                   data)
     659{
     660  rtems_rtl_tramp_data* td = (rtems_rtl_tramp_data*) data;
     661  if (rec->type == rtems_rtl_trampoline_reloc)
     662  {
     663    const rtems_rtl_tramp_reloc* tramp = &rec->rec.tramp;
     664
     665    ++td->total;
     666
     667    if (tramp->obj == td->obj)
     668    {
     669      const rtems_rtl_obj_sect* targetsect;
     670      Elf_Byte                  st_info;
     671      Elf_Word                  symvalue;
     672      rtems_rtl_elf_rel_status  rs;
     673      bool*                     failure = (bool*) data;
     674      const bool                is_rela = (tramp->flags & 1) == 1;
     675      const bool                unresolved = (tramp->flags & (1 << 1)) != 0;
     676
     677      ++td->count;
     678
     679      targetsect = rtems_rtl_obj_find_section_by_index (tramp->obj, tramp->sect);
     680      st_info = tramp->flags >> 8;
     681      symvalue = tramp->symvalue;
     682
     683      if (is_rela)
     684      {
     685        Elf_Rela rela = {
     686          .r_offset = tramp->rel[REL_R_OFFSET],
     687          .r_info   = tramp->rel[REL_R_INFO],
     688          .r_addend = tramp->rel[REL_R_ADDEND]
     689        };
     690        if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
     691          printf ("rtl: rela tramp: check: %c(%d)=%08jx type:%d off:%08jx addend:%d\n",
     692                  ELF_ST_BIND (st_info) == STB_GLOBAL ||
     693                  ELF_ST_BIND (st_info) == STB_WEAK ? 'G' : 'L',
     694                  (int) ELF_R_SYM (rela.r_info),
     695                  (uintmax_t) symvalue, (int) ELF_R_TYPE (rela.r_info),
     696                  (uintmax_t) rela.r_offset, (int) rela.r_addend);
     697        rs = rtems_rtl_elf_relocate_rela_tramp (tramp->obj, &rela, targetsect,
     698                                                NULL, st_info, symvalue);
     699      }
     700      else
     701      {
     702        Elf_Rel rel = {
     703          .r_offset = tramp->rel[REL_R_OFFSET],
     704          .r_info   = tramp->rel[REL_R_INFO],
     705        };
     706        if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
     707          printf ("rtl: rel tramp: check: %c(%d)=%08jx type:%d off:%08jx\n",
     708                  ELF_ST_BIND (st_info) == STB_GLOBAL ||
     709                  ELF_ST_BIND (st_info) == STB_WEAK ? 'G' : 'L',
     710                  (int) ELF_R_SYM (rel.r_info),
     711                  (uintmax_t) symvalue, (int) ELF_R_TYPE (rel.r_info),
     712                  (uintmax_t) rel.r_offset);
     713        rs = rtems_rtl_elf_relocate_rel_tramp (tramp->obj, &rel, targetsect,
     714                                               NULL, st_info, symvalue);
     715      }
     716
     717      if (unresolved || rs == rtems_rtl_elf_rel_tramp_add)
     718        tramp->obj->tramps_size += tramp->obj->tramp_size;
     719      if (rs == rtems_rtl_elf_rel_failure)
     720      {
     721        *failure = true;
     722        return true;
     723      }
     724    }
     725  }
     726
     727  return false;
     728}
     729
    624730static bool
    625731rtems_rtl_elf_alloc_trampoline (rtems_rtl_obj* obj, size_t unresolved)
    626732{
     733  rtems_rtl_tramp_data td =  { 0 };
     734  td.obj = obj;
     735  /*
     736   * See which relocs are out of range and need a trampoline.
     737   */
     738  rtems_rtl_unresolved_iterate (rtems_rtl_elf_tramp_resolve_reloc, &td);
     739  if (td.failure)
     740    return false;
     741  rtems_rtl_trampoline_remove (obj);
     742  obj->tramp_relocs = obj->tramp_size == 0 ? 0 : obj->tramps_size / obj->tramp_size;
     743  if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
     744    printf ("rtl: tramp:elf: tramps: %zu count:%zu total:%zu\n",
     745            obj->tramp_relocs, td.count, td.total);
    627746  /*
    628747   * Add on enough space to handle the unresolved externals that need to be
     
    630749   * trampolines.
    631750   */
    632   obj->tramp_size +=
    633     rtems_rtl_elf_relocate_tramp_max_size () * unresolved;
     751  obj->tramps_size += obj->tramp_size * unresolved;
     752  if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
     753    printf ("rtl: tramp:elf: slots: %zu (%zu)\n",
     754            obj->tramp_size == 0 ? 0 : obj->tramps_size / obj->tramp_size,
     755            obj->tramps_size);
    634756  return rtems_rtl_obj_alloc_trampoline (obj);
    635757}
     
    654776
    655777static bool
    656 rtems_rtl_elf_symbols (rtems_rtl_obj*      obj,
    657                        int                 fd,
    658                        rtems_rtl_obj_sect* sect,
    659                        void*               data)
     778rtems_rtl_elf_symbols_load (rtems_rtl_obj*      obj,
     779                            int                 fd,
     780                            rtems_rtl_obj_sect* sect,
     781                            void*               data)
    660782{
    661783  rtems_rtl_obj_cache* symbols;
     
    721843     */
    722844    if (rtems_rtl_trace (RTEMS_RTL_TRACE_SYMBOL))
    723       printf ("rtl: sym:elf:%-2d name:%-2d:%-20s bind:%-2d " \
    724               "type:%-2d sect:%d size:%d\n",
     845      printf ("rtl: sym:elf:%-4d name:%-4d: %-20s: bind:%-2d " \
     846              "type:%-2d sect:%-5d size:%-5d value:%d\n",
    725847              sym, (int) symbol.st_name, name,
    726848              (int) ELF_ST_BIND (symbol.st_info),
    727849              (int) ELF_ST_TYPE (symbol.st_info),
    728850              symbol.st_shndx,
    729               (int) symbol.st_size);
    730 
    731             /*
    732          * If a duplicate forget it.
    733          */
    734         if (rtems_rtl_symbol_global_find (name))
    735           continue;
     851              (int) symbol.st_size,
     852              (int) symbol.st_value);
     853
     854    /*
     855     * If a duplicate forget it.
     856     */
     857    if (rtems_rtl_symbol_global_find (name))
     858      continue;
    736859
    737860    if ((symbol.st_shndx != 0) &&
     
    776899          {
    777900            if (rtems_rtl_trace (RTEMS_RTL_TRACE_SYMBOL))
    778               printf ("rtl: sym:elf:%-2d name:%-2d:%-20s: global\n",
     901              printf ("rtl: sym:elf:%-4d name:%-4d: %-20s: global\n",
    779902                      sym, (int) symbol.st_name, name);
    780903            ++globals;
     
    785908        {
    786909          if (rtems_rtl_trace (RTEMS_RTL_TRACE_SYMBOL))
    787             printf ("rtl: sym:elf:%-2d name:%-2d:%-20s: local\n",
     910            printf ("rtl: sym:elf:%-4d name:%-4d: %-20s: local\n",
    788911                    sym, (int) symbol.st_name, name);
    789912          ++locals;
     
    850973                                         &symbol, sizeof (symbol)))
    851974    {
    852       if (locals)
     975      if (obj->local_syms)
    853976      {
    854977        rtems_rtl_alloc_del (RTEMS_RTL_ALLOC_SYMBOL, obj->local_table);
     
    857980        obj->local_syms = 0;
    858981      }
    859       if (globals)
     982      if (obj->global_syms)
    860983      {
    861984        rtems_rtl_alloc_del (RTEMS_RTL_ALLOC_SYMBOL, obj->global_table);
     
    876999          (ELF_ST_BIND (symbol.st_info) == STB_LOCAL)))
    8771000    {
     1001      rtems_rtl_obj_sym* osym;
     1002      char*              string;
     1003      Elf_Word           value;
     1004      const char*        name;
     1005
     1006      off = obj->ooffset + strtab->offset + symbol.st_name;
     1007      len = RTEMS_RTL_ELF_STRING_MAX;
     1008
     1009      if (!rtems_rtl_obj_cache_read (strings, fd, off, (void**) &name, &len))
     1010        return false;
     1011
     1012      /*
     1013       * If a duplicate forget it.
     1014       */
     1015      if (rtems_rtl_symbol_global_find (name))
     1016        continue;
     1017
     1018      if ((ELF_ST_BIND (symbol.st_info) == STB_GLOBAL) ||
     1019          (ELF_ST_BIND (symbol.st_info) == STB_WEAK))
     1020      {
     1021        osym = gsym;
     1022        string = gstring;
     1023        gstring += strlen (name) + 1;
     1024        ++gsym;
     1025      }
     1026      else
     1027      {
     1028        osym = lsym;
     1029        string = lstring;
     1030        lstring += strlen (name) + 1;
     1031        ++lsym;
     1032      }
     1033
     1034      /*
     1035       * Allocate any common symbols in the common section.
     1036       */
     1037      if (symbol.st_shndx == SHN_COMMON)
     1038      {
     1039        size_t value_off = rtems_rtl_obj_align (common_offset,
     1040                                                symbol.st_value);
     1041        common_offset = value_off + symbol.st_size;
     1042        value = value_off;
     1043      }
     1044      else
     1045      {
     1046        value = symbol.st_value;
     1047      }
     1048
     1049      rtems_chain_set_off_chain (&osym->node);
     1050      memcpy (string, name, strlen (name) + 1);
     1051      osym->name = string;
     1052      osym->value = (uint8_t*) value;
     1053      osym->data = symbol.st_shndx;
     1054
     1055      if (rtems_rtl_trace (RTEMS_RTL_TRACE_SYMBOL))
     1056        printf ("rtl: sym:add:%-4d name:%-4d: %-20s: bind:%-2d " \
     1057                "type:%-2d val:%-8p sect:%-3d size:%d\n",
     1058                sym, (int) symbol.st_name, osym->name,
     1059                (int) ELF_ST_BIND (symbol.st_info),
     1060                (int) ELF_ST_TYPE (symbol.st_info),
     1061                osym->value, symbol.st_shndx,
     1062                (int) symbol.st_size);
     1063    }
     1064  }
     1065
     1066  return true;
     1067}
     1068
     1069static bool
     1070rtems_rtl_elf_symbols_locate (rtems_rtl_obj*      obj,
     1071                              int                 fd,
     1072                              rtems_rtl_obj_sect* sect,
     1073                              void*               data)
     1074{
     1075  int sym;
     1076
     1077  for (sym = 0; sym < obj->local_syms; ++sym)
     1078  {
     1079      rtems_rtl_obj_sym*  osym = &obj->local_table[sym];
    8781080      rtems_rtl_obj_sect* symsect;
    879       rtems_rtl_obj_sym*  osym;
    880       char*               string;
    881       Elf_Word            value;
    882 
    883       symsect = rtems_rtl_obj_find_section_by_index (obj, symbol.st_shndx);
     1081      symsect = rtems_rtl_obj_find_section_by_index (obj, osym->data);
    8841082      if (symsect)
    8851083      {
    886         const char* name;
    887 
    888         off = obj->ooffset + strtab->offset + symbol.st_name;
    889         len = RTEMS_RTL_ELF_STRING_MAX;
    890 
    891         if (!rtems_rtl_obj_cache_read (strings, fd, off, (void**) &name, &len))
    892           return false;
    893 
    894         /*
    895          * If a duplicate forget it.
    896          */
    897         if (rtems_rtl_symbol_global_find (name))
    898           continue;
    899 
    900         if ((ELF_ST_BIND (symbol.st_info) == STB_GLOBAL) ||
    901             (ELF_ST_BIND (symbol.st_info) == STB_WEAK))
    902         {
    903           osym = gsym;
    904           string = gstring;
    905           gstring += strlen (name) + 1;
    906           ++gsym;
    907         }
    908         else
    909         {
    910           osym = lsym;
    911           string = lstring;
    912           lstring += strlen (name) + 1;
    913           ++lsym;
    914         }
    915 
    916         /*
    917          * Allocate any common symbols in the common section.
    918          */
    919         if (symbol.st_shndx == SHN_COMMON)
    920         {
    921           size_t value_off = rtems_rtl_obj_align (common_offset,
    922                                                   symbol.st_value);
    923           common_offset = value_off + symbol.st_size;
    924           value = value_off;
    925         }
    926         else
    927         {
    928           value = symbol.st_value;
    929         }
    930 
    931         rtems_chain_set_off_chain (&osym->node);
    932         memcpy (string, name, strlen (name) + 1);
    933         osym->name = string;
    934         osym->value = value + (uint8_t*) symsect->base;
    935         osym->data = symbol.st_info;
    936 
     1084        osym->value += (intptr_t) symsect->base;
    9371085        if (rtems_rtl_trace (RTEMS_RTL_TRACE_SYMBOL))
    938           printf ("rtl: sym:add:%-2d name:%-2d:%-20s bind:%-2d " \
    939                   "type:%-2d val:%8p sect:%d size:%d\n",
    940                   sym, (int) symbol.st_name, osym->name,
    941                   (int) ELF_ST_BIND (symbol.st_info),
    942                   (int) ELF_ST_TYPE (symbol.st_info),
    943                   osym->value, symbol.st_shndx,
    944                   (int) symbol.st_size);
    945       }
    946     }
    947   }
    948 
    949   if (globals)
     1086          printf ("rtl: sym:locate:local :%-4d name: %-20s val:%-8p sect:%-3d (%s, %p)\n",
     1087                  sym, osym->name, osym->value, osym->data,
     1088                  symsect->name, symsect->base);
     1089      }
     1090  }
     1091
     1092  for (sym = 0; sym < obj->global_syms; ++sym)
     1093  {
     1094      rtems_rtl_obj_sym*  osym = &obj->global_table[sym];
     1095      rtems_rtl_obj_sect* symsect;
     1096      symsect = rtems_rtl_obj_find_section_by_index (obj, osym->data);
     1097      if (symsect)
     1098      {
     1099        osym->value += (intptr_t) symsect->base;
     1100        if (rtems_rtl_trace (RTEMS_RTL_TRACE_SYMBOL))
     1101          printf ("rtl: sym:locate:global:%-4d name: %-20s val:%-8p sect:%-3d (%s, %p)\n",
     1102                  sym, osym->name, osym->value, osym->data,
     1103                  symsect->name, symsect->base);
     1104      }
     1105  }
     1106
     1107  if (obj->global_size)
    9501108    rtems_rtl_symbol_obj_add (obj);
    9511109
     
    14361594
    14371595  /*
     1596   * Set the format's architecture's maximum tramp size.
     1597   */
     1598  obj->tramp_size = rtems_rtl_elf_relocate_tramp_max_size ();
     1599
     1600  /*
    14381601   * Parse the section information first so we have the memory map of the object
    14391602   * file and the memory allocated. Any further allocations we make to complete
     
    14441607
    14451608  /*
    1446    * See if there are any common variables and if there are add a common
    1447    * section.
     1609   * Set the entry point if there is one.
     1610   */
     1611  obj->entry = (void*)(uintptr_t) ehdr.e_entry;
     1612
     1613  /*
     1614   * Load the symbol table.
     1615   *
     1616   * 1. See if there are any common variables and if there are add a
     1617   *    common section.
     1618   * 2. Add up the common.
     1619   * 3.
    14481620   */
    14491621  if (!rtems_rtl_obj_load_symbols (obj, fd, rtems_rtl_elf_common, &common))
     
    14511623  if (!rtems_rtl_elf_add_common (obj, common.size, common.alignment))
    14521624    return false;
    1453 
    1454   /*
    1455    * Set the entry point if there is one.
    1456    */
    1457   obj->entry = (void*)(uintptr_t) ehdr.e_entry;
     1625  if (!rtems_rtl_obj_load_symbols (obj, fd, rtems_rtl_elf_symbols_load, &ehdr))
     1626    return false;
     1627
     1628  /*
     1629   * Parse the relocation records. It lets us know how many dependents
     1630   * and fixup trampolines there are.
     1631   */
     1632  if (!rtems_rtl_obj_relocate (obj, fd, rtems_rtl_elf_relocs_parser, &relocs))
     1633    return false;
    14581634
    14591635  /*
     
    14691645    return false;
    14701646
     1647  if (!rtems_rtl_obj_load_symbols (obj, fd, rtems_rtl_elf_symbols_locate, &ehdr))
     1648    return false;
     1649
     1650  if (!rtems_rtl_elf_dependents (obj, &relocs))
     1651    return false;
     1652
     1653  if (!rtems_rtl_elf_alloc_trampoline (obj, relocs.unresolved))
     1654    return false;
     1655
     1656  /*
     1657   * Unlock the allocator.
     1658   */
     1659  rtems_rtl_alloc_unlock ();
     1660
    14711661  /*
    14721662   * Load the sections and symbols and then relocation to the base address.
     
    14761666
    14771667  /*
    1478    * Parse the relocation records. It lets us know how many dependents
    1479    * and fixup trampolines there are.
    1480    */
    1481   if (!rtems_rtl_obj_relocate (obj, fd, rtems_rtl_elf_relocs_parser, &relocs))
    1482     return false;
    1483 
    1484   if (!rtems_rtl_elf_dependents (obj, &relocs))
    1485     return false;
    1486 
    1487   if (!rtems_rtl_elf_alloc_trampoline (obj, relocs.unresolved))
    1488     return false;
    1489 
    1490   /*
    1491    * Unlock the allocator.
    1492    */
    1493   rtems_rtl_alloc_unlock ();
    1494 
    1495   if (!rtems_rtl_obj_load_symbols (obj, fd, rtems_rtl_elf_symbols, &ehdr))
    1496     return false;
    1497 
     1668   * Fix up the relocations.
     1669   */
    14981670  if (!rtems_rtl_obj_relocate (obj, fd, rtems_rtl_elf_relocs_locator, &ehdr))
    14991671    return false;
  • cpukit/libdl/rtl-elf.h

    rbe50969 rb36c5209  
    5151 ** Imported NetBSD ELF Specifics End.
    5252 **/
     53
     54/**
     55 * ELF Relocation status codes.
     56 */
     57typedef enum rtems_rtl_elf_rel_status
     58{
     59  rtems_rtl_elf_rel_no_error,    /**< There is no error processing the record. */
     60  rtems_rtl_elf_rel_failure,     /**< There was a failure processing the record. */
     61  rtems_rtl_elf_rel_tramp_cache, /**< The reloc record may need a trampoliine. */
     62  rtems_rtl_elf_rel_tramp_add    /**< Add a trampoliine. */
     63} rtems_rtl_elf_rel_status;
    5364
    5465/**
     
    144155 *
    145156 * @param obj The object file being relocated.
    146  * @param rel The ELF relocation record.
    147  * @param sect The section of the object file the relocation is for.
    148  * @param symname The symbol's name.
    149  * @param syminfo The ELF symbol info field.
    150  * @param symvalue If a symbol is referenced, this is the symbols value.
    151  * @retval bool The relocation is valid.
    152  * @retval bool The relocation is not valid.
    153  */
    154 bool rtems_rtl_elf_relocate_rel_tramp (rtems_rtl_obj*            obj,
    155                                        const Elf_Rel*            rel,
    156                                        const rtems_rtl_obj_sect* sect,
    157                                        const char*               symname,
    158                                        const Elf_Byte            syminfo,
    159                                        const Elf_Word            symvalue);
     157 * @param rela The ELF relocation record.
     158 * @param sect The section of the object file the relocation is for.
     159 * @param symname The symbol's name.
     160 * @param syminfo The ELF symbol info field.
     161 * @param symvalue If a symbol is referenced, this is the symbols value.
     162 * @retval rtems_rtl_elf_rel_status The result of the trampoline parsing.
     163 */
     164rtems_rtl_elf_rel_status rtems_rtl_elf_relocate_rel_tramp (rtems_rtl_obj*            obj,
     165                                                           const Elf_Rel*            rel,
     166                                                           const rtems_rtl_obj_sect* sect,
     167                                                           const char*               symname,
     168                                                           const Elf_Byte            syminfo,
     169                                                           const Elf_Word            symvalue);
    160170
    161171/**
     
    170180 * @param syminfo The ELF symbol info field.
    171181 * @param symvalue If a symbol is referenced, this is the symbols value.
    172  * @retval bool The relocation is valid.
    173  * @retval bool The relocation is not valid.
    174  */
    175 bool rtems_rtl_elf_relocate_rela_tramp (rtems_rtl_obj*            obj,
    176                                         const Elf_Rela*           rela,
    177                                         const rtems_rtl_obj_sect* sect,
    178                                         const char*               symname,
    179                                         const Elf_Byte            syminfo,
    180                                         const Elf_Word            symvalue);
     182 * @retval rtems_rtl_elf_rel_status The result of the trampoline parsing.
     183 */
     184rtems_rtl_elf_rel_status  rtems_rtl_elf_relocate_rela_tramp (rtems_rtl_obj*            obj,
     185                                                             const Elf_Rela*           rela,
     186                                                             const rtems_rtl_obj_sect* sect,
     187                                                             const char*               symname,
     188                                                             const Elf_Byte            syminfo,
     189                                                             const Elf_Word            symvalue);
    181190
    182191/**
     
    191200 * @param syminfo The ELF symbol info field.
    192201 * @param symvalue If a symbol is referenced, this is the symbols value.
    193  * @retval bool The relocation has been applied.
    194  * @retval bool The relocation could not be applied.
    195  */
    196 bool rtems_rtl_elf_relocate_rel (rtems_rtl_obj*            obj,
    197                                  const Elf_Rel*            rel,
    198                                  const rtems_rtl_obj_sect* sect,
    199                                  const char*               symname,
    200                                  const Elf_Byte            syminfo,
    201                                  const Elf_Word            symvalue);
     202 * @retval rtems_rtl_elf_rel_status The result of the trampoline parsing.
     203 */
     204rtems_rtl_elf_rel_status rtems_rtl_elf_relocate_rel (rtems_rtl_obj*            obj,
     205                                                     const Elf_Rel*            rel,
     206                                                     const rtems_rtl_obj_sect* sect,
     207                                                     const char*               symname,
     208                                                     const Elf_Byte            syminfo,
     209                                                     const Elf_Word            symvalue);
    202210
    203211/**
     
    212220 * @param syminfo The ELF symbol info field.
    213221 * @param symvalue If a symbol is referenced, this is the symbols value.
    214  * @retval bool The relocation has been applied.
    215  * @retval bool The relocation could not be applied.
    216  */
    217 bool rtems_rtl_elf_relocate_rela (rtems_rtl_obj*            obj,
    218                                   const Elf_Rela*           rela,
    219                                   const rtems_rtl_obj_sect* sect,
    220                                   const char*               symname,
    221                                   const Elf_Byte            syminfo,
    222                                   const Elf_Word            symvalue);
     222 * @retval rtems_rtl_elf_rel_status The result of the trampoline parsing.
     223 */
     224rtems_rtl_elf_rel_status rtems_rtl_elf_relocate_rela (rtems_rtl_obj*            obj,
     225                                                      const Elf_Rela*           rela,
     226                                                      const rtems_rtl_obj_sect* sect,
     227                                                      const char*               symname,
     228                                                      const Elf_Byte            syminfo,
     229                                                      const Elf_Word            symvalue);
    223230
    224231/**
  • cpukit/libdl/rtl-mdreloc-arm.c

    rbe50969 rb36c5209  
    148148}
    149149
    150 bool
     150rtems_rtl_elf_rel_status
    151151rtems_rtl_elf_relocate_rela_tramp (rtems_rtl_obj*            obj,
    152152                                   const Elf_Rela*           rela,
     
    163163  (void) symvalue;
    164164  rtems_rtl_set_error (EINVAL, "rela type record not supported");
    165   return false;
    166 }
    167 
    168 bool
     165  return rtems_rtl_elf_rel_failure;
     166}
     167
     168rtems_rtl_elf_rel_status
    169169rtems_rtl_elf_relocate_rela (rtems_rtl_obj*            obj,
    170170                             const Elf_Rela*           rela,
     
    181181  (void) symvalue;
    182182  rtems_rtl_set_error (EINVAL, "rela type record not supported");
    183   return false;
    184 }
    185 
    186 static bool
     183  return rtems_rtl_elf_rel_failure;
     184}
     185
     186static rtems_rtl_elf_rel_status
    187187rtems_rtl_elf_reloc_rel (rtems_rtl_obj*            obj,
    188188                         const Elf_Rel*            rel,
     
    210210    case R_TYPE(CALL):    /* BL/BLX */
    211211    case R_TYPE(JUMP24):  /* B/BL<cond> */
    212       insn = *where;
    213 
    214       if (insn & 0x00800000)
    215         addend = insn | 0xff000000;
    216       else addend = insn & 0x00ffffff;
    217 
    218       if (isThumb(symvalue)) {
    219         if ((insn & 0xfe000000) == 0xfa000000);         /* Already blx */
    220         else {
    221           if ((insn & 0xff000000) == 0xeb000000) {      /* BL <label> */
    222             *where = (insn & 0x00ffffff) | 0xfa000000;  /* BL-->BLX */
    223           } else {
    224             printf("JUMP24 is not suppored from arm to thumb\n");
    225             return false;
     212      if (parsing)
     213      {
     214        addend = 0;
     215      }
     216      else
     217      {
     218        insn = *where;
     219
     220        if (insn & 0x00800000)
     221          addend = insn | 0xff000000;
     222        else addend = insn & 0x00ffffff;
     223
     224        if (isThumb(symvalue)) {
     225          if ((insn & 0xfe000000) == 0xfa000000);         /* Already blx */
     226          else {
     227            if ((insn & 0xff000000) == 0xeb000000) {      /* BL <label> */
     228              *where = (insn & 0x00ffffff) | 0xfa000000;  /* BL-->BLX */
     229            } else {
     230              printf("JUMP24 is not suppored from arm to thumb\n");
     231              return rtems_rtl_elf_rel_failure;
     232            }
    226233          }
    227234        }
     235      }
     236
     237      if (parsing && sect->base == 0) {
     238        if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
     239          printf ("rtl: JUMP24/PC24/CALL tramp cache\n");
     240        return rtems_rtl_elf_rel_tramp_cache;
    228241      }
    229242
     
    236249
    237250        if (parsing) {
    238           obj->tramp_size += tramp_size;
    239           return true;
    240         }
    241 
    242         if (!rtems_rtl_obj_has_ramp_space (obj, tramp_size)) {
     251          if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
     252            printf ("rtl: JUMP24/PC24/CALL tramp add\n");
     253          return rtems_rtl_elf_rel_tramp_add;
     254        }
     255
     256        if (!rtems_rtl_obj_has_tramp_space (obj, tramp_size)) {
    243257          rtems_rtl_set_error (EINVAL,
    244258                               "%s: CALL/JUMP24: overflow: no tramp memory",
    245259                               sect->name);
    246           return false;
     260          return rtems_rtl_elf_rel_failure;
    247261        }
    248262
     
    287301        if (((Elf_Sword)tmp > 0x7fff) || ((Elf_Sword)tmp < -0x8000)) {
    288302          printf("MOVT_ABS Overflow\n");
    289           return false;
     303          return rtems_rtl_elf_rel_failure;
    290304        }
    291305      }
     
    368382      /* same as THM_PC22; insn b.w */
    369383    case R_TYPE(THM_PC22):
    370       upper_insn = *(uint16_t *)where;
    371       lower_insn = *((uint16_t *)where + 1);
    372       sign = (upper_insn & (1 << 10)) >> 10;
    373       i1 = ((lower_insn >> 13) & 1) ^ sign ? 0 : 1;
    374       i2 = ((lower_insn >> 11) & 1) ^ sign ? 0 : 1;
    375       tmp = (i1 << 23) | (i2 << 22) | ((upper_insn & 0x3ff) << 12) | ((lower_insn & 0x7ff) << 1);
    376       addend = (tmp | ((sign ? 0 : 1) << 24)) - (1 << 24);
     384      if (parsing)
     385      {
     386        addend = 0;
     387        upper_insn = 0;
     388        lower_insn = 0;
     389      }
     390      else
     391      {
     392        upper_insn = *(uint16_t *)where;
     393        lower_insn = *((uint16_t *)where + 1);
     394        sign = (upper_insn & (1 << 10)) >> 10;
     395        i1 = ((lower_insn >> 13) & 1) ^ sign ? 0 : 1;
     396        i2 = ((lower_insn >> 11) & 1) ^ sign ? 0 : 1;
     397        tmp = (i1 << 23) | (i2 << 22) | ((upper_insn & 0x3ff) << 12) | ((lower_insn & 0x7ff) << 1);
     398        addend = (tmp | ((sign ? 0 : 1) << 24)) - (1 << 24);
     399      }
    377400
    378401      if (isThumb(symvalue)) ;/*Thumb to Thumb call, nothing to care */
     
    382405#if !ALLOW_UNTESTED_RELOCS
    383406          printf("THM_JUMP24 to arm not supported\n");
    384           return false;
     407          return rtems_rtl_elf_rel_failure;
    385408#endif
    386409        }
    387410        else {
    388411          /* THM_CALL bl-->blx */
    389           lower_insn &=~(1<<12);
    390         }
     412          lower_insn &= ~(1<<12);
     413        }
     414      }
     415
     416      if (parsing && sect->base == 0) {
     417        if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
     418          printf ("rtl: THM_CALL/JUMP24 tramp cache\n");
     419        return rtems_rtl_elf_rel_tramp_cache;
    391420      }
    392421
     
    395424
    396425      if (((Elf_Sword)tmp > 0x7fffff) || ((Elf_Sword)tmp < -0x800000)) {
    397           Elf_Word tramp_addr;
    398           size_t   tramp_size = get_veneer_size(ELF_R_TYPE(rel->r_info));
     426        Elf_Word tramp_addr;
     427        size_t   tramp_size = get_veneer_size(ELF_R_TYPE(rel->r_info));
    399428
    400429        if (parsing) {
    401           obj->tramp_size += tramp_size;
    402           return true;
    403         }
    404 
    405         if (!rtems_rtl_obj_has_ramp_space (obj, tramp_size)) {
     430          if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
     431            printf ("rtl: THM_CALL/JUMP24 tramp add: %08x - %p = %i\n",
     432                    symvalue + addend, where, (Elf_Sword) tmp);
     433          return rtems_rtl_elf_rel_tramp_add;
     434        }
     435
     436        if (!rtems_rtl_obj_has_tramp_space (obj, tramp_size)) {
    406437          rtems_rtl_set_error (EINVAL,
    407438                               "%s: THM_CALL/JUMP24: overflow: no tramp memory",
    408439                               sect->name);
    409           return false;
     440          return rtems_rtl_elf_rel_failure;
    410441        }
    411442
     
    439470      if (!isThumb(symvalue)) {
    440471        printf("THM_JUMP19 to arm not supported\n");
    441         return false;
     472        return rtems_rtl_elf_rel_failure;
    442473      }
    443474
     
    464495                             "THM_JUMP19 relocations",
    465496                             sect->name, (uint32_t) ELF_R_TYPE(rel->r_info));
    466         return true;
    467         return false;
     497        return rtems_rtl_elf_rel_failure;
    468498      }
    469499
     
    512542                           "in non-PLT relocations",
    513543                           sect->name, (uint32_t) ELF_R_TYPE(rel->r_info));
    514       return false;
     544      return rtems_rtl_elf_rel_failure;
    515545  }
    516546
    517   return true;
    518 }
    519 
    520 bool
     547  return rtems_rtl_elf_rel_no_error;
     548}
     549
     550rtems_rtl_elf_rel_status
    521551rtems_rtl_elf_relocate_rel_tramp (rtems_rtl_obj*            obj,
    522552                                  const Elf_Rel*            rel,
     
    535565}
    536566
    537 bool
     567rtems_rtl_elf_rel_status
    538568rtems_rtl_elf_relocate_rel (rtems_rtl_obj*            obj,
    539569                            const Elf_Rel*            rel,
  • cpukit/libdl/rtl-mdreloc-bfin.c

    rbe50969 rb36c5209  
    7474}
    7575
    76 bool
     76rtems_rtl_elf_rel_status
    7777rtems_rtl_elf_relocate_rela_tramp (rtems_rtl_obj*            obj,
    7878                                   const Elf_Rela*           rela,
     
    8888  (void) syminfo;
    8989  (void) symvalue;
    90   return true;
    91 }
    92 
    93 bool
     90  return rtems_rtl_elf_rel_no_error;
     91}
     92
     93rtems_rtl_elf_rel_status
    9494rtems_rtl_elf_relocate_rela (rtems_rtl_obj*            obj,
    9595                             const Elf_Rela*           rela,
     
    137137      if ((tmp & 0xff000000) && (~tmp & 0xff800000)) {
    138138        printf("PCREL24/PCREL24_JU Overflow\n");
    139         return false;
     139        return rtems_rtl_elf_rel_failure;
    140140      }
    141141
     
    153153      if ((tmp & 0xfffff000) && (~tmp & 0xfffff800)) {
    154154        printf("PCREL12_JUMP_S Overflow\n");
    155         return false;
     155        return rtems_rtl_elf_rel_failure;
    156156      }
    157157
     
    162162    default:
    163163      printf("Unspported rela type\n");
    164       return false;
     164      return rtems_rtl_elf_rel_failure;
    165165  }
    166166
    167167  memcpy((void*)where, &tmp, size);
    168168
    169   return true;
    170 }
    171 
    172 bool
     169  return rtems_rtl_elf_rel_no_error;
     170}
     171
     172rtems_rtl_elf_rel_status
    173173rtems_rtl_elf_relocate_rel_tramp (rtems_rtl_obj*            obj,
    174174                                  const Elf_Rel*            rel,
     
    185185  (void) symvalue;
    186186  rtems_rtl_set_error (EINVAL, "rel type record not supported");
    187   return false;
    188 }
    189 
    190 bool
     187  return rtems_rtl_elf_rel_failure;
     188}
     189
     190rtems_rtl_elf_rel_status
    191191rtems_rtl_elf_relocate_rel (rtems_rtl_obj*            obj,
    192192                            const Elf_Rel*            rel,
     
    203203  (void) symvalue;
    204204  rtems_rtl_set_error (EINVAL, "rel type record not supported");
    205   return false;
     205  return rtems_rtl_elf_rel_failure;
    206206}
    207207
  • cpukit/libdl/rtl-mdreloc-h8300.c

    rbe50969 rb36c5209  
    6767}
    6868
    69 bool
     69rtems_rtl_elf_rel_status
    7070rtems_rtl_elf_relocate_rela_tramp (rtems_rtl_obj*            obj,
    7171                                   const Elf_Rela*           rela,
     
    8181  (void) syminfo;
    8282  (void) symvalue;
    83   return true;
    84 }
    85 
    86 bool
     83  return rtems_rtl_elf_rel_no_error;
     84}
     85
     86rtems_rtl_elf_rel_status
    8787rtems_rtl_elf_relocate_rela (rtems_rtl_obj*            obj,
    8888                             const Elf_Rela*           rela,
     
    131131      if (((Elf32_Sword)tmp > 0x7f) || ((Elf32_Sword)tmp < -(Elf32_Sword)0x80)){
    132132        printf("PCREL8 overflow\n");
    133           return false;
     133          return rtems_rtl_elf_rel_failure;
    134134      } else {
    135135        *(uint8_t *)where = tmp;
     
    142142      if (((Elf32_Sword)tmp > 0x7fff) || ((Elf32_Sword)tmp < -(Elf32_Sword)0x8000)){
    143143        printf("PCREL16 overflow\n");
    144        return false;
     144       return rtems_rtl_elf_rel_failure;
    145145      } else {
    146146       *(uint16_t *)where = tmp;
     
    151151      rtems_rtl_set_error (EINVAL, "rela type record not supported");
    152152      printf("Unsupported reloc types\n");
    153       return false;
     153      return rtems_rtl_elf_rel_failure;
    154154  }
    155   return true;
    156 }
    157 
    158 bool
     155  return rtems_rtl_elf_rel_no_error;
     156}
     157
     158rtems_rtl_elf_rel_status
    159159rtems_rtl_elf_relocate_rel_tramp (rtems_rtl_obj*           obj,
    160160                                  const Elf_Rel*            rel,
     
    171171  (void) symvalue;
    172172  rtems_rtl_set_error (EINVAL, "rel type record not supported");
    173   return false;
    174 }
    175 
    176 bool
     173  return rtems_rtl_elf_rel_failure;
     174}
     175
     176rtems_rtl_elf_rel_status
    177177rtems_rtl_elf_relocate_rel (rtems_rtl_obj*            obj,
    178178                            const Elf_Rel*            rel,
     
    189189  (void) symvalue;
    190190  rtems_rtl_set_error (EINVAL, "rel type record not supported");
    191   return false;
     191  return rtems_rtl_elf_rel_failure;
    192192}
    193193
  • cpukit/libdl/rtl-mdreloc-i386.c

    rbe50969 rb36c5209  
    7474}
    7575
    76 bool
     76rtems_rtl_elf_rel_status
    7777rtems_rtl_elf_relocate_rela_tramp (rtems_rtl_obj*            obj,
    7878                                   const Elf_Rela*           rela,
     
    8989  (void) symvalue;
    9090  rtems_rtl_set_error (EINVAL, "rela type record not supported");
    91   return false;
    92 }
    93 
    94 bool
     91  return rtems_rtl_elf_rel_failure;
     92}
     93
     94rtems_rtl_elf_rel_status
    9595rtems_rtl_elf_relocate_rela (rtems_rtl_obj*            obj,
    9696                             const Elf_Rela*           rel,
     
    107107  (void) symvalue;
    108108  rtems_rtl_set_error (EINVAL, "rela type record not supported");
    109   return false;
    110 }
    111 
    112 bool
     109  return rtems_rtl_elf_rel_failure;
     110}
     111
     112rtems_rtl_elf_rel_status
    113113rtems_rtl_elf_relocate_rel_tramp (rtems_rtl_obj*            obj,
    114114                                  const Elf_Rel*            rel,
     
    124124  (void) syminfo;
    125125  (void) symvalue;
    126   return true;
    127 }
    128 
    129 bool
     126  return rtems_rtl_elf_rel_no_error;
     127}
     128
     129rtems_rtl_elf_rel_status
    130130rtems_rtl_elf_relocate_rel (rtems_rtl_obj*            obj,
    131131                            const Elf_Rel*            rel,
     
    189189                           "in non-PLT relocations",
    190190                           sect->name, (uint32_t) ELF_R_TYPE(rel->r_info));
    191       return false;
     191      return rtems_rtl_elf_rel_failure;
    192192  }
    193193
    194   return true;
     194  return rtems_rtl_elf_rel_no_error;
    195195}
    196196
  • cpukit/libdl/rtl-mdreloc-lm32.c

    rbe50969 rb36c5209  
    6767}
    6868
    69 bool
     69rtems_rtl_elf_rel_status
    7070rtems_rtl_elf_relocate_rela_tramp (rtems_rtl_obj*            obj,
    7171                                   const Elf_Rela*           rela,
     
    8181  (void) syminfo;
    8282  (void) symvalue;
    83   return true;
    84 }
    85 
    86 bool
     83  return rtems_rtl_elf_rel_no_error;
     84}
     85
     86rtems_rtl_elf_rel_status
    8787rtems_rtl_elf_relocate_rela (rtems_rtl_obj*            obj,
    8888                             const Elf_Rela*           rela,
     
    152152      if (((Elf32_Sword)tmp > 0x7fff) || ((Elf32_Sword)tmp < -0x8000)){
    153153        printf("BRANCH Overflow\n");
    154         return false;
     154        return rtems_rtl_elf_rel_failure;
    155155      }
    156156
     
    165165      rtems_rtl_set_error (EINVAL, "rela type record not supported");
    166166      printf("Unsupported reloc types\n");
    167       return false;
     167      return rtems_rtl_elf_rel_failure;
    168168  }
    169169
     
    172172      printf("relocated address 0x%08lx\n", (Elf_Addr)where);
    173173  }
    174   return true;
    175 }
    176 
    177 bool
     174
     175  return rtems_rtl_elf_rel_no_error;
     176}
     177
     178rtems_rtl_elf_rel_status
    178179rtems_rtl_elf_relocate_rel_tramp (rtems_rtl_obj*            obj,
    179180                                  const Elf_Rel*            rel,
     
    190191  (void) symvalue;
    191192  rtems_rtl_set_error (EINVAL, "rel type record not supported");
    192   return false;
    193 }
    194 
    195 bool
     193  return rtems_rtl_elf_rel_failure;
     194}
     195
     196rtems_rtl_elf_rel_status
    196197rtems_rtl_elf_relocate_rel (rtems_rtl_obj*            obj,
    197198                            const Elf_Rel*            rel,
     
    208209  (void) symvalue;
    209210  rtems_rtl_set_error (EINVAL, "rela type record not supported");
    210   return false;
     211  return rtems_rtl_elf_rel_failure;
    211212}
    212213
  • cpukit/libdl/rtl-mdreloc-m68k.c

    rbe50969 rb36c5209  
    8787}
    8888
    89 bool
     89rtems_rtl_elf_rel_status
    9090rtems_rtl_elf_relocate_rela_tramp (rtems_rtl_obj*            obj,
    9191                                   const Elf_Rela*           rela,
     
    101101  (void) syminfo;
    102102  (void) symvalue;
    103   return true;
    104 }
    105 
    106 bool
     103  return rtems_rtl_elf_rel_no_error;
     104}
     105
     106rtems_rtl_elf_rel_status
    107107rtems_rtl_elf_relocate_rela (rtems_rtl_obj*            obj,
    108108                             const Elf_Rela*           rela,
     
    119119
    120120  switch (ELF_R_TYPE(rela->r_info)) {
    121                 case R_TYPE(NONE):
    122                         break;
    123 
    124     case R_TYPE(PC8):
    125       tmp = symvalue + rela->r_addend - (Elf_Addr)where;
    126       if (overflow_8_check(tmp))
    127         return false;
    128 
    129       *(uint8_t *)where = tmp;
    130 
    131       if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
    132         printf ("rtl: reloc R_TYPE_8/PC8 in %s --> %p (%p) in %s\n",
    133                 sect->name, (void*) (symvalue + rela->r_addend),
    134                 (void *)*where, rtems_rtl_obj_oname (obj));
    135       break;
    136 
    137     case R_TYPE(PC16):
    138       tmp = symvalue + rela->r_addend - (Elf_Addr)where;
    139       if (overflow_16_check(tmp))
    140         return false;
    141 
    142       *(uint16_t*)where = tmp;
    143 
    144       if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
    145         printf ("rtl: reloc R_TYPE_16/PC16 in %s --> %p (%p) in %s\n",
    146                 sect->name, (void*) (symvalue + rela->r_addend),
    147                 (void *)*where, rtems_rtl_obj_oname (obj));
    148       break;
    149                 case R_TYPE(PC32):
    150       target = (Elf_Addr) symvalue + rela->r_addend;
    151       *where += target - (Elf_Addr)where;
    152 
    153       if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
    154         printf ("rtl: reloc PC32 in %s --> %p (%p) in %s\n",
    155                 sect->name, (void*) (symvalue + rela->r_addend),
    156                 (void *)*where, rtems_rtl_obj_oname (obj));
    157       break;
    158 
    159                 case R_TYPE(GOT32):
    160                 case R_TYPE(32):
    161                 case R_TYPE(GLOB_DAT):
    162       target = (Elf_Addr) symvalue + rela->r_addend;
    163 
    164                         if (*where != target)
    165                                 *where = target;
    166 
    167       if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
    168         printf ("rtl: reloc 32/GLOB_DAT in %s --> %p in %s\n",
    169                 sect->name, (void *)*where,
    170                 rtems_rtl_obj_oname (obj));
    171                         break;
    172 
    173                 case R_TYPE(RELATIVE):
    174                         *where += (Elf_Addr) sect->base + rela->r_addend;
    175       if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
    176         printf ("rtl: reloc RELATIVE in %s --> %p\n",
    177                 rtems_rtl_obj_oname (obj), (void *)*where);
    178                         break;
    179 
    180                 case R_TYPE(COPY):
    181                         /*
    182                         * These are deferred until all other relocations have
    183                         * been done.  All we do here is make sure that the
    184                         * COPY relocation is not in a shared library.  They
    185                         * are allowed only in executable files.
    186                         */
    187       printf ("rtl: reloc COPY (please report)\n");
    188                         break;
    189 
    190                 default:
    191       printf ("rtl: reloc unknown: sym = %u, type = %u, offset = %p, "
    192               "contents = %p\n",
    193               ELF_R_SYM(rela->r_info), (uint32_t) ELF_R_TYPE(rela->r_info),
    194               (void *)rela->r_offset, (void *)*where);
    195       rtems_rtl_set_error (EINVAL,
    196                            "%s: Unsupported relocation type %d "
    197                            "in non-PLT relocations",
    198                            sect->name, (uint32_t) ELF_R_TYPE(rela->r_info));
    199       return false;
     121  case R_TYPE(NONE):
     122    break;
     123
     124  case R_TYPE(PC8):
     125    tmp = symvalue + rela->r_addend - (Elf_Addr)where;
     126    if (overflow_8_check(tmp))
     127      return rtems_rtl_elf_rel_failure;
     128
     129    *(uint8_t *)where = tmp;
     130
     131    if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
     132      printf ("rtl: reloc R_TYPE_8/PC8 in %s --> %p (%p) in %s\n",
     133              sect->name, (void*) (symvalue + rela->r_addend),
     134              (void *)*where, rtems_rtl_obj_oname (obj));
     135    break;
     136
     137  case R_TYPE(PC16):
     138    tmp = symvalue + rela->r_addend - (Elf_Addr)where;
     139    if (overflow_16_check(tmp))
     140      return rtems_rtl_elf_rel_failure;
     141
     142    *(uint16_t*)where = tmp;
     143
     144    if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
     145      printf ("rtl: reloc R_TYPE_16/PC16 in %s --> %p (%p) in %s\n",
     146              sect->name, (void*) (symvalue + rela->r_addend),
     147              (void *)*where, rtems_rtl_obj_oname (obj));
     148    break;
     149  case R_TYPE(PC32):
     150    target = (Elf_Addr) symvalue + rela->r_addend;
     151    *where += target - (Elf_Addr)where;
     152
     153    if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
     154      printf ("rtl: reloc PC32 in %s --> %p (%p) in %s\n",
     155              sect->name, (void*) (symvalue + rela->r_addend),
     156              (void *)*where, rtems_rtl_obj_oname (obj));
     157    break;
     158
     159  case R_TYPE(GOT32):
     160  case R_TYPE(32):
     161  case R_TYPE(GLOB_DAT):
     162    target = (Elf_Addr) symvalue + rela->r_addend;
     163
     164    if (*where != target)
     165      *where = target;
     166
     167    if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
     168      printf ("rtl: reloc 32/GLOB_DAT in %s --> %p in %s\n",
     169              sect->name, (void *)*where,
     170              rtems_rtl_obj_oname (obj));
     171    break;
     172
     173  case R_TYPE(RELATIVE):
     174    *where += (Elf_Addr) sect->base + rela->r_addend;
     175    if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
     176      printf ("rtl: reloc RELATIVE in %s --> %p\n",
     177              rtems_rtl_obj_oname (obj), (void *)*where);
     178    break;
     179
     180  case R_TYPE(COPY):
     181    /*
     182    * These are deferred until all other relocations have
     183    * been done.  All we do here is make sure that the
     184    * COPY relocation is not in a shared library.  They
     185    * are allowed only in executable files.
     186    */
     187    printf ("rtl: reloc COPY (please report)\n");
     188    break;
     189
     190  default:
     191    printf ("rtl: reloc unknown: sym = %u, type = %u, offset = %p, "
     192            "contents = %p\n",
     193            ELF_R_SYM(rela->r_info), (uint32_t) ELF_R_TYPE(rela->r_info),
     194            (void *)rela->r_offset, (void *)*where);
     195    rtems_rtl_set_error (EINVAL,
     196                         "%s: Unsupported relocation type %d "
     197                         "in non-PLT relocations",
     198                         sect->name, (uint32_t) ELF_R_TYPE(rela->r_info));
     199    return rtems_rtl_elf_rel_failure;
    200200  }
    201201
    202   return true;
    203 }
    204 
    205 bool
     202  return rtems_rtl_elf_rel_no_error;
     203}
     204
     205rtems_rtl_elf_rel_status
    206206rtems_rtl_elf_relocate_rel_tramp (rtems_rtl_obj*            obj,
    207207                                  const Elf_Rel*            rel,
     
    218218  (void) symvalue;
    219219  rtems_rtl_set_error (EINVAL, "rel type record not supported");
    220   return false;
    221 }
    222 
    223 bool
     220  return rtems_rtl_elf_rel_failure;
     221}
     222
     223rtems_rtl_elf_rel_status
    224224rtems_rtl_elf_relocate_rel (rtems_rtl_obj*            obj,
    225225                            const Elf_Rel*            rel,
     
    236236  (void) symvalue;
    237237  rtems_rtl_set_error (EINVAL, "rel type record not supported");
    238   return false;
     238  return rtems_rtl_elf_rel_failure;
    239239}
    240240
  • cpukit/libdl/rtl-mdreloc-mips.c

    rbe50969 rb36c5209  
    6767}
    6868
    69 bool
     69rtems_rtl_elf_rel_status
    7070rtems_rtl_elf_relocate_rela_tramp (rtems_rtl_obj*            obj,
    7171                                   const Elf_Rela*           rela,
     
    8282  (void) symvalue;
    8383  rtems_rtl_set_error (EINVAL, "rela type record not supported");
    84   return false;
    85 }
    86 
    87 bool
     84  return rtems_rtl_elf_rel_failure;
     85}
     86
     87rtems_rtl_elf_rel_status
    8888rtems_rtl_elf_relocate_rela (rtems_rtl_obj*            obj,
    8989                             const Elf_Rela*           rela,
     
    100100  (void) symvalue;
    101101  rtems_rtl_set_error (EINVAL, "rela type record not supported");
    102   return false;
    103 }
    104 
    105 bool
     102  return rtems_rtl_elf_rel_failure;
     103}
     104
     105rtems_rtl_elf_rel_status
    106106rtems_rtl_elf_relocate_rel_tramp (rtems_rtl_obj*            obj,
    107107                                  const Elf_Rel*            rel,
     
    117117  (void) syminfo;
    118118  (void) symvalue;
    119   return true;
     119  return rtems_rtl_elf_rel_no_error;
    120120}
    121121
     
    128128 * just consider symtype here.
    129129 */
    130 bool
     130rtems_rtl_elf_rel_status
    131131rtems_rtl_elf_relocate_rel (rtems_rtl_obj*            obj,
    132132                            const Elf_Rel*            rel,
     
    163163      if ((tmp & 0xffff0000) != 0) {
    164164        printf("R_MIPS_16 Overflow\n");
    165         return false;
     165        return rtems_rtl_elf_rel_failure;
    166166      }
    167167
     
    225225      tmp = symvalue;
    226226      if (tmp == 0)
    227         return false;
     227        return rtems_rtl_elf_rel_failure;
    228228
    229229      addend &= 0xffff0000;
     
    255255      if (((Elf_Sword)tmp > 0x7fff) || ((Elf_Sword)tmp < -0x8000)) {
    256256        printf("R_MIPS_PC16 Overflow\n");
    257         return false;
     257        return rtems_rtl_elf_rel_failure;
    258258      }
    259259
     
    275275                           "in non-PLT relocations",
    276276                           sect->name, (uint32_t) ELF_R_TYPE(rel->r_info));
    277       return false;
     277      return rtems_rtl_elf_rel_failure;
    278278  }
    279279
    280   return true;
     280  return rtems_rtl_elf_rel_no_error;
    281281}
    282282
  • cpukit/libdl/rtl-mdreloc-moxie.c

    rbe50969 rb36c5209  
    6868}
    6969
    70 bool
     70rtems_rtl_elf_rel_status
    7171rtems_rtl_elf_relocate_rela_tramp (rtems_rtl_obj*            obj,
    7272                                   const Elf_Rela*           rela,
     
    8282  (void) syminfo;
    8383  (void) symvalue;
    84   return true;
     84  return rtems_rtl_elf_rel_no_error;
    8585}
    8686
    87 bool
     87rtems_rtl_elf_rel_status
    8888rtems_rtl_elf_relocate_rela (rtems_rtl_obj*            obj,
    8989                             const Elf_Rela*           rela,
     
    123123      if (((Elf32_Sword)tmp > 0x1ff) || ((Elf32_Sword)tmp < -(Elf32_Sword)0x200)){
    124124        printf("Overflow for PCREL10: %ld exceed -0x200:0x1ff\n", tmp);
    125         return false;
     125        return rtems_rtl_elf_rel_failure;
    126126      }
    127127
     
    137137      rtems_rtl_set_error (EINVAL, "rela type record not supported");
    138138      printf("Unsupported reloc types\n");
    139       return false;
     139      return rtems_rtl_elf_rel_failure;
    140140  }
    141141
    142   return true;
     142  return rtems_rtl_elf_rel_no_error;
    143143}
    144144
    145 bool
     145rtems_rtl_elf_rel_status
    146146rtems_rtl_elf_relocate_rel_tramp (rtems_rtl_obj*            obj,
    147147                                  const Elf_Rel*            rel,
     
    158158  (void) symvalue;
    159159  rtems_rtl_set_error (EINVAL, "rel type record not supported");
    160   return false;
     160  return rtems_rtl_elf_rel_failure;
    161161}
    162162
    163 bool
     163rtems_rtl_elf_rel_status
    164164rtems_rtl_elf_relocate_rel (rtems_rtl_obj*            obj,
    165165                            const Elf_Rel*            rel,
     
    176176  (void) symvalue;
    177177  rtems_rtl_set_error (EINVAL, "rel type record not supported");
    178   return false;
     178  return rtems_rtl_elf_rel_failure;
    179179}
    180180
  • cpukit/libdl/rtl-mdreloc-powerpc.c

    rbe50969 rb36c5209  
    214214}
    215215
    216 static bool
     216/**
     217 * The offsets in the reloc words.
     218 */
     219#define REL_R_OFFSET (0)
     220#define REL_R_INFO   (1)
     221#define REL_R_ADDEND (2)
     222
     223static rtems_rtl_elf_rel_status
    217224rtems_rtl_elf_reloc_rela (rtems_rtl_obj*            obj,
    218225                          const Elf_Rela*           rela,
     
    227234  uint32_t mask = 0;
    228235  uint32_t bits = 0;
     236  bool     needs_tramp = false;
    229237
    230238  where = (Elf_Addr *)(sect->base + rela->r_offset);
     
    260268        mask = 0x3fffffc;
    261269      }
     270
     271      if (parsing && sect->base == 0) {
     272        if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
     273          printf ("rtl: ADDR14/ADDR24 tramp cache\n");
     274        return rtems_rtl_elf_rel_tramp_cache;
     275      }
     276
    262277      tmp = (symvalue + rela->r_addend) >> 2;
    263278      if (tmp > ((1<<bits) - 1 )) {
     
    265280        size_t   tramp_size = get_veneer_size(ELF_R_TYPE(rela->r_info));
    266281        if (parsing) {
    267           obj->tramp_size += tramp_size;
    268           return true;
     282          if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
     283            printf ("rtl: ADDR14/ADDR24 tramp add\n");
     284          return rtems_rtl_elf_rel_tramp_add;
    269285        }
     286        if (!rtems_rtl_obj_has_tramp_space (obj, tramp_size)) {
     287          if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
     288            printf ("rtl: ADDR14/ADDR24 no tramp slot: %s\n", rtems_rtl_obj_oname (obj));
     289          rtems_rtl_set_error (ENOMEM, "%s: tramp: no slot: ADDR14/ADDR24", sect->name);
     290          return rtems_rtl_elf_rel_failure;
     291        }
     292        needs_tramp = true;
    270293        tramp_addr = (Elf_Addr) obj->tramp_brk;
    271294        obj->tramp_brk = set_veneer(obj->tramp_brk,
     
    284307        *where = tmp;
    285308        if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
    286           printf ("rtl: ADDR14/ADDR24 %p @ %p in %s\n",
     309          printf ("rtl: ADDR14/ADDR24%s %p @ %p in %s\n",
     310                  needs_tramp ? "(tramp)" : "",
    287311                  (void *)*where, where, rtems_rtl_obj_oname (obj));
    288312      }
     
    340364        mask = 0xfffc;
    341365        bits = 14;
     366      }
     367
     368      if (parsing && sect->base == 0) {
     369        if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
     370          printf ("rtl: REL24/REL14 tramp cache\n");
     371        return rtems_rtl_elf_rel_tramp_cache;
    342372      }
    343373
     
    348378        size_t   tramp_size = get_veneer_size(ELF_R_TYPE(rela->r_info));
    349379        if (parsing) {
    350           obj->tramp_size += tramp_size;
    351           return true;
     380          if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
     381            printf ("rtl: REL24/REL14 tramp add\n");
     382          return rtems_rtl_elf_rel_tramp_add;
    352383        }
     384        if (!rtems_rtl_obj_has_tramp_space (obj, tramp_size)) {
     385          if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
     386            printf ("rtl: REL24/REL14 no tramp slot: %s\n", rtems_rtl_obj_oname (obj));
     387          rtems_rtl_set_error (ENOMEM, "%s: tramp: no slot: REL24/REL14", sect->name);
     388          return rtems_rtl_elf_rel_failure;
     389        }
     390        needs_tramp = true;
    353391        tramp_addr = (Elf_Addr) obj->tramp_brk;
    354392        obj->tramp_brk = set_veneer(obj->tramp_brk,
     
    368406        *where = tmp;
    369407        if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
    370           printf ("rtl: REL24/REL14 %p @ %p in %s\n",
     408          printf ("rtl: REL24/REL14%s %p @ %p in %s\n",
     409                  needs_tramp ? "(tramp)" : "",
    371410                  (void *)*where, where, rtems_rtl_obj_oname (obj));
    372411      }
     
    413452                           "in non-PLT relocations",
    414453                           sect->name, (uint32_t) ELF_R_TYPE(rela->r_info));
    415       return false;
     454      return rtems_rtl_elf_rel_failure;
    416455  }
    417   return true;
    418 }
    419 
    420 bool
     456  return rtems_rtl_elf_rel_no_error;
     457}
     458
     459rtems_rtl_elf_rel_status
    421460rtems_rtl_elf_relocate_rela_tramp (rtems_rtl_obj*            obj,
    422461                                   const Elf_Rela*           rela,
     
    435474}
    436475
    437 bool
     476rtems_rtl_elf_rel_status
    438477rtems_rtl_elf_relocate_rela (rtems_rtl_obj*            obj,
    439478                             const Elf_Rela*           rela,
     
    452491}
    453492
    454 bool
     493rtems_rtl_elf_rel_status
    455494rtems_rtl_elf_relocate_rel_tramp (rtems_rtl_obj*            obj,
    456495                                  const Elf_Rel*            rel,
     
    467506  (void) symvalue;
    468507  rtems_rtl_set_error (EINVAL, "rel type record not supported");
    469   return false;
    470 }
    471 
    472 bool
     508  return rtems_rtl_elf_rel_failure;
     509}
     510
     511rtems_rtl_elf_rel_status
    473512rtems_rtl_elf_relocate_rel (rtems_rtl_obj*            obj,
    474513                            const Elf_Rel*            rel,
     
    485524  (void) symvalue;
    486525  rtems_rtl_set_error (EINVAL, "rel type record not supported");
    487   return false;
     526  return rtems_rtl_elf_rel_failure;
    488527}
    489528
  • cpukit/libdl/rtl-mdreloc-sparc.c

    rbe50969 rb36c5209  
    186186}
    187187
    188 bool
     188rtems_rtl_elf_rel_status
    189189rtems_rtl_elf_relocate_rela_tramp (rtems_rtl_obj*            obj,
    190190                                   const Elf_Rela*           rela,
     
    200200  (void) syminfo;
    201201  (void) symvalue;
    202   return true;
    203 }
    204 
    205 bool
     202  return rtems_rtl_elf_rel_no_error;
     203}
     204
     205rtems_rtl_elf_rel_status
    206206rtems_rtl_elf_relocate_rela (rtems_rtl_obj*            obj,
    207207                             const Elf_Rela*           rela,
     
    219219  type = ELF_R_TYPE(rela->r_info);
    220220  if (type == R_TYPE(NONE))
    221     return true;
     221    return rtems_rtl_elf_rel_no_error;
    222222
    223223  /* We do JMP_SLOTs in _rtld_bind() below */
    224224  if (type == R_TYPE(JMP_SLOT))
    225     return true;
     225    return rtems_rtl_elf_rel_no_error;
    226226
    227227  /* COPY relocs are also handled elsewhere */
    228228  if (type == R_TYPE(COPY))
    229     return true;
     229    return rtems_rtl_elf_rel_no_error;
    230230
    231231  /*
     
    234234   */
    235235  if (type > R_TYPE(6))
    236     return false;
     236    return rtems_rtl_elf_rel_failure;
    237237
    238238  value = rela->r_addend;
     
    246246      printf ("rtl: reloc relative in %s --> %p",
    247247              rtems_rtl_obj_oname (obj), (void *)*where);
    248     return true;
     248    return rtems_rtl_elf_rel_no_error;
    249249  }
    250250
     
    316316            (void *)tmp, where, rtems_rtl_obj_oname (obj));
    317317
    318   return true;
    319 }
    320 
    321 bool
     318  return rtems_rtl_elf_rel_no_error;
     319}
     320
     321rtems_rtl_elf_rel_status
    322322rtems_rtl_elf_relocate_rel_tramp (rtems_rtl_obj*            obj,
    323323                                  const Elf_Rel*            rel,
     
    334334  (void) symvalue;
    335335  rtems_rtl_set_error (EINVAL, "rel type record not supported");
    336   return false;
    337 }
    338 
    339 bool
     336  return rtems_rtl_elf_rel_failure;
     337}
     338
     339rtems_rtl_elf_rel_status
    340340rtems_rtl_elf_relocate_rel (rtems_rtl_obj*            obj,
    341341                            const Elf_Rel*            rel,
     
    352352  (void) symvalue;
    353353  printf ("rtl: rel type record not supported; please report\n");
    354   return false;
     354  return rtems_rtl_elf_rel_failure;
    355355}
    356356
  • cpukit/libdl/rtl-mdreloc-v850.c

    rbe50969 rb36c5209  
    6868}
    6969
    70 bool
     70rtems_rtl_elf_rel_status
    7171rtems_rtl_elf_relocate_rela_tramp (rtems_rtl_obj*            obj,
    7272                                   const Elf_Rela*           rela,
     
    8282  (void) syminfo;
    8383  (void) symvalue;
    84   return true;
    85 }
    86 
    87 bool
     84  return rtems_rtl_elf_rel_no_error;
     85}
     86
     87rtems_rtl_elf_rel_status
    8888rtems_rtl_elf_relocate_rela (rtems_rtl_obj*            obj,
    8989                             const Elf_Rela*           rela,
     
    126126      if (((Elf_Sword)tmp > 0x1fffff) || ((Elf_Sword)tmp < -0x200000)) {
    127127        printf("Overflow\n");
    128         return false;
     128        return rtems_rtl_elf_rel_failure;
    129129      }
    130130
     
    146146      rtems_rtl_set_error (EINVAL, "rela type record not supported");
    147147      printf("error reloc type\n");
    148       return false;
     148      return rtems_rtl_elf_rel_failure;
    149149  }
    150150
    151   return true;
    152 }
    153 
    154 bool
     151  return rtems_rtl_elf_rel_no_error;
     152}
     153
     154rtems_rtl_elf_rel_status
    155155rtems_rtl_elf_relocate_rel_tramp (rtems_rtl_obj*            obj,
    156156                                  const Elf_Rel*            rel,
     
    167167  (void) symvalue;
    168168  rtems_rtl_set_error (EINVAL, "rel type record not supported");
    169   return false;
    170 }
    171 
    172 bool
     169  return rtems_rtl_elf_rel_failure;
     170}
     171
     172rtems_rtl_elf_rel_status
    173173rtems_rtl_elf_relocate_rel (rtems_rtl_obj*            obj,
    174174                            const Elf_Rel*            rel,
     
    185185  (void) symvalue;
    186186  rtems_rtl_set_error (EINVAL, "rel type record not supported");
    187   return false;
     187  return rtems_rtl_elf_rel_failure;
    188188}
    189189
  • cpukit/libdl/rtl-obj.c

    rbe50969 rb36c5209  
    584584rtems_rtl_obj_alloc_trampoline (rtems_rtl_obj* obj)
    585585{
    586   if (obj->tramp_size == 0)
     586  if (obj->tramps_size == 0)
    587587    return true;
    588588  obj->trampoline = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_OBJECT,
    589                                          obj->tramp_size,
     589                                         obj->tramps_size,
    590590                                         true);
    591591  if (obj->trampoline == NULL)
     
    904904  {
    905905    rtems_cache_instruction_sync_after_code_change(obj->trampoline,
    906                                                    obj->tramp_size);
     906                                                   obj->tramps_size);
    907907  }
    908908}
     
    999999}
    10001000
     1001static void
     1002rtems_rtl_obj_sections_locate (uint32_t            mask,
     1003                               rtems_rtl_alloc_tag tag,
     1004                               rtems_rtl_obj*      obj,
     1005                               uint8_t*            base)
     1006{
     1007  rtems_chain_control* sections = &obj->sections;
     1008  rtems_chain_node*    node = rtems_chain_first (sections);
     1009  size_t               base_offset = 0;
     1010  int                  order = 0;
     1011
     1012  if (rtems_rtl_trace (RTEMS_RTL_TRACE_LOAD_SECT))
     1013    printf ("rtl: locating section: mask:%08" PRIx32 " base:%p\n", mask, base);
     1014
     1015  while (!rtems_chain_is_tail (sections, node))
     1016  {
     1017    rtems_rtl_obj_sect* sect = (rtems_rtl_obj_sect*) node;
     1018
     1019    if ((sect->size != 0) && ((sect->flags & mask) == mask))
     1020    {
     1021      if (sect->load_order == order)
     1022      {
     1023        if ((sect->flags & RTEMS_RTL_OBJ_SECT_ARCH_ALLOC) == 0)
     1024        {
     1025          base_offset = rtems_rtl_obj_align (base_offset, sect->alignment);
     1026          sect->base = base + base_offset;
     1027        }
     1028
     1029        if (rtems_rtl_trace (RTEMS_RTL_TRACE_LOAD_SECT))
     1030          printf ("rtl: locating:%2d: %s -> %p (s:%zi f:%04" PRIx32
     1031                  " a:%" PRIu32 " l:%02d)\n",
     1032                  order, sect->name, sect->base, sect->size,
     1033                  sect->flags, sect->alignment, sect->link);
     1034
     1035        if (sect->base)
     1036          base_offset += sect->size;
     1037
     1038        ++order;
     1039
     1040        node = rtems_chain_first (sections);
     1041        continue;
     1042      }
     1043    }
     1044
     1045    node = rtems_chain_next (node);
     1046  }
     1047}
     1048
     1049bool
     1050rtems_rtl_obj_alloc_sections (rtems_rtl_obj*             obj,
     1051                              int                        fd,
     1052                              rtems_rtl_obj_sect_handler handler,
     1053                              void*                      data)
     1054{
     1055  size_t text_size;
     1056  size_t const_size;
     1057  size_t eh_size;
     1058  size_t data_size;
     1059  size_t bss_size;
     1060
     1061  text_size  = rtems_rtl_obj_text_size (obj) + rtems_rtl_obj_const_alignment (obj);
     1062  const_size = rtems_rtl_obj_const_size (obj) + rtems_rtl_obj_eh_alignment (obj);
     1063  eh_size    = rtems_rtl_obj_eh_size (obj) + rtems_rtl_obj_data_alignment (obj);
     1064  data_size  = rtems_rtl_obj_data_size (obj) + rtems_rtl_obj_bss_alignment (obj);
     1065  bss_size   = rtems_rtl_obj_bss_size (obj);
     1066
     1067  /*
     1068   * Set the sizes held in the object data. We need this for a fast reference.
     1069   */
     1070  obj->text_size  = text_size;
     1071  obj->const_size = const_size;
     1072  obj->data_size  = data_size;
     1073  obj->eh_size    = eh_size;
     1074  obj->bss_size   = bss_size;
     1075
     1076  /*
     1077   * Perform any specific allocations for sections.
     1078   */
     1079  if (handler != NULL)
     1080  {
     1081    if (!rtems_rtl_obj_section_handler (RTEMS_RTL_OBJ_SECT_TYPES,
     1082                                        obj,
     1083                                        fd,
     1084                                        handler,
     1085                                        data))
     1086    {
     1087      obj->exec_size = 0;
     1088      return false;
     1089    }
     1090  }
     1091
     1092  /*
     1093   * Let the allocator manage the actual allocation. The user can use the
     1094   * standard heap or provide a specific allocator with memory protection.
     1095   */
     1096  if (!rtems_rtl_alloc_module_new (&obj->text_base, text_size,
     1097                                   &obj->const_base, const_size,
     1098                                   &obj->eh_base, eh_size,
     1099                                   &obj->data_base, data_size,
     1100                                   &obj->bss_base, bss_size))
     1101  {
     1102    obj->exec_size = 0;
     1103    rtems_rtl_set_error (ENOMEM, "no memory to load obj");
     1104    return false;
     1105  }
     1106
     1107  obj->exec_size = text_size + const_size + eh_size + data_size + bss_size;
     1108
     1109  if (rtems_rtl_trace (RTEMS_RTL_TRACE_LOAD_SECT))
     1110  {
     1111    printf ("rtl: load sect: text  - b:%p s:%zi a:%" PRIu32 "\n",
     1112            obj->text_base, text_size, rtems_rtl_obj_text_alignment (obj));
     1113    printf ("rtl: load sect: const - b:%p s:%zi a:%" PRIu32 "\n",
     1114            obj->const_base, const_size, rtems_rtl_obj_const_alignment (obj));
     1115    printf ("rtl: load sect: eh    - b:%p s:%zi a:%" PRIu32 "\n",
     1116            obj->eh_base, eh_size, rtems_rtl_obj_eh_alignment (obj));
     1117    printf ("rtl: load sect: data  - b:%p s:%zi a:%" PRIu32 "\n",
     1118            obj->data_base, data_size, rtems_rtl_obj_data_alignment (obj));
     1119    printf ("rtl: load sect: bss   - b:%p s:%zi a:%" PRIu32 "\n",
     1120            obj->bss_base, bss_size, rtems_rtl_obj_bss_alignment (obj));
     1121  }
     1122
     1123  /*
     1124   * Determine the load order.
     1125   */
     1126  rtems_rtl_obj_sections_link_order (RTEMS_RTL_OBJ_SECT_TEXT,  obj);
     1127  rtems_rtl_obj_sections_link_order (RTEMS_RTL_OBJ_SECT_CONST, obj);
     1128  rtems_rtl_obj_sections_link_order (RTEMS_RTL_OBJ_SECT_EH,    obj);
     1129  rtems_rtl_obj_sections_link_order (RTEMS_RTL_OBJ_SECT_DATA,  obj);
     1130  rtems_rtl_obj_sections_link_order (RTEMS_RTL_OBJ_SECT_BSS,   obj);
     1131
     1132  /*
     1133   * Locate all text, data and bss sections in seperate operations so each type of
     1134   * section is grouped together.
     1135   */
     1136  rtems_rtl_obj_sections_locate (RTEMS_RTL_OBJ_SECT_TEXT,
     1137                                 rtems_rtl_alloc_text_tag (),
     1138                                 obj, obj->text_base);
     1139  rtems_rtl_obj_sections_locate (RTEMS_RTL_OBJ_SECT_CONST,
     1140                                 rtems_rtl_alloc_const_tag (),
     1141                                 obj, obj->const_base);
     1142  rtems_rtl_obj_sections_locate (RTEMS_RTL_OBJ_SECT_EH,
     1143                                 rtems_rtl_alloc_eh_tag (),
     1144                                 obj, obj->eh_base);
     1145  rtems_rtl_obj_sections_locate (RTEMS_RTL_OBJ_SECT_DATA,
     1146                                 rtems_rtl_alloc_data_tag (),
     1147                                 obj, obj->data_base);
     1148  rtems_rtl_obj_sections_locate (RTEMS_RTL_OBJ_SECT_BSS,
     1149                                 rtems_rtl_alloc_bss_tag (),
     1150                                 obj, obj->bss_base);
     1151
     1152  return true;
     1153}
     1154
    10011155static bool
    10021156rtems_rtl_obj_sections_loader (uint32_t                   mask,
     
    10101164  rtems_chain_control* sections = &obj->sections;
    10111165  rtems_chain_node*    node = rtems_chain_first (sections);
    1012   size_t               base_offset = 0;
    10131166  int                  order = 0;
    10141167
     
    10261179      if (sect->load_order == order)
    10271180      {
    1028         if ((sect->flags & RTEMS_RTL_OBJ_SECT_ARCH_ALLOC) == 0)
    1029         {
    1030           base_offset = rtems_rtl_obj_align (base_offset, sect->alignment);
    1031           sect->base = base + base_offset;
    1032         }
    1033 
    10341181        if (rtems_rtl_trace (RTEMS_RTL_TRACE_LOAD_SECT))
    10351182          printf ("rtl: loading:%2d: %s -> %p (s:%zi f:%04" PRIx32
     
    10591206        }
    10601207
    1061         if (sect->base)
    1062           base_offset += sect->size;
    1063 
    10641208        ++order;
    10651209
     
    10731217
    10741218  rtems_rtl_alloc_wr_disable (tag, base);
    1075 
    1076   return true;
    1077 }
    1078 
    1079 bool
    1080 rtems_rtl_obj_alloc_sections (rtems_rtl_obj*             obj,
    1081                               int                        fd,
    1082                               rtems_rtl_obj_sect_handler handler,
    1083                               void*                      data)
    1084 {
    1085   size_t text_size;
    1086   size_t const_size;
    1087   size_t eh_size;
    1088   size_t data_size;
    1089   size_t bss_size;
    1090 
    1091   text_size  = rtems_rtl_obj_text_size (obj) + rtems_rtl_obj_const_alignment (obj);
    1092   const_size = rtems_rtl_obj_const_size (obj) + rtems_rtl_obj_eh_alignment (obj);
    1093   eh_size    = rtems_rtl_obj_eh_size (obj) + rtems_rtl_obj_data_alignment (obj);
    1094   data_size  = rtems_rtl_obj_data_size (obj) + rtems_rtl_obj_bss_alignment (obj);
    1095   bss_size   = rtems_rtl_obj_bss_size (obj);
    1096 
    1097   /*
    1098    * Set the sizes held in the object data. We need this for a fast reference.
    1099    */
    1100   obj->text_size  = text_size;
    1101   obj->const_size = const_size;
    1102   obj->data_size  = data_size;
    1103   obj->eh_size    = eh_size;
    1104   obj->bss_size   = bss_size;
    1105 
    1106   /*
    1107    * Perform any specific allocations for sections.
    1108    */
    1109   if (handler != NULL)
    1110   {
    1111     if (!rtems_rtl_obj_section_handler (RTEMS_RTL_OBJ_SECT_TYPES,
    1112                                         obj,
    1113                                         fd,
    1114                                         handler,
    1115                                         data))
    1116     {
    1117       obj->exec_size = 0;
    1118       return false;
    1119     }
    1120   }
    1121 
    1122   /*
    1123    * Let the allocator manage the actual allocation. The user can use the
    1124    * standard heap or provide a specific allocator with memory protection.
    1125    */
    1126   if (!rtems_rtl_alloc_module_new (&obj->text_base, text_size,
    1127                                    &obj->const_base, const_size,
    1128                                    &obj->eh_base, eh_size,
    1129                                    &obj->data_base, data_size,
    1130                                    &obj->bss_base, bss_size))
    1131   {
    1132     obj->exec_size = 0;
    1133     rtems_rtl_set_error (ENOMEM, "no memory to load obj");
    1134     return false;
    1135   }
    1136 
    1137   obj->exec_size = text_size + const_size + eh_size + data_size + bss_size;
    1138 
    1139   if (rtems_rtl_trace (RTEMS_RTL_TRACE_LOAD_SECT))
    1140   {
    1141     printf ("rtl: load sect: text  - b:%p s:%zi a:%" PRIu32 "\n",
    1142             obj->text_base, text_size, rtems_rtl_obj_text_alignment (obj));
    1143     printf ("rtl: load sect: const - b:%p s:%zi a:%" PRIu32 "\n",
    1144             obj->const_base, const_size, rtems_rtl_obj_const_alignment (obj));
    1145     printf ("rtl: load sect: eh    - b:%p s:%zi a:%" PRIu32 "\n",
    1146             obj->eh_base, eh_size, rtems_rtl_obj_eh_alignment (obj));
    1147     printf ("rtl: load sect: data  - b:%p s:%zi a:%" PRIu32 "\n",
    1148             obj->data_base, data_size, rtems_rtl_obj_data_alignment (obj));
    1149     printf ("rtl: load sect: bss   - b:%p s:%zi a:%" PRIu32 "\n",
    1150             obj->bss_base, bss_size, rtems_rtl_obj_bss_alignment (obj));
    1151   }
    1152 
    1153   /*
    1154    * Determine the load order.
    1155    */
    1156   rtems_rtl_obj_sections_link_order (RTEMS_RTL_OBJ_SECT_TEXT,  obj);
    1157   rtems_rtl_obj_sections_link_order (RTEMS_RTL_OBJ_SECT_CONST, obj);
    1158   rtems_rtl_obj_sections_link_order (RTEMS_RTL_OBJ_SECT_EH,    obj);
    1159   rtems_rtl_obj_sections_link_order (RTEMS_RTL_OBJ_SECT_DATA,  obj);
    1160   rtems_rtl_obj_sections_link_order (RTEMS_RTL_OBJ_SECT_BSS,   obj);
    11611219
    11621220  return true;
  • cpukit/libdl/rtl-shell.c

    rbe50969 rb36c5209  
    144144  bool                 symbols;      /**< Print the global symbols. */
    145145  bool                 dependencies; /**< Print any dependencies. */
     146  bool                 trampolines;  /**< Print trampoline stats. */
    146147  bool                 base;         /**< Include the base object file. */
    147148  const char*          re_name;      /**< Name regx to filter on. */
     
    516517    rtems_printf (print->printer, "%-*cusers         : %zu\n", indent, ' ', obj->users);
    517518    rtems_printf (print->printer, "%-*creferences    : %zu\n", indent, ' ', obj->refs);
     519    rtems_printf (print->printer, "%-*ctrampolines   : %zu\n", indent, ' ',
     520                  rtems_rtl_obj_trampolines (obj));
    518521    rtems_printf (print->printer, "%-*csymbols       : %zi\n", indent, ' ', obj->global_syms);
    519522    rtems_printf (print->printer, "%-*csymbol memory : %zi\n", indent, ' ', obj->global_size);
     
    536539      rtems_printf (print->printer, "\n");
    537540  }
     541  if (print->trampolines)
     542  {
     543    if (obj->tramp_size == 0)
     544    {
     545      rtems_printf (print->printer, "%-*ctrampolines: not supported\n", indent, ' ');
     546    }
     547    else
     548    {
     549      size_t slots = rtems_rtl_obj_trampoline_slots (obj);
     550      size_t used = rtems_rtl_obj_trampolines (obj);
     551      rtems_printf (print->printer, "%-*ctrampolines:\n", indent, ' ');
     552      rtems_printf (print->printer, "%-*cslots     : %zu\n", indent + 4, ' ',
     553                    slots);
     554      rtems_printf (print->printer, "%-*csize      : %zu\n", indent + 4, ' ',
     555                    obj->tramps_size);
     556      rtems_printf (print->printer, "%-*cslot size : %zu\n", indent + 4, ' ',
     557                    obj->tramp_size);
     558      rtems_printf (print->printer, "%-*cused      : %zu\n", indent + 4, ' ',
     559                    used);
     560      rtems_printf (print->printer, "%-*crelocs    : %zu\n", indent + 4, ' ',
     561                    obj->tramp_relocs);
     562      rtems_printf (print->printer, "%-*cunresolved: %zu\n", indent + 4, ' ',
     563                    slots - obj->tramp_relocs);
     564      rtems_printf (print->printer, "%-*cyield     : %zu%%\n", indent + 4, ' ',
     565                    slots ? (used * 100) / slots : 0);
     566    }
     567  }
    538568  return true;
    539569}
     
    568598{
    569599  rtems_rtl_obj_print print = { 0 };
    570   if (!rtems_rtl_check_opts (printer, "nlmsdb", argc, argv))
     600  if (!rtems_rtl_check_opts (printer, "anlmsdbt", argc, argv))
    571601    return 1;
    572602  print.printer = printer;
    573603  print.indent = 1;
    574604  print.oname = true;
    575   print.names = rtems_rtl_parse_opt ('n', argc, argv);
    576   print.stats = rtems_rtl_parse_opt ('l', argc, argv);;
    577   print.memory_map = rtems_rtl_parse_opt ('m', argc, argv);;
    578   print.symbols = rtems_rtl_parse_opt ('s', argc, argv);
    579   print.dependencies = rtems_rtl_parse_opt ('d', argc, argv);;
    580   print.base = rtems_rtl_parse_opt ('b', argc, argv);;
    581   print.re_name = rtems_rtl_parse_arg (' ', NULL, argc, argv);
     605  if (rtems_rtl_parse_opt ('a', argc, argv))
     606  {
     607    print.names = true;
     608    print.stats = true;
     609    print.memory_map = true;
     610    print.symbols = true;
     611    print.dependencies = true;
     612    print.trampolines = true;
     613  }
     614  else
     615  {
     616    print.names = rtems_rtl_parse_opt ('n', argc, argv);
     617    print.stats = rtems_rtl_parse_opt ('l', argc, argv);;
     618    print.memory_map = rtems_rtl_parse_opt ('m', argc, argv);;
     619    print.symbols = rtems_rtl_parse_opt ('s', argc, argv);
     620    print.dependencies = rtems_rtl_parse_opt ('d', argc, argv);;
     621    print.trampolines = rtems_rtl_parse_opt ('t', argc, argv);;
     622    print.base = rtems_rtl_parse_opt ('b', argc, argv);;
     623    print.re_name = rtems_rtl_parse_arg (' ', NULL, argc, argv);
     624  }
    582625  print.re_symbol = NULL;
    583626  print.rtl = rtems_rtl_lock ();
  • cpukit/libdl/rtl-unresolved.c

    rbe50969 rb36c5209  
    2828#include <rtems/rtl/rtl-unresolved.h>
    2929#include <rtems/rtl/rtl-trace.h>
     30#include "rtl-trampoline.h"
    3031
    3132static rtems_rtl_unresolv_block*
     
    7071static int
    7172rtems_rtl_unresolved_rec_index (rtems_rtl_unresolv_block* block,
    72                                 rtems_rtl_unresolv_rec* rec)
     73                                rtems_rtl_unresolv_rec*   rec)
    7374{
    7475  return rec - &block->rec[0];
     
    102103
    103104    case rtems_rtl_unresolved_reloc:
     105    case rtems_rtl_trampoline_reloc:
    104106      ++rec;
    105107      break;
     
    402404  bytes = count * sizeof (rtems_rtl_unresolv_rec);
    403405  memset (&block->rec[block->recs], 0, bytes);
     406}
     407
     408static rtems_chain_node*
     409rtems_rtl_unresolved_delete_block_if_empty (rtems_chain_control*      blocks,
     410                                            rtems_rtl_unresolv_block* block)
     411{
     412  rtems_chain_node* node = &block->link;
     413  rtems_chain_node* next_node = rtems_chain_next (node);
     414  /*
     415   * Always leave a single block allocated. Eases possible heap fragmentation.
     416   */
     417  if (block->recs == 0 && !rtems_chain_has_only_one_node (blocks))
     418  {
     419    if (rtems_rtl_trace (RTEMS_RTL_TRACE_UNRESOLVED))
     420      printf ("rtl: unresolv: block-del %p\n", block);
     421    rtems_chain_extract (node);
     422    rtems_rtl_alloc_del (RTEMS_RTL_ALLOC_EXTERNAL, block);
     423  }
     424  return next_node;
    404425}
    405426
     
    457478      }
    458479
    459       if (block->recs == 0)
    460       {
    461         rtems_chain_node* next_node = rtems_chain_next (node);
    462         if (rtems_rtl_trace (RTEMS_RTL_TRACE_UNRESOLVED))
    463           printf ("rtl: unresolv: block-del %p\n", block);
    464         rtems_chain_extract (node);
    465         rtems_rtl_alloc_del (RTEMS_RTL_ALLOC_EXTERNAL, block);
    466         node = next_node;
    467       }
    468       else
    469       {
    470         node = rtems_chain_next (node);
    471       }
     480      node = rtems_rtl_unresolved_delete_block_if_empty (&unresolved->blocks,
     481                                                         block);
    472482    }
    473483  }
     
    481491  unresolved->block_recs = block_recs;
    482492  rtems_chain_initialize_empty (&unresolved->blocks);
    483   return true;
     493  return rtems_rtl_unresolved_block_alloc (unresolved);
    484494}
    485495
     
    633643  /*
    634644   * The resolving process is two separate stages, The first stage is to
    635    * iterate over the unresolved symbols search the global symbol table. If a
    636    * symbol is found iterate over the unresolved relocation records for the
     645   * iterate over the unresolved symbols searching the global symbol table. If
     646   * a symbol is found iterate over the unresolved relocation records for the
    637647   * symbol fixing up the relocations. The second stage is to search the
    638    * archives for symbols we have not been search before and if a symbol if
    639    * found in an archve loaded the object file. Loading an object file stops
    640    * the search of the archives for symbols and stage one is performed
    641    * again. The process repeats until no more symbols are resolved.
     648   * archives for symbols we have not searched before and if a symbol is found
     649   * in an archve load the object file. Loading an object file stops the
     650   * search of the archives for symbols and stage one is performed again. The
     651   * process repeats until no more symbols are resolved or there is an error.
    642652   */
    643653  while (resolving)
     
    666676
    667677bool
    668 rtems_rtl_unresolved_remove (rtems_rtl_obj*        obj,
    669                              const char*           name,
    670                              const uint16_t        sect,
    671                              const rtems_rtl_word* rel)
    672 {
    673   rtems_rtl_unresolved* unresolved;
     678rtems_rtl_trampoline_add (rtems_rtl_obj*        obj,
     679                          const uint16_t        flags,
     680                          const uint16_t        sect,
     681                          const rtems_rtl_word  symvalue,
     682                          const rtems_rtl_word* rel)
     683{
     684  rtems_rtl_unresolved*     unresolved;
     685  rtems_rtl_unresolv_block* block;
     686  rtems_rtl_unresolv_rec*   rec;
     687
     688  if (rtems_rtl_trace (RTEMS_RTL_TRACE_UNRESOLVED))
     689    printf ("rtl: tramp: add: %s sect:%d flags:%04x\n",
     690            rtems_rtl_obj_oname (obj), sect, flags);
     691
    674692  unresolved = rtems_rtl_unresolved_unprotected ();
    675   if (unresolved == NULL)
     693  if (!unresolved)
    676694    return false;
     695
     696  block = rtems_rtl_unresolved_alloc_recs (unresolved, 1);
     697  if (block == NULL)
     698  {
     699    block = rtems_rtl_unresolved_block_alloc (unresolved);
     700    if (!block)
     701      return false;
     702  }
     703
     704  rec = rtems_rtl_unresolved_rec_first_free (block);
     705  rec->type = rtems_rtl_trampoline_reloc;
     706  rec->rec.tramp.obj = obj;
     707  rec->rec.tramp.flags = flags;
     708  rec->rec.tramp.sect = sect;
     709  rec->rec.tramp.symvalue = symvalue;
     710  rec->rec.tramp.rel[0] = rel[0];
     711  rec->rec.tramp.rel[1] = rel[1];
     712  rec->rec.tramp.rel[2] = rel[2];
     713
     714  ++block->recs;
     715
    677716  return true;
     717}
     718
     719void
     720rtems_rtl_trampoline_remove (rtems_rtl_obj* obj)
     721{
     722  rtems_rtl_unresolved* unresolved = rtems_rtl_unresolved_unprotected ();
     723  if (unresolved)
     724  {
     725    /*
     726     * Iterate over the blocks clearing any trampoline records.
     727     */
     728    rtems_chain_node* node = rtems_chain_first (&unresolved->blocks);
     729    while (!rtems_chain_is_tail (&unresolved->blocks, node))
     730    {
     731      rtems_rtl_unresolv_block* block = (rtems_rtl_unresolv_block*) node;
     732      rtems_rtl_unresolv_rec*   rec = rtems_rtl_unresolved_rec_first (block);
     733
     734      /*
     735       * Search the table for a trampoline record and if found clean the
     736       * record moving the remaining records down the block.
     737       */
     738      while (!rtems_rtl_unresolved_rec_is_last (block, rec))
     739      {
     740        bool next_rec = true;
     741
     742        if (rec->type == rtems_rtl_trampoline_reloc && rec->rec.tramp.obj == obj)
     743        {
     744            rtems_rtl_unresolved_clean_block (block, rec, 1,
     745                                              unresolved->block_recs);
     746            next_rec = false;
     747        }
     748
     749        if (next_rec)
     750          rec = rtems_rtl_unresolved_rec_next (rec);
     751      }
     752
     753      node = rtems_rtl_unresolved_delete_block_if_empty (&unresolved->blocks,
     754                                                         block);
     755    }
     756  }
    678757}
    679758
     
    709788    break;
    710789  case rtems_rtl_unresolved_reloc:
     790  case rtems_rtl_trampoline_reloc:
    711791    if (dd->show_relocs)
    712       printf (" %3zu: 2: reloc: obj:%s name:%2d: sect:%d\n",
     792      printf (" %3zu: 2:reloc%c: obj:%s name:%2d: sect:%d\n",
     793              rec->type == rtems_rtl_unresolved_reloc ? 'R' : 'T',
    713794              dd->rec,
    714795              rec->rec.reloc.obj == NULL ? "resolved" : rec->rec.reloc.obj->oname,
  • cpukit/libdl/rtl.c

    rbe50969 rb36c5209  
    478478rtems_rtl_find_obj_with_symbol (const rtems_rtl_obj_sym* sym)
    479479{
    480   rtems_chain_node* node = rtems_chain_first (&rtl->objects);
    481   while (!rtems_chain_is_tail (&rtl->objects, node))
    482   {
    483     rtems_rtl_obj* obj = (rtems_rtl_obj*) node;
    484     if (rtems_rtl_obj_has_symbol (obj, sym))
    485       return obj;
    486     node = rtems_chain_next (node);
    487   }
    488   node = rtems_chain_first (&rtl->pending);
    489   while (!rtems_chain_is_tail (&rtl->pending, node))
    490   {
    491     rtems_rtl_obj* obj = (rtems_rtl_obj*) node;
    492     if (rtems_rtl_obj_has_symbol (obj, sym))
    493       return obj;
    494     node = rtems_chain_next (node);
     480  if (sym != NULL)
     481  {
     482    rtems_chain_node* node = rtems_chain_first (&rtl->objects);
     483    while (!rtems_chain_is_tail (&rtl->objects, node))
     484    {
     485      rtems_rtl_obj* obj = (rtems_rtl_obj*) node;
     486      if (rtems_rtl_obj_has_symbol (obj, sym))
     487        return obj;
     488      node = rtems_chain_next (node);
     489    }
     490    node = rtems_chain_first (&rtl->pending);
     491    while (!rtems_chain_is_tail (&rtl->pending, node))
     492    {
     493      rtems_rtl_obj* obj = (rtems_rtl_obj*) node;
     494      if (rtems_rtl_obj_has_symbol (obj, sym))
     495        return obj;
     496      node = rtems_chain_next (node);
     497    }
    495498  }
    496499  return NULL;
  • testsuites/libtests/dl08/init.c

    rbe50969 rb36c5209  
    5757  }
    5858
    59   for (i = 0; i < 100; ++i)
     59  for (i = 0; i < 4; ++i)
    6060  {
    6161    printf ("--------------------------------------------------\n");
  • testsuites/libtests/dl09/dl-o1.c

    rbe50969 rb36c5209  
    5656  printf (DL_NAME ":       dl01_const2: %4zu: %p: %f\n",   PAINT_VAR (dl01_const2));
    5757  printf (DL_NAME ":        dl01_func1: %4zu: %p\n",       sizeof(dl01_func1), &dl01_func1);
     58  printf (DL_NAME ":     rtems_main_o2:       %p\n",       &rtems_main_o2);
    5859
    5960  rtems_main_o2 ();
  • testsuites/libtests/dl09/init.c

    rbe50969 rb36c5209  
    5757  }
    5858
    59   for (i = 0; i < 100; ++i)
     59  for (i = 0; i < 4; ++i)
    6060  {
    6161    printf ("--------------------------------------------------\n");
Note: See TracChangeset for help on using the changeset viewer.