// inremental.h -- incremental linking support for gold -*- C++ -*-
-// Copyright 2009, 2010 Free Software Foundation, Inc.
+// Copyright (C) 2009-2020 Free Software Foundation, Inc.
// Written by Mikolaj Zalewski <mikolajz@google.com>.
// This file is part of gold.
#include "workqueue.h"
#include "fileread.h"
#include "output.h"
+#include "archive.h"
namespace gold
{
-class Archive;
class Input_argument;
class Incremental_inputs_checker;
class Incremental_script_entry;
class Incremental_object_entry;
+class Incremental_dynobj_entry;
class Incremental_archive_entry;
class Incremental_inputs;
+class Incremental_binary;
+class Incremental_library;
class Object;
// Incremental input type as stored in .gnu_incremental_inputs.
INCREMENTAL_INPUT_SCRIPT = 5
};
-// An object representing the ELF file we edit during an incremental build.
-// Similar to Object or Dynobj, but operates on Output_file and contains
-// method specific to file edition (TBD). This is the abstract parent class
-// implemented in Sized_incremental_binary<size, big_endian> for a specific
-// endianness and size.
+// Incremental input file flags.
+// The input file type is stored in the lower eight bits.
-class Incremental_binary
+enum Incremental_input_flags
{
- public:
- Incremental_binary(Output_file* output, Target* target)
- : output_(output), target_(target)
- { }
-
- virtual
- ~Incremental_binary()
- { }
-
- // Functions and types for the elfcpp::Elf_file interface. This
- // permit us to use Incremental_binary as the File template parameter for
- // elfcpp::Elf_file.
-
- // The View class is returned by view. It must support a single
- // method, data(). This is trivial, because Output_file::get_output_view
- // does what we need.
- class View
- {
- public:
- View(const unsigned char* p)
- : p_(p)
- { }
-
- const unsigned char*
- data() const
- { return this->p_; }
-
- private:
- const unsigned char* p_;
- };
-
- // Return a View.
- View
- view(off_t file_offset, section_size_type data_size)
- { return View(this->output_->get_input_view(file_offset, data_size)); }
-
- // A location in the file.
- struct Location
- {
- off_t file_offset;
- off_t data_size;
-
- Location(off_t fo, section_size_type ds)
- : file_offset(fo), data_size(ds)
- { }
-
- Location()
- : file_offset(0), data_size(0)
- { }
- };
-
- // Get a View given a Location.
- View
- view(Location loc)
- { return View(this->view(loc.file_offset, loc.data_size)); }
-
- // Report an error.
- void
- error(const char* format, ...) const ATTRIBUTE_PRINTF_2;
-
- // Find the .gnu_incremental_inputs and related sections. It selects the
- // first section of type SHT_GNU_INCREMENTAL_INPUTS,
- // SHT_GNU_INCREMENTAL_SYMTAB, and SHT_GNU_INCREMENTAL_RELOCS.
- // Returns false if the sections are not found.
- bool
- find_incremental_inputs_sections(unsigned int* p_inputs_shndx,
- unsigned int* p_symtab_shndx,
- unsigned int* p_relocs_shndx,
- unsigned int* p_got_plt_shndx,
- unsigned int* p_strtab_shndx)
- {
- return do_find_incremental_inputs_sections(p_inputs_shndx, p_symtab_shndx,
- p_relocs_shndx, p_got_plt_shndx,
- p_strtab_shndx);
- }
-
- // Check the .gnu_incremental_inputs section to see whether an incremental
- // build is possible.
- // TODO: on success, should report what files needs to be rebuilt.
- // INCREMENTAL_INPUTS is used to read the canonical form of the command line
- // and read the input arguments. TODO: for items that don't need to be
- // rebuilt, we should also copy the incremental input information.
- virtual bool
- check_inputs(Incremental_inputs* incremental_inputs)
- { return do_check_inputs(incremental_inputs); }
-
- protected:
- // Find incremental inputs section.
- virtual bool
- do_find_incremental_inputs_sections(unsigned int* p_inputs_shndx,
- unsigned int* p_symtab_shndx,
- unsigned int* p_relocs_shndx,
- unsigned int* p_got_plt_shndx,
- unsigned int* p_strtab_shndx) = 0;
-
- // Check the .gnu_incremental_inputs section to see whether an incremental
- // build is possible.
- virtual bool
- do_check_inputs(Incremental_inputs* incremental_inputs) = 0;
-
- private:
- // Edited output file object.
- Output_file* output_;
- // Target of the output file.
- Target* target_;
+ INCREMENTAL_INPUT_IN_SYSTEM_DIR = 0x8000,
+ INCREMENTAL_INPUT_AS_NEEDED = 0x4000
};
-template<int size, bool big_endian>
-class Sized_incremental_binary : public Incremental_binary
-{
- public:
- Sized_incremental_binary(Output_file* output,
- const elfcpp::Ehdr<size, big_endian>& ehdr,
- Target* target)
- : Incremental_binary(output, target), elf_file_(this, ehdr)
- { }
+// Symbol flags for the incremental symbol table.
+// These flags are stored in the top two bits of
+// the symbol index field.
- protected:
- virtual bool
- do_find_incremental_inputs_sections(unsigned int* p_inputs_shndx,
- unsigned int* p_symtab_shndx,
- unsigned int* p_relocs_shndx,
- unsigned int* p_got_plt_shndx,
- unsigned int* p_strtab_shndx);
+enum Incremental_shlib_symbol_flags
+{
+ // Symbol is defined in this library.
+ INCREMENTAL_SHLIB_SYM_DEF = 2,
+ // Symbol is defined in this library, with a COPY relocation.
+ INCREMENTAL_SHLIB_SYM_COPY = 3
+};
- virtual bool
- do_check_inputs(Incremental_inputs* incremental_inputs);
+static const int INCREMENTAL_SHLIB_SYM_FLAGS_SHIFT = 30;
- private:
- // Output as an ELF file.
- elfcpp::Elf_file<size, big_endian, Incremental_binary> elf_file_;
-};
+// Return TRUE if a section of type SH_TYPE can be updated in place
+// during an incremental update.
+bool
+can_incremental_update(unsigned int sh_type);
// Create an Incremental_binary object for FILE. Returns NULL is this is not
// possible, e.g. FILE is not an ELF file or has an unsupported target.
Incremental_binary*
open_incremental_binary(Output_file* file);
-// Code invoked early during an incremental link that checks what files need
-// to be relinked.
-
-class Incremental_checker
-{
- public:
- // Check if the file named OUTPUT_NAME can be linked incrementally.
- // INCREMENTAL_INPUTS must have the canonical form of the command line
- // and input arguments filled - at this point of linking other fields are
- // probably not filled yet. TODO: for inputs that don't need to be
- // rebuilt, this function should fill the incremental input information.
- Incremental_checker(const char* output_name,
- Incremental_inputs* incremental_inputs)
- : output_name_(output_name), incremental_inputs_(incremental_inputs)
- { }
-
- // Analyzes the output file to check if incremental linking is possible and
- // what files needs to be relinked.
- bool
- can_incrementally_link_output_file();
-
- private:
- // Name of the output file to analyze.
- const char* output_name_;
-
- // The Incremental_inputs object. At this stage of link, only the command
- // line and inputs are filled.
- Incremental_inputs* incremental_inputs_;
-};
-
// Base class for recording each input file.
class Incremental_input_entry
{
public:
- Incremental_input_entry(Stringpool::Key filename_key, Timespec mtime)
- : filename_key_(filename_key), offset_(0), info_offset_(0), mtime_(mtime)
+ Incremental_input_entry(Stringpool::Key filename_key, unsigned int arg_serial,
+ Timespec mtime)
+ : filename_key_(filename_key), file_index_(0), offset_(0), info_offset_(0),
+ arg_serial_(arg_serial), mtime_(mtime), is_in_system_directory_(false),
+ as_needed_(false)
{ }
virtual
type() const
{ return this->do_type(); }
- // Set the section offset of this input file entry.
+ // Set the index and section offset of this input file entry.
void
- set_offset(unsigned int offset)
- { this->offset_ = offset; }
+ set_offset(unsigned int file_index, unsigned int offset)
+ {
+ this->file_index_ = file_index;
+ this->offset_ = offset;
+ }
// Set the section offset of the supplemental information for this entry.
void
set_info_offset(unsigned int info_offset)
{ this->info_offset_ = info_offset; }
+ // Get the index of this input file entry.
+ unsigned int
+ get_file_index() const
+ { return this->file_index_; }
+
// Get the section offset of this input file entry.
unsigned int
get_offset() const
get_filename_key() const
{ return this->filename_key_; }
+ // Get the serial number of the input file.
+ unsigned int
+ arg_serial() const
+ { return this->arg_serial_; }
+
// Get the modification time of the input file.
const Timespec&
get_mtime() const
{ return this->mtime_; }
+ // Record that the file was found in a system directory.
+ void
+ set_is_in_system_directory()
+ { this->is_in_system_directory_ = true; }
+
+ // Return TRUE if the file was found in a system directory.
+ bool
+ is_in_system_directory() const
+ { return this->is_in_system_directory_; }
+
+ // Record that the file was linked with --as-needed.
+ void
+ set_as_needed()
+ { this->as_needed_ = true; }
+
+ // Return TRUE if the file was linked with --as-needed.
+ bool
+ as_needed() const
+ { return this->as_needed_; }
+
// Return a pointer to the derived Incremental_script_entry object.
// Return NULL for input entries that are not script files.
Incremental_script_entry*
object_entry()
{ return this->do_object_entry(); }
+ // Return a pointer to the derived Incremental_dynobj_entry object.
+ // Return NULL for input entries that are not shared object files.
+ Incremental_dynobj_entry*
+ dynobj_entry()
+ { return this->do_dynobj_entry(); }
+
// Return a pointer to the derived Incremental_archive_entry object.
// Return NULL for input entries that are not archive files.
Incremental_archive_entry*
do_object_entry()
{ return NULL; }
+ // Return a pointer to the derived Incremental_dynobj_entry object.
+ // Return NULL for input entries that are not shared object files.
+ virtual Incremental_dynobj_entry*
+ do_dynobj_entry()
+ { return NULL; }
+
// Return a pointer to the derived Incremental_archive_entry object.
// Return NULL for input entries that are not archive files.
virtual Incremental_archive_entry*
// Key of the filename string in the section stringtable.
Stringpool::Key filename_key_;
+ // Index of the entry in the output section.
+ unsigned int file_index_;
+
// Offset of the entry in the output section.
unsigned int offset_;
// Offset of the extra information in the output section.
unsigned int info_offset_;
+ // Serial number of the file in the argument list.
+ unsigned int arg_serial_;
+
// Last modification time of the file.
Timespec mtime_;
+
+ // TRUE if the file was found in a system directory.
+ bool is_in_system_directory_;
+
+ // TRUE if the file was linked with --as-needed.
+ bool as_needed_;
+};
+
+// Information about a script input that will persist during the whole linker
+// run. Needed only during an incremental build to retrieve the input files
+// added by this script.
+
+class Script_info
+{
+ public:
+ Script_info(const std::string& filename)
+ : filename_(filename), input_file_index_(0),
+ incremental_script_entry_(NULL)
+ { }
+
+ Script_info(const std::string& filename, unsigned int input_file_index)
+ : filename_(filename), input_file_index_(input_file_index),
+ incremental_script_entry_(NULL)
+ { }
+
+ // Store a pointer to the incremental information for this script.
+ void
+ set_incremental_info(Incremental_script_entry* entry)
+ { this->incremental_script_entry_ = entry; }
+
+ // Return the filename.
+ const std::string&
+ filename() const
+ { return this->filename_; }
+
+ // Return the input file index.
+ unsigned int
+ input_file_index() const
+ { return this->input_file_index_; }
+
+ // Return the pointer to the incremental information for this script.
+ Incremental_script_entry*
+ incremental_info() const
+ { return this->incremental_script_entry_; }
+
+ private:
+ const std::string filename_;
+ unsigned int input_file_index_;
+ Incremental_script_entry* incremental_script_entry_;
};
// Class for recording input scripts.
class Incremental_script_entry : public Incremental_input_entry
{
public:
- Incremental_script_entry(Stringpool::Key filename_key, Script_info* script,
+ Incremental_script_entry(Stringpool::Key filename_key,
+ unsigned int arg_serial, Script_info* /*script*/,
Timespec mtime)
- : Incremental_input_entry(filename_key, mtime), script_(script)
+ : Incremental_input_entry(filename_key, arg_serial, mtime),
+ objects_()
{ }
+ // Add a member object to the archive.
+ void
+ add_object(Incremental_input_entry* obj_entry)
+ {
+ this->objects_.push_back(obj_entry);
+ }
+
+ // Return the number of objects included by this script.
+ unsigned int
+ get_object_count()
+ { return this->objects_.size(); }
+
+ // Return the Nth object.
+ Incremental_input_entry*
+ get_object(unsigned int n)
+ {
+ gold_assert(n < this->objects_.size());
+ return this->objects_[n];
+ }
+
protected:
virtual Incremental_input_type
do_type() const
{ return this; }
private:
- // Information about the script file.
- Script_info* script_;
+ // Objects that have been included by this script.
+ std::vector<Incremental_input_entry*> objects_;
};
// Class for recording input object files.
{
public:
Incremental_object_entry(Stringpool::Key filename_key, Object* obj,
- Timespec mtime)
- : Incremental_input_entry(filename_key, mtime), obj_(obj),
- is_member_(false), sections_()
- {
- if (!obj_->is_dynamic())
- this->sections_.reserve(obj->shnum());
- }
+ unsigned int arg_serial, Timespec mtime)
+ : Incremental_input_entry(filename_key, arg_serial, mtime), obj_(obj),
+ is_member_(false), sections_(), groups_()
+ { this->sections_.reserve(obj->shnum()); }
// Get the object.
Object*
// Add an input section.
void
add_input_section(unsigned int shndx, Stringpool::Key name_key, off_t sh_size)
- {
- if (shndx >= this->sections_.size())
- this->sections_.resize(shndx + 1);
- this->sections_[shndx].name_key = name_key;
- this->sections_[shndx].sh_size = sh_size;
- }
+ { this->sections_.push_back(Input_section(shndx, name_key, sh_size)); }
// Return the number of input sections in this object.
unsigned int
get_input_section_count() const
{ return this->sections_.size(); }
+ // Return the input section index for the Nth input section.
+ Stringpool::Key
+ get_input_section_index(unsigned int n) const
+ { return this->sections_[n].shndx_; }
+
// Return the stringpool key of the Nth input section.
Stringpool::Key
get_input_section_name_key(unsigned int n) const
- { return this->sections_[n].name_key; }
+ { return this->sections_[n].name_key_; }
// Return the size of the Nth input section.
off_t
get_input_section_size(unsigned int n) const
- { return this->sections_[n].sh_size; }
+ { return this->sections_[n].sh_size_; }
+
+ // Add a kept COMDAT group.
+ void
+ add_comdat_group(Stringpool::Key signature_key)
+ { this->groups_.push_back(signature_key); }
+
+ // Return the number of COMDAT groups.
+ unsigned int
+ get_comdat_group_count() const
+ { return this->groups_.size(); }
+
+ // Return the stringpool key for the signature of the Nth comdat group.
+ Stringpool::Key
+ get_comdat_signature_key(unsigned int n) const
+ { return this->groups_[n]; }
protected:
virtual Incremental_input_type
{
return (this->is_member_
? INCREMENTAL_INPUT_ARCHIVE_MEMBER
- : (this->obj_->is_dynamic()
- ? INCREMENTAL_INPUT_SHARED_LIBRARY
- : INCREMENTAL_INPUT_OBJECT));
+ : INCREMENTAL_INPUT_OBJECT);
}
// Return a pointer to the derived Incremental_object_entry object.
// Input sections.
struct Input_section
{
- Stringpool::Key name_key;
- off_t sh_size;
+ Input_section(unsigned int shndx, Stringpool::Key name_key, off_t sh_size)
+ : shndx_(shndx), name_key_(name_key), sh_size_(sh_size)
+ { }
+ unsigned int shndx_;
+ Stringpool::Key name_key_;
+ off_t sh_size_;
};
std::vector<Input_section> sections_;
+
+ // COMDAT groups.
+ std::vector<Stringpool::Key> groups_;
+};
+
+// Class for recording shared library input files.
+
+class Incremental_dynobj_entry : public Incremental_input_entry
+{
+ public:
+ Incremental_dynobj_entry(Stringpool::Key filename_key,
+ Stringpool::Key soname_key, Object* obj,
+ unsigned int arg_serial, Timespec mtime)
+ : Incremental_input_entry(filename_key, arg_serial, mtime),
+ soname_key_(soname_key), obj_(obj)
+ { }
+
+ // Get the object.
+ Object*
+ object() const
+ { return this->obj_; }
+
+ // Get the stringpool key for the soname.
+ Stringpool::Key
+ get_soname_key() const
+ { return this->soname_key_; }
+
+ protected:
+ virtual Incremental_input_type
+ do_type() const
+ { return INCREMENTAL_INPUT_SHARED_LIBRARY; }
+
+ // Return a pointer to the derived Incremental_dynobj_entry object.
+ virtual Incremental_dynobj_entry*
+ do_dynobj_entry()
+ { return this; }
+
+ private:
+ // Key of the soname string in the section stringtable.
+ Stringpool::Key soname_key_;
+
+ // The object file itself.
+ Object* obj_;
};
// Class for recording archive library input files.
class Incremental_archive_entry : public Incremental_input_entry
{
public:
- Incremental_archive_entry(Stringpool::Key filename_key, Archive*,
- Timespec mtime)
- : Incremental_input_entry(filename_key, mtime), members_(), unused_syms_()
+ Incremental_archive_entry(Stringpool::Key filename_key,
+ unsigned int arg_serial, Timespec mtime)
+ : Incremental_input_entry(filename_key, arg_serial, mtime), members_(),
+ unused_syms_()
{ }
// Add a member object to the archive.
// Record the initial info for archive file ARCHIVE.
void
- report_archive_begin(Archive* arch);
+ report_archive_begin(Library_base* arch, unsigned int arg_serial,
+ Script_info* script_info);
// Record the final info for archive file ARCHIVE.
void
- report_archive_end(Archive* arch);
+ report_archive_end(Library_base* arch);
// Record the info for object file OBJ. If ARCH is not NULL,
// attach the object file to the archive.
void
- report_object(Object* obj, Archive* arch);
+ report_object(Object* obj, unsigned int arg_serial, Library_base* arch,
+ Script_info* script_info);
// Record an input section belonging to object file OBJ.
void
report_input_section(Object* obj, unsigned int shndx, const char* name,
off_t sh_size);
+ // Record a kept COMDAT group belonging to object file OBJ.
+ void
+ report_comdat_group(Object* obj, const char* name);
+
// Record the info for input script SCRIPT.
void
- report_script(const std::string& filename, Script_info* script,
+ report_script(Script_info* script, unsigned int arg_serial,
Timespec mtime);
// Return the running count of incremental relocations.
unsigned int reloc_count_;
};
+// Reader class for global symbol info from an object file entry in
+// the .gnu_incremental_inputs section.
+
+template<bool big_endian>
+class Incremental_global_symbol_reader
+{
+ private:
+ typedef elfcpp::Swap<32, big_endian> Swap32;
+
+ public:
+ Incremental_global_symbol_reader(const unsigned char* p)
+ : p_(p)
+ { }
+
+ unsigned int
+ output_symndx() const
+ { return Swap32::readval(this->p_); }
+
+ unsigned int
+ shndx() const
+ { return Swap32::readval(this->p_ + 4); }
+
+ unsigned int
+ next_offset() const
+ { return Swap32::readval(this->p_ + 8); }
+
+ unsigned int
+ reloc_count() const
+ { return Swap32::readval(this->p_ + 12); }
+
+ unsigned int
+ reloc_offset() const
+ { return Swap32::readval(this->p_ + 16); }
+
+ private:
+ // Base address of the symbol entry.
+ const unsigned char* p_;
+};
+
// Reader class for .gnu_incremental_inputs section.
template<int size, bool big_endian>
typedef elfcpp::Swap<64, big_endian> Swap64;
public:
- Incremental_inputs_reader(const unsigned char* p, elfcpp::Elf_strtab& strtab)
+ // Size of the .gnu_incremental_inputs header.
+ // (3 x 4-byte fields, plus 4 bytes padding.)
+ static const unsigned int header_size = 16;
+ // Size of an input file entry.
+ // (2 x 4-byte fields, 1 x 12-byte field, 2 x 2-byte fields.)
+ static const unsigned int input_entry_size = 24;
+ // Size of the first part of the supplemental info block for
+ // relocatable objects and archive members.
+ // (7 x 4-byte fields, plus 4 bytes padding.)
+ static const unsigned int object_info_size = 32;
+ // Size of an input section entry.
+ // (2 x 4-byte fields, 2 x address-sized fields.)
+ static const unsigned int input_section_entry_size = 8 + 2 * size / 8;
+ // Size of a global symbol entry in the supplemental info block.
+ // (5 x 4-byte fields.)
+ static const unsigned int global_sym_entry_size = 20;
+
+ Incremental_inputs_reader()
+ : p_(NULL), strtab_(NULL, 0), input_file_count_(0)
+ { }
+
+ Incremental_inputs_reader(const unsigned char* p,
+ const elfcpp::Elf_strtab& strtab)
: p_(p), strtab_(strtab)
{ this->input_file_count_ = Swap32::readval(this->p_ + 4); }
// Reader class for an input file entry and its supplemental info.
class Incremental_input_entry_reader
{
+ private:
+ static const unsigned int object_info_size =
+ Incremental_inputs_reader<size, big_endian>::object_info_size;
+ static const unsigned int input_section_entry_size =
+ Incremental_inputs_reader<size, big_endian>::input_section_entry_size;
+ static const unsigned int global_sym_entry_size =
+ Incremental_inputs_reader<size, big_endian>::global_sym_entry_size;
+
public:
Incremental_input_entry_reader(const Incremental_inputs_reader* inputs,
unsigned int offset)
: inputs_(inputs), offset_(offset)
{
this->info_offset_ = Swap32::readval(inputs->p_ + offset + 4);
- int type = Swap16::readval(this->inputs_->p_ + offset + 20);
- this->type_ = static_cast<Incremental_input_type>(type);
+ this->flags_ = Swap16::readval(this->inputs_->p_ + offset + 20);
}
// Return the filename.
return this->inputs_->get_string(offset);
}
+ // Return the argument serial number.
+ unsigned int
+ arg_serial() const
+ {
+ return Swap16::readval(this->inputs_->p_ + this->offset_ + 22);
+ }
+
// Return the timestamp.
Timespec
get_mtime() const
// Return the type of input file.
Incremental_input_type
type() const
- { return this->type_; }
+ { return static_cast<Incremental_input_type>(this->flags_ & 0xff); }
+
+ // Return TRUE if the file was found in a system directory.
+ bool
+ is_in_system_directory() const
+ { return (this->flags_ & INCREMENTAL_INPUT_IN_SYSTEM_DIR) != 0; }
+
+ // Return TRUE if the file was linked with --as-needed.
+ bool
+ as_needed() const
+ { return (this->flags_ & INCREMENTAL_INPUT_AS_NEEDED) != 0; }
// Return the input section count -- for objects only.
unsigned int
get_input_section_count() const
{
- gold_assert(this->type_ == INCREMENTAL_INPUT_OBJECT
- || this->type_ == INCREMENTAL_INPUT_ARCHIVE_MEMBER);
+ gold_assert(this->type() == INCREMENTAL_INPUT_OBJECT
+ || this->type() == INCREMENTAL_INPUT_ARCHIVE_MEMBER);
return Swap32::readval(this->inputs_->p_ + this->info_offset_);
}
+ // Return the soname -- for shared libraries only.
+ const char*
+ get_soname() const
+ {
+ gold_assert(this->type() == INCREMENTAL_INPUT_SHARED_LIBRARY);
+ unsigned int offset = Swap32::readval(this->inputs_->p_
+ + this->info_offset_);
+ return this->inputs_->get_string(offset);
+ }
+
// Return the offset of the supplemental info for symbol SYMNDX --
// for objects only.
unsigned int
get_symbol_offset(unsigned int symndx) const
{
- gold_assert(this->type_ == INCREMENTAL_INPUT_OBJECT
- || this->type_ == INCREMENTAL_INPUT_ARCHIVE_MEMBER);
+ gold_assert(this->type() == INCREMENTAL_INPUT_OBJECT
+ || this->type() == INCREMENTAL_INPUT_ARCHIVE_MEMBER);
unsigned int section_count = this->get_input_section_count();
- return (this->info_offset_ + 8
- + section_count * input_section_entry_size
- + symndx * 16);
+ return (this->info_offset_
+ + this->object_info_size
+ + section_count * this->input_section_entry_size
+ + symndx * this->global_sym_entry_size);
}
// Return the global symbol count -- for objects & shared libraries only.
unsigned int
get_global_symbol_count() const
{
- switch (this->type_)
- {
- case INCREMENTAL_INPUT_OBJECT:
- case INCREMENTAL_INPUT_ARCHIVE_MEMBER:
- return Swap32::readval(this->inputs_->p_ + this->info_offset_ + 4);
- case INCREMENTAL_INPUT_SHARED_LIBRARY:
- return Swap32::readval(this->inputs_->p_ + this->info_offset_);
- default:
- gold_unreachable();
- }
+ gold_assert(this->type() == INCREMENTAL_INPUT_OBJECT
+ || this->type() == INCREMENTAL_INPUT_ARCHIVE_MEMBER
+ || this->type() == INCREMENTAL_INPUT_SHARED_LIBRARY);
+ return Swap32::readval(this->inputs_->p_ + this->info_offset_ + 4);
}
- // Return the member count -- for archives only.
+ // Return the offset of the first local symbol -- for objects only.
unsigned int
- get_member_count() const
+ get_local_symbol_offset() const
{
- gold_assert(this->type_ == INCREMENTAL_INPUT_ARCHIVE);
- return Swap32::readval(this->inputs_->p_ + this->info_offset_);
+ gold_assert(this->type() == INCREMENTAL_INPUT_OBJECT
+ || this->type() == INCREMENTAL_INPUT_ARCHIVE_MEMBER);
+
+ return Swap32::readval(this->inputs_->p_ + this->info_offset_ + 8);
}
- // Return the unused symbol count -- for archives only.
+ // Return the local symbol count -- for objects only.
unsigned int
- get_unused_symbol_count() const
+ get_local_symbol_count() const
{
- gold_assert(this->type_ == INCREMENTAL_INPUT_ARCHIVE);
- return Swap32::readval(this->inputs_->p_ + this->info_offset_ + 4);
+ gold_assert(this->type() == INCREMENTAL_INPUT_OBJECT
+ || this->type() == INCREMENTAL_INPUT_ARCHIVE_MEMBER);
+
+ return Swap32::readval(this->inputs_->p_ + this->info_offset_ + 12);
}
- // Return the input file offset for archive member N -- for archives only.
+ // Return the index of the first dynamic relocation -- for objects only.
unsigned int
- get_member_offset(unsigned int n) const
+ get_first_dyn_reloc() const
{
- gold_assert(this->type_ == INCREMENTAL_INPUT_ARCHIVE);
+ gold_assert(this->type() == INCREMENTAL_INPUT_OBJECT
+ || this->type() == INCREMENTAL_INPUT_ARCHIVE_MEMBER);
+
+ return Swap32::readval(this->inputs_->p_ + this->info_offset_ + 16);
+ }
+
+ // Return the dynamic relocation count -- for objects only.
+ unsigned int
+ get_dyn_reloc_count() const
+ {
+ gold_assert(this->type() == INCREMENTAL_INPUT_OBJECT
+ || this->type() == INCREMENTAL_INPUT_ARCHIVE_MEMBER);
+
+ return Swap32::readval(this->inputs_->p_ + this->info_offset_ + 20);
+ }
+
+ // Return the COMDAT group count -- for objects only.
+ unsigned int
+ get_comdat_group_count() const
+ {
+ gold_assert(this->type() == INCREMENTAL_INPUT_OBJECT
+ || this->type() == INCREMENTAL_INPUT_ARCHIVE_MEMBER);
+
+ return Swap32::readval(this->inputs_->p_ + this->info_offset_ + 24);
+ }
+
+ // Return the object count -- for scripts only.
+ unsigned int
+ get_object_count() const
+ {
+ gold_assert(this->type() == INCREMENTAL_INPUT_SCRIPT);
+ return Swap32::readval(this->inputs_->p_ + this->info_offset_);
+ }
+
+ // Return the input file offset for object N -- for scripts only.
+ unsigned int
+ get_object_offset(unsigned int n) const
+ {
+ gold_assert(this->type() == INCREMENTAL_INPUT_SCRIPT);
+ return Swap32::readval(this->inputs_->p_ + this->info_offset_
+ + 4 + n * 4);
+ }
+
+ // Return the member count -- for archives only.
+ unsigned int
+ get_member_count() const
+ {
+ gold_assert(this->type() == INCREMENTAL_INPUT_ARCHIVE);
+ return Swap32::readval(this->inputs_->p_ + this->info_offset_);
+ }
+
+ // Return the unused symbol count -- for archives only.
+ unsigned int
+ get_unused_symbol_count() const
+ {
+ gold_assert(this->type() == INCREMENTAL_INPUT_ARCHIVE);
+ return Swap32::readval(this->inputs_->p_ + this->info_offset_ + 4);
+ }
+
+ // Return the input file offset for archive member N -- for archives only.
+ unsigned int
+ get_member_offset(unsigned int n) const
+ {
+ gold_assert(this->type() == INCREMENTAL_INPUT_ARCHIVE);
return Swap32::readval(this->inputs_->p_ + this->info_offset_
+ 8 + n * 4);
}
const char*
get_unused_symbol(unsigned int n) const
{
- gold_assert(this->type_ == INCREMENTAL_INPUT_ARCHIVE);
+ gold_assert(this->type() == INCREMENTAL_INPUT_ARCHIVE);
unsigned int member_count = this->get_member_count();
unsigned int offset = Swap32::readval(this->inputs_->p_
+ this->info_offset_ + 8
{
Input_section_info info;
const unsigned char* p = (this->inputs_->p_
- + this->info_offset_ + 8
- + n * input_section_entry_size);
+ + this->info_offset_
+ + this->object_info_size
+ + n * this->input_section_entry_size);
unsigned int name_offset = Swap32::readval(p);
info.name = this->inputs_->get_string(name_offset);
info.output_shndx = Swap32::readval(p + 4);
return info;
}
- // Information about a global symbol.
- struct Global_symbol_info
+ // Return info about the Nth global symbol -- for objects only.
+ Incremental_global_symbol_reader<big_endian>
+ get_global_symbol_reader(unsigned int n) const
{
- unsigned int output_symndx;
- unsigned int next_offset;
- unsigned int reloc_count;
- unsigned int reloc_offset;
- };
+ gold_assert(this->type() == INCREMENTAL_INPUT_OBJECT
+ || this->type() == INCREMENTAL_INPUT_ARCHIVE_MEMBER);
+ unsigned int section_count = this->get_input_section_count();
+ const unsigned char* p = (this->inputs_->p_
+ + this->info_offset_
+ + this->object_info_size
+ + section_count * this->input_section_entry_size
+ + n * this->global_sym_entry_size);
+ return Incremental_global_symbol_reader<big_endian>(p);
+ }
- // Return info about the Nth global symbol -- for objects only.
- Global_symbol_info
- get_global_symbol_info(unsigned int n) const
+ // Return the signature of the Nth comdat group -- for objects only.
+ const char*
+ get_comdat_group_signature(unsigned int n) const
{
- Global_symbol_info info;
unsigned int section_count = this->get_input_section_count();
+ unsigned int symbol_count = this->get_global_symbol_count();
+ const unsigned char* p = (this->inputs_->p_
+ + this->info_offset_
+ + this->object_info_size
+ + section_count * this->input_section_entry_size
+ + symbol_count * this->global_sym_entry_size
+ + n * 4);
+ unsigned int name_offset = Swap32::readval(p);
+ return this->inputs_->get_string(name_offset);
+ }
+
+ // Return the output symbol index for the Nth global symbol -- for shared
+ // libraries only. Sets *IS_DEF to TRUE if the symbol is defined in this
+ // input file. Sets *IS_COPY to TRUE if the symbol was copied from this
+ // input file with a COPY relocation.
+ unsigned int
+ get_output_symbol_index(unsigned int n, bool* is_def, bool* is_copy)
+ {
+ gold_assert(this->type() == INCREMENTAL_INPUT_SHARED_LIBRARY);
const unsigned char* p = (this->inputs_->p_
+ this->info_offset_ + 8
- + section_count * input_section_entry_size
- + n * 16);
- info.output_symndx = Swap32::readval(p);
- info.next_offset = Swap32::readval(p + 4);
- info.reloc_count = Swap::readval(p + 8);
- info.reloc_offset = Swap::readval(p + 12);
- return info;
+ + n * 4);
+ unsigned int output_symndx = Swap32::readval(p);
+ unsigned int flags = output_symndx >> INCREMENTAL_SHLIB_SYM_FLAGS_SHIFT;
+ output_symndx &= ((1U << INCREMENTAL_SHLIB_SYM_FLAGS_SHIFT) - 1);
+ switch (flags)
+ {
+ case INCREMENTAL_SHLIB_SYM_DEF:
+ *is_def = true;
+ *is_copy = false;
+ break;
+ case INCREMENTAL_SHLIB_SYM_COPY:
+ *is_def = true;
+ *is_copy = true;
+ break;
+ default:
+ *is_def = false;
+ *is_copy = false;
+ }
+ return output_symndx;
}
private:
- // Size of an input section entry.
- static const unsigned int input_section_entry_size = 8 + 2 * size / 8;
// The reader instance for the containing section.
const Incremental_inputs_reader* inputs_;
- // The type of input file.
- Incremental_input_type type_;
+ // The flags, including the type of input file.
+ unsigned int flags_;
// Section offset to the input file entry.
unsigned int offset_;
// Section offset to the supplemental info for the input file.
unsigned int info_offset_;
};
+ // Return the offset of an input file entry given its index N.
+ unsigned int
+ input_file_offset(unsigned int n) const
+ {
+ gold_assert(n < this->input_file_count_);
+ return this->header_size + n * this->input_entry_size;
+ }
+
+ // Return the index of an input file entry given its OFFSET.
+ unsigned int
+ input_file_index(unsigned int offset) const
+ {
+ int n = ((offset - this->header_size) / this->input_entry_size);
+ gold_assert(input_file_offset(n) == offset);
+ return n;
+ }
+
// Return a reader for the Nth input file entry.
Incremental_input_entry_reader
input_file(unsigned int n) const
+ { return Incremental_input_entry_reader(this, this->input_file_offset(n)); }
+
+ // Return a reader for the input file entry at OFFSET.
+ Incremental_input_entry_reader
+ input_file_at_offset(unsigned int offset) const
{
- gold_assert(n < this->input_file_count_);
- Incremental_input_entry_reader input(this, 16 + n * 24);
- return input;
+ gold_assert(offset < (this->header_size
+ + this->input_file_count_ * this->input_entry_size));
+ return Incremental_input_entry_reader(this, offset);
+ }
+
+ // Return a reader for the global symbol info at OFFSET.
+ Incremental_global_symbol_reader<big_endian>
+ global_symbol_reader_at_offset(unsigned int offset) const
+ {
+ const unsigned char* p = this->p_ + offset;
+ return Incremental_global_symbol_reader<big_endian>(p);
}
private:
class Incremental_symtab_reader
{
public:
- Incremental_symtab_reader(const unsigned char* p) : p_(p)
+ Incremental_symtab_reader()
+ : p_(NULL), len_(0)
+ { }
+
+ Incremental_symtab_reader(const unsigned char* p, off_t len)
+ : p_(p), len_(len)
{ }
+ // Return the count of symbols in this section.
+ unsigned int
+ symbol_count() const
+ { return static_cast<unsigned int>(this->len_ / 4); }
+
// Return the list head for symbol table entry N.
- unsigned int get_list_head(unsigned int n) const
+ unsigned int
+ get_list_head(unsigned int n) const
{ return elfcpp::Swap<32, big_endian>::readval(this->p_ + 4 * n); }
private:
// Base address of the .gnu_incremental_relocs section.
const unsigned char* p_;
+ // Size of the section.
+ off_t len_;
};
// Reader class for the .gnu_incremental_relocs section.
// Size of each entry.
static const unsigned int reloc_size = 8 + 2 * field_size;
- Incremental_relocs_reader(const unsigned char* p) : p_(p)
+ Incremental_relocs_reader()
+ : p_(NULL), len_(0)
{ }
+ Incremental_relocs_reader(const unsigned char* p, off_t len)
+ : p_(p), len_(len)
+ { }
+
+ // Return the count of relocations in this section.
+ unsigned int
+ reloc_count() const
+ { return static_cast<unsigned int>(this->len_ / reloc_size); }
+
// Return the relocation type for relocation entry at offset OFF.
unsigned int
get_r_type(unsigned int off) const
- {
- return elfcpp::Swap<32, big_endian>::readval(this->p_ + off);
- }
+ { return elfcpp::Swap<32, big_endian>::readval(this->p_ + off); }
// Return the output section index for relocation entry at offset OFF.
unsigned int
get_r_shndx(unsigned int off) const
- {
- return elfcpp::Swap<32, big_endian>::readval(this->p_ + off + 4);
- }
+ { return elfcpp::Swap<32, big_endian>::readval(this->p_ + off + 4); }
// Return the output section offset for relocation entry at offset OFF.
Address
get_r_offset(unsigned int off) const
- {
- return elfcpp::Swap<size, big_endian>::readval(this->p_ + off + 8);
- }
+ { return elfcpp::Swap<size, big_endian>::readval(this->p_ + off + 8); }
// Return the addend for relocation entry at offset OFF.
Addend
+ this->field_size);
}
+ // Return a pointer to the relocation entry at offset OFF.
+ const unsigned char*
+ data(unsigned int off) const
+ { return this->p_ + off; }
+
private:
// Base address of the .gnu_incremental_relocs section.
const unsigned char* p_;
+ // Size of the section.
+ off_t len_;
};
// Reader class for the .gnu_incremental_got_plt section.
class Incremental_got_plt_reader
{
public:
+ Incremental_got_plt_reader()
+ : p_(NULL), got_count_(0), got_desc_p_(NULL), plt_desc_p_(NULL)
+ { }
+
Incremental_got_plt_reader(const unsigned char* p) : p_(p)
{
this->got_count_ = elfcpp::Swap<32, big_endian>::readval(p);
this->got_desc_p_ = p + 8 + ((this->got_count_ + 3) & ~3);
- this->plt_desc_p_ = this->got_desc_p_ + this->got_count_ * 4;
+ this->plt_desc_p_ = this->got_desc_p_ + this->got_count_ * 8;
}
// Return the GOT entry count.
return this->p_[8 + n];
}
- // Return the GOT descriptor for GOT entry N.
+ // Return the symbol index for GOT entry N.
+ unsigned int
+ get_got_symndx(unsigned int n)
+ {
+ return elfcpp::Swap<32, big_endian>::readval(this->got_desc_p_ + n * 8);
+ }
+
+ // Return the input file index for GOT entry N.
unsigned int
- get_got_desc(unsigned int n)
+ get_got_input_index(unsigned int n)
{
- return elfcpp::Swap<32, big_endian>::readval(this->got_desc_p_ + n * 4);
+ return elfcpp::Swap<32, big_endian>::readval(this->got_desc_p_ + n * 8 + 4);
}
// Return the PLT descriptor for PLT entry N.
const unsigned char* plt_desc_p_;
};
+// An object representing the ELF file we edit during an incremental build.
+// Similar to Object or Dynobj, but operates on Output_file and contains
+// methods to support incremental updating. This is the abstract parent class
+// implemented in Sized_incremental_binary<size, big_endian> for a specific
+// endianness and size.
+
+class Incremental_binary
+{
+ public:
+ Incremental_binary(Output_file* output, Target* /*target*/)
+ : input_args_map_(), library_map_(), script_map_(),
+ output_(output)
+ { }
+
+ virtual
+ ~Incremental_binary()
+ { }
+
+ // Check the .gnu_incremental_inputs section to see whether an incremental
+ // build is possible.
+ bool
+ check_inputs(const Command_line& cmdline,
+ Incremental_inputs* incremental_inputs)
+ { return this->do_check_inputs(cmdline, incremental_inputs); }
+
+ // Report an error.
+ void
+ error(const char* format, ...) const ATTRIBUTE_PRINTF_2;
+
+ // Proxy class for a sized Incremental_input_entry_reader.
+
+ class Input_reader
+ {
+ public:
+ Input_reader()
+ { }
+
+ Input_reader(const Input_reader&)
+ { }
+
+ virtual
+ ~Input_reader()
+ { }
+
+ const char*
+ filename() const
+ { return this->do_filename(); }
+
+ Timespec
+ get_mtime() const
+ { return this->do_get_mtime(); }
+
+ Incremental_input_type
+ type() const
+ { return this->do_type(); }
+
+ unsigned int
+ arg_serial() const
+ { return this->do_arg_serial(); }
+
+ unsigned int
+ get_unused_symbol_count() const
+ { return this->do_get_unused_symbol_count(); }
+
+ const char*
+ get_unused_symbol(unsigned int n) const
+ { return this->do_get_unused_symbol(n); }
+
+ protected:
+ virtual const char*
+ do_filename() const = 0;
+
+ virtual Timespec
+ do_get_mtime() const = 0;
+
+ virtual Incremental_input_type
+ do_type() const = 0;
+
+ virtual unsigned int
+ do_arg_serial() const = 0;
+
+ virtual unsigned int
+ do_get_unused_symbol_count() const = 0;
+
+ virtual const char*
+ do_get_unused_symbol(unsigned int n) const = 0;
+ };
+
+ // Return the number of input files.
+ unsigned int
+ input_file_count() const
+ { return this->do_input_file_count(); }
+
+ // Return an Input_reader for input file N.
+ const Input_reader*
+ get_input_reader(unsigned int n) const
+ { return this->do_get_input_reader(n); }
+
+ // Return TRUE if the input file N has changed since the last link.
+ bool
+ file_has_changed(unsigned int n) const
+ { return this->do_file_has_changed(n); }
+
+ // Return the Input_argument for input file N. Returns NULL if
+ // the Input_argument is not available.
+ const Input_argument*
+ get_input_argument(unsigned int n) const
+ {
+ const Input_reader* input_file = this->do_get_input_reader(n);
+ unsigned int arg_serial = input_file->arg_serial();
+ if (arg_serial == 0 || arg_serial > this->input_args_map_.size())
+ return NULL;
+ return this->input_args_map_[arg_serial - 1];
+ }
+
+ // Return an Incremental_library for the given input file.
+ Incremental_library*
+ get_library(unsigned int n) const
+ { return this->library_map_[n]; }
+
+ // Return a Script_info for the given input file.
+ Script_info*
+ get_script_info(unsigned int n) const
+ { return this->script_map_[n]; }
+
+ // Initialize the layout of the output file based on the existing
+ // output file.
+ void
+ init_layout(Layout* layout)
+ { this->do_init_layout(layout); }
+
+ // Mark regions of the input file that must be kept unchanged.
+ void
+ reserve_layout(unsigned int input_file_index)
+ { this->do_reserve_layout(input_file_index); }
+
+ // Process the GOT and PLT entries from the existing output file.
+ void
+ process_got_plt(Symbol_table* symtab, Layout* layout)
+ { this->do_process_got_plt(symtab, layout); }
+
+ // Emit COPY relocations from the existing output file.
+ void
+ emit_copy_relocs(Symbol_table* symtab)
+ { this->do_emit_copy_relocs(symtab); }
+
+ // Apply incremental relocations for symbols whose values have changed.
+ void
+ apply_incremental_relocs(const Symbol_table* symtab, Layout* layout,
+ Output_file* of)
+ { this->do_apply_incremental_relocs(symtab, layout, of); }
+
+ // Functions and types for the elfcpp::Elf_file interface. This
+ // permit us to use Incremental_binary as the File template parameter for
+ // elfcpp::Elf_file.
+
+ // The View class is returned by view. It must support a single
+ // method, data(). This is trivial, because Output_file::get_output_view
+ // does what we need.
+ class View
+ {
+ public:
+ View(const unsigned char* p)
+ : p_(p)
+ { }
+
+ const unsigned char*
+ data() const
+ { return this->p_; }
+
+ private:
+ const unsigned char* p_;
+ };
+
+ // Return a View.
+ View
+ view(off_t file_offset, section_size_type data_size)
+ { return View(this->output_->get_input_view(file_offset, data_size)); }
+
+ // A location in the file.
+ struct Location
+ {
+ off_t file_offset;
+ off_t data_size;
+
+ Location(off_t fo, section_size_type ds)
+ : file_offset(fo), data_size(ds)
+ { }
+
+ Location()
+ : file_offset(0), data_size(0)
+ { }
+ };
+
+ // Get a View given a Location.
+ View
+ view(Location loc)
+ { return View(this->view(loc.file_offset, loc.data_size)); }
+
+ // Return the Output_file.
+ Output_file*
+ output_file()
+ { return this->output_; }
+
+ protected:
+ // Check the .gnu_incremental_inputs section to see whether an incremental
+ // build is possible.
+ virtual bool
+ do_check_inputs(const Command_line& cmdline,
+ Incremental_inputs* incremental_inputs) = 0;
+
+ // Return TRUE if input file N has changed since the last incremental link.
+ virtual bool
+ do_file_has_changed(unsigned int n) const = 0;
+
+ // Initialize the layout of the output file based on the existing
+ // output file.
+ virtual void
+ do_init_layout(Layout* layout) = 0;
+
+ // Mark regions of the input file that must be kept unchanged.
+ virtual void
+ do_reserve_layout(unsigned int input_file_index) = 0;
+
+ // Process the GOT and PLT entries from the existing output file.
+ virtual void
+ do_process_got_plt(Symbol_table* symtab, Layout* layout) = 0;
+
+ // Emit COPY relocations from the existing output file.
+ virtual void
+ do_emit_copy_relocs(Symbol_table* symtab) = 0;
+
+ // Apply incremental relocations for symbols whose values have changed.
+ virtual void
+ do_apply_incremental_relocs(const Symbol_table*, Layout*, Output_file*) = 0;
+
+ virtual unsigned int
+ do_input_file_count() const = 0;
+
+ virtual const Input_reader*
+ do_get_input_reader(unsigned int) const = 0;
+
+ // Map from input file index to Input_argument.
+ std::vector<const Input_argument*> input_args_map_;
+ // Map from an input file index to an Incremental_library.
+ std::vector<Incremental_library*> library_map_;
+ // Map from an input file index to a Script_info.
+ std::vector<Script_info*> script_map_;
+
+ private:
+ // Edited output file object.
+ Output_file* output_;
+};
+
+template<int size, bool big_endian>
+class Sized_relobj_incr;
+
+template<int size, bool big_endian>
+class Sized_incremental_binary : public Incremental_binary
+{
+ public:
+ Sized_incremental_binary(Output_file* output,
+ const elfcpp::Ehdr<size, big_endian>& ehdr,
+ Target* target)
+ : Incremental_binary(output, target), elf_file_(this, ehdr),
+ input_objects_(), section_map_(), symbol_map_(), copy_relocs_(),
+ main_symtab_loc_(), main_strtab_loc_(), has_incremental_info_(false),
+ inputs_reader_(), symtab_reader_(), relocs_reader_(), got_plt_reader_(),
+ input_entry_readers_()
+ { this->setup_readers(); }
+
+ // Returns TRUE if the file contains incremental info.
+ bool
+ has_incremental_info() const
+ { return this->has_incremental_info_; }
+
+ // Record a pointer to the object for input file N.
+ void
+ set_input_object(unsigned int n,
+ Sized_relobj_incr<size, big_endian>* obj)
+ { this->input_objects_[n] = obj; }
+
+ // Return a pointer to the object for input file N.
+ Sized_relobj_incr<size, big_endian>*
+ input_object(unsigned int n) const
+ {
+ gold_assert(n < this->input_objects_.size());
+ return this->input_objects_[n];
+ }
+
+ // Return the Output_section for section index SHNDX.
+ Output_section*
+ output_section(unsigned int shndx)
+ { return this->section_map_[shndx]; }
+
+ // Map a symbol table entry from the base file to the output symbol table.
+ // SYMNDX is relative to the first forced-local or global symbol in the
+ // input file symbol table.
+ void
+ add_global_symbol(unsigned int symndx, Symbol* gsym)
+ { this->symbol_map_[symndx] = gsym; }
+
+ // Map a symbol table entry from the base file to the output symbol table.
+ // SYMNDX is relative to the first forced-local or global symbol in the
+ // input file symbol table.
+ Symbol*
+ global_symbol(unsigned int symndx) const
+ { return this->symbol_map_[symndx]; }
+
+ // Add a COPY relocation for a global symbol.
+ void
+ add_copy_reloc(Symbol* gsym, Output_section* os, off_t offset)
+ { this->copy_relocs_.push_back(Copy_reloc(gsym, os, offset)); }
+
+ // Readers for the incremental info sections.
+
+ const Incremental_inputs_reader<size, big_endian>&
+ inputs_reader() const
+ { return this->inputs_reader_; }
+
+ const Incremental_symtab_reader<big_endian>&
+ symtab_reader() const
+ { return this->symtab_reader_; }
+
+ const Incremental_relocs_reader<size, big_endian>&
+ relocs_reader() const
+ { return this->relocs_reader_; }
+
+ const Incremental_got_plt_reader<big_endian>&
+ got_plt_reader() const
+ { return this->got_plt_reader_; }
+
+ void
+ get_symtab_view(View* symtab_view, unsigned int* sym_count,
+ elfcpp::Elf_strtab* strtab);
+
+ protected:
+ typedef Incremental_inputs_reader<size, big_endian> Inputs_reader;
+ typedef typename Inputs_reader::Incremental_input_entry_reader
+ Input_entry_reader;
+
+ virtual bool
+ do_check_inputs(const Command_line& cmdline,
+ Incremental_inputs* incremental_inputs);
+
+ // Return TRUE if input file N has changed since the last incremental link.
+ virtual bool
+ do_file_has_changed(unsigned int n) const;
+
+ // Initialize the layout of the output file based on the existing
+ // output file.
+ virtual void
+ do_init_layout(Layout* layout);
+
+ // Mark regions of the input file that must be kept unchanged.
+ virtual void
+ do_reserve_layout(unsigned int input_file_index);
+
+ // Process the GOT and PLT entries from the existing output file.
+ virtual void
+ do_process_got_plt(Symbol_table* symtab, Layout* layout);
+
+ // Emit COPY relocations from the existing output file.
+ virtual void
+ do_emit_copy_relocs(Symbol_table* symtab);
+
+ // Apply incremental relocations for symbols whose values have changed.
+ virtual void
+ do_apply_incremental_relocs(const Symbol_table* symtab, Layout* layout,
+ Output_file* of);
+
+ // Proxy class for a sized Incremental_input_entry_reader.
+
+ class Sized_input_reader : public Input_reader
+ {
+ public:
+ Sized_input_reader(Input_entry_reader r)
+ : Input_reader(), reader_(r)
+ { }
+
+ Sized_input_reader(const Sized_input_reader& r)
+ : Input_reader(), reader_(r.reader_)
+ { }
+
+ virtual
+ ~Sized_input_reader()
+ { }
+
+ private:
+ const char*
+ do_filename() const
+ { return this->reader_.filename(); }
+
+ Timespec
+ do_get_mtime() const
+ { return this->reader_.get_mtime(); }
+
+ Incremental_input_type
+ do_type() const
+ { return this->reader_.type(); }
+
+ unsigned int
+ do_arg_serial() const
+ { return this->reader_.arg_serial(); }
+
+ unsigned int
+ do_get_unused_symbol_count() const
+ { return this->reader_.get_unused_symbol_count(); }
+
+ const char*
+ do_get_unused_symbol(unsigned int n) const
+ { return this->reader_.get_unused_symbol(n); }
+
+ Input_entry_reader reader_;
+ };
+
+ virtual unsigned int
+ do_input_file_count() const
+ { return this->inputs_reader_.input_file_count(); }
+
+ virtual const Input_reader*
+ do_get_input_reader(unsigned int n) const
+ {
+ gold_assert(n < this->input_entry_readers_.size());
+ return &this->input_entry_readers_[n];
+ }
+
+ private:
+ // List of symbols that need COPY relocations.
+ struct Copy_reloc
+ {
+ Copy_reloc(Symbol* sym, Output_section* os, off_t off)
+ : symbol(sym), output_section(os), offset(off)
+ { }
+
+ // The global symbol to copy.
+ Symbol* symbol;
+ // The output section into which the symbol was copied.
+ Output_section* output_section;
+ // The offset within that output section.
+ off_t offset;
+ };
+ typedef std::vector<Copy_reloc> Copy_relocs;
+
+ bool
+ find_incremental_inputs_sections(unsigned int* p_inputs_shndx,
+ unsigned int* p_symtab_shndx,
+ unsigned int* p_relocs_shndx,
+ unsigned int* p_got_plt_shndx,
+ unsigned int* p_strtab_shndx);
+
+ void
+ setup_readers();
+
+ // Output as an ELF file.
+ elfcpp::Elf_file<size, big_endian, Incremental_binary> elf_file_;
+
+ // Vector of pointers to the input objects for the unchanged files.
+ // For replaced files, the corresponding pointer is NULL.
+ std::vector<Sized_relobj_incr<size, big_endian>*> input_objects_;
+
+ // Map section index to an Output_section in the updated layout.
+ std::vector<Output_section*> section_map_;
+
+ // Map global symbols from the input file to the symbol table.
+ std::vector<Symbol*> symbol_map_;
+
+ // List of symbols that need COPY relocations.
+ Copy_relocs copy_relocs_;
+
+ // Locations of the main symbol table and symbol string table.
+ Location main_symtab_loc_;
+ Location main_strtab_loc_;
+
+ // Readers for the incremental info sections.
+ bool has_incremental_info_;
+ Incremental_inputs_reader<size, big_endian> inputs_reader_;
+ Incremental_symtab_reader<big_endian> symtab_reader_;
+ Incremental_relocs_reader<size, big_endian> relocs_reader_;
+ Incremental_got_plt_reader<big_endian> got_plt_reader_;
+ std::vector<Sized_input_reader> input_entry_readers_;
+};
+
+// An incremental Relobj. This class represents a relocatable object
+// that has not changed since the last incremental link, and whose contents
+// can be used directly from the base file.
+
+template<int size, bool big_endian>
+class Sized_relobj_incr : public Sized_relobj<size, big_endian>
+{
+ public:
+ typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
+ typedef typename Sized_relobj<size, big_endian>::Symbols Symbols;
+
+ Sized_relobj_incr(const std::string& name,
+ Sized_incremental_binary<size, big_endian>* ibase,
+ unsigned int input_file_index);
+
+ private:
+ // For convenience.
+ typedef Sized_relobj_incr<size, big_endian> This;
+ static const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
+
+ typedef typename Sized_relobj<size, big_endian>::Output_sections
+ Output_sections;
+ typedef Incremental_inputs_reader<size, big_endian> Inputs_reader;
+ typedef typename Inputs_reader::Incremental_input_entry_reader
+ Input_entry_reader;
+
+ // A local symbol.
+ struct Local_symbol
+ {
+ Local_symbol(const char* name_, Address value_, unsigned int size_,
+ unsigned int shndx_, unsigned int type_,
+ bool needs_dynsym_entry_)
+ : st_value(value_), name(name_), st_size(size_), st_shndx(shndx_),
+ st_type(type_), output_dynsym_index(0),
+ needs_dynsym_entry(needs_dynsym_entry_)
+ { }
+ // The symbol value.
+ Address st_value;
+ // The symbol name. This points to the stringpool entry.
+ const char* name;
+ // The symbol size.
+ unsigned int st_size;
+ // The output section index.
+ unsigned int st_shndx : 28;
+ // The symbol type.
+ unsigned int st_type : 4;
+ // The index of the symbol in the output dynamic symbol table.
+ unsigned int output_dynsym_index : 31;
+ // TRUE if the symbol needs to appear in the dynamic symbol table.
+ unsigned int needs_dynsym_entry : 1;
+ };
+
+ // Return TRUE if this is an incremental (unchanged) input file.
+ bool
+ do_is_incremental() const
+ { return true; }
+
+ // Return the last modified time of the file.
+ Timespec
+ do_get_mtime()
+ { return this->input_reader_.get_mtime(); }
+
+ // Read the symbols.
+ void
+ do_read_symbols(Read_symbols_data*);
+
+ // Lay out the input sections.
+ void
+ do_layout(Symbol_table*, Layout*, Read_symbols_data*);
+
+ // Layout sections whose layout was deferred while waiting for
+ // input files from a plugin.
+ void
+ do_layout_deferred_sections(Layout*);
+
+ // Add the symbols to the symbol table.
+ void
+ do_add_symbols(Symbol_table*, Read_symbols_data*, Layout*);
+
+ Archive::Should_include
+ do_should_include_member(Symbol_table* symtab, Layout*, Read_symbols_data*,
+ std::string* why);
+
+ // Iterate over global symbols, calling a visitor class V for each.
+ void
+ do_for_all_global_symbols(Read_symbols_data* sd,
+ Library_base::Symbol_visitor_base* v);
+
+ // Get the size of a section.
+ uint64_t
+ do_section_size(unsigned int shndx);
+
+ // Get the name of a section.
+ std::string
+ do_section_name(unsigned int shndx) const;
+
+ // Return a view of the contents of a section.
+ const unsigned char*
+ do_section_contents(unsigned int shndx, section_size_type* plen,
+ bool cache);
+
+ // Return section flags.
+ uint64_t
+ do_section_flags(unsigned int shndx);
+
+ // Return section entsize.
+ uint64_t
+ do_section_entsize(unsigned int shndx);
+
+ // Return section address.
+ uint64_t
+ do_section_address(unsigned int shndx);
+
+ // Return section type.
+ unsigned int
+ do_section_type(unsigned int shndx);
+
+ // Return the section link field.
+ unsigned int
+ do_section_link(unsigned int shndx);
+
+ // Return the section link field.
+ unsigned int
+ do_section_info(unsigned int shndx);
+
+ // Return the section alignment.
+ uint64_t
+ do_section_addralign(unsigned int shndx);
+
+ // Return the Xindex structure to use.
+ Xindex*
+ do_initialize_xindex();
+
+ // Get symbol counts.
+ void
+ do_get_global_symbol_counts(const Symbol_table*, size_t*, size_t*) const;
+
+ // Get global symbols.
+ const Symbols*
+ do_get_global_symbols() const
+ { return &this->symbols_; }
+
+ // Return the value of a local symbol.
+ uint64_t
+ do_local_symbol_value(unsigned int, uint64_t) const
+ { gold_unreachable(); }
+
+ unsigned int
+ do_local_plt_offset(unsigned int) const
+ { gold_unreachable(); }
+
+ bool
+ do_local_is_tls(unsigned int) const
+ { gold_unreachable(); }
+
+ // Return the number of local symbols.
+ unsigned int
+ do_local_symbol_count() const
+ { return this->local_symbol_count_; }
+
+ // Return the number of local symbols in the output symbol table.
+ unsigned int
+ do_output_local_symbol_count() const
+ { return this->local_symbol_count_; }
+
+ // Return the file offset for local symbols in the output symbol table.
+ off_t
+ do_local_symbol_offset() const
+ { return this->local_symbol_offset_; }
+
+ // Read the relocs.
+ void
+ do_read_relocs(Read_relocs_data*);
+
+ // Process the relocs to find list of referenced sections. Used only
+ // during garbage collection.
+ void
+ do_gc_process_relocs(Symbol_table*, Layout*, Read_relocs_data*);
+
+ // Scan the relocs and adjust the symbol table.
+ void
+ do_scan_relocs(Symbol_table*, Layout*, Read_relocs_data*);
+
+ // Count the local symbols.
+ void
+ do_count_local_symbols(Stringpool_template<char>*,
+ Stringpool_template<char>*);
+
+ // Finalize the local symbols.
+ unsigned int
+ do_finalize_local_symbols(unsigned int, off_t, Symbol_table*);
+
+ // Set the offset where local dynamic symbol information will be stored.
+ unsigned int
+ do_set_local_dynsym_indexes(unsigned int);
+
+ // Set the offset where local dynamic symbol information will be stored.
+ unsigned int
+ do_set_local_dynsym_offset(off_t);
+
+ // Relocate the input sections and write out the local symbols.
+ void
+ do_relocate(const Symbol_table* symtab, const Layout*, Output_file* of);
+
+ // Set the offset of a section.
+ void
+ do_set_section_offset(unsigned int shndx, uint64_t off);
+
+ // The Incremental_binary base file.
+ Sized_incremental_binary<size, big_endian>* ibase_;
+ // The index of the object in the input file list.
+ unsigned int input_file_index_;
+ // The reader for the input file.
+ Input_entry_reader input_reader_;
+ // The number of local symbols.
+ unsigned int local_symbol_count_;
+ // The number of local symbols which go into the output file's dynamic
+ // symbol table.
+ unsigned int output_local_dynsym_count_;
+ // This starting symbol index in the output symbol table.
+ unsigned int local_symbol_index_;
+ // The file offset for local symbols in the output symbol table.
+ unsigned int local_symbol_offset_;
+ // The file offset for local symbols in the output symbol table.
+ unsigned int local_dynsym_offset_;
+ // The entries in the symbol table for the external symbols.
+ Symbols symbols_;
+ // Number of symbols defined in object file itself.
+ size_t defined_count_;
+ // The offset of the first incremental relocation for this object.
+ unsigned int incr_reloc_offset_;
+ // The number of incremental relocations for this object.
+ unsigned int incr_reloc_count_;
+ // The index of the first incremental relocation for this object in the
+ // updated output file.
+ unsigned int incr_reloc_output_index_;
+ // A copy of the incremental relocations from this object.
+ unsigned char* incr_relocs_;
+ // The local symbols.
+ std::vector<Local_symbol> local_symbols_;
+};
+
+// An incremental Dynobj. This class represents a shared object that has
+// not changed since the last incremental link, and whose contents can be
+// used directly from the base file.
+
+template<int size, bool big_endian>
+class Sized_incr_dynobj : public Dynobj
+{
+ public:
+ typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
+
+ static const Address invalid_address = static_cast<Address>(0) - 1;
+
+ Sized_incr_dynobj(const std::string& name,
+ Sized_incremental_binary<size, big_endian>* ibase,
+ unsigned int input_file_index);
+
+ private:
+ typedef Incremental_inputs_reader<size, big_endian> Inputs_reader;
+ typedef typename Inputs_reader::Incremental_input_entry_reader
+ Input_entry_reader;
+
+ // Return TRUE if this is an incremental (unchanged) input file.
+ bool
+ do_is_incremental() const
+ { return true; }
+
+ // Return the last modified time of the file.
+ Timespec
+ do_get_mtime()
+ { return this->input_reader_.get_mtime(); }
+
+ // Read the symbols.
+ void
+ do_read_symbols(Read_symbols_data*);
+
+ // Lay out the input sections.
+ void
+ do_layout(Symbol_table*, Layout*, Read_symbols_data*);
+
+ // Add the symbols to the symbol table.
+ void
+ do_add_symbols(Symbol_table*, Read_symbols_data*, Layout*);
+
+ Archive::Should_include
+ do_should_include_member(Symbol_table* symtab, Layout*, Read_symbols_data*,
+ std::string* why);
+
+ // Iterate over global symbols, calling a visitor class V for each.
+ void
+ do_for_all_global_symbols(Read_symbols_data* sd,
+ Library_base::Symbol_visitor_base* v);
+
+ // Iterate over local symbols, calling a visitor class V for each GOT offset
+ // associated with a local symbol.
+ void
+ do_for_all_local_got_entries(Got_offset_list::Visitor* v) const;
+
+ // Get the size of a section.
+ uint64_t
+ do_section_size(unsigned int shndx);
+
+ // Get the name of a section.
+ std::string
+ do_section_name(unsigned int shndx) const;
+
+ // Return a view of the contents of a section.
+ const unsigned char*
+ do_section_contents(unsigned int shndx, section_size_type* plen,
+ bool cache);
+
+ // Return section flags.
+ uint64_t
+ do_section_flags(unsigned int shndx);
+
+ // Return section entsize.
+ uint64_t
+ do_section_entsize(unsigned int shndx);
+
+ // Return section address.
+ uint64_t
+ do_section_address(unsigned int shndx);
+
+ // Return section type.
+ unsigned int
+ do_section_type(unsigned int shndx);
+
+ // Return the section link field.
+ unsigned int
+ do_section_link(unsigned int shndx);
+
+ // Return the section link field.
+ unsigned int
+ do_section_info(unsigned int shndx);
+
+ // Return the section alignment.
+ uint64_t
+ do_section_addralign(unsigned int shndx);
+
+ // Return the Xindex structure to use.
+ Xindex*
+ do_initialize_xindex();
+
+ // Get symbol counts.
+ void
+ do_get_global_symbol_counts(const Symbol_table*, size_t*, size_t*) const;
+
+ // Get global symbols.
+ const Symbols*
+ do_get_global_symbols() const
+ { return &this->symbols_; }
+
+ // The Incremental_binary base file.
+ Sized_incremental_binary<size, big_endian>* ibase_;
+ // The index of the object in the input file list.
+ unsigned int input_file_index_;
+ // The reader for the input file.
+ Input_entry_reader input_reader_;
+ // The entries in the symbol table for the external symbols.
+ Symbols symbols_;
+ // Number of symbols defined in object file itself.
+ size_t defined_count_;
+};
+
+// Allocate an incremental object of the appropriate size and endianness.
+extern Object*
+make_sized_incremental_object(
+ Incremental_binary* base,
+ unsigned int input_file_index,
+ Incremental_input_type input_type,
+ const Incremental_binary::Input_reader* input_reader);
+
+// This class represents an Archive library (or --start-lib/--end-lib group)
+// that has not changed since the last incremental link. Its contents come
+// from the incremental inputs entry in the base file.
+
+class Incremental_library : public Library_base
+{
+ public:
+ Incremental_library(const char* filename, unsigned int input_file_index,
+ const Incremental_binary::Input_reader* input_reader)
+ : Library_base(NULL), filename_(filename),
+ input_file_index_(input_file_index), input_reader_(input_reader),
+ unused_symbols_(), is_reported_(false)
+ { }
+
+ // Return the input file index.
+ unsigned int
+ input_file_index() const
+ { return this->input_file_index_; }
+
+ // Return the serial number of the input file.
+ unsigned int
+ arg_serial() const
+ { return this->input_reader_->arg_serial(); }
+
+ // Copy the unused symbols from the incremental input info.
+ // We need to do this because we may be overwriting the incremental
+ // input info in the base file before we write the new incremental
+ // info.
+ void
+ copy_unused_symbols();
+
+ // Return FALSE on the first call to indicate that the library needs
+ // to be recorded; return TRUE subsequently.
+ bool
+ is_reported()
+ {
+ bool was_reported = this->is_reported_;
+ is_reported_ = true;
+ return was_reported;
+ }
+
+ private:
+ typedef std::vector<std::string> Symbol_list;
+
+ // The file name.
+ const std::string&
+ do_filename() const
+ { return this->filename_; }
+
+ // Return the modification time of the archive file.
+ Timespec
+ do_get_mtime()
+ { return this->input_reader_->get_mtime(); }
+
+ // Iterator for unused global symbols in the library.
+ void
+ do_for_all_unused_symbols(Symbol_visitor_base* v) const;
+
+ // The name of the library.
+ std::string filename_;
+ // The input file index of this library.
+ unsigned int input_file_index_;
+ // A reader for the incremental input information.
+ const Incremental_binary::Input_reader* input_reader_;
+ // List of unused symbols defined in this library.
+ Symbol_list unused_symbols_;
+ // TRUE when this library has been reported to the new incremental info.
+ bool is_reported_;
+};
+
} // End namespace gold.
#endif // !defined(GOLD_INCREMENTAL_H)