// After reading it, the start another task to process the
// information. These tasks requires access to the file.
-Task::Is_runnable_type
-Read_relocs::is_runnable(Workqueue*)
+Task_token*
+Read_relocs::is_runnable()
{
- return this->object_->is_locked() ? IS_LOCKED : IS_RUNNABLE;
+ return this->object_->is_locked() ? this->object_->token() : NULL;
}
// Lock the file.
-Task_locker*
-Read_relocs::locks(Workqueue*)
+void
+Read_relocs::locks(Task_locker* tl)
{
- return new Task_locker_obj<Object>(*this->object_);
+ tl->add(this, this->object_->token());
}
// Read the relocations and then start a Scan_relocs_task.
{
Read_relocs_data *rd = new Read_relocs_data;
this->object_->read_relocs(rd);
+ this->object_->release();
+
workqueue->queue_front(new Scan_relocs(this->options_, this->symtab_,
this->layout_, this->object_, rd,
this->symtab_lock_, this->blocker_));
// use a lock on the symbol table to keep them from interfering with
// each other.
-Task::Is_runnable_type
-Scan_relocs::is_runnable(Workqueue*)
+Task_token*
+Scan_relocs::is_runnable()
{
- if (!this->symtab_lock_->is_writable() || this->object_->is_locked())
- return IS_LOCKED;
- return IS_RUNNABLE;
+ if (!this->symtab_lock_->is_writable())
+ return this->symtab_lock_;
+ if (this->object_->is_locked())
+ return this->object_->token();
+ return NULL;
}
// Return the locks we hold: one on the file, one on the symbol table
// and one blocker.
-class Scan_relocs::Scan_relocs_locker : public Task_locker
-{
- public:
- Scan_relocs_locker(Object* object, Task_token& symtab_lock, Task* task,
- Task_token& blocker, Workqueue* workqueue)
- : objlock_(*object), symtab_locker_(symtab_lock, task),
- blocker_(blocker, workqueue)
- { }
-
- private:
- Task_locker_obj<Object> objlock_;
- Task_locker_write symtab_locker_;
- Task_locker_block blocker_;
-};
-
-Task_locker*
-Scan_relocs::locks(Workqueue* workqueue)
+void
+Scan_relocs::locks(Task_locker* tl)
{
- return new Scan_relocs_locker(this->object_, *this->symtab_lock_, this,
- *this->blocker_, workqueue);
+ tl->add(this, this->object_->token());
+ tl->add(this, this->symtab_lock_);
+ tl->add(this, this->blocker_);
}
// Scan the relocs.
{
this->object_->scan_relocs(this->options_, this->symtab_, this->layout_,
this->rd_);
+ this->object_->release();
delete this->rd_;
this->rd_ = NULL;
}
// We may have to wait for the output sections to be written.
-Task::Is_runnable_type
-Relocate_task::is_runnable(Workqueue*)
+Task_token*
+Relocate_task::is_runnable()
{
if (this->object_->relocs_must_follow_section_writes()
&& this->output_sections_blocker_->is_blocked())
- return IS_BLOCKED;
+ return this->output_sections_blocker_;
if (this->object_->is_locked())
- return IS_LOCKED;
+ return this->object_->token();
- return IS_RUNNABLE;
+ return NULL;
}
// We want to lock the file while we run. We want to unblock
// INPUT_SECTIONS_BLOCKER and FINAL_BLOCKER when we are done.
+// INPUT_SECTIONS_BLOCKER may be NULL.
-class Relocate_task::Relocate_locker : public Task_locker
-{
- public:
- Relocate_locker(Task_token& input_sections_blocker,
- Task_token& final_blocker, Workqueue* workqueue,
- Object* object)
- : input_sections_blocker_(input_sections_blocker, workqueue),
- final_blocker_(final_blocker, workqueue),
- objlock_(*object)
- { }
-
- private:
- Task_block_token input_sections_blocker_;
- Task_block_token final_blocker_;
- Task_locker_obj<Object> objlock_;
-};
-
-Task_locker*
-Relocate_task::locks(Workqueue* workqueue)
+void
+Relocate_task::locks(Task_locker* tl)
{
- return new Relocate_locker(*this->input_sections_blocker_,
- *this->final_blocker_,
- workqueue,
- this->object_);
+ if (this->input_sections_blocker_ != NULL)
+ tl->add(this, this->input_sections_blocker_);
+ tl->add(this, this->final_blocker_);
+ tl->add(this, this->object_->token());
}
// Run the task.
{
this->object_->relocate(this->options_, this->symtab_, this->layout_,
this->of_);
+ this->object_->release();
}
// Return a debugging name for the task.
{
if (views[i].view != NULL)
{
- if (views[i].is_input_output_view)
- of->write_input_output_view(views[i].offset, views[i].view_size,
- views[i].view);
- else
- of->write_output_view(views[i].offset, views[i].view_size,
- views[i].view);
+ if (!views[i].is_postprocessing_view)
+ {
+ if (views[i].is_input_output_view)
+ of->write_input_output_view(views[i].offset,
+ views[i].view_size,
+ views[i].view);
+ else
+ of->write_output_view(views[i].offset, views[i].view_size,
+ views[i].view);
+ }
}
}
// Write out the local symbols.
- this->write_local_symbols(of, layout->sympool());
+ this->write_local_symbols(of, layout->sympool(), layout->dynpool());
}
// Write section data to the output file. PSHDRS points to the
void
Sized_relobj<size, big_endian>::write_sections(const unsigned char* pshdrs,
Output_file* of,
- Views* pviews)
+ Views* pviews) const
{
unsigned int shnum = this->shnum();
- std::vector<Map_to_output>& map_sections(this->map_to_output());
+ const std::vector<Map_to_output>& map_sections(this->map_to_output());
const unsigned char* p = pshdrs + This::shdr_size;
for (unsigned int i = 1; i < shnum; ++i, p += This::shdr_size)
if (shdr.get_sh_type() == elfcpp::SHT_NOBITS)
continue;
+ // In the normal case, this input section is simply mapped to
+ // the output section at offset OUTPUT_OFFSET.
+
+ // However, if OUTPUT_OFFSET == -1, then input data is handled
+ // specially--e.g., a .eh_frame section. The relocation
+ // routines need to check for each reloc where it should be
+ // applied. For this case, we need an input/output view for the
+ // entire contents of the section in the output file. We don't
+ // want to copy the contents of the input section to the output
+ // section; the output section contents were already written,
+ // and we waited for them in Relocate_task::is_runnable because
+ // relocs_must_follow_section_writes is set for the object.
+
+ // Regardless of which of the above cases is true, we have to
+ // check requires_postprocessing of the output section. If that
+ // is false, then we work with views of the output file
+ // directly. If it is true, then we work with a separate
+ // buffer, and the output section is responsible for writing the
+ // final data to the output file.
+
+ off_t output_section_offset;
+ off_t output_section_size;
+ if (!os->requires_postprocessing())
+ {
+ output_section_offset = os->offset();
+ output_section_size = os->data_size();
+ }
+ else
+ {
+ output_section_offset = 0;
+ output_section_size = os->postprocessing_buffer_size();
+ }
+
off_t view_start;
- off_t view_size;
+ section_size_type view_size;
if (output_offset != -1)
{
- view_start = os->offset() + output_offset;
- view_size = shdr.get_sh_size();
+ view_start = output_section_offset + output_offset;
+ view_size = convert_to_section_size_type(shdr.get_sh_size());
}
else
{
- view_start = os->offset();
- view_size = os->data_size();
+ view_start = output_section_offset;
+ view_size = convert_to_section_size_type(output_section_size);
}
if (view_size == 0)
gold_assert(output_offset == -1
|| (output_offset >= 0
- && output_offset + view_size <= os->data_size()));
+ && output_offset + view_size <= output_section_size));
unsigned char* view;
- if (output_offset == -1)
- view = of->get_input_output_view(view_start, view_size);
+ if (os->requires_postprocessing())
+ {
+ unsigned char* buffer = os->postprocessing_buffer();
+ view = buffer + view_start;
+ if (output_offset != -1)
+ this->read(shdr.get_sh_offset(), view_size, view);
+ }
else
{
- view = of->get_output_view(view_start, view_size);
- this->read(shdr.get_sh_offset(), view_size, view);
+ if (output_offset == -1)
+ view = of->get_input_output_view(view_start, view_size);
+ else
+ {
+ view = of->get_output_view(view_start, view_size);
+ this->read(shdr.get_sh_offset(), view_size, view);
+ }
}
pvs->view = view;
pvs->offset = view_start;
pvs->view_size = view_size;
pvs->is_input_output_view = output_offset == -1;
+ pvs->is_postprocessing_view = os->requires_postprocessing();
}
}
unsigned int shnum = this->shnum();
Sized_target<size, big_endian>* target = this->sized_target();
- std::vector<Map_to_output>& map_sections(this->map_to_output());
+ const std::vector<Map_to_output>& map_sections(this->map_to_output());
Relocate_info<size, big_endian> relinfo;
relinfo.options = &options;
continue;
}
+ gold_assert(output_offset != -1
+ || this->relocs_must_follow_section_writes());
+
relinfo.reloc_shndx = i;
relinfo.data_shndx = index;
target->relocate_section(&relinfo,