// common.cc -- handle common symbols for gold #include "gold.h" #include #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 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 bool Sort_commons::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* psa; psa = symtab->get_sized_symbol SELECT_SIZE_NAME(size) (pa SELECT_SIZE(size)); const Sized_symbol* psb; psb = symtab->get_sized_symbol SELECT_SIZE_NAME(size) (pb SELECT_SIZE(size)); typename Sized_symbol::Size_type sa = psa->symsize(); typename Sized_symbol::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::Value_type va = psa->value(); typename Sized_symbol::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 void Symbol_table::do_allocate_commons(const General_options&, Layout* layout) { typedef typename Sized_symbol::Value_type Value_type; typedef typename Sized_symbol::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* 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(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* 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.