// readsyms.cc -- read input file symbols for gold
+// Copyright 2006, 2007 Free Software Foundation, Inc.
+// Written by Ian Lance Taylor <iant@google.com>.
+
+// This file is part of gold.
+
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+// MA 02110-1301, USA.
+
#include "gold.h"
#include <cstring>
#include "elfcpp.h"
#include "options.h"
#include "dirsearch.h"
+#include "symtab.h"
#include "object.h"
#include "archive.h"
+#include "script.h"
#include "readsyms.h"
namespace gold
Task::Is_runnable_type
Read_symbols::is_runnable(Workqueue*)
{
- if (this->input_.is_file()
- && this->input_.file().is_lib()
+ if (this->input_argument_->is_file()
+ && this->input_argument_->file().is_lib()
&& this->dirpath_.token().is_blocked())
return IS_BLOCKED;
void
Read_symbols::run(Workqueue* workqueue)
{
- if (this->input_.is_group())
+ if (this->input_argument_->is_group())
{
- assert(this->input_group_ == NULL);
+ gold_assert(this->input_group_ == NULL);
this->do_group(workqueue);
return;
}
- Input_file* input_file = new Input_file(this->input_.file());
+ Input_file* input_file = new Input_file(&this->input_argument_->file());
input_file->open(this->options_, this->dirpath_);
// Read enough of the file to pick up the entire ELF header.
- int ehdr_size = elfcpp::Elf_sizes<64>::ehdr_size;
- off_t bytes;
- const unsigned char* p = input_file->file().get_view(0, ehdr_size, &bytes);
- if (bytes >= 4)
+ off_t filesize = input_file->file().filesize();
+
+ if (filesize == 0)
+ {
+ fprintf(stderr, _("%s: %s: file is empty\n"),
+ program_name, input_file->file().filename().c_str());
+ gold_exit(false);
+ }
+
+ unsigned char ehdr_buf[elfcpp::Elf_sizes<64>::ehdr_size];
+
+ int read_size = elfcpp::Elf_sizes<64>::ehdr_size;
+ if (filesize < read_size)
+ read_size = filesize;
+
+ input_file->file().read(0, read_size, ehdr_buf);
+
+ if (read_size >= 4)
{
static unsigned char elfmagic[4] =
{
elfcpp::ELFMAG0, elfcpp::ELFMAG1,
elfcpp::ELFMAG2, elfcpp::ELFMAG3
};
- if (memcmp(p, elfmagic, 4) == 0)
+ if (memcmp(ehdr_buf, elfmagic, 4) == 0)
{
// This is an ELF object.
- if (this->input_group_ != NULL)
+ Object* obj = make_elf_object(input_file->filename(),
+ input_file, 0, ehdr_buf, read_size);
+
+ // We don't have a way to record a non-archive in an input
+ // group. If this is an ordinary object file, we can't
+ // include it more than once anyhow. If this is a dynamic
+ // object, then including it a second time changes nothing.
+ if (this->input_group_ != NULL && !obj->is_dynamic())
{
fprintf(stderr,
_("%s: %s: ordinary object found in input group\n"),
gold_exit(false);
}
- Object* obj = make_elf_object(this->input_.file().name(),
- input_file, 0, p, bytes);
-
Read_symbols_data* sd = new Read_symbols_data;
obj->read_symbols(sd);
workqueue->queue_front(new Add_symbols(this->input_objects_,
}
}
- if (bytes >= Archive::sarmag)
+ if (read_size >= Archive::sarmag)
{
- if (memcmp(p, Archive::armag, Archive::sarmag) == 0)
+ if (memcmp(ehdr_buf, Archive::armag, Archive::sarmag) == 0)
{
// This is an archive.
- Archive* arch = new Archive(this->input_.file().name(), input_file);
+ Archive* arch = new Archive(this->input_argument_->file().name(),
+ input_file);
arch->setup();
workqueue->queue(new Add_archive_symbols(this->symtab_,
this->layout_,
}
}
+ // Try to parse this file as a script.
+ if (read_input_script(workqueue, this->options_, this->symtab_,
+ this->layout_, this->dirpath_, this->input_objects_,
+ this->input_group_, this->input_argument_, input_file,
+ ehdr_buf, read_size, this->this_blocker_,
+ this->next_blocker_))
+ return;
+
// Here we have to handle any other input file types we need.
fprintf(stderr, _("%s: %s: not an object or archive\n"),
program_name, input_file->file().filename().c_str());
{
Input_group* input_group = new Input_group();
- const Input_file_group* group = this->input_.group();
+ const Input_file_group* group = this->input_argument_->group();
Task_token* this_blocker = this->this_blocker_;
for (Input_file_group::const_iterator p = group->begin();
p != group->end();
++p)
{
- const Input_argument& arg(*p);
- assert(arg.is_file());
+ const Input_argument* arg = &*p;
+ gold_assert(arg->is_file());
Task_token* next_blocker = new Task_token();
next_blocker->add_blocker();
void
Add_symbols::run(Workqueue*)
{
- this->input_objects_->add_object(this->object_);
- this->object_->layout(this->layout_, this->sd_);
- this->object_->add_symbols(this->symtab_, this->sd_);
+ if (!this->input_objects_->add_object(this->object_))
+ {
+ // FIXME: We need to close the descriptor here.
+ delete this->object_;
+ }
+ else
+ {
+ this->object_->layout(this->symtab_, this->layout_, this->sd_);
+ this->object_->add_symbols(this->symtab_, this->sd_);
+ }
delete this->sd_;
this->sd_ = NULL;
}
projects / deliverable / binutils-gdb.git / blobdiff