// gold.cc -- main linker functions
-// Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+// Copyright 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
#include "reloc.h"
#include "defstd.h"
#include "plugin.h"
+#include "gc.h"
#include "icf.h"
#include "incremental.h"
if (cmdline.options().incremental())
{
Incremental_checker incremental_checker(
- parameters->options().output_file_name());
+ parameters->options().output_file_name(),
+ layout->incremental_inputs());
if (incremental_checker.can_incrementally_link_output_file())
{
// TODO: remove when incremental linking implemented.
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;
}
}
if (parameters->options().relocatable()
- && (parameters->options().gc_sections() || parameters->options().icf()))
+ && (parameters->options().gc_sections()
+ || parameters->options().icf_enabled()))
gold_error(_("cannot mix -r with --gc-sections or --icf"));
- if (parameters->options().gc_sections() || parameters->options().icf())
+ if (parameters->options().gc_sections()
+ || parameters->options().icf_enabled())
{
workqueue->queue(new Task_function(new Gc_runner(options,
- input_objects,
+ input_objects,
symtab,
layout,
mapfile),
{
// 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);
- 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)
{
- // We can read and process the relocations in any order.
- blocker->add_blocker();
- workqueue->queue(new Read_relocs(options, 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;
}
-
- Task_token* this_blocker = new Task_token(true);
workqueue->queue(new Task_function(new Middle_runner(options,
input_objects,
symtab,
start_sym = symtab->lookup(parameters->options().entry());
else
start_sym = symtab->lookup("_start");
- if (start_sym !=NULL)
+ if (start_sym != NULL)
{
bool is_ordinary;
unsigned int shndx = start_sym->shndx(&is_ordinary);
// If identical code folding (--icf) is chosen it makes sense to do it
// only after garbage collection (--gc-sections) as we do not want to
// be folding sections that will be garbage.
- if (parameters->options().icf())
+ if (parameters->options().icf_enabled())
{
symtab->icf()->find_identical_sections(input_objects, symtab);
}
// --gc-sections or --icf is turned on, Object::layout is
// called twice. It is called the first time when the
// symbols are added.
- if (parameters->options().gc_sections() || parameters->options().icf())
+ if (parameters->options().gc_sections()
+ || parameters->options().icf_enabled())
{
for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
p != input_objects->relobj_end();
plugins->layout_deferred_objects();
}
- if (parameters->options().gc_sections() || parameters->options().icf())
+ if (parameters->options().gc_sections()
+ || parameters->options().icf_enabled())
{
for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
p != input_objects->relobj_end();
workqueue->set_thread_count(thread_count);
// Now we have seen all the input files.
- const bool doing_static_link = (!input_objects->any_dynamic()
- && !parameters->options().shared());
+ const bool doing_static_link =
+ (!input_objects->any_dynamic()
+ && !parameters->options().output_is_position_independent());
set_parameters_doing_static_link(doing_static_link);
if (!doing_static_link && options.is_static())
{
gold_fatal(_("cannot use non-ELF output format with dynamic object %s"),
(*input_objects->dynobj_begin())->name().c_str());
+ if (parameters->options().relocatable())
+ {
+ Input_objects::Relobj_iterator p = input_objects->relobj_begin();
+ if (p != input_objects->relobj_end())
+ {
+ bool uses_split_stack = (*p)->uses_split_stack();
+ for (++p; p != input_objects->relobj_end(); ++p)
+ {
+ if ((*p)->uses_split_stack() != uses_split_stack)
+ gold_fatal(_("cannot mix split-stack '%s' and "
+ "non-split-stack '%s' when using -r"),
+ (*input_objects->relobj_begin())->name().c_str(),
+ (*p)->name().c_str());
+ }
+ }
+ }
+
if (is_debugging_enabled(DEBUG_SCRIPT))
layout->script_options()->print(stderr);
// TODO: if this is too slow, do this as a task, rather than inline.
symtab->detect_odr_violations(task, options.output_file_name());
+ // Do the --no-undefined-version check.
+ if (!parameters->options().undefined_version())
+ {
+ Script_options* so = layout->script_options();
+ so->version_script_info()->check_unmatched_names(symtab);
+ }
+
// Create any automatic note sections.
layout->create_notes();
// Make sure we have symbols for any required group signatures.
layout->define_group_signatures(symtab);
- Task_token* blocker = new Task_token(true);
- Task_token* symtab_lock = new Task_token(false);
+ Task_token* this_blocker = NULL;
+
+ // 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.
- if (parameters->options().gc_sections() || parameters->options().icf())
+ if (parameters->options().gc_sections()
+ || parameters->options().icf_enabled())
{
for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
p != input_objects->relobj_end();
++p)
- {
- blocker->add_blocker();
- workqueue->queue(new Scan_relocs(options, 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.
- blocker->add_blocker();
- workqueue->queue(new Read_relocs(options, 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())
+ // 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.
+ if (this_blocker == NULL)
{
- blocker->add_blocker();
- workqueue->queue(new Allocate_commons_task(symtab, layout, mapfile,
- symtab_lock, blocker));
+ gold_assert(parameters->errors()->error_count() > 0);
+ gold_exit(false);
}
// When all those tasks are complete, we can start laying out the
target,
layout,
mapfile),
- blocker,
+ this_blocker,
"Task_function Layout_task_runner"));
}
// written out.
Task_token* input_sections_blocker = NULL;
if (!any_postprocessing_sections)
- input_sections_blocker = new Task_token(true);
+ {
+ input_sections_blocker = new Task_token(true);
+ input_sections_blocker->add_blockers(input_objects->number_of_relobjs());
+ }
// Use a blocker to block any objects which have to wait for the
// output sections to complete before they can apply relocations.
Task_token* output_sections_blocker = new Task_token(true);
+ output_sections_blocker->add_blocker();
// Use a blocker to block the final cleanup task.
Task_token* final_blocker = new Task_token(true);
+ // Write_symbols_task, Write_sections_task, Write_data_task,
+ // Relocate_tasks.
+ final_blocker->add_blockers(3);
+ final_blocker->add_blockers(input_objects->number_of_relobjs());
+ if (!any_postprocessing_sections)
+ final_blocker->add_blocker();
// Queue a task to write out the symbol table.
- final_blocker->add_blocker();
workqueue->queue(new Write_symbols_task(layout,
symtab,
input_objects,
final_blocker));
// Queue a task to write out the output sections.
- output_sections_blocker->add_blocker();
- final_blocker->add_blocker();
workqueue->queue(new Write_sections_task(layout, of, output_sections_blocker,
final_blocker));
// Queue a task to write out everything else.
- final_blocker->add_blocker();
workqueue->queue(new Write_data_task(layout, symtab, of, final_blocker));
// Queue a task for each input object to relocate the sections and
for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
p != input_objects->relobj_end();
++p)
- {
- if (input_sections_blocker != NULL)
- input_sections_blocker->add_blocker();
- final_blocker->add_blocker();
- workqueue->queue(new Relocate_task(options, symtab, layout, *p, of,
- input_sections_blocker,
- output_sections_blocker,
- final_blocker));
- }
+ workqueue->queue(new Relocate_task(symtab, layout, *p, of,
+ input_sections_blocker,
+ output_sections_blocker,
+ final_blocker));
// Queue a task to write out the output sections which depend on
// input sections. If there are any sections which require
// the output file.
if (!any_postprocessing_sections)
{
- final_blocker->add_blocker();
Task* t = new Write_after_input_sections_task(layout, of,
input_sections_blocker,
final_blocker);