diff -rupN --no-dereference binutils-2.38/gold/fileread.cc binutils-2.38-new/gold/fileread.cc

--- binutils-2.38/gold/fileread.cc	2022-01-22 13:14:09.000000000 +0100

+++ binutils-2.38-new/gold/fileread.cc	2022-04-26 13:54:56.336537927 +0200

@@ -385,6 +385,12 @@ File_read::do_read(off_t start, section_

   ssize_t bytes;

   if (this->whole_file_view_ != NULL)

     {

+      // See PR 23765 for an example of a testcase that triggers this error.

+      if (((ssize_t) start) < 0)

+	gold_fatal(_("%s: read failed, starting offset (%#llx) less than zero"),

+		   this->filename().c_str(),

+		   static_cast<long long>(start));

+	

       bytes = this->size_ - start;

       if (static_cast<section_size_type>(bytes) >= size)

 	{

diff -rupN --no-dereference binutils-2.38/gold/fileread.cc.orig binutils-2.38-new/gold/fileread.cc.orig

--- binutils-2.38/gold/fileread.cc.orig	1970-01-01 01:00:00.000000000 +0100

+++ binutils-2.38-new/gold/fileread.cc.orig	2022-01-22 13:14:09.000000000 +0100

@@ -0,0 +1,1172 @@

+// fileread.cc -- read files for gold

+

+// Copyright (C) 2006-2022 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 <cerrno>

+#include <climits>

+#include <fcntl.h>

+#include <unistd.h>

+

+#ifdef HAVE_SYS_MMAN_H

+#include <sys/mman.h>

+#endif

+

+#ifdef HAVE_READV

+#include <sys/uio.h>

+#endif

+

+#include <sys/stat.h>

+#include "filenames.h"

+

+#include "debug.h"

+#include "parameters.h"

+#include "options.h"

+#include "dirsearch.h"

+#include "target.h"

+#include "binary.h"

+#include "descriptors.h"

+#include "gold-threads.h"

+#include "fileread.h"

+

+// For systems without mmap support.

+#ifndef HAVE_MMAP

+# define mmap gold_mmap

+# define munmap gold_munmap

+# ifndef MAP_FAILED

+#  define MAP_FAILED (reinterpret_cast<void*>(-1))

+# endif

+# ifndef PROT_READ

+#  define PROT_READ 0

+# endif

+# ifndef MAP_PRIVATE

+#  define MAP_PRIVATE 0

+# endif

+

+# ifndef ENOSYS

+#  define ENOSYS EINVAL

+# endif

+

+static void *

+gold_mmap(void *, size_t, int, int, int, off_t)

+{

+  errno = ENOSYS;

+  return MAP_FAILED;

+}

+

+static int

+gold_munmap(void *, size_t)

+{

+  errno = ENOSYS;

+  return -1;

+}

+

+#endif

+

+#ifndef HAVE_READV

+struct iovec { void* iov_base; size_t iov_len; };

+ssize_t

+readv(int, const iovec*, int)

+{

+  gold_unreachable();

+}

+#endif

+

+namespace gold

+{

+

+// Get the last modified time of an unopened file.

+

+bool

+get_mtime(const char* filename, Timespec* mtime)

+{

+  struct stat file_stat;

+

+  if (stat(filename, &file_stat) < 0)

+    return false;

+#ifdef HAVE_STAT_ST_MTIM

+  mtime->seconds = file_stat.st_mtim.tv_sec;

+  mtime->nanoseconds = file_stat.st_mtim.tv_nsec;

+#else

+  mtime->seconds = file_stat.st_mtime;

+  mtime->nanoseconds = 0;

+#endif

+  return true;

+}

+

+// Class File_read.

+

+// A lock for the File_read static variables.

+static Lock* file_counts_lock = NULL;

+static Initialize_lock file_counts_initialize_lock(&file_counts_lock);

+

+// The File_read static variables.

+unsigned long long File_read::total_mapped_bytes;

+unsigned long long File_read::current_mapped_bytes;

+unsigned long long File_read::maximum_mapped_bytes;

+std::vector<std::string> File_read::files_read;

+

+// Class File_read::View.

+

+File_read::View::~View()

+{

+  gold_assert(!this->is_locked());

+  switch (this->data_ownership_)

+    {

+    case DATA_ALLOCATED_ARRAY:

+      free(const_cast<unsigned char*>(this->data_));

+      break;

+    case DATA_MMAPPED:

+      if (::munmap(const_cast<unsigned char*>(this->data_), this->size_) != 0)

+	gold_warning(_("munmap failed: %s"), strerror(errno));

+      if (!parameters->options_valid() || parameters->options().stats())

+	{

+	  file_counts_initialize_lock.initialize();

+	  Hold_optional_lock hl(file_counts_lock);

+	  File_read::current_mapped_bytes -= this->size_;

+	}

+      break;

+    case DATA_NOT_OWNED:

+      break;

+    default:

+      gold_unreachable();

+    }

+}

+

+void

+File_read::View::lock()

+{

+  ++this->lock_count_;

+}

+

+void

+File_read::View::unlock()

+{

+  gold_assert(this->lock_count_ > 0);

+  --this->lock_count_;

+}

+

+bool

+File_read::View::is_locked()

+{

+  return this->lock_count_ > 0;

+}

+

+// Class File_read.

+

+File_read::~File_read()

+{

+  gold_assert(this->token_.is_writable());

+  if (this->is_descriptor_opened_)

+    {

+      release_descriptor(this->descriptor_, true);

+      this->descriptor_ = -1;

+      this->is_descriptor_opened_ = false;

+    }

+  this->name_.clear();

+  this->clear_views(CLEAR_VIEWS_ALL);

+}

+

+// Open the file.

+

+bool

+File_read::open(const Task* task, const std::string& name)

+{

+  gold_assert(this->token_.is_writable()

+	      && this->descriptor_ < 0

+	      && !this->is_descriptor_opened_

+	      && this->name_.empty());

+  this->name_ = name;

+

+  this->descriptor_ = open_descriptor(-1, this->name_.c_str(),

+				      O_RDONLY);

+

+  if (this->descriptor_ >= 0)

+    {

+      this->is_descriptor_opened_ = true;

+      struct stat s;

+      if (::fstat(this->descriptor_, &s) < 0)

+	gold_error(_("%s: fstat failed: %s"),

+		   this->name_.c_str(), strerror(errno));

+      this->size_ = s.st_size;

+      gold_debug(DEBUG_FILES, "Attempt to open %s succeeded",

+		 this->name_.c_str());

+      this->token_.add_writer(task);

+      file_counts_initialize_lock.initialize();

+      Hold_optional_lock hl(file_counts_lock);

+      record_file_read(this->name_);

+    }

+

+  return this->descriptor_ >= 0;

+}

+

+// Open the file with the contents in memory.

+

+bool

+File_read::open(const Task* task, const std::string& name,

+		const unsigned char* contents, off_t size)

+{

+  gold_assert(this->token_.is_writable()

+	      && this->descriptor_ < 0

+	      && !this->is_descriptor_opened_

+	      && this->name_.empty());

+  this->name_ = name;

+  this->whole_file_view_ = new View(0, size, contents, 0, false,

+				    View::DATA_NOT_OWNED);

+  this->add_view(this->whole_file_view_);

+  this->size_ = size;

+  this->token_.add_writer(task);

+  return true;

+}

+

+// Reopen a descriptor if necessary.

+

+void

+File_read::reopen_descriptor()

+{

+  if (!this->is_descriptor_opened_)

+    {

+      this->descriptor_ = open_descriptor(this->descriptor_,

+					  this->name_.c_str(),

+					  O_RDONLY);

+      if (this->descriptor_ < 0)

+	gold_fatal(_("could not reopen file %s"), this->name_.c_str());

+      this->is_descriptor_opened_ = true;

+    }

+}

+

+// Release the file.  This is called when we are done with the file in

+// a Task.

+

+void

+File_read::release()

+{

+  gold_assert(this->is_locked());

+

+  if (!parameters->options_valid() || parameters->options().stats())

+    {

+      file_counts_initialize_lock.initialize();

+      Hold_optional_lock hl(file_counts_lock);

+      File_read::total_mapped_bytes += this->mapped_bytes_;

+      File_read::current_mapped_bytes += this->mapped_bytes_;

+      if (File_read::current_mapped_bytes > File_read::maximum_mapped_bytes)

+	File_read::maximum_mapped_bytes = File_read::current_mapped_bytes;

+    }

+

+  this->mapped_bytes_ = 0;

+

+  // Only clear views if there is only one attached object.  Otherwise

+  // we waste time trying to clear cached archive views.  Similarly

+  // for releasing the descriptor.

+  if (this->object_count_ <= 1)

+    {

+      this->clear_views(CLEAR_VIEWS_NORMAL);

+      if (this->is_descriptor_opened_)

+	{

+	  release_descriptor(this->descriptor_, false);

+	  this->is_descriptor_opened_ = false;

+	}

+    }

+

+  this->released_ = true;

+}

+

+// Lock the file.

+

+void

+File_read::lock(const Task* task)

+{

+  gold_assert(this->released_);

+  gold_debug(DEBUG_FILES, "Locking file \"%s\"", this->name_.c_str());

+  this->token_.add_writer(task);

+  this->released_ = false;

+}

+

+// Unlock the file.

+

+void

+File_read::unlock(const Task* task)

+{

+  gold_debug(DEBUG_FILES, "Unlocking file \"%s\"", this->name_.c_str());

+  this->release();

+  this->token_.remove_writer(task);

+}

+

+// Return whether the file is locked.

+

+bool

+File_read::is_locked() const

+{

+  if (!this->token_.is_writable())

+    return true;

+  // The file is not locked, so it should have been released.

+  gold_assert(this->released_);

+  return false;

+}

+

+// See if we have a view which covers the file starting at START for

+// SIZE bytes.  Return a pointer to the View if found, NULL if not.

+// If BYTESHIFT is not -1U, the returned View must have the specified

+// byte shift; otherwise, it may have any byte shift.  If VSHIFTED is

+// not NULL, this sets *VSHIFTED to a view which would have worked if

+// not for the requested BYTESHIFT.

+

+inline File_read::View*

+File_read::find_view(off_t start, section_size_type size,

+		     unsigned int byteshift, File_read::View** vshifted) const

+{

+  gold_assert(start <= this->size_

+	      && (static_cast<unsigned long long>(size)

+		  <= static_cast<unsigned long long>(this->size_ - start)));

+

+  if (vshifted != NULL)

+    *vshifted = NULL;

+

+  // If we have the whole file mmapped, and the alignment is right,

+  // we can return it.

+  if (this->whole_file_view_)

+    if (byteshift == -1U || byteshift == 0)

+      return this->whole_file_view_;

+

+  off_t page = File_read::page_offset(start);

+

+  unsigned int bszero = 0;

+  Views::const_iterator p = this->views_.upper_bound(std::make_pair(page - 1,

+								    bszero));

+

+  while (p != this->views_.end() && p->first.first <= page)

+    {

+      if (p->second->start() <= start

+	  && (p->second->start() + static_cast<off_t>(p->second->size())

+	      >= start + static_cast<off_t>(size)))

+	{

+	  if (byteshift == -1U || byteshift == p->second->byteshift())

+	    {

+	      p->second->set_accessed();

+	      return p->second;

+	    }

+

+	  if (vshifted != NULL && *vshifted == NULL)

+	    *vshifted = p->second;

+	}

+

+      ++p;

+    }

+

+  return NULL;

+}

+

+// Read SIZE bytes from the file starting at offset START.  Read into

+// the buffer at P.

+

+void

+File_read::do_read(off_t start, section_size_type size, void* p)

+{

+  ssize_t bytes;

+  if (this->whole_file_view_ != NULL)

+    {

+      bytes = this->size_ - start;

+      if (static_cast<section_size_type>(bytes) >= size)

+	{

+	  memcpy(p, this->whole_file_view_->data() + start, size);

+	  return;

+	}

+    }

+  else

+    {

+      this->reopen_descriptor();

+

+      char *read_ptr = static_cast<char *>(p);

+      off_t read_pos = start;

+      size_t to_read = size;

+      do

+	{

+	  bytes = ::pread(this->descriptor_, read_ptr, to_read, read_pos);

+	  if (bytes < 0)

+	    gold_fatal(_("%s: pread failed: %s"),

+		       this->filename().c_str(), strerror(errno));

+

+	  read_pos += bytes;

+	  read_ptr += bytes;

+	  to_read -= bytes;

+	  if (to_read == 0)

+	    return;

+	}

+      while (bytes > 0);

+

+      bytes = size - to_read;

+    }

+

+  gold_fatal(_("%s: file too short: read only %lld of %lld bytes at %lld"),

+	     this->filename().c_str(),

+	     static_cast<long long>(bytes),

+	     static_cast<long long>(size),

+	     static_cast<long long>(start));

+}

+

+// Read data from the file.

+

+void

+File_read::read(off_t start, section_size_type size, void* p)

+{

+  const File_read::View* pv = this->find_view(start, size, -1U, NULL);

+  if (pv != NULL)

+    {

+      memcpy(p, pv->data() + (start - pv->start() + pv->byteshift()), size);

+      return;

+    }

+

+  this->do_read(start, size, p);

+}

+

+// Add a new view.  There may already be an existing view at this

+// offset.  If there is, the new view will be larger, and should

+// replace the old view.

+

+void

+File_read::add_view(File_read::View* v)

+{

+  std::pair<Views::iterator, bool> ins =

+    this->views_.insert(std::make_pair(std::make_pair(v->start(),

+						      v->byteshift()),

+				       v));

+  if (ins.second)

+    return;

+

+  // There was an existing view at this offset.  It must not be large

+  // enough.  We can't delete it here, since something might be using

+  // it; we put it on a list to be deleted when the file is unlocked.

+  File_read::View* vold = ins.first->second;

+  gold_assert(vold->size() < v->size());

+  if (vold->should_cache())

+    {

+      v->set_cache();

+      vold->clear_cache();

+    }

+  this->saved_views_.push_back(vold);

+

+  ins.first->second = v;

+}

+

+// Make a new view with a specified byteshift, reading the data from

+// the file.

+

+File_read::View*

+File_read::make_view(off_t start, section_size_type size,

+		     unsigned int byteshift, bool cache)

+{

+  gold_assert(size > 0);

+  gold_assert(start <= this->size_

+	      && (static_cast<unsigned long long>(size)

+		  <= static_cast<unsigned long long>(this->size_ - start)));

+

+  off_t poff = File_read::page_offset(start);

+

+  section_size_type psize = File_read::pages(size + (start - poff));

+

+  if (poff + static_cast<off_t>(psize) >= this->size_)

+    {

+      psize = this->size_ - poff;

+      gold_assert(psize >= size);

+    }

+

+  void* p;

+  View::Data_ownership ownership;

+  if (byteshift != 0)

+    {

+      p = malloc(psize + byteshift);

+      if (p == NULL)

+	gold_nomem();

+      memset(p, 0, byteshift);

+      this->do_read(poff, psize, static_cast<unsigned char*>(p) + byteshift);

+      ownership = View::DATA_ALLOCATED_ARRAY;

+    }

+  else

+    {

+      this->reopen_descriptor();

+      p = ::mmap(NULL, psize, PROT_READ, MAP_PRIVATE, this->descriptor_, poff);

+      if (p != MAP_FAILED)

+	{

+	  ownership = View::DATA_MMAPPED;

+	  this->mapped_bytes_ += psize;

+	}

+      else

+	{

+	  p = malloc(psize);

+	  if (p == NULL)

+	    gold_nomem();

+	  this->do_read(poff, psize, p);

+	  ownership = View::DATA_ALLOCATED_ARRAY;

+	}

+    }

+

+  const unsigned char* pbytes = static_cast<const unsigned char*>(p);

+  File_read::View* v = new File_read::View(poff, psize, pbytes, byteshift,

+					   cache, ownership);

+

+  this->add_view(v);

+

+  return v;

+}

+

+// Find a View or make a new one, shifted as required by the file

+// offset OFFSET and ALIGNED.

+

+File_read::View*

+File_read::find_or_make_view(off_t offset, off_t start,

+			     section_size_type size, bool aligned, bool cache)

+{

+  // Check that start and end of the view are within the file.

+  if (start > this->size_

+      || (static_cast<unsigned long long>(size)

+	  > static_cast<unsigned long long>(this->size_ - start)))

+    gold_fatal(_("%s: attempt to map %lld bytes at offset %lld exceeds "

+		 "size of file; the file may be corrupt"),

+		   this->filename().c_str(),

+		   static_cast<long long>(size),

+		   static_cast<long long>(start));

+

+  unsigned int byteshift;

+  if (offset == 0)

+    byteshift = 0;

+  else

+    {

+      unsigned int target_size = (!parameters->target_valid()

+				  ? 64

+				  : parameters->target().get_size());

+      byteshift = offset & ((target_size / 8) - 1);

+

+      // Set BYTESHIFT to the number of dummy bytes which must be

+      // inserted before the data in order for this data to be

+      // aligned.

+      if (byteshift != 0)

+	byteshift = (target_size / 8) - byteshift;

+    }

+

+  // If --map-whole-files is set, make sure we have a

+  // whole file view.  Options may not yet be ready, e.g.,

+  // when reading a version script.  We then default to

+  // --no-map-whole-files.

+  if (this->whole_file_view_ == NULL

+      && parameters->options_valid()

+      && parameters->options().map_whole_files())

+    this->whole_file_view_ = this->make_view(0, this->size_, 0, cache);

+

+  // Try to find a View with the required BYTESHIFT.

+  File_read::View* vshifted;

+  File_read::View* v = this->find_view(offset + start, size,

+				       aligned ? byteshift : -1U,

+				       &vshifted);

+  if (v != NULL)

+    {

+      if (cache)

+	v->set_cache();

+      return v;

+    }

+

+  // If VSHIFTED is not NULL, then it has the data we need, but with

+  // the wrong byteshift.

+  v = vshifted;

+  if (v != NULL)

+    {

+      gold_assert(aligned);

+

+      unsigned char* pbytes;

+      pbytes = static_cast<unsigned char*>(malloc(v->size() + byteshift));

+      if (pbytes == NULL)

+	gold_nomem();

+      memset(pbytes, 0, byteshift);

+      memcpy(pbytes + byteshift, v->data() + v->byteshift(), v->size());

+

+      File_read::View* shifted_view =

+	  new File_read::View(v->start(), v->size(), pbytes, byteshift,

+			      cache, View::DATA_ALLOCATED_ARRAY);

+

+      this->add_view(shifted_view);

+      return shifted_view;

+    }

+

+  // Make a new view.  If we don't need an aligned view, use a

+  // byteshift of 0, so that we can use mmap.

+  return this->make_view(offset + start, size,

+			 aligned ? byteshift : 0,

+			 cache);

+}

+

+// Get a view into the file.

+

+const unsigned char*

+File_read::get_view(off_t offset, off_t start, section_size_type size,

+		    bool aligned, bool cache)

+{

+  File_read::View* pv = this->find_or_make_view(offset, start, size,

+						aligned, cache);

+  return pv->data() + (offset + start - pv->start() + pv->byteshift());

+}

+

+File_view*

+File_read::get_lasting_view(off_t offset, off_t start, section_size_type size,

+			    bool aligned, bool cache)

+{

+  File_read::View* pv = this->find_or_make_view(offset, start, size,

+						aligned, cache);

+  pv->lock();

+  return new File_view(*this, pv,

+		       (pv->data()

+			+ (offset + start - pv->start() + pv->byteshift())));

+}

+

+// Use readv to read COUNT entries from RM starting at START.  BASE

+// must be added to all file offsets in RM.

+

+void

+File_read::do_readv(off_t base, const Read_multiple& rm, size_t start,

+		    size_t count)

+{

+  unsigned char discard[File_read::page_size];

+  iovec iov[File_read::max_readv_entries * 2];

+  size_t iov_index = 0;

+

+  off_t first_offset = rm[start].file_offset;

+  off_t last_offset = first_offset;

+  ssize_t want = 0;

+  for (size_t i = 0; i < count; ++i)

+    {

+      const Read_multiple_entry& i_entry(rm[start + i]);

+

+      if (i_entry.file_offset > last_offset)

+	{

+	  size_t skip = i_entry.file_offset - last_offset;

+	  gold_assert(skip <= sizeof discard);

+

+	  iov[iov_index].iov_base = discard;

+	  iov[iov_index].iov_len = skip;

+	  ++iov_index;

+

+	  want += skip;

+	}

+

+      iov[iov_index].iov_base = i_entry.buffer;

+      iov[iov_index].iov_len = i_entry.size;

+      ++iov_index;

+

+      want += i_entry.size;

+

+      last_offset = i_entry.file_offset + i_entry.size;

+    }

+

+  this->reopen_descriptor();

+

+  gold_assert(iov_index < sizeof iov / sizeof iov[0]);

+

+  if (::lseek(this->descriptor_, base + first_offset, SEEK_SET) < 0)

+    gold_fatal(_("%s: lseek failed: %s"),

+	       this->filename().c_str(), strerror(errno));

+

+  ssize_t got = ::readv(this->descriptor_, iov, iov_index);

+

+  if (got < 0)

+    gold_fatal(_("%s: readv failed: %s"),

+	       this->filename().c_str(), strerror(errno));

+  if (got != want)

+    gold_fatal(_("%s: file too short: read only %zd of %zd bytes at %lld"),

+	       this->filename().c_str(),

+	       got, want, static_cast<long long>(base + first_offset));

+}

+

+// Portable IOV_MAX.

+

+#if !defined(HAVE_READV)

+#define GOLD_IOV_MAX 1