// layout.h -- lay out output file sections for gold -*- C++ -*-
-// Copyright 2006, 2007 Free Software Foundation, Inc.
+// Copyright 2006, 2007, 2008 Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
#include <utility>
#include <vector>
+#include "script.h"
#include "workqueue.h"
#include "object.h"
#include "dynobj.h"
// Run the operation.
void
- run(Workqueue*);
+ run(Workqueue*, const Task*);
private:
Layout_task_runner(const Layout_task_runner&);
class Layout
{
public:
- Layout(const General_options& options);
+ Layout(const General_options& options, Script_options*);
// Given an input section SHNDX, named NAME, with data in SHDR, from
// the object file OBJECT, return the output section where this
// Create dynamic sections if necessary.
void
- create_initial_dynamic_sections(const Input_objects*, Symbol_table*);
+ create_initial_dynamic_sections(Symbol_table*);
// Define __start and __stop symbols for output sections.
void
- define_section_symbols(Symbol_table*, const Target*);
+ define_section_symbols(Symbol_table*);
+
+ // Define symbols from any linker script.
+ void
+ define_script_symbols(Symbol_table* symtab)
+ { this->script_options_->add_symbols_to_table(symtab); }
// Return the Stringpool used for symbol names.
const Stringpool*
// Finalize the layout after all the input sections have been added.
off_t
- finalize(const Input_objects*, Symbol_table*);
+ finalize(const Input_objects*, Symbol_table*, const Task*);
+
+ // Return whether any sections require postprocessing.
+ bool
+ any_postprocessing_sections() const
+ { return this->any_postprocessing_sections_; }
// Return the size of the output file.
off_t
has_static_tls() const
{ return this->has_static_tls_; }
+ // Return the options which may be set by a linker script.
+ Script_options*
+ script_options()
+ { return this->script_options_; }
+
+ const Script_options*
+ script_options() const
+ { return this->script_options_; }
+
// Dump statistical information to stderr.
void
print_stats() const;
// Count the local symbols in the regular symbol table and the dynamic
// symbol table, and build the respective string pools.
void
- count_local_symbols(const Input_objects*);
+ count_local_symbols(const Task*, const Input_objects*);
// Create the output sections for the symbol table.
void
// Create the dynamic symbol table.
void
- create_dynamic_symtab(const Input_objects*, const Target*,
- Symbol_table*, Output_section** pdynstr,
+ create_dynamic_symtab(const Input_objects*, Symbol_table*,
+ Output_section** pdynstr,
unsigned int* plocal_dynamic_count,
std::vector<Symbol*>* pdynamic_symbols,
Versions* versions);
// Set the final file offsets of all the sections not associated
// with a segment. We set section offsets in three passes: the
// first handles all allocated sections, the second sections that
- // can be handled after input-sections are processed, and the last
- // the late-bound STRTAB sections (probably only shstrtab, which is
- // the one we care about because it holds section names).
+ // require postprocessing, and the last the late-bound STRTAB
+ // sections (probably only shstrtab, which is the one we care about
+ // because it holds section names).
enum Section_offset_pass
{
BEFORE_INPUT_SECTIONS_PASS,
- AFTER_INPUT_SECTIONS_PASS,
- STRTAB_AFTER_INPUT_SECTIONS_PASS
+ POSTPROCESSING_SECTIONS_PASS,
+ STRTAB_AFTER_POSTPROCESSING_SECTIONS_PASS
};
off_t
set_section_offsets(off_t, Section_offset_pass pass);
// A reference to the options on the command line.
const General_options& options_;
+ // Information set by scripts or by command line options.
+ Script_options* script_options_;
// The output section names.
Stringpool namepool_;
// The output symbol names.
bool input_without_gnu_stack_note_;
// Whether we have seen an object file that uses the static TLS model.
bool has_static_tls_;
+ // Whether any sections require postprocessing.
+ bool any_postprocessing_sections_;
};
// This task handles writing out data in output sections which is not
// The standard Task methods.
- Is_runnable_type
- is_runnable(Workqueue*);
+ Task_token*
+ is_runnable();
- Task_locker*
- locks(Workqueue*);
+ void
+ locks(Task_locker*);
void
run(Workqueue*);
// The standard Task methods.
- Is_runnable_type
- is_runnable(Workqueue*);
+ Task_token*
+ is_runnable();
- Task_locker*
- locks(Workqueue*);
+ void
+ locks(Task_locker*);
void
run(Workqueue*);
// The standard Task methods.
- Is_runnable_type
- is_runnable(Workqueue*);
+ Task_token*
+ is_runnable();
- Task_locker*
- locks(Workqueue*);
+ void
+ locks(Task_locker*);
void
run(Workqueue*);
// The standard Task methods.
- Is_runnable_type
- is_runnable(Workqueue*);
+ Task_token*
+ is_runnable();
- Task_locker*
- locks(Workqueue*);
+ void
+ locks(Task_locker*);
void
run(Workqueue*);
{ return "Write_after_input_sections_task"; }
private:
- class Write_sections_locker;
-
Layout* layout_;
Output_file* of_;
Task_token* input_sections_blocker_;
// Run the operation.
void
- run(Workqueue*);
+ run(Workqueue*, const Task*);
private:
Output_file* of_;