[BACK]Return to plugin.cc CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / external / gpl3 / binutils.old / dist / gold

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/external/gpl3/binutils.old/dist/gold/plugin.cc between version 1.5 and 1.5.2.1

version 1.5, 2018/04/14 15:49:42 version 1.5.2.1, 2020/04/08 14:05:47
Line 1 
Line 1 
 // 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.
Line 22 
Line 22 
   
 #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
Line 63  dlerror(void)
Line 67  dlerror(void)
 #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.
Line 211  Plugin::load()
Line 223  Plugin::load()
   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];
Line 346  Plugin::load()
Line 358  Plugin::load()
   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.
Line 460  void
Line 706  void
 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
     }      }
   

Legend:
Removed from v.1.5  
changed lines
  Added in v.1.5.2.1

CVSweb <webmaster@jp.NetBSD.org>