#include "elfcpp.h"
#include "options.h"
+#include "mapfile.h"
#include "fileread.h"
#include "readsyms.h"
#include "symtab.h"
if (xname == "/")
{
const unsigned char* p = this->get_view(off + sizeof(Archive_header),
- extended_size, true);
+ extended_size, false, true);
const char* px = reinterpret_cast<const char*>(p);
this->extended_names_.assign(px, extended_size);
}
Archive::read_armap(off_t start, section_size_type size)
{
// Read in the entire armap.
- const unsigned char* p = this->get_view(start, size, false);
+ const unsigned char* p = this->get_view(start, size, true, false);
// Numbers in the armap are always big-endian.
const elfcpp::Elf_Word* pword = reinterpret_cast<const elfcpp::Elf_Word*>(p);
Archive::read_header(off_t off, bool cache, std::string* pname,
off_t* nested_off)
{
- const unsigned char* p = this->get_view(off, sizeof(Archive_header), cache);
+ const unsigned char* p = this->get_view(off, sizeof(Archive_header), true,
+ cache);
const Archive_header* hdr = reinterpret_cast<const Archive_header*>(p);
return this->interpret_header(hdr, off, pname, nested_off);
}
off_t
Archive::interpret_header(const Archive_header* hdr, off_t off,
- std::string* pname, off_t* nested_off)
+ std::string* pname, off_t* nested_off) const
{
if (memcmp(hdr->ar_fmag, arfmag, sizeof arfmag) != 0)
{
void
Archive::add_symbols(Symbol_table* symtab, Layout* layout,
- Input_objects* input_objects)
+ Input_objects* input_objects, Mapfile* mapfile)
{
if (this->input_file_->options().whole_archive())
- return this->include_all_members(symtab, layout, input_objects);
+ return this->include_all_members(symtab, layout, input_objects,
+ mapfile);
+
+ input_objects->archive_start(this);
const size_t armap_size = this->armap_.size();
+ this->armap_[i].name_offset);
Symbol* sym = symtab->lookup(sym_name);
if (sym == NULL)
- continue;
+ {
+ // Check whether the symbol was named in a -u option.
+ if (!parameters->options().is_undefined(sym_name))
+ continue;
+ }
else if (!sym->is_undefined())
{
this->armap_checked_[i] = true;
last_seen_offset = this->armap_[i].file_offset;
this->seen_offsets_.insert(last_seen_offset);
this->armap_checked_[i] = true;
+
+ std::string why;
+ if (sym == NULL)
+ {
+ why = "-u ";
+ why += sym_name;
+ }
this->include_member(symtab, layout, input_objects,
- last_seen_offset);
+ last_seen_offset, mapfile, sym, why.c_str());
+
added_new_object = true;
}
}
while (added_new_object);
+
+ input_objects->archive_stop(this);
}
-// Include all the archive members in the link. This is for --whole-archive.
+// An archive member iterator.
+
+class Archive::const_iterator
+{
+ public:
+ // The header of an archive member. This is what this iterator
+ // points to.
+ struct Header
+ {
+ // The name of the member.
+ std::string name;
+ // The file offset of the member.
+ off_t off;
+ // The file offset of a nested archive member.
+ off_t nested_off;
+ // The size of the member.
+ off_t size;
+ };
+
+ const_iterator(const Archive* archive, off_t off)
+ : archive_(archive), off_(off)
+ { this->read_next_header(); }
+
+ const Header&
+ operator*() const
+ { return this->header_; }
+
+ const Header*
+ operator->() const
+ { return &this->header_; }
+
+ const_iterator&
+ operator++()
+ {
+ if (this->off_ == this->archive_->file().filesize())
+ return *this;
+ this->off_ += sizeof(Archive_header);
+ if (!this->archive_->is_thin_archive())
+ this->off_ += this->header_.size;
+ if ((this->off_ & 1) != 0)
+ ++this->off_;
+ this->read_next_header();
+ return *this;
+ }
+
+ const_iterator
+ operator++(int)
+ {
+ const_iterator ret = *this;
+ ++*this;
+ return ret;
+ }
+
+ bool
+ operator==(const const_iterator p) const
+ { return this->off_ == p->off; }
+
+ bool
+ operator!=(const const_iterator p) const
+ { return this->off_ != p->off; }
+
+ private:
+ void
+ read_next_header();
+
+ // The underlying archive.
+ const Archive* archive_;
+ // The current offset in the file.
+ off_t off_;
+ // The current archive header.
+ Header header_;
+};
+
+// Read the next archive header.
void
-Archive::include_all_members(Symbol_table* symtab, Layout* layout,
- Input_objects* input_objects)
+Archive::const_iterator::read_next_header()
{
- off_t off = sarmag;
- off_t filesize = this->input_file_->file().filesize();
+ off_t filesize = this->archive_->file().filesize();
while (true)
{
- if (filesize - off < static_cast<off_t>(sizeof(Archive_header)))
- {
- if (filesize != off)
- gold_error(_("%s: short archive header at %zu"),
- this->name().c_str(), static_cast<size_t>(off));
- break;
- }
+ if (filesize - this->off_ < static_cast<off_t>(sizeof(Archive_header)))
+ {
+ if (filesize != this->off_)
+ {
+ gold_error(_("%s: short archive header at %zu"),
+ this->archive_->filename().c_str(),
+ static_cast<size_t>(this->off_));
+ this->off_ = filesize;
+ }
+ this->header_.off = filesize;
+ return;
+ }
- unsigned char hdr_buf[sizeof(Archive_header)];
- this->input_file_->file().read(off, sizeof(Archive_header), hdr_buf);
+ unsigned char buf[sizeof(Archive_header)];
+ this->archive_->file().read(this->off_, sizeof(Archive_header), buf);
- const Archive_header* hdr =
- reinterpret_cast<const Archive_header*>(hdr_buf);
- std::string name;
- off_t size = this->interpret_header(hdr, off, &name, NULL);
- if (name.empty())
- {
- // Symbol table.
- }
- else if (name == "/")
- {
- // Extended name table.
- }
- else
- this->include_member(symtab, layout, input_objects, off);
-
- off += sizeof(Archive_header);
- if (!this->is_thin_archive_)
- off += size;
- if ((off & 1) != 0)
- ++off;
+ const Archive_header* hdr = reinterpret_cast<const Archive_header*>(buf);
+ this->header_.size =
+ this->archive_->interpret_header(hdr, this->off_, &this->header_.name,
+ &this->header_.nested_off);
+ this->header_.off = this->off_;
+
+ // Skip special members.
+ if (!this->header_.name.empty() && this->header_.name != "/")
+ return;
+
+ this->off_ += sizeof(Archive_header) + this->header_.size;
+ if ((this->off_ & 1) != 0)
+ ++this->off_;
}
}
+// Initial iterator.
+
+Archive::const_iterator
+Archive::begin() const
+{
+ return Archive::const_iterator(this, sarmag);
+}
+
+// Final iterator.
+
+Archive::const_iterator
+Archive::end() const
+{
+ return Archive::const_iterator(this, this->input_file_->file().filesize());
+}
+
+// Include all the archive members in the link. This is for --whole-archive.
+
+void
+Archive::include_all_members(Symbol_table* symtab, Layout* layout,
+ Input_objects* input_objects, Mapfile* mapfile)
+{
+ input_objects->archive_start(this);
+
+ for (Archive::const_iterator p = this->begin();
+ p != this->end();
+ ++p)
+ this->include_member(symtab, layout, input_objects, p->off,
+ mapfile, NULL, "--whole-archive");
+
+ input_objects->archive_stop(this);
+}
+
+// Return the number of members in the archive. This is only used for
+// reports.
+
+size_t
+Archive::count_members() const
+{
+ size_t ret = 0;
+ for (Archive::const_iterator p = this->begin();
+ p != this->end();
+ ++p)
+ ++ret;
+ return ret;
+}
+
// Include an archive member in the link. OFF is the file offset of
-// the member header.
+// the member header. WHY is the reason we are including this member.
void
Archive::include_member(Symbol_table* symtab, Layout* layout,
- Input_objects* input_objects, off_t off)
+ Input_objects* input_objects, off_t off,
+ Mapfile* mapfile, Symbol* sym, const char* why)
{
std::string n;
off_t nested_off;
this->read_header(off, false, &n, &nested_off);
+ if (mapfile != NULL)
+ mapfile->report_include_archive_member(this, n, sym, why);
+
Input_file* input_file;
off_t memoff;
this->nested_archives_.insert(std::make_pair(n, arch));
gold_assert(ins.second);
}
- arch->include_member(symtab, layout, input_objects, nested_off);
+ arch->include_member(symtab, layout, input_objects, nested_off,
+ NULL, NULL, NULL);
return;
}
// This is an external member of a thin archive. Open the
memoff = 0;
}
- // Read enough of the file to pick up the entire ELF header.
- unsigned char ehdr_buf[elfcpp::Elf_sizes<64>::ehdr_size];
-
off_t filesize = input_file->file().filesize();
int read_size = elfcpp::Elf_sizes<64>::ehdr_size;
if (filesize - memoff < read_size)
return;
}
- input_file->file().read(memoff, read_size, ehdr_buf);
+ const unsigned char* ehdr = input_file->file().get_view(memoff, 0, read_size,
+ true, false);
static unsigned char elfmagic[4] =
{
elfcpp::ELFMAG0, elfcpp::ELFMAG1,
elfcpp::ELFMAG2, elfcpp::ELFMAG3
};
- if (memcmp(ehdr_buf, elfmagic, 4) != 0)
+ if (memcmp(ehdr, elfmagic, 4) != 0)
{
gold_error(_("%s: member at %zu is not an ELF object"),
this->name().c_str(), static_cast<size_t>(off));
Object* obj = make_elf_object((std::string(this->input_file_->filename())
+ "(" + n + ")"),
- input_file, memoff, ehdr_buf,
- read_size);
+ input_file, memoff, ehdr, read_size);
if (input_objects->add_object(obj))
{
Add_archive_symbols::run(Workqueue*)
{
this->archive_->add_symbols(this->symtab_, this->layout_,
- this->input_objects_);
+ this->input_objects_, this->mapfile_);
this->archive_->unlock_nested_archives();
this->archive_->release();
+ this->archive_->clear_uncached_views();
if (this->input_group_ != NULL)
this->input_group_->add_archive(this->archive_);
projects / binutils-gdb.git / blobdiff