OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [gold/] [plugin.cc] - Diff between revs 159 and 163

Go to most recent revision | Show entire file | Details | Blame | View Log

Rev 159 Rev 163
Line 76... Line 76...
 
 
static enum ld_plugin_status
static enum ld_plugin_status
get_symbols(const void *handle, int nsyms, struct ld_plugin_symbol *syms);
get_symbols(const void *handle, int nsyms, struct ld_plugin_symbol *syms);
 
 
static enum ld_plugin_status
static enum ld_plugin_status
 
get_symbols_v2(const void *handle, int nsyms, struct ld_plugin_symbol *syms);
 
 
 
static enum ld_plugin_status
add_input_file(const char *pathname);
add_input_file(const char *pathname);
 
 
static enum ld_plugin_status
static enum ld_plugin_status
add_input_library(const char *pathname);
add_input_library(const char *pathname);
 
 
Line 154... Line 157...
  int major = 0;
  int major = 0;
  int minor = 0;
  int minor = 0;
  sscanf(ver, "%d.%d", &major, &minor);
  sscanf(ver, "%d.%d", &major, &minor);
 
 
  // Allocate and populate a transfer vector.
  // Allocate and populate a transfer vector.
  const int tv_fixed_size = 23;
  const int tv_fixed_size = 24;
 
 
  int tv_size = this->args_.size() + tv_fixed_size;
  int tv_size = this->args_.size() + tv_fixed_size;
  ld_plugin_tv* tv = new ld_plugin_tv[tv_size];
  ld_plugin_tv* tv = new ld_plugin_tv[tv_size];
 
 
  // Put LDPT_MESSAGE at the front of the list so the plugin can use it
  // Put LDPT_MESSAGE at the front of the list so the plugin can use it
Line 226... Line 229...
  ++i;
  ++i;
  tv[i].tv_tag = LDPT_GET_SYMBOLS;
  tv[i].tv_tag = LDPT_GET_SYMBOLS;
  tv[i].tv_u.tv_get_symbols = get_symbols;
  tv[i].tv_u.tv_get_symbols = get_symbols;
 
 
  ++i;
  ++i;
 
  tv[i].tv_tag = LDPT_GET_SYMBOLS_V2;
 
  tv[i].tv_u.tv_get_symbols = get_symbols_v2;
 
 
 
  ++i;
  tv[i].tv_tag = LDPT_ADD_INPUT_FILE;
  tv[i].tv_tag = LDPT_ADD_INPUT_FILE;
  tv[i].tv_u.tv_add_input_file = add_input_file;
  tv[i].tv_u.tv_add_input_file = add_input_file;
 
 
  ++i;
  ++i;
  tv[i].tv_tag = LDPT_ADD_INPUT_LIBRARY;
  tv[i].tv_tag = LDPT_ADD_INPUT_LIBRARY;
Line 808... Line 815...
  : Object(name, input_file, false, offset),
  : Object(name, input_file, false, offset),
    nsyms_(0), syms_(NULL), symbols_(), filesize_(filesize), comdat_map_()
    nsyms_(0), syms_(NULL), symbols_(), filesize_(filesize), comdat_map_()
{
{
}
}
 
 
// Return TRUE if a defined symbol might be reachable from outside the
// Return TRUE if a defined symbol is referenced from outside the
// universe of claimed objects.
// universe of claimed objects.  Only references from relocatable,
 
// non-IR (unclaimed) objects count as a reference.  References from
 
// dynamic objects count only as "visible".
 
 
static inline bool
static inline bool
is_visible_from_outside(Symbol* lsym)
is_referenced_from_outside(Symbol* lsym)
{
{
  if (lsym->in_real_elf())
  if (lsym->in_real_elf())
    return true;
    return true;
  if (parameters->options().relocatable())
  if (parameters->options().relocatable())
    return true;
    return true;
  if (parameters->options().is_undefined(lsym->name()))
  if (parameters->options().is_undefined(lsym->name()))
    return true;
    return true;
 
  return false;
 
}
 
 
 
// Return TRUE if a defined symbol might be reachable from outside the
 
// load module.
 
 
 
static inline bool
 
is_visible_from_outside(Symbol* lsym)
 
{
 
  if (lsym->in_dyn())
 
    return true;
  if (parameters->options().export_dynamic() || parameters->options().shared())
  if (parameters->options().export_dynamic() || parameters->options().shared())
    return lsym->is_externally_visible();
    return lsym->is_externally_visible();
  return false;
  return false;
}
}
 
 
// Get symbol resolution info.
// Get symbol resolution info.
 
 
ld_plugin_status
ld_plugin_status
Pluginobj::get_symbol_resolution_info(int nsyms, ld_plugin_symbol* syms) const
Pluginobj::get_symbol_resolution_info(int nsyms,
{
                                      ld_plugin_symbol* syms,
 
                                      int version) const
 
{
 
  // For version 1 of this interface, we cannot use
 
  // LDPR_PREVAILING_DEF_IRONLY_EXP, so we return LDPR_PREVAILING_DEF
 
  // instead.
 
  const ld_plugin_symbol_resolution ldpr_prevailing_def_ironly_exp
 
      = (version > 1
 
         ? LDPR_PREVAILING_DEF_IRONLY_EXP
 
         : LDPR_PREVAILING_DEF);
 
 
  if (nsyms > this->nsyms_)
  if (nsyms > this->nsyms_)
    return LDPS_NO_SYMS;
    return LDPS_NO_SYMS;
 
 
  if (static_cast<size_t>(nsyms) > this->symbols_.size())
  if (static_cast<size_t>(nsyms) > this->symbols_.size())
    {
    {
Line 860... Line 890...
        {
        {
          // The original symbol was undefined or common.
          // The original symbol was undefined or common.
          if (lsym->source() != Symbol::FROM_OBJECT)
          if (lsym->source() != Symbol::FROM_OBJECT)
            res = LDPR_RESOLVED_EXEC;
            res = LDPR_RESOLVED_EXEC;
          else if (lsym->object()->pluginobj() == this)
          else if (lsym->object()->pluginobj() == this)
            res = (is_visible_from_outside(lsym)
            {
                   ? LDPR_PREVAILING_DEF
              if (is_referenced_from_outside(lsym))
                   : LDPR_PREVAILING_DEF_IRONLY);
                res = LDPR_PREVAILING_DEF;
 
              else if (is_visible_from_outside(lsym))
 
                res = ldpr_prevailing_def_ironly_exp;
 
              else
 
                res = LDPR_PREVAILING_DEF_IRONLY;
 
            }
          else if (lsym->object()->pluginobj() != NULL)
          else if (lsym->object()->pluginobj() != NULL)
            res = LDPR_RESOLVED_IR;
            res = LDPR_RESOLVED_IR;
          else if (lsym->object()->is_dynamic())
          else if (lsym->object()->is_dynamic())
            res = LDPR_RESOLVED_DYN;
            res = LDPR_RESOLVED_DYN;
          else
          else
Line 876... Line 911...
        {
        {
          // The original symbol was a definition.
          // The original symbol was a definition.
          if (lsym->source() != Symbol::FROM_OBJECT)
          if (lsym->source() != Symbol::FROM_OBJECT)
            res = LDPR_PREEMPTED_REG;
            res = LDPR_PREEMPTED_REG;
          else if (lsym->object() == static_cast<const Object*>(this))
          else if (lsym->object() == static_cast<const Object*>(this))
            res = (is_visible_from_outside(lsym)
            {
                   ? LDPR_PREVAILING_DEF
              if (is_referenced_from_outside(lsym))
                   : LDPR_PREVAILING_DEF_IRONLY);
                res = LDPR_PREVAILING_DEF;
 
              else if (is_visible_from_outside(lsym))
 
                res = ldpr_prevailing_def_ironly_exp;
 
              else
 
                res = LDPR_PREVAILING_DEF_IRONLY;
 
            }
          else
          else
            res = (lsym->object()->pluginobj() != NULL
            res = (lsym->object()->pluginobj() != NULL
                   ? LDPR_PREEMPTED_IR
                   ? LDPR_PREEMPTED_IR
                   : LDPR_PREEMPTED_REG);
                   : LDPR_PREEMPTED_REG);
        }
        }
Line 1206... Line 1246...
{
{
  gold_unreachable();
  gold_unreachable();
  return NULL;
  return NULL;
}
}
 
 
// Get symbol counts.  Not used for plugin objects.
// Get symbol counts.  Don't count plugin objects; the replacement
 
// files will provide the counts.
 
 
template<int size, bool big_endian>
template<int size, bool big_endian>
void
void
Sized_pluginobj<size, big_endian>::do_get_global_symbol_counts(const Symbol_table*,
Sized_pluginobj<size, big_endian>::do_get_global_symbol_counts(
                                                   size_t*, size_t*) const
    const Symbol_table*,
 
    size_t* defined,
 
    size_t* used) const
{
{
  gold_unreachable();
  *defined = 0;
 
  *used = 0;
}
}
 
 
// Get symbols.  Not used for plugin objects.
// Get symbols.  Not used for plugin objects.
 
 
template<int size, bool big_endian>
template<int size, bool big_endian>
Line 1409... Line 1453...
  if (obj == NULL)
  if (obj == NULL)
    return LDPS_ERR;
    return LDPS_ERR;
  Pluginobj* plugin_obj = obj->pluginobj();
  Pluginobj* plugin_obj = obj->pluginobj();
  if (plugin_obj == NULL)
  if (plugin_obj == NULL)
    return LDPS_ERR;
    return LDPS_ERR;
  return plugin_obj->get_symbol_resolution_info(nsyms, syms);
  return plugin_obj->get_symbol_resolution_info(nsyms, syms, 1);
 
}
 
 
 
// Version 2 of the above.  The only difference is that this version
 
// is allowed to return the resolution code LDPR_PREVAILING_DEF_IRONLY_EXP.
 
 
 
static enum ld_plugin_status
 
get_symbols_v2(const void* handle, int nsyms, ld_plugin_symbol* syms)
 
{
 
  gold_assert(parameters->options().has_plugins());
 
  Object* obj = parameters->options().plugins()->object(
 
    static_cast<unsigned int>(reinterpret_cast<intptr_t>(handle)));
 
  if (obj == NULL)
 
    return LDPS_ERR;
 
  Pluginobj* plugin_obj = obj->pluginobj();
 
  if (plugin_obj == NULL)
 
    return LDPS_ERR;
 
  return plugin_obj->get_symbol_resolution_info(nsyms, syms, 2);
}
}
 
 
// Add a new (real) input file generated by a plugin.
// Add a new (real) input file generated by a plugin.
 
 
static enum ld_plugin_status
static enum ld_plugin_status
Line 1586... Line 1647...
    return LDPS_OK;
    return LDPS_OK;
 
 
  if (section_list == NULL)
  if (section_list == NULL)
    return LDPS_ERR;
    return LDPS_ERR;
 
 
  std::map<Section_id, unsigned int> order_map;
  Layout* layout = parameters->options().plugins()->layout();
 
  gold_assert (layout != NULL);
 
 
 
  std::map<Section_id, unsigned int>* order_map
 
    = layout->get_section_order_map();
 
 
 
  /* Store the mapping from Section_id to section position in layout's
 
     order_map to consult after output sections are added.  */
  for (unsigned int i = 0; i < num_sections; ++i)
  for (unsigned int i = 0; i < num_sections; ++i)
    {
    {
      Object* obj = parameters->options().plugins()->get_elf_object(
      Object* obj = parameters->options().plugins()->get_elf_object(
          section_list[i].handle);
          section_list[i].handle);
      if (obj == NULL)
      if (obj == NULL)
        return LDPS_BAD_HANDLE;
        return LDPS_BAD_HANDLE;
      unsigned int shndx = section_list[i].shndx;
      unsigned int shndx = section_list[i].shndx;
      Section_id secn_id(obj, shndx);
      Section_id secn_id(obj, shndx);
      order_map[secn_id] = i + 1;
      (*order_map)[secn_id] = i + 1;
    }
    }
 
 
  Layout* layout = parameters->options().plugins()->layout();
 
  gold_assert (layout != NULL);
 
 
 
  for (Layout::Section_list::const_iterator p = layout->section_list().begin();
 
       p != layout->section_list().end();
 
       ++p)
 
    (*p)->update_section_layout(order_map);
 
 
 
  return LDPS_OK;
  return LDPS_OK;
}
}
 
 
// Let the linker know that the sections could be reordered.
// Let the linker know that the sections could be reordered.
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.