version 1.5, 2018/04/14 15:49:42 |
version 1.5.2.1, 2020/04/08 14:05:47 |
|
|
// plugin.cc -- plugin manager for gold -*- C++ -*- |
// plugin.cc -- plugin manager for gold -*- C++ -*- |
|
|
// Copyright (C) 2008-2016 Free Software Foundation, Inc. |
// Copyright (C) 2008-2018 Free Software Foundation, Inc. |
// Written by Cary Coutant <ccoutant@google.com>. |
// Written by Cary Coutant <ccoutant@google.com>. |
|
|
// This file is part of gold. |
// This file is part of gold. |
|
|
|
|
#include "gold.h" |
#include "gold.h" |
|
|
|
#include <cerrno> |
#include <cstdio> |
#include <cstdio> |
#include <cstdarg> |
#include <cstdarg> |
#include <cstring> |
#include <cstring> |
#include <string> |
#include <string> |
#include <vector> |
#include <vector> |
|
#include <fcntl.h> |
|
#include <unistd.h> |
|
#include "libiberty.h" |
|
|
#ifdef ENABLE_PLUGINS |
#ifdef ENABLE_PLUGINS |
#ifdef HAVE_DLFCN_H |
#ifdef HAVE_DLFCN_H |
|
|
#endif /* ENABLE_PLUGINS */ |
#endif /* ENABLE_PLUGINS */ |
|
|
#include "parameters.h" |
#include "parameters.h" |
|
#include "debug.h" |
#include "errors.h" |
#include "errors.h" |
#include "fileread.h" |
#include "fileread.h" |
#include "layout.h" |
#include "layout.h" |
Line 167 static enum ld_plugin_status |
|
Line 172 static enum ld_plugin_status |
|
get_input_section_size(const struct ld_plugin_section section, |
get_input_section_size(const struct ld_plugin_section section, |
uint64_t* secsize); |
uint64_t* secsize); |
|
|
|
static enum ld_plugin_status |
|
register_new_input(ld_plugin_new_input_handler handler); |
|
|
|
static enum ld_plugin_status |
|
get_wrap_symbols(uint64_t *num_symbols, const char ***wrap_symbol_list); |
|
|
}; |
}; |
|
|
#endif // ENABLE_PLUGINS |
#endif // ENABLE_PLUGINS |
|
|
static Pluginobj* make_sized_plugin_object(Input_file* input_file, |
static Pluginobj* make_sized_plugin_object(const std::string& filename, |
|
Input_file* input_file, |
off_t offset, off_t filesize); |
off_t offset, off_t filesize); |
|
|
// Plugin methods. |
// Plugin methods. |
|
|
sscanf(ver, "%d.%d", &major, &minor); |
sscanf(ver, "%d.%d", &major, &minor); |
|
|
// Allocate and populate a transfer vector. |
// Allocate and populate a transfer vector. |
const int tv_fixed_size = 29; |
const int tv_fixed_size = 31; |
|
|
int tv_size = this->args_.size() + tv_fixed_size; |
int tv_size = this->args_.size() + tv_fixed_size; |
ld_plugin_tv* tv = new ld_plugin_tv[tv_size]; |
ld_plugin_tv* tv = new ld_plugin_tv[tv_size]; |
|
|
tv[i].tv_u.tv_get_input_section_size = get_input_section_size; |
tv[i].tv_u.tv_get_input_section_size = get_input_section_size; |
|
|
++i; |
++i; |
|
tv[i].tv_tag = LDPT_REGISTER_NEW_INPUT_HOOK; |
|
tv[i].tv_u.tv_register_new_input = register_new_input; |
|
|
|
++i; |
|
tv[i].tv_tag = LDPT_GET_WRAP_SYMBOLS; |
|
tv[i].tv_u.tv_get_wrap_symbols = get_wrap_symbols; |
|
|
|
++i; |
tv[i].tv_tag = LDPT_NULL; |
tv[i].tv_tag = LDPT_NULL; |
tv[i].tv_u.tv_val = 0; |
tv[i].tv_u.tv_val = 0; |
|
|
Line 383 Plugin::all_symbols_read() |
|
Line 403 Plugin::all_symbols_read() |
|
(*this->all_symbols_read_handler_)(); |
(*this->all_symbols_read_handler_)(); |
} |
} |
|
|
|
// Call the new_input handler. |
|
|
|
inline void |
|
Plugin::new_input(struct ld_plugin_input_file* plugin_input_file) |
|
{ |
|
if (this->new_input_handler_ != NULL) |
|
(*this->new_input_handler_)(plugin_input_file); |
|
} |
|
|
// Call the cleanup handler. |
// Call the cleanup handler. |
|
|
inline void |
inline void |
Line 437 class Plugin_rescan : public Task |
|
Line 466 class Plugin_rescan : public Task |
|
Task_token* next_blocker_; |
Task_token* next_blocker_; |
}; |
}; |
|
|
|
// Plugin_recorder logs plugin actions and saves intermediate files |
|
// for later replay. |
|
|
|
class Plugin_recorder |
|
{ |
|
public: |
|
Plugin_recorder() : file_count_(0), tempdir_(NULL), logfile_(NULL) |
|
{ } |
|
|
|
bool |
|
init(); |
|
|
|
void |
|
claimed_file(const std::string& obj_name, off_t offset, off_t filesize, |
|
const std::string& plugin_name); |
|
|
|
void |
|
unclaimed_file(const std::string& obj_name, off_t offset, off_t filesize); |
|
|
|
void |
|
replacement_file(const char* name, bool is_lib); |
|
|
|
void |
|
record_symbols(const Object* obj, int nsyms, |
|
const struct ld_plugin_symbol* syms); |
|
|
|
void |
|
finish() |
|
{ ::fclose(this->logfile_); } |
|
|
|
private: |
|
unsigned int file_count_; |
|
const char* tempdir_; |
|
FILE* logfile_; |
|
}; |
|
|
|
bool |
|
Plugin_recorder::init() |
|
{ |
|
// Create a temporary directory where we can stash the log and |
|
// copies of replacement files. |
|
char dir_template[] = "gold-recording-XXXXXX"; |
|
if (mkdtemp(dir_template) == NULL) |
|
return false; |
|
|
|
size_t len = strlen(dir_template) + 1; |
|
char* tempdir = new char[len]; |
|
strncpy(tempdir, dir_template, len); |
|
|
|
// Create the log file. |
|
std::string logname(tempdir); |
|
logname.append("/log"); |
|
FILE* logfile = ::fopen(logname.c_str(), "w"); |
|
if (logfile == NULL) |
|
return false; |
|
|
|
this->tempdir_ = tempdir; |
|
this->logfile_ = logfile; |
|
|
|
gold_info(_("%s: recording to %s"), program_name, this->tempdir_); |
|
|
|
return true; |
|
} |
|
|
|
void |
|
Plugin_recorder::claimed_file(const std::string& obj_name, |
|
off_t offset, |
|
off_t filesize, |
|
const std::string& plugin_name) |
|
{ |
|
fprintf(this->logfile_, "PLUGIN: %s\n", plugin_name.c_str()); |
|
fprintf(this->logfile_, "CLAIMED: %s", obj_name.c_str()); |
|
if (offset > 0) |
|
fprintf(this->logfile_, " @%ld", static_cast<long>(offset)); |
|
fprintf(this->logfile_, " %ld\n", static_cast<long>(filesize)); |
|
} |
|
|
|
void |
|
Plugin_recorder::unclaimed_file(const std::string& obj_name, |
|
off_t offset, |
|
off_t filesize) |
|
{ |
|
fprintf(this->logfile_, "UNCLAIMED: %s", obj_name.c_str()); |
|
if (offset > 0) |
|
fprintf(this->logfile_, " @%ld", static_cast<long>(offset)); |
|
fprintf(this->logfile_, " %ld\n", static_cast<long>(filesize)); |
|
} |
|
|
|
// Make a hard link to INNAME from OUTNAME, if possible. |
|
// If not, copy the file. |
|
|
|
static bool |
|
link_or_copy_file(const char* inname, const char* outname) |
|
{ |
|
static char buf[4096]; |
|
|
|
if (::link(inname, outname) == 0) |
|
return true; |
|
|
|
int in = ::open(inname, O_RDONLY); |
|
if (in < 0) |
|
{ |
|
gold_warning(_("%s: can't open (%s)"), inname, strerror(errno)); |
|
return false; |
|
} |
|
int out = ::open(outname, O_CREAT | O_TRUNC | O_WRONLY, 0600); |
|
if (out < 0) |
|
{ |
|
gold_warning(_("%s: can't create (%s)"), outname, strerror(errno)); |
|
::close(in); |
|
return false; |
|
} |
|
ssize_t len; |
|
while ((len = ::read(in, buf, sizeof(buf))) > 0) |
|
{ |
|
if (::write(out, buf, len) != len) |
|
{ |
|
gold_warning(_("%s: write error while making copy of file (%s)"), |
|
inname, strerror(errno)); |
|
break; |
|
} |
|
} |
|
::close(in); |
|
::close(out); |
|
return true; |
|
} |
|
|
|
void |
|
Plugin_recorder::replacement_file(const char* name, bool is_lib) |
|
{ |
|
fprintf(this->logfile_, "REPLACEMENT: %s", name); |
|
if (is_lib) |
|
fprintf(this->logfile_, "(lib)"); |
|
else |
|
{ |
|
char counter[10]; |
|
const char* basename = lbasename(name); |
|
snprintf(counter, sizeof(counter), "%05d", this->file_count_); |
|
++this->file_count_; |
|
std::string outname(this->tempdir_); |
|
outname.append("/"); |
|
outname.append(counter); |
|
outname.append("-"); |
|
outname.append(basename); |
|
if (link_or_copy_file(name, outname.c_str())) |
|
fprintf(this->logfile_, " -> %s", outname.c_str()); |
|
} |
|
fprintf(this->logfile_, "\n"); |
|
} |
|
|
|
void |
|
Plugin_recorder::record_symbols(const Object* obj, int nsyms, |
|
const struct ld_plugin_symbol* syms) |
|
{ |
|
fprintf(this->logfile_, "SYMBOLS: %d %s\n", nsyms, obj->name().c_str()); |
|
for (int i = 0; i < nsyms; ++i) |
|
{ |
|
const struct ld_plugin_symbol* isym = &syms[i]; |
|
|
|
const char* def; |
|
switch (isym->def) |
|
{ |
|
case LDPK_DEF: |
|
def = "D"; |
|
break; |
|
case LDPK_WEAKDEF: |
|
def = "WD"; |
|
break; |
|
case LDPK_UNDEF: |
|
def = "U"; |
|
break; |
|
case LDPK_WEAKUNDEF: |
|
def = "WU"; |
|
break; |
|
case LDPK_COMMON: |
|
def = "C"; |
|
break; |
|
default: |
|
def = "?"; |
|
break; |
|
} |
|
|
|
char vis; |
|
switch (isym->visibility) |
|
{ |
|
case LDPV_PROTECTED: |
|
vis = 'P'; |
|
break; |
|
case LDPV_INTERNAL: |
|
vis = 'I'; |
|
break; |
|
case LDPV_HIDDEN: |
|
vis = 'H'; |
|
break; |
|
case LDPV_DEFAULT: |
|
vis = 'D'; |
|
break; |
|
default: |
|
vis = '?'; |
|
break; |
|
} |
|
|
|
fprintf(this->logfile_, " %5d: %-2s %c %s", i, def, vis, isym->name); |
|
if (isym->version != NULL && isym->version[0] != '\0') |
|
fprintf(this->logfile_, "@%s", isym->version); |
|
if (isym->comdat_key != NULL && isym->comdat_key[0] != '\0') |
|
{ |
|
if (strcmp(isym->name, isym->comdat_key) == 0) |
|
fprintf(this->logfile_, " [comdat]"); |
|
else |
|
fprintf(this->logfile_, " [comdat: %s]", isym->comdat_key); |
|
} |
|
fprintf(this->logfile_, "\n"); |
|
} |
|
} |
|
|
// Plugin_manager methods. |
// Plugin_manager methods. |
|
|
Plugin_manager::~Plugin_manager() |
Plugin_manager::~Plugin_manager() |
Line 452 Plugin_manager::~Plugin_manager() |
|
Line 697 Plugin_manager::~Plugin_manager() |
|
delete *obj; |
delete *obj; |
this->objects_.clear(); |
this->objects_.clear(); |
delete this->lock_; |
delete this->lock_; |
|
delete this->recorder_; |
} |
} |
|
|
// Load all plugin libraries. |
// Load all plugin libraries. |
|
|
Plugin_manager::load_plugins(Layout* layout) |
Plugin_manager::load_plugins(Layout* layout) |
{ |
{ |
this->layout_ = layout; |
this->layout_ = layout; |
|
|
|
if (is_debugging_enabled(DEBUG_PLUGIN)) |
|
{ |
|
this->recorder_ = new Plugin_recorder(); |
|
this->recorder_->init(); |
|
} |
|
|
for (this->current_ = this->plugins_.begin(); |
for (this->current_ = this->plugins_.begin(); |
this->current_ != this->plugins_.end(); |
this->current_ != this->plugins_.end(); |
++this->current_) |
++this->current_) |
Line 476 Plugin_manager::claim_file(Input_file* i |
|
Line 729 Plugin_manager::claim_file(Input_file* i |
|
|
|
gold_assert(lock_initialized); |
gold_assert(lock_initialized); |
Hold_lock hl(*this->lock_); |
Hold_lock hl(*this->lock_); |
if (this->in_replacement_phase_) |
|
return NULL; |
|
|
|
unsigned int handle = this->objects_.size(); |
unsigned int handle = this->objects_.size(); |
this->input_file_ = input_file; |
this->input_file_ = input_file; |
Line 494 Plugin_manager::claim_file(Input_file* i |
|
Line 745 Plugin_manager::claim_file(Input_file* i |
|
this->current_ != this->plugins_.end(); |
this->current_ != this->plugins_.end(); |
++this->current_) |
++this->current_) |
{ |
{ |
if ((*this->current_)->claim_file(&this->plugin_input_file_)) |
// If we aren't yet in replacement phase, allow plugins to claim input |
|
// files, otherwise notify the plugin of the new input file, if needed. |
|
if (!this->in_replacement_phase_) |
{ |
{ |
this->any_claimed_ = true; |
if ((*this->current_)->claim_file(&this->plugin_input_file_)) |
this->in_claim_file_handler_ = false; |
{ |
|
this->any_claimed_ = true; |
|
this->in_claim_file_handler_ = false; |
|
|
|
if (this->recorder_ != NULL) |
|
{ |
|
const std::string& objname = (elf_object == NULL |
|
? input_file->filename() |
|
: elf_object->name()); |
|
this->recorder_->claimed_file(objname, |
|
offset, filesize, |
|
(*this->current_)->filename()); |
|
} |
|
|
if (this->objects_.size() > handle |
if (this->objects_.size() > handle |
&& this->objects_[handle]->pluginobj() != NULL) |
&& this->objects_[handle]->pluginobj() != NULL) |
return this->objects_[handle]->pluginobj(); |
return this->objects_[handle]->pluginobj(); |
|
|
// If the plugin claimed the file but did not call the |
// If the plugin claimed the file but did not call the |
// add_symbols callback, we need to create the Pluginobj now. |
// add_symbols callback, we need to create the Pluginobj now. |
Pluginobj* obj = this->make_plugin_object(handle); |
Pluginobj* obj = this->make_plugin_object(handle); |
return obj; |
return obj; |
|
} |
|
} |
|
else |
|
{ |
|
(*this->current_)->new_input(&this->plugin_input_file_); |
} |
} |
} |
} |
|
|
this->in_claim_file_handler_ = false; |
this->in_claim_file_handler_ = false; |
|
|
|
if (this->recorder_ != NULL) |
|
this->recorder_->unclaimed_file(input_file->filename(), offset, filesize); |
|
|
return NULL; |
return NULL; |
} |
} |
|
|
Line 557 Plugin_manager::all_symbols_read(Workque |
|
Line 831 Plugin_manager::all_symbols_read(Workque |
|
this->mapfile_ = mapfile; |
this->mapfile_ = mapfile; |
this->this_blocker_ = NULL; |
this->this_blocker_ = NULL; |
|
|
|
// Set symbols used in defsym expressions as seen in real ELF. |
|
Layout *layout = parameters->options().plugins()->layout(); |
|
layout->script_options()->set_defsym_uses_in_real_elf(symtab); |
|
layout->script_options()->find_defsym_defs(this->defsym_defines_set_); |
|
|
for (this->current_ = this->plugins_.begin(); |
for (this->current_ = this->plugins_.begin(); |
this->current_ != this->plugins_.end(); |
this->current_ != this->plugins_.end(); |
++this->current_) |
++this->current_) |
Line 752 Plugin_manager::make_plugin_object(unsig |
|
Line 1031 Plugin_manager::make_plugin_object(unsig |
|
&& this->objects_[handle]->pluginobj() != NULL) |
&& this->objects_[handle]->pluginobj() != NULL) |
return NULL; |
return NULL; |
|
|
Pluginobj* obj = make_sized_plugin_object(this->input_file_, |
const std::string* filename = &this->input_file_->filename(); |
|
|
|
// If the elf object for this file was pushed into the objects_ vector, |
|
// use its filename, then delete it to make room for the Pluginobj as |
|
// this file is claimed. |
|
if (this->objects_.size() != handle) |
|
{ |
|
filename = &this->objects_.back()->name(); |
|
this->objects_.pop_back(); |
|
} |
|
|
|
Pluginobj* obj = make_sized_plugin_object(*filename, |
|
this->input_file_, |
this->plugin_input_file_.offset, |
this->plugin_input_file_.offset, |
this->plugin_input_file_.filesize); |
this->plugin_input_file_.filesize); |
|
|
|
|
// If the elf object for this file was pushed into the objects_ vector, delete |
|
// it to make room for the Pluginobj as this file is claimed. |
|
if (this->objects_.size() != handle) |
|
this->objects_.pop_back(); |
|
|
|
this->objects_.push_back(obj); |
this->objects_.push_back(obj); |
return obj; |
return obj; |
Line 880 Plugin_manager::add_input_file(const cha |
|
Line 1167 Plugin_manager::add_input_file(const cha |
|
if (parameters->incremental()) |
if (parameters->incremental()) |
gold_error(_("input files added by plug-ins in --incremental mode not " |
gold_error(_("input files added by plug-ins in --incremental mode not " |
"supported yet")); |
"supported yet")); |
|
|
|
if (this->recorder_ != NULL) |
|
this->recorder_->replacement_file(pathname, is_lib); |
|
|
this->workqueue_->queue_soon(new Read_symbols(this->input_objects_, |
this->workqueue_->queue_soon(new Read_symbols(this->input_objects_, |
this->symtab_, |
this->symtab_, |
this->layout_, |
this->layout_, |
Line 930 is_visible_from_outside(Symbol* lsym) |
|
Line 1221 is_visible_from_outside(Symbol* lsym) |
|
{ |
{ |
if (lsym->in_dyn()) |
if (lsym->in_dyn()) |
return true; |
return true; |
if (parameters->options().export_dynamic() || parameters->options().shared()) |
if (parameters->options().export_dynamic() || parameters->options().shared() |
|
|| parameters->options().in_dynamic_list(lsym->name()) |
|
|| parameters->options().is_export_dynamic_symbol(lsym->name())) |
return lsym->is_externally_visible(); |
return lsym->is_externally_visible(); |
return false; |
return false; |
} |
} |
Line 964 Pluginobj::get_symbol_resolution_info(Sy |
|
Line 1257 Pluginobj::get_symbol_resolution_info(Sy |
|
return version > 2 ? LDPS_NO_SYMS : LDPS_OK; |
return version > 2 ? LDPS_NO_SYMS : LDPS_OK; |
} |
} |
|
|
|
Plugin_manager* plugins = parameters->options().plugins(); |
for (int i = 0; i < nsyms; i++) |
for (int i = 0; i < nsyms; i++) |
{ |
{ |
ld_plugin_symbol* isym = &syms[i]; |
ld_plugin_symbol* isym = &syms[i]; |
Line 972 Pluginobj::get_symbol_resolution_info(Sy |
|
Line 1266 Pluginobj::get_symbol_resolution_info(Sy |
|
lsym = symtab->resolve_forwards(lsym); |
lsym = symtab->resolve_forwards(lsym); |
ld_plugin_symbol_resolution res = LDPR_UNKNOWN; |
ld_plugin_symbol_resolution res = LDPR_UNKNOWN; |
|
|
if (lsym->is_undefined()) |
if (plugins->is_defsym_def(lsym->name())) |
// The symbol remains undefined. |
{ |
res = LDPR_UNDEF; |
// The symbol is redefined via defsym. |
|
res = LDPR_PREEMPTED_REG; |
|
} |
|
else if (lsym->is_undefined()) |
|
{ |
|
// The symbol remains undefined. |
|
res = LDPR_UNDEF; |
|
} |
else if (isym->def == LDPK_UNDEF |
else if (isym->def == LDPK_UNDEF |
|| isym->def == LDPK_WEAKUNDEF |
|| isym->def == LDPK_WEAKUNDEF |
|| isym->def == LDPK_COMMON) |
|| isym->def == LDPK_COMMON) |
Line 1085 Sized_pluginobj<size, big_endian>::do_ad |
|
Line 1386 Sized_pluginobj<size, big_endian>::do_ad |
|
elfcpp::Sym<size, big_endian> sym(symbuf); |
elfcpp::Sym<size, big_endian> sym(symbuf); |
elfcpp::Sym_write<size, big_endian> osym(symbuf); |
elfcpp::Sym_write<size, big_endian> osym(symbuf); |
|
|
|
Plugin_recorder* recorder = parameters->options().plugins()->recorder(); |
|
if (recorder != NULL) |
|
recorder->record_symbols(this, this->nsyms_, this->syms_); |
|
|
this->symbols_.resize(this->nsyms_); |
this->symbols_.resize(this->nsyms_); |
|
|
for (int i = 0; i < this->nsyms_; ++i) |
for (int i = 0; i < this->nsyms_; ++i) |
Line 1119 Sized_pluginobj<size, big_endian>::do_ad |
|
Line 1424 Sized_pluginobj<size, big_endian>::do_ad |
|
{ |
{ |
case LDPK_DEF: |
case LDPK_DEF: |
case LDPK_WEAKDEF: |
case LDPK_WEAKDEF: |
shndx = elfcpp::SHN_ABS; |
// We use an arbitrary section number for a defined symbol. |
|
shndx = 1; |
break; |
break; |
case LDPK_COMMON: |
case LDPK_COMMON: |
shndx = elfcpp::SHN_COMMON; |
shndx = elfcpp::SHN_COMMON; |
Line 1397 class Plugin_finish : public Task |
|
Line 1703 class Plugin_finish : public Task |
|
void |
void |
run(Workqueue*) |
run(Workqueue*) |
{ |
{ |
|
Plugin_manager* plugins = parameters->options().plugins(); |
|
gold_assert(plugins != NULL); |
// We could call early cleanup handlers here. |
// We could call early cleanup handlers here. |
|
if (plugins->recorder()) |
|
plugins->recorder()->finish(); |
} |
} |
|
|
std::string |
std::string |
Line 1795 get_input_section_size(const struct ld_p |
|
Line 2105 get_input_section_size(const struct ld_p |
|
return LDPS_OK; |
return LDPS_OK; |
} |
} |
|
|
|
static enum ld_plugin_status |
|
get_wrap_symbols(uint64_t *count, const char ***wrap_symbols) |
|
{ |
|
gold_assert(parameters->options().has_plugins()); |
|
*count = parameters->options().wrap_size(); |
|
|
|
if (*count == 0) |
|
return LDPS_OK; |
|
|
|
*wrap_symbols = new const char *[*count]; |
|
int i = 0; |
|
for (options::String_set::const_iterator |
|
it = parameters->options().wrap_begin(); |
|
it != parameters->options().wrap_end(); ++it, ++i) { |
|
(*wrap_symbols)[i] = it->c_str(); |
|
} |
|
return LDPS_OK; |
|
} |
|
|
|
|
// Specify the ordering of sections in the final layout. The sections are |
// Specify the ordering of sections in the final layout. The sections are |
// specified as (handle,shndx) pairs in the two arrays in the order in |
// specified as (handle,shndx) pairs in the two arrays in the order in |
Line 1903 unique_segment_for_sections(const char* |
|
Line 2232 unique_segment_for_sections(const char* |
|
return LDPS_OK; |
return LDPS_OK; |
} |
} |
|
|
|
// Register a new_input handler. |
|
|
|
static enum ld_plugin_status |
|
register_new_input(ld_plugin_new_input_handler handler) |
|
{ |
|
gold_assert(parameters->options().has_plugins()); |
|
parameters->options().plugins()->set_new_input_handler(handler); |
|
return LDPS_OK; |
|
} |
|
|
#endif // ENABLE_PLUGINS |
#endif // ENABLE_PLUGINS |
|
|
// Allocate a Pluginobj object of the appropriate size and endianness. |
// Allocate a Pluginobj object of the appropriate size and endianness. |
|
|
static Pluginobj* |
static Pluginobj* |
make_sized_plugin_object(Input_file* input_file, off_t offset, off_t filesize) |
make_sized_plugin_object(const std::string& filename, |
|
Input_file* input_file, off_t offset, off_t filesize) |
{ |
{ |
Pluginobj* obj = NULL; |
Pluginobj* obj = NULL; |
|
|
Line 1919 make_sized_plugin_object(Input_file* inp |
|
Line 2259 make_sized_plugin_object(Input_file* inp |
|
{ |
{ |
if (target.is_big_endian()) |
if (target.is_big_endian()) |
#ifdef HAVE_TARGET_32_BIG |
#ifdef HAVE_TARGET_32_BIG |
obj = new Sized_pluginobj<32, true>(input_file->filename(), |
obj = new Sized_pluginobj<32, true>(filename, input_file, |
input_file, offset, filesize); |
offset, filesize); |
#else |
#else |
gold_error(_("%s: not configured to support " |
gold_error(_("%s: not configured to support " |
"32-bit big-endian object"), |
"32-bit big-endian object"), |
input_file->filename().c_str()); |
filename.c_str()); |
#endif |
#endif |
else |
else |
#ifdef HAVE_TARGET_32_LITTLE |
#ifdef HAVE_TARGET_32_LITTLE |
obj = new Sized_pluginobj<32, false>(input_file->filename(), |
obj = new Sized_pluginobj<32, false>(filename, input_file, |
input_file, offset, filesize); |
offset, filesize); |
#else |
#else |
gold_error(_("%s: not configured to support " |
gold_error(_("%s: not configured to support " |
"32-bit little-endian object"), |
"32-bit little-endian object"), |
input_file->filename().c_str()); |
filename.c_str()); |
#endif |
#endif |
} |
} |
else if (target.get_size() == 64) |
else if (target.get_size() == 64) |
{ |
{ |
if (target.is_big_endian()) |
if (target.is_big_endian()) |
#ifdef HAVE_TARGET_64_BIG |
#ifdef HAVE_TARGET_64_BIG |
obj = new Sized_pluginobj<64, true>(input_file->filename(), |
obj = new Sized_pluginobj<64, true>(filename, input_file, |
input_file, offset, filesize); |
offset, filesize); |
#else |
#else |
gold_error(_("%s: not configured to support " |
gold_error(_("%s: not configured to support " |
"64-bit big-endian object"), |
"64-bit big-endian object"), |
input_file->filename().c_str()); |
filename.c_str()); |
#endif |
#endif |
else |
else |
#ifdef HAVE_TARGET_64_LITTLE |
#ifdef HAVE_TARGET_64_LITTLE |
obj = new Sized_pluginobj<64, false>(input_file->filename(), |
obj = new Sized_pluginobj<64, false>(filename, input_file, |
input_file, offset, filesize); |
offset, filesize); |
#else |
#else |
gold_error(_("%s: not configured to support " |
gold_error(_("%s: not configured to support " |
"64-bit little-endian object"), |
"64-bit little-endian object"), |
input_file->filename().c_str()); |
filename.c_str()); |
#endif |
#endif |
} |
} |
|
|