binutils-gdb/gold/common.cc

// common.cc -- handle common symbols for gold

#include "gold.h"

#include <algorithm>

#include "workqueue.h"
#include "layout.h"
#include "output.h"
#include "symtab.h"
#include "common.h"

namespace gold
{

// Allocate_commons_task methods.

// This task allocates the common symbols.  We need a lock on the
// symbol table.

Task::Is_runnable_type
Allocate_commons_task::is_runnable(Workqueue*)
{
  if (!this->symtab_lock_->is_writable())
    return IS_LOCKED;
  return IS_RUNNABLE;
}

// Return the locks we hold: one on the symbol table, and one blocker.

class Allocate_commons_task::Allocate_commons_locker : public Task_locker
{
 public:
  Allocate_commons_locker(Task_token& symtab_lock, Task* task,
			  Task_token& blocker, Workqueue* workqueue)
    : symtab_locker_(symtab_lock, task),
      blocker_(blocker, workqueue)
  { }

 private:
  Task_locker_write symtab_locker_;
  Task_locker_block blocker_;
};

Task_locker*
Allocate_commons_task::locks(Workqueue* workqueue)
{
  return new Allocate_commons_locker(*this->symtab_lock_, this,
				     *this->blocker_, workqueue);
}

// Allocate the common symbols.

void
Allocate_commons_task::run(Workqueue*)
{
  this->symtab_->allocate_commons(this->options_, this->layout_);
}

// This class is used to sort the common symbol by size.  We put the
// larger common symbols first.

template<int size>
class Sort_commons
{
 public:
  Sort_commons(const Symbol_table* symtab)
    : symtab_(symtab)
  { }

  bool operator()(const Symbol* a, const Symbol* b) const;

 private:
  const Symbol_table* symtab_;
};

template<int size>
bool
Sort_commons<size>::operator()(const Symbol* pa, const Symbol* pb) const
{
  if (pa == NULL)
    return false;
  if (pb == NULL)
    return true;

  const Symbol_table* symtab = this->symtab_;
  const Sized_symbol<size>* psa;
  psa = symtab->get_sized_symbol SELECT_SIZE_NAME(size) (pa
                                                         SELECT_SIZE(size));
  const Sized_symbol<size>* psb;
  psb = symtab->get_sized_symbol SELECT_SIZE_NAME(size) (pb
                                                         SELECT_SIZE(size));

  typename Sized_symbol<size>::Size_type sa = psa->symsize();
  typename Sized_symbol<size>::Size_type sb = psb->symsize();
  if (sa < sb)
    return false;
  else if (sb > sa)
    return true;

  // When the symbols are the same size, we sort them by alignment.
  typename Sized_symbol<size>::Value_type va = psa->value();
  typename Sized_symbol<size>::Value_type vb = psb->value();
  if (va < vb)
    return false;
  else if (vb > va)
    return true;

  // Otherwise we stabilize the sort by sorting by name.
  return strcmp(psa->name(), psb->name()) < 0;
}

// Allocate the common symbols.

void
Symbol_table::allocate_commons(const General_options& options, Layout* layout)
{
  if (this->get_size() == 32)
    this->do_allocate_commons<32>(options, layout);
  else if (this->get_size() == 64)
    this->do_allocate_commons<64>(options, layout);
  else
    abort();
}

// Allocated the common symbols, sized version.

template<int size>
void
Symbol_table::do_allocate_commons(const General_options&,
				  Layout* layout)
{
  typedef typename Sized_symbol<size>::Value_type Value_type;
  typedef typename Sized_symbol<size>::Size_type Size_type;

  // We've kept a list of all the common symbols.  But the symbol may
  // have been resolved to a defined symbol by now.  And it may be a
  // forwarder.  First remove all non-common symbols.
  bool any = false;
  uint64_t addralign = 0;
  for (Commons_type::iterator p = this->commons_.begin();
       p != this->commons_.end();
       ++p)
    {
      Symbol* sym = *p;
      if (sym->is_forwarder())
	{
	  sym = this->resolve_forwards(sym);
	  *p = sym;
	}
      if (!sym->is_common())
	*p = NULL;
      else
	{
	  any = true;
	  Sized_symbol<size>* ssym;
	  ssym = this->get_sized_symbol SELECT_SIZE_NAME(size) (
              sym
              SELECT_SIZE(size));
	  if (ssym->value() > addralign)
	    addralign = ssym->value();
	}
    }
  if (!any)
    return;

  // Sort the common symbols by size, so that they pack better into
  // memory.
  std::sort(this->commons_.begin(), this->commons_.end(),
	    Sort_commons<size>(this));

  // Place them in a newly allocated .bss section.

  Output_section_common *poc = new Output_section_common(addralign);

  layout->add_output_section_data(".bss", elfcpp::SHT_NOBITS,
				  elfcpp::SHF_WRITE | elfcpp::SHF_ALLOC,
				  poc);

  // Allocate them all.

  off_t off = 0;
  for (Commons_type::iterator p = this->commons_.begin();
       p != this->commons_.end();
       ++p)
    {
      Symbol* sym = *p;
      if (sym == NULL)
	break;

      Sized_symbol<size>* ssym;
      ssym = this->get_sized_symbol SELECT_SIZE_NAME(size) (sym
                                                            SELECT_SIZE(size));

      off = align_address(off, ssym->value());

      Size_type symsize = ssym->symsize();
      ssym->init(ssym->name(), poc, off, symsize, ssym->type(),
		 ssym->binding(), ssym->visibility(), ssym->nonvis(),
		 false);

      off += symsize;
    }

  poc->set_common_size(off);

  this->commons_.clear();
}

} // End namespace gold.