thread_count = cmdline.number_of_input_files();
workqueue->set_thread_count(thread_count);
- if (cmdline.options().incremental())
+ if (parameters->incremental())
{
Incremental_checker incremental_checker(
parameters->options().output_file_name(),
next_blocker->add_blocker();
workqueue->queue(new Read_symbols(input_objects, symtab, layout,
&search_path, 0, mapfile, &*p, NULL,
- this_blocker, next_blocker));
+ NULL, this_blocker, next_blocker));
this_blocker = next_blocker;
}
{
// Read_relocs for all the objects must be done and processed to find
// unused sections before any scanning of the relocs can take place.
- Task_token* blocker = new Task_token(true);
- blocker->add_blockers(input_objects->number_of_relobjs());
- Task_token* symtab_lock = new Task_token(false);
+ Task_token* this_blocker = NULL;
for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
p != input_objects->relobj_end();
++p)
- workqueue->queue(new Read_relocs(symtab, layout, *p, symtab_lock,
- blocker));
+ {
+ Task_token* next_blocker = new Task_token(true);
+ next_blocker->add_blocker();
+ workqueue->queue(new Read_relocs(symtab, layout, *p, this_blocker,
+ next_blocker));
+ this_blocker = next_blocker;
+ }
+
+ // If we are given only archives in input, we have no regular
+ // objects and THIS_BLOCKER is NULL here. Create a dummy
+ // blocker here so that we can run the middle tasks immediately.
+ if (this_blocker == NULL)
+ {
+ gold_assert(input_objects->number_of_relobjs() == 0);
+ this_blocker = new Task_token(true);
+ }
workqueue->queue(new Task_function(new Middle_runner(options,
input_objects,
symtab,
layout,
mapfile),
- blocker,
+ this_blocker,
"Task_function Middle_runner"));
}
Mapfile* mapfile)
{
// Add any symbols named with -u options to the symbol table.
- symtab->add_undefined_symbols_from_command_line();
+ symtab->add_undefined_symbols_from_command_line(layout);
// If garbage collection was chosen, relocs have been read and processed
// at this point by pre_middle_tasks. Layout can then be done for all
}
}
// Symbols named with -u should not be considered garbage.
- symtab->gc_mark_undef_symbols();
+ symtab->gc_mark_undef_symbols(layout);
gold_assert(symtab->gc() != NULL);
// Do a transitive closure on all references to determine the worklist.
symtab->gc()->do_transitive_closure();
p != input_objects->relobj_end();
++p)
{
+ Task_lock_obj<Object> tlo(task, *p);
(*p)->layout(symtab, layout, NULL);
}
}
++p)
{
// Update the value of output_section stored in rd.
- Read_relocs_data *rd = (*p)->get_relocs_data();
+ Read_relocs_data* rd = (*p)->get_relocs_data();
for (Read_relocs_data::Relocs_list::iterator q = rd->relocs.begin();
q != rd->relocs.end();
++q)
// Make sure we have symbols for any required group signatures.
layout->define_group_signatures(symtab);
- Task_token* blocker = new Task_token(true);
- blocker->add_blockers(input_objects->number_of_relobjs());
- if (parameters->options().define_common())
- blocker->add_blocker();
+ Task_token* this_blocker = NULL;
- Task_token* symtab_lock = new Task_token(false);
+ // Allocate common symbols. We use a blocker to run this before the
+ // Scan_relocs tasks, because it writes to the symbol table just as
+ // they do.
+ if (parameters->options().define_common())
+ {
+ this_blocker = new Task_token(true);
+ this_blocker->add_blocker();
+ workqueue->queue(new Allocate_commons_task(symtab, layout, mapfile,
+ this_blocker));
+ }
// If doing garbage collection, the relocations have already been read.
// Otherwise, read and scan the relocations.
for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
p != input_objects->relobj_end();
++p)
- workqueue->queue(new Scan_relocs(symtab, layout, *p,
- (*p)->get_relocs_data(),
- symtab_lock, blocker));
+ {
+ Task_token* next_blocker = new Task_token(true);
+ next_blocker->add_blocker();
+ workqueue->queue(new Scan_relocs(symtab, layout, *p,
+ (*p)->get_relocs_data(),
+ this_blocker, next_blocker));
+ this_blocker = next_blocker;
+ }
}
else
{
p != input_objects->relobj_end();
++p)
{
- // We can read and process the relocations in any order. But we
- // only want one task to write to the symbol table at a time.
- // So we queue up a task for each object to read the
- // relocations. That task will in turn queue a task to wait
- // until it can write to the symbol table.
- workqueue->queue(new Read_relocs(symtab, layout, *p, symtab_lock,
- blocker));
+ Task_token* next_blocker = new Task_token(true);
+ next_blocker->add_blocker();
+ workqueue->queue(new Read_relocs(symtab, layout, *p, this_blocker,
+ next_blocker));
+ this_blocker = next_blocker;
}
}
- // Allocate common symbols. This requires write access to the
- // symbol table, but is independent of the relocation processing.
- if (parameters->options().define_common())
- workqueue->queue(new Allocate_commons_task(symtab, layout, mapfile,
- symtab_lock, blocker));
+ if (this_blocker == NULL)
+ {
+ if (input_objects->number_of_relobjs() == 0)
+ {
+ // If we are given only archives in input, we have no regular
+ // objects and THIS_BLOCKER is NULL here. Create a dummy
+ // blocker here so that we can run the layout task immediately.
+ this_blocker = new Task_token(true);
+ }
+ else
+ {
+ // If we failed to open any input files, it's possible for
+ // THIS_BLOCKER to be NULL here. There's no real point in
+ // continuing if that happens.
+ gold_assert(parameters->errors()->error_count() > 0);
+ gold_exit(false);
+ }
+ }
// When all those tasks are complete, we can start laying out the
// output file.
target,
layout,
mapfile),
- blocker,
+ this_blocker,
"Task_function Layout_task_runner"));
}
}
else
{
- Task_token *new_final_blocker = new Task_token(true);
+ Task_token* new_final_blocker = new Task_token(true);
new_final_blocker->add_blocker();
Task* t = new Write_after_input_sections_task(layout, of,
final_blocker,