gold/fileread.cc

   1 // fileread.cc -- read files for gold
   2
   3 // Copyright 2006, 2007 Free Software Foundation, Inc.
   4 // Written by Ian Lance Taylor <iant@google.com>.
   5
   6 // This file is part of gold.
   7
   8 // This program is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 3 of the License, or
  11 // (at your option) any later version.
  12
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the Free Software
  20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21 // MA 02110-1301, USA.
  22
  23 #include "gold.h"
  24
  25 #include <cstring>
  26 #include <cerrno>
  27 #include <fcntl.h>
  28 #include <unistd.h>
  29
  30 #include "options.h"
  31 #include "dirsearch.h"
  32 #include "fileread.h"
  33
  34 namespace gold
  35 {
  36
  37 // Class File_read::View.
  38
  39 File_read::View::~View()
  40 {
  41   gold_assert(!this->is_locked());
  42   delete[] this->data_;
  43 }
  44
  45 void
  46 File_read::View::lock()
  47 {
  48   ++this->lock_count_;
  49 }
  50
  51 void
  52 File_read::View::unlock()
  53 {
  54   gold_assert(this->lock_count_ > 0);
  55   --this->lock_count_;
  56 }
  57
  58 bool
  59 File_read::View::is_locked()
  60 {
  61   return this->lock_count_ > 0;
  62 }
  63
  64 // Class File_read.
  65
  66 // The File_read class is designed to support file descriptor caching,
  67 // but this is not currently implemented.
  68
  69 File_read::~File_read()
  70 {
  71   gold_assert(this->lock_count_ == 0);
  72   if (this->descriptor_ >= 0)
  73     {
  74       if (close(this->descriptor_) < 0)
  75         fprintf(stderr, _("%s: warning: close(%s) failed: %s"),
  76                 program_name, this->name_.c_str(), strerror(errno));
  77       this->descriptor_ = -1;
  78     }
  79   this->name_.clear();
  80   this->clear_views(true);
  81 }
  82
  83 // Open the file.
  84
  85 bool
  86 File_read::open(const std::string& name)
  87 {
  88   gold_assert(this->lock_count_ == 0
  89               && this->descriptor_ < 0
  90               && this->name_.empty());
  91   this->name_ = name;
  92   this->descriptor_ = ::open(this->name_.c_str(), O_RDONLY);
  93   ++this->lock_count_;
  94   return this->descriptor_ >= 0;
  95 }
  96
  97 // Open the file for testing purposes.
  98
  99 bool
 100 File_read::open(const std::string& name, const unsigned char* contents,
 101                 off_t contents_size)
 102 {
 103   gold_assert(this->lock_count_ == 0
 104               && this->descriptor_ < 0
 105               && this->name_.empty());
 106   this->name_ = name;
 107   this->contents_ = contents;
 108   this->contents_size_ = contents_size;
 109   ++this->lock_count_;
 110   return true;
 111 }
 112
 113 void
 114 File_read::lock()
 115 {
 116   ++this->lock_count_;
 117 }
 118
 119 void
 120 File_read::unlock()
 121 {
 122   gold_assert(this->lock_count_ > 0);
 123   --this->lock_count_;
 124 }
 125
 126 bool
 127 File_read::is_locked()
 128 {
 129   return this->lock_count_ > 0;
 130 }
 131
 132 // See if we have a view which covers the file starting at START for
 133 // SIZE bytes.  Return a pointer to the View if found, NULL if not.
 134
 135 inline File_read::View*
 136 File_read::find_view(off_t start, off_t size)
 137 {
 138   off_t page = File_read::page_offset(start);
 139   Views::iterator p = this->views_.find(page);
 140   if (p == this->views_.end())
 141     return NULL;
 142   if (p->second->size() - (start - page) < size)
 143     return NULL;
 144   return p->second;
 145 }
 146
 147 // Read data from the file.  Return the number of bytes read.  If
 148 // PBYTES is not NULL, store the number of bytes in *PBYTES, otherwise
 149 // require that we read exactly the number of bytes requested.
 150
 151 off_t
 152 File_read::do_read(off_t start, off_t size, void* p, off_t* pbytes)
 153 {
 154   gold_assert(this->lock_count_ > 0);
 155
 156   off_t bytes;
 157   if (this->contents_ == NULL)
 158     {
 159       int o = this->descriptor_;
 160
 161       if (lseek(o, start, SEEK_SET) < 0)
 162         {
 163           fprintf(stderr, _("%s: %s: lseek to %lld failed: %s"),
 164                   program_name, this->filename().c_str(),
 165                   static_cast<long long>(start),
 166                   strerror(errno));
 167           gold_exit(false);
 168         }
 169
 170       bytes = ::read(o, p, size);
 171       if (bytes < 0)
 172         {
 173           fprintf(stderr, _("%s: %s: read failed: %s\n"),
 174                   program_name, this->filename().c_str(), strerror(errno));
 175           gold_exit(false);
 176         }
 177     }
 178   else
 179     {
 180       bytes = this->contents_size_ - start;
 181       if (bytes < 0)
 182         bytes = 0;
 183       else if (bytes > size)
 184         bytes = size;
 185       memcpy(p, this->contents_ + start, bytes);
 186     }
 187
 188   if (pbytes != NULL)
 189     *pbytes = bytes;
 190   else if (bytes != size)
 191     {
 192       fprintf(stderr,
 193               _("%s: %s: file too short: read only %lld of %lld "
 194                 "bytes at %lld\n"),
 195               program_name, this->filename().c_str(),
 196               static_cast<long long>(bytes),
 197               static_cast<long long>(size),
 198               static_cast<long long>(start));
 199       gold_exit(false);
 200     }
 201
 202   return bytes;
 203 }
 204
 205 // Read data from the file.
 206
 207 void
 208 File_read::read(off_t start, off_t size, void* p)
 209 {
 210   gold_assert(this->lock_count_ > 0);
 211
 212   File_read::View* pv = this->find_view(start, size);
 213   if (pv != NULL)
 214     {
 215       memcpy(p, pv->data() + (start - pv->start()), size);
 216       return;
 217     }
 218
 219   this->do_read(start, size, p, NULL);
 220 }
 221
 222 void
 223 File_read::read_up_to(off_t start, off_t size, void* p, off_t* pbytes)
 224 {
 225   gold_assert(this->lock_count_ > 0);
 226
 227   File_read::View* pv = this->find_view(start, size);
 228   if (pv != NULL)
 229     {
 230       memcpy(p, pv->data() + (start - pv->start()), size);
 231       if (pbytes != NULL)
 232         *pbytes = size;
 233       return;
 234     }
 235
 236   this->do_read(start, size, p, pbytes);
 237 }
 238
 239 // Find an existing view or make a new one.
 240
 241 File_read::View*
 242 File_read::find_or_make_view(off_t start, off_t size, off_t* pbytes)
 243 {
 244   gold_assert(this->lock_count_ > 0);
 245
 246   off_t poff = File_read::page_offset(start);
 247
 248   File_read::View* const vnull = NULL;
 249   std::pair<Views::iterator, bool> ins =
 250     this->views_.insert(std::make_pair(poff, vnull));
 251
 252   if (!ins.second)
 253     {
 254       // There was an existing view at this offset.
 255       File_read::View* v = ins.first->second;
 256       if (v->size() - (start - v->start()) >= size)
 257         {
 258           if (pbytes != NULL)
 259             *pbytes = size;
 260           return v;
 261         }
 262
 263       // This view is not large enough.
 264       this->saved_views_.push_back(v);
 265     }
 266
 267   // We need to read data from the file.
 268
 269   off_t psize = File_read::pages(size + (start - poff));
 270   unsigned char* p = new unsigned char[psize];
 271
 272   off_t got_bytes;
 273   off_t bytes = this->do_read(poff, psize, p, &got_bytes);
 274
 275   File_read::View* v = new File_read::View(poff, bytes, p);
 276
 277   ins.first->second = v;
 278
 279   if (bytes - (start - poff) >= size)
 280     {
 281       if (pbytes != NULL)
 282         *pbytes = size;
 283       return v;
 284     }
 285
 286   if (pbytes != NULL)
 287     {
 288       *pbytes = bytes - (start - poff);
 289       return v;
 290     }
 291
 292   fprintf(stderr,
 293           _("%s: %s: file too short: read only %lld of %lld bytes at %lld\n"),
 294           program_name, this->filename().c_str(),
 295           static_cast<long long>(bytes - (start - poff)),
 296           static_cast<long long>(size),
 297           static_cast<long long>(start));
 298   gold_exit(false);
 299 }
 300
 301 // This implementation of get_view just reads into a memory buffer,
 302 // which we store on view_list_.  At some point we should support
 303 // mmap.
 304
 305 const unsigned char*
 306 File_read::get_view(off_t start, off_t size)
 307 {
 308   gold_assert(this->lock_count_ > 0);
 309   File_read::View* pv = this->find_or_make_view(start, size, NULL);
 310   return pv->data() + (start - pv->start());
 311 }
 312
 313 const unsigned char*
 314 File_read::get_view_and_size(off_t start, off_t size, off_t* pbytes)
 315 {
 316   gold_assert(this->lock_count_ > 0);
 317   File_read::View* pv = this->find_or_make_view(start, size, pbytes);
 318   return pv->data() + (start - pv->start());
 319 }
 320
 321 File_view*
 322 File_read::get_lasting_view(off_t start, off_t size)
 323 {
 324   gold_assert(this->lock_count_ > 0);
 325   File_read::View* pv = this->find_or_make_view(start, size, NULL);
 326   pv->lock();
 327   return new File_view(*this, pv, pv->data() + (start - pv->start()));
 328 }
 329
 330 // Remove all the file views.
 331
 332 void
 333 File_read::clear_views(bool destroying)
 334 {
 335   for (Views::iterator p = this->views_.begin();
 336        p != this->views_.end();
 337        ++p)
 338     {
 339       if (!p->second->is_locked())
 340         delete p->second;
 341       else
 342         {
 343           gold_assert(!destroying);
 344           this->saved_views_.push_back(p->second);
 345         }
 346     }
 347   this->views_.clear();
 348
 349   Saved_views::iterator p = this->saved_views_.begin();
 350   while (p != this->saved_views_.end())
 351     {
 352       if (!(*p)->is_locked())
 353         {
 354           delete *p;
 355           p = this->saved_views_.erase(p);
 356         }
 357       else
 358         {
 359           gold_assert(!destroying);
 360           ++p;
 361         }
 362     }
 363 }
 364
 365 // Class File_view.
 366
 367 File_view::~File_view()
 368 {
 369   gold_assert(this->file_.is_locked());
 370   this->view_->unlock();
 371 }
 372
 373 // Class Input_file.
 374
 375 // Create a file for testing.
 376
 377 Input_file::Input_file(const char* name, const unsigned char* contents,
 378                        off_t size)
 379   : file_()
 380 {
 381   this->input_argument_ =
 382     new Input_file_argument(name, false, Position_dependent_options());
 383   bool ok = file_.open(name, contents, size);
 384   gold_assert(ok);
 385 }
 386
 387 // Open the file.
 388
 389 void
 390 Input_file::open(const General_options& options, const Dirsearch& dirpath)
 391 {
 392   std::string name;
 393   if (!this->input_argument_->is_lib())
 394     name = this->input_argument_->name();
 395   else
 396     {
 397       std::string n1("lib");
 398       n1 += this->input_argument_->name();
 399       std::string n2;
 400       if (options.is_static())
 401         n1 += ".a";
 402       else
 403         {
 404           n2 = n1 + ".a";
 405           n1 += ".so";
 406         }
 407       name = dirpath.find(n1, n2);
 408       if (name.empty())
 409         {
 410           fprintf(stderr, _("%s: cannot find %s\n"), program_name,
 411                   this->input_argument_->name());
 412           gold_exit(false);
 413         }
 414     }
 415
 416   if (!this->file_.open(name))
 417     {
 418       fprintf(stderr, _("%s: cannot open %s: %s\n"), program_name,
 419               name.c_str(), strerror(errno));
 420       gold_exit(false);
 421     }
 422 }
 423
 424 } // End namespace gold.