1ed0d50c3Schristos // fileread.cc -- read files for gold
2ed0d50c3Schristos
3*b88e3e88Schristos // Copyright (C) 2006-2020 Free Software Foundation, Inc.
4ed0d50c3Schristos // Written by Ian Lance Taylor <iant@google.com>.
5ed0d50c3Schristos
6ed0d50c3Schristos // This file is part of gold.
7ed0d50c3Schristos
8ed0d50c3Schristos // This program is free software; you can redistribute it and/or modify
9ed0d50c3Schristos // it under the terms of the GNU General Public License as published by
10ed0d50c3Schristos // the Free Software Foundation; either version 3 of the License, or
11ed0d50c3Schristos // (at your option) any later version.
12ed0d50c3Schristos
13ed0d50c3Schristos // This program is distributed in the hope that it will be useful,
14ed0d50c3Schristos // but WITHOUT ANY WARRANTY; without even the implied warranty of
15ed0d50c3Schristos // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16ed0d50c3Schristos // GNU General Public License for more details.
17ed0d50c3Schristos
18ed0d50c3Schristos // You should have received a copy of the GNU General Public License
19ed0d50c3Schristos // along with this program; if not, write to the Free Software
20ed0d50c3Schristos // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21ed0d50c3Schristos // MA 02110-1301, USA.
22ed0d50c3Schristos
23ed0d50c3Schristos #include "gold.h"
24ed0d50c3Schristos
25ed0d50c3Schristos #include <cstring>
26ed0d50c3Schristos #include <cerrno>
27ed0d50c3Schristos #include <climits>
28ed0d50c3Schristos #include <fcntl.h>
29ed0d50c3Schristos #include <unistd.h>
30ed0d50c3Schristos
31ed0d50c3Schristos #ifdef HAVE_SYS_MMAN_H
32ed0d50c3Schristos #include <sys/mman.h>
33ed0d50c3Schristos #endif
34ed0d50c3Schristos
35ed0d50c3Schristos #ifdef HAVE_READV
36ed0d50c3Schristos #include <sys/uio.h>
37ed0d50c3Schristos #endif
38ed0d50c3Schristos
39ed0d50c3Schristos #include <sys/stat.h>
40ed0d50c3Schristos #include "filenames.h"
41ed0d50c3Schristos
42ed0d50c3Schristos #include "debug.h"
43ed0d50c3Schristos #include "parameters.h"
44ed0d50c3Schristos #include "options.h"
45ed0d50c3Schristos #include "dirsearch.h"
46ed0d50c3Schristos #include "target.h"
47ed0d50c3Schristos #include "binary.h"
48ed0d50c3Schristos #include "descriptors.h"
49ed0d50c3Schristos #include "gold-threads.h"
50ed0d50c3Schristos #include "fileread.h"
51ed0d50c3Schristos
52ed0d50c3Schristos // For systems without mmap support.
53ed0d50c3Schristos #ifndef HAVE_MMAP
54ed0d50c3Schristos # define mmap gold_mmap
55ed0d50c3Schristos # define munmap gold_munmap
56ed0d50c3Schristos # ifndef MAP_FAILED
57ed0d50c3Schristos # define MAP_FAILED (reinterpret_cast<void*>(-1))
58ed0d50c3Schristos # endif
59ed0d50c3Schristos # ifndef PROT_READ
60ed0d50c3Schristos # define PROT_READ 0
61ed0d50c3Schristos # endif
62ed0d50c3Schristos # ifndef MAP_PRIVATE
63ed0d50c3Schristos # define MAP_PRIVATE 0
64ed0d50c3Schristos # endif
65ed0d50c3Schristos
66ed0d50c3Schristos # ifndef ENOSYS
67ed0d50c3Schristos # define ENOSYS EINVAL
68ed0d50c3Schristos # endif
69ed0d50c3Schristos
70ed0d50c3Schristos static void *
gold_mmap(void *,size_t,int,int,int,off_t)71ed0d50c3Schristos gold_mmap(void *, size_t, int, int, int, off_t)
72ed0d50c3Schristos {
73ed0d50c3Schristos errno = ENOSYS;
74ed0d50c3Schristos return MAP_FAILED;
75ed0d50c3Schristos }
76ed0d50c3Schristos
77ed0d50c3Schristos static int
gold_munmap(void *,size_t)78ed0d50c3Schristos gold_munmap(void *, size_t)
79ed0d50c3Schristos {
80ed0d50c3Schristos errno = ENOSYS;
81ed0d50c3Schristos return -1;
82ed0d50c3Schristos }
83ed0d50c3Schristos
84ed0d50c3Schristos #endif
85ed0d50c3Schristos
86ed0d50c3Schristos #ifndef HAVE_READV
87ed0d50c3Schristos struct iovec { void* iov_base; size_t iov_len; };
88ed0d50c3Schristos ssize_t
readv(int,const iovec *,int)89ed0d50c3Schristos readv(int, const iovec*, int)
90ed0d50c3Schristos {
91ed0d50c3Schristos gold_unreachable();
92ed0d50c3Schristos }
93ed0d50c3Schristos #endif
94ed0d50c3Schristos
95ed0d50c3Schristos namespace gold
96ed0d50c3Schristos {
97ed0d50c3Schristos
98ed0d50c3Schristos // Get the last modified time of an unopened file.
99ed0d50c3Schristos
100ed0d50c3Schristos bool
get_mtime(const char * filename,Timespec * mtime)101ed0d50c3Schristos get_mtime(const char* filename, Timespec* mtime)
102ed0d50c3Schristos {
103ed0d50c3Schristos struct stat file_stat;
104ed0d50c3Schristos
105ed0d50c3Schristos if (stat(filename, &file_stat) < 0)
106ed0d50c3Schristos return false;
107ed0d50c3Schristos #ifdef HAVE_STAT_ST_MTIM
108ed0d50c3Schristos mtime->seconds = file_stat.st_mtim.tv_sec;
109ed0d50c3Schristos mtime->nanoseconds = file_stat.st_mtim.tv_nsec;
110ed0d50c3Schristos #else
111ed0d50c3Schristos mtime->seconds = file_stat.st_mtime;
112ed0d50c3Schristos mtime->nanoseconds = 0;
113ed0d50c3Schristos #endif
114ed0d50c3Schristos return true;
115ed0d50c3Schristos }
116ed0d50c3Schristos
117ed0d50c3Schristos // Class File_read.
118ed0d50c3Schristos
119ed0d50c3Schristos // A lock for the File_read static variables.
120ed0d50c3Schristos static Lock* file_counts_lock = NULL;
121ed0d50c3Schristos static Initialize_lock file_counts_initialize_lock(&file_counts_lock);
122ed0d50c3Schristos
123ed0d50c3Schristos // The File_read static variables.
124ed0d50c3Schristos unsigned long long File_read::total_mapped_bytes;
125ed0d50c3Schristos unsigned long long File_read::current_mapped_bytes;
126ed0d50c3Schristos unsigned long long File_read::maximum_mapped_bytes;
127ed0d50c3Schristos
128ed0d50c3Schristos // Class File_read::View.
129ed0d50c3Schristos
~View()130ed0d50c3Schristos File_read::View::~View()
131ed0d50c3Schristos {
132ed0d50c3Schristos gold_assert(!this->is_locked());
133ed0d50c3Schristos switch (this->data_ownership_)
134ed0d50c3Schristos {
135ed0d50c3Schristos case DATA_ALLOCATED_ARRAY:
136ed0d50c3Schristos free(const_cast<unsigned char*>(this->data_));
137ed0d50c3Schristos break;
138ed0d50c3Schristos case DATA_MMAPPED:
139ed0d50c3Schristos if (::munmap(const_cast<unsigned char*>(this->data_), this->size_) != 0)
140ed0d50c3Schristos gold_warning(_("munmap failed: %s"), strerror(errno));
141ed0d50c3Schristos if (!parameters->options_valid() || parameters->options().stats())
142ed0d50c3Schristos {
143ed0d50c3Schristos file_counts_initialize_lock.initialize();
144ed0d50c3Schristos Hold_optional_lock hl(file_counts_lock);
145ed0d50c3Schristos File_read::current_mapped_bytes -= this->size_;
146ed0d50c3Schristos }
147ed0d50c3Schristos break;
148ed0d50c3Schristos case DATA_NOT_OWNED:
149ed0d50c3Schristos break;
150ed0d50c3Schristos default:
151ed0d50c3Schristos gold_unreachable();
152ed0d50c3Schristos }
153ed0d50c3Schristos }
154ed0d50c3Schristos
155ed0d50c3Schristos void
lock()156ed0d50c3Schristos File_read::View::lock()
157ed0d50c3Schristos {
158ed0d50c3Schristos ++this->lock_count_;
159ed0d50c3Schristos }
160ed0d50c3Schristos
161ed0d50c3Schristos void
unlock()162ed0d50c3Schristos File_read::View::unlock()
163ed0d50c3Schristos {
164ed0d50c3Schristos gold_assert(this->lock_count_ > 0);
165ed0d50c3Schristos --this->lock_count_;
166ed0d50c3Schristos }
167ed0d50c3Schristos
168ed0d50c3Schristos bool
is_locked()169ed0d50c3Schristos File_read::View::is_locked()
170ed0d50c3Schristos {
171ed0d50c3Schristos return this->lock_count_ > 0;
172ed0d50c3Schristos }
173ed0d50c3Schristos
174ed0d50c3Schristos // Class File_read.
175ed0d50c3Schristos
~File_read()176ed0d50c3Schristos File_read::~File_read()
177ed0d50c3Schristos {
178ed0d50c3Schristos gold_assert(this->token_.is_writable());
179ed0d50c3Schristos if (this->is_descriptor_opened_)
180ed0d50c3Schristos {
181ed0d50c3Schristos release_descriptor(this->descriptor_, true);
182ed0d50c3Schristos this->descriptor_ = -1;
183ed0d50c3Schristos this->is_descriptor_opened_ = false;
184ed0d50c3Schristos }
185ed0d50c3Schristos this->name_.clear();
186ed0d50c3Schristos this->clear_views(CLEAR_VIEWS_ALL);
187ed0d50c3Schristos }
188ed0d50c3Schristos
189ed0d50c3Schristos // Open the file.
190ed0d50c3Schristos
191ed0d50c3Schristos bool
open(const Task * task,const std::string & name)192ed0d50c3Schristos File_read::open(const Task* task, const std::string& name)
193ed0d50c3Schristos {
194ed0d50c3Schristos gold_assert(this->token_.is_writable()
195ed0d50c3Schristos && this->descriptor_ < 0
196ed0d50c3Schristos && !this->is_descriptor_opened_
197ed0d50c3Schristos && this->name_.empty());
198ed0d50c3Schristos this->name_ = name;
199ed0d50c3Schristos
200ed0d50c3Schristos this->descriptor_ = open_descriptor(-1, this->name_.c_str(),
201ed0d50c3Schristos O_RDONLY);
202ed0d50c3Schristos
203ed0d50c3Schristos if (this->descriptor_ >= 0)
204ed0d50c3Schristos {
205ed0d50c3Schristos this->is_descriptor_opened_ = true;
206ed0d50c3Schristos struct stat s;
207ed0d50c3Schristos if (::fstat(this->descriptor_, &s) < 0)
208ed0d50c3Schristos gold_error(_("%s: fstat failed: %s"),
209ed0d50c3Schristos this->name_.c_str(), strerror(errno));
210ed0d50c3Schristos this->size_ = s.st_size;
211ed0d50c3Schristos gold_debug(DEBUG_FILES, "Attempt to open %s succeeded",
212ed0d50c3Schristos this->name_.c_str());
213ed0d50c3Schristos this->token_.add_writer(task);
214ed0d50c3Schristos }
215ed0d50c3Schristos
216ed0d50c3Schristos return this->descriptor_ >= 0;
217ed0d50c3Schristos }
218ed0d50c3Schristos
219ed0d50c3Schristos // Open the file with the contents in memory.
220ed0d50c3Schristos
221ed0d50c3Schristos bool
open(const Task * task,const std::string & name,const unsigned char * contents,off_t size)222ed0d50c3Schristos File_read::open(const Task* task, const std::string& name,
223ed0d50c3Schristos const unsigned char* contents, off_t size)
224ed0d50c3Schristos {
225ed0d50c3Schristos gold_assert(this->token_.is_writable()
226ed0d50c3Schristos && this->descriptor_ < 0
227ed0d50c3Schristos && !this->is_descriptor_opened_
228ed0d50c3Schristos && this->name_.empty());
229ed0d50c3Schristos this->name_ = name;
230ed0d50c3Schristos this->whole_file_view_ = new View(0, size, contents, 0, false,
231ed0d50c3Schristos View::DATA_NOT_OWNED);
232ed0d50c3Schristos this->add_view(this->whole_file_view_);
233ed0d50c3Schristos this->size_ = size;
234ed0d50c3Schristos this->token_.add_writer(task);
235ed0d50c3Schristos return true;
236ed0d50c3Schristos }
237ed0d50c3Schristos
238ed0d50c3Schristos // Reopen a descriptor if necessary.
239ed0d50c3Schristos
240ed0d50c3Schristos void
reopen_descriptor()241ed0d50c3Schristos File_read::reopen_descriptor()
242ed0d50c3Schristos {
243ed0d50c3Schristos if (!this->is_descriptor_opened_)
244ed0d50c3Schristos {
245ed0d50c3Schristos this->descriptor_ = open_descriptor(this->descriptor_,
246ed0d50c3Schristos this->name_.c_str(),
247ed0d50c3Schristos O_RDONLY);
248ed0d50c3Schristos if (this->descriptor_ < 0)
249ed0d50c3Schristos gold_fatal(_("could not reopen file %s"), this->name_.c_str());
250ed0d50c3Schristos this->is_descriptor_opened_ = true;
251ed0d50c3Schristos }
252ed0d50c3Schristos }
253ed0d50c3Schristos
254ed0d50c3Schristos // Release the file. This is called when we are done with the file in
255ed0d50c3Schristos // a Task.
256ed0d50c3Schristos
257ed0d50c3Schristos void
release()258ed0d50c3Schristos File_read::release()
259ed0d50c3Schristos {
260ed0d50c3Schristos gold_assert(this->is_locked());
261ed0d50c3Schristos
262ed0d50c3Schristos if (!parameters->options_valid() || parameters->options().stats())
263ed0d50c3Schristos {
264ed0d50c3Schristos file_counts_initialize_lock.initialize();
265ed0d50c3Schristos Hold_optional_lock hl(file_counts_lock);
266ed0d50c3Schristos File_read::total_mapped_bytes += this->mapped_bytes_;
267ed0d50c3Schristos File_read::current_mapped_bytes += this->mapped_bytes_;
268ed0d50c3Schristos if (File_read::current_mapped_bytes > File_read::maximum_mapped_bytes)
269ed0d50c3Schristos File_read::maximum_mapped_bytes = File_read::current_mapped_bytes;
270ed0d50c3Schristos }
271ed0d50c3Schristos
272ed0d50c3Schristos this->mapped_bytes_ = 0;
273ed0d50c3Schristos
274ed0d50c3Schristos // Only clear views if there is only one attached object. Otherwise
275ed0d50c3Schristos // we waste time trying to clear cached archive views. Similarly
276ed0d50c3Schristos // for releasing the descriptor.
277ed0d50c3Schristos if (this->object_count_ <= 1)
278ed0d50c3Schristos {
279ed0d50c3Schristos this->clear_views(CLEAR_VIEWS_NORMAL);
280ed0d50c3Schristos if (this->is_descriptor_opened_)
281ed0d50c3Schristos {
282ed0d50c3Schristos release_descriptor(this->descriptor_, false);
283ed0d50c3Schristos this->is_descriptor_opened_ = false;
284ed0d50c3Schristos }
285ed0d50c3Schristos }
286ed0d50c3Schristos
287ed0d50c3Schristos this->released_ = true;
288ed0d50c3Schristos }
289ed0d50c3Schristos
290ed0d50c3Schristos // Lock the file.
291ed0d50c3Schristos
292ed0d50c3Schristos void
lock(const Task * task)293ed0d50c3Schristos File_read::lock(const Task* task)
294ed0d50c3Schristos {
295ed0d50c3Schristos gold_assert(this->released_);
296ed0d50c3Schristos gold_debug(DEBUG_FILES, "Locking file \"%s\"", this->name_.c_str());
297ed0d50c3Schristos this->token_.add_writer(task);
298ed0d50c3Schristos this->released_ = false;
299ed0d50c3Schristos }
300ed0d50c3Schristos
301ed0d50c3Schristos // Unlock the file.
302ed0d50c3Schristos
303ed0d50c3Schristos void
unlock(const Task * task)304ed0d50c3Schristos File_read::unlock(const Task* task)
305ed0d50c3Schristos {
306ed0d50c3Schristos gold_debug(DEBUG_FILES, "Unlocking file \"%s\"", this->name_.c_str());
307ed0d50c3Schristos this->release();
308ed0d50c3Schristos this->token_.remove_writer(task);
309ed0d50c3Schristos }
310ed0d50c3Schristos
311ed0d50c3Schristos // Return whether the file is locked.
312ed0d50c3Schristos
313ed0d50c3Schristos bool
is_locked() const314ed0d50c3Schristos File_read::is_locked() const
315ed0d50c3Schristos {
316ed0d50c3Schristos if (!this->token_.is_writable())
317ed0d50c3Schristos return true;
318ed0d50c3Schristos // The file is not locked, so it should have been released.
319ed0d50c3Schristos gold_assert(this->released_);
320ed0d50c3Schristos return false;
321ed0d50c3Schristos }
322ed0d50c3Schristos
323ed0d50c3Schristos // See if we have a view which covers the file starting at START for
324ed0d50c3Schristos // SIZE bytes. Return a pointer to the View if found, NULL if not.
325ed0d50c3Schristos // If BYTESHIFT is not -1U, the returned View must have the specified
326ed0d50c3Schristos // byte shift; otherwise, it may have any byte shift. If VSHIFTED is
327ed0d50c3Schristos // not NULL, this sets *VSHIFTED to a view which would have worked if
328ed0d50c3Schristos // not for the requested BYTESHIFT.
329ed0d50c3Schristos
330ed0d50c3Schristos inline File_read::View*
find_view(off_t start,section_size_type size,unsigned int byteshift,File_read::View ** vshifted) const331ed0d50c3Schristos File_read::find_view(off_t start, section_size_type size,
332ed0d50c3Schristos unsigned int byteshift, File_read::View** vshifted) const
333ed0d50c3Schristos {
334ed0d50c3Schristos gold_assert(start <= this->size_
335ed0d50c3Schristos && (static_cast<unsigned long long>(size)
336ed0d50c3Schristos <= static_cast<unsigned long long>(this->size_ - start)));
337ed0d50c3Schristos
338ed0d50c3Schristos if (vshifted != NULL)
339ed0d50c3Schristos *vshifted = NULL;
340ed0d50c3Schristos
341ed0d50c3Schristos // If we have the whole file mmapped, and the alignment is right,
342ed0d50c3Schristos // we can return it.
343ed0d50c3Schristos if (this->whole_file_view_)
344ed0d50c3Schristos if (byteshift == -1U || byteshift == 0)
345ed0d50c3Schristos return this->whole_file_view_;
346ed0d50c3Schristos
347ed0d50c3Schristos off_t page = File_read::page_offset(start);
348ed0d50c3Schristos
349ed0d50c3Schristos unsigned int bszero = 0;
350ed0d50c3Schristos Views::const_iterator p = this->views_.upper_bound(std::make_pair(page - 1,
351ed0d50c3Schristos bszero));
352ed0d50c3Schristos
353ed0d50c3Schristos while (p != this->views_.end() && p->first.first <= page)
354ed0d50c3Schristos {
355ed0d50c3Schristos if (p->second->start() <= start
356ed0d50c3Schristos && (p->second->start() + static_cast<off_t>(p->second->size())
357ed0d50c3Schristos >= start + static_cast<off_t>(size)))
358ed0d50c3Schristos {
359ed0d50c3Schristos if (byteshift == -1U || byteshift == p->second->byteshift())
360ed0d50c3Schristos {
361ed0d50c3Schristos p->second->set_accessed();
362ed0d50c3Schristos return p->second;
363ed0d50c3Schristos }
364ed0d50c3Schristos
365ed0d50c3Schristos if (vshifted != NULL && *vshifted == NULL)
366ed0d50c3Schristos *vshifted = p->second;
367ed0d50c3Schristos }
368ed0d50c3Schristos
369ed0d50c3Schristos ++p;
370ed0d50c3Schristos }
371ed0d50c3Schristos
372ed0d50c3Schristos return NULL;
373ed0d50c3Schristos }
374ed0d50c3Schristos
375ed0d50c3Schristos // Read SIZE bytes from the file starting at offset START. Read into
376ed0d50c3Schristos // the buffer at P.
377ed0d50c3Schristos
378ed0d50c3Schristos void
do_read(off_t start,section_size_type size,void * p)379ed0d50c3Schristos File_read::do_read(off_t start, section_size_type size, void* p)
380ed0d50c3Schristos {
381ed0d50c3Schristos ssize_t bytes;
382ed0d50c3Schristos if (this->whole_file_view_ != NULL)
383ed0d50c3Schristos {
384ed0d50c3Schristos bytes = this->size_ - start;
385ed0d50c3Schristos if (static_cast<section_size_type>(bytes) >= size)
386ed0d50c3Schristos {
387ed0d50c3Schristos memcpy(p, this->whole_file_view_->data() + start, size);
388ed0d50c3Schristos return;
389ed0d50c3Schristos }
390ed0d50c3Schristos }
391ed0d50c3Schristos else
392ed0d50c3Schristos {
393ed0d50c3Schristos this->reopen_descriptor();
394ed0d50c3Schristos
395ed0d50c3Schristos char *read_ptr = static_cast<char *>(p);
396ed0d50c3Schristos off_t read_pos = start;
397ed0d50c3Schristos size_t to_read = size;
398ed0d50c3Schristos do
399ed0d50c3Schristos {
400ed0d50c3Schristos bytes = ::pread(this->descriptor_, read_ptr, to_read, read_pos);
401ed0d50c3Schristos if (bytes < 0)
402ed0d50c3Schristos gold_fatal(_("%s: pread failed: %s"),
403ed0d50c3Schristos this->filename().c_str(), strerror(errno));
404ed0d50c3Schristos
405ed0d50c3Schristos read_pos += bytes;
406ed0d50c3Schristos read_ptr += bytes;
407ed0d50c3Schristos to_read -= bytes;
408ed0d50c3Schristos if (to_read == 0)
409ed0d50c3Schristos return;
410ed0d50c3Schristos }
411ed0d50c3Schristos while (bytes > 0);
412ed0d50c3Schristos
413ed0d50c3Schristos bytes = size - to_read;
414ed0d50c3Schristos }
415ed0d50c3Schristos
416ed0d50c3Schristos gold_fatal(_("%s: file too short: read only %lld of %lld bytes at %lld"),
417ed0d50c3Schristos this->filename().c_str(),
418ed0d50c3Schristos static_cast<long long>(bytes),
419ed0d50c3Schristos static_cast<long long>(size),
420ed0d50c3Schristos static_cast<long long>(start));
421ed0d50c3Schristos }
422ed0d50c3Schristos
423ed0d50c3Schristos // Read data from the file.
424ed0d50c3Schristos
425ed0d50c3Schristos void
read(off_t start,section_size_type size,void * p)426ed0d50c3Schristos File_read::read(off_t start, section_size_type size, void* p)
427ed0d50c3Schristos {
428ed0d50c3Schristos const File_read::View* pv = this->find_view(start, size, -1U, NULL);
429ed0d50c3Schristos if (pv != NULL)
430ed0d50c3Schristos {
431ed0d50c3Schristos memcpy(p, pv->data() + (start - pv->start() + pv->byteshift()), size);
432ed0d50c3Schristos return;
433ed0d50c3Schristos }
434ed0d50c3Schristos
435ed0d50c3Schristos this->do_read(start, size, p);
436ed0d50c3Schristos }
437ed0d50c3Schristos
438ed0d50c3Schristos // Add a new view. There may already be an existing view at this
439ed0d50c3Schristos // offset. If there is, the new view will be larger, and should
440ed0d50c3Schristos // replace the old view.
441ed0d50c3Schristos
442ed0d50c3Schristos void
add_view(File_read::View * v)443ed0d50c3Schristos File_read::add_view(File_read::View* v)
444ed0d50c3Schristos {
445ed0d50c3Schristos std::pair<Views::iterator, bool> ins =
446ed0d50c3Schristos this->views_.insert(std::make_pair(std::make_pair(v->start(),
447ed0d50c3Schristos v->byteshift()),
448ed0d50c3Schristos v));
449ed0d50c3Schristos if (ins.second)
450ed0d50c3Schristos return;
451ed0d50c3Schristos
452ed0d50c3Schristos // There was an existing view at this offset. It must not be large
453ed0d50c3Schristos // enough. We can't delete it here, since something might be using
454ed0d50c3Schristos // it; we put it on a list to be deleted when the file is unlocked.
455ed0d50c3Schristos File_read::View* vold = ins.first->second;
456ed0d50c3Schristos gold_assert(vold->size() < v->size());
457ed0d50c3Schristos if (vold->should_cache())
458ed0d50c3Schristos {
459ed0d50c3Schristos v->set_cache();
460ed0d50c3Schristos vold->clear_cache();
461ed0d50c3Schristos }
462ed0d50c3Schristos this->saved_views_.push_back(vold);
463ed0d50c3Schristos
464ed0d50c3Schristos ins.first->second = v;
465ed0d50c3Schristos }
466ed0d50c3Schristos
467ed0d50c3Schristos // Make a new view with a specified byteshift, reading the data from
468ed0d50c3Schristos // the file.
469ed0d50c3Schristos
470ed0d50c3Schristos File_read::View*
make_view(off_t start,section_size_type size,unsigned int byteshift,bool cache)471ed0d50c3Schristos File_read::make_view(off_t start, section_size_type size,
472ed0d50c3Schristos unsigned int byteshift, bool cache)
473ed0d50c3Schristos {
474ed0d50c3Schristos gold_assert(size > 0);
475ed0d50c3Schristos gold_assert(start <= this->size_
476ed0d50c3Schristos && (static_cast<unsigned long long>(size)
477ed0d50c3Schristos <= static_cast<unsigned long long>(this->size_ - start)));
478ed0d50c3Schristos
479ed0d50c3Schristos off_t poff = File_read::page_offset(start);
480ed0d50c3Schristos
481ed0d50c3Schristos section_size_type psize = File_read::pages(size + (start - poff));
482ed0d50c3Schristos
483ed0d50c3Schristos if (poff + static_cast<off_t>(psize) >= this->size_)
484ed0d50c3Schristos {
485ed0d50c3Schristos psize = this->size_ - poff;
486ed0d50c3Schristos gold_assert(psize >= size);
487ed0d50c3Schristos }
488ed0d50c3Schristos
489ed0d50c3Schristos void* p;
490ed0d50c3Schristos View::Data_ownership ownership;
491ed0d50c3Schristos if (byteshift != 0)
492ed0d50c3Schristos {
493ed0d50c3Schristos p = malloc(psize + byteshift);
494ed0d50c3Schristos if (p == NULL)
495ed0d50c3Schristos gold_nomem();
496ed0d50c3Schristos memset(p, 0, byteshift);
497ed0d50c3Schristos this->do_read(poff, psize, static_cast<unsigned char*>(p) + byteshift);
498ed0d50c3Schristos ownership = View::DATA_ALLOCATED_ARRAY;
499ed0d50c3Schristos }
500ed0d50c3Schristos else
501ed0d50c3Schristos {
502ed0d50c3Schristos this->reopen_descriptor();
503ed0d50c3Schristos p = ::mmap(NULL, psize, PROT_READ, MAP_PRIVATE, this->descriptor_, poff);
504ed0d50c3Schristos if (p != MAP_FAILED)
505ed0d50c3Schristos {
506ed0d50c3Schristos ownership = View::DATA_MMAPPED;
507ed0d50c3Schristos this->mapped_bytes_ += psize;
508ed0d50c3Schristos }
509ed0d50c3Schristos else
510ed0d50c3Schristos {
511ed0d50c3Schristos p = malloc(psize);
512ed0d50c3Schristos if (p == NULL)
513ed0d50c3Schristos gold_nomem();
514ed0d50c3Schristos this->do_read(poff, psize, p);
515ed0d50c3Schristos ownership = View::DATA_ALLOCATED_ARRAY;
516ed0d50c3Schristos }
517ed0d50c3Schristos }
518ed0d50c3Schristos
519ed0d50c3Schristos const unsigned char* pbytes = static_cast<const unsigned char*>(p);
520ed0d50c3Schristos File_read::View* v = new File_read::View(poff, psize, pbytes, byteshift,
521ed0d50c3Schristos cache, ownership);
522ed0d50c3Schristos
523ed0d50c3Schristos this->add_view(v);
524ed0d50c3Schristos
525ed0d50c3Schristos return v;
526ed0d50c3Schristos }
527ed0d50c3Schristos
528ed0d50c3Schristos // Find a View or make a new one, shifted as required by the file
529ed0d50c3Schristos // offset OFFSET and ALIGNED.
530ed0d50c3Schristos
531ed0d50c3Schristos File_read::View*
find_or_make_view(off_t offset,off_t start,section_size_type size,bool aligned,bool cache)532ed0d50c3Schristos File_read::find_or_make_view(off_t offset, off_t start,
533ed0d50c3Schristos section_size_type size, bool aligned, bool cache)
534ed0d50c3Schristos {
535ed0d50c3Schristos // Check that start and end of the view are within the file.
536ed0d50c3Schristos if (start > this->size_
537ed0d50c3Schristos || (static_cast<unsigned long long>(size)
538ed0d50c3Schristos > static_cast<unsigned long long>(this->size_ - start)))
539ed0d50c3Schristos gold_fatal(_("%s: attempt to map %lld bytes at offset %lld exceeds "
540ed0d50c3Schristos "size of file; the file may be corrupt"),
541ed0d50c3Schristos this->filename().c_str(),
542ed0d50c3Schristos static_cast<long long>(size),
543ed0d50c3Schristos static_cast<long long>(start));
544ed0d50c3Schristos
545ed0d50c3Schristos unsigned int byteshift;
546ed0d50c3Schristos if (offset == 0)
547ed0d50c3Schristos byteshift = 0;
548ed0d50c3Schristos else
549ed0d50c3Schristos {
550ed0d50c3Schristos unsigned int target_size = (!parameters->target_valid()
551ed0d50c3Schristos ? 64
552ed0d50c3Schristos : parameters->target().get_size());
553ed0d50c3Schristos byteshift = offset & ((target_size / 8) - 1);
554ed0d50c3Schristos
555ed0d50c3Schristos // Set BYTESHIFT to the number of dummy bytes which must be
556ed0d50c3Schristos // inserted before the data in order for this data to be
557ed0d50c3Schristos // aligned.
558ed0d50c3Schristos if (byteshift != 0)
559ed0d50c3Schristos byteshift = (target_size / 8) - byteshift;
560ed0d50c3Schristos }
561ed0d50c3Schristos
562ed0d50c3Schristos // If --map-whole-files is set, make sure we have a
563ed0d50c3Schristos // whole file view. Options may not yet be ready, e.g.,
564ed0d50c3Schristos // when reading a version script. We then default to
565ed0d50c3Schristos // --no-map-whole-files.
566ed0d50c3Schristos if (this->whole_file_view_ == NULL
567ed0d50c3Schristos && parameters->options_valid()
568ed0d50c3Schristos && parameters->options().map_whole_files())
569ed0d50c3Schristos this->whole_file_view_ = this->make_view(0, this->size_, 0, cache);
570ed0d50c3Schristos
571ed0d50c3Schristos // Try to find a View with the required BYTESHIFT.
572ed0d50c3Schristos File_read::View* vshifted;
573ed0d50c3Schristos File_read::View* v = this->find_view(offset + start, size,
574ed0d50c3Schristos aligned ? byteshift : -1U,
575ed0d50c3Schristos &vshifted);
576ed0d50c3Schristos if (v != NULL)
577ed0d50c3Schristos {
578ed0d50c3Schristos if (cache)
579ed0d50c3Schristos v->set_cache();
580ed0d50c3Schristos return v;
581ed0d50c3Schristos }
582ed0d50c3Schristos
583ed0d50c3Schristos // If VSHIFTED is not NULL, then it has the data we need, but with
584ed0d50c3Schristos // the wrong byteshift.
585ed0d50c3Schristos v = vshifted;
586ed0d50c3Schristos if (v != NULL)
587ed0d50c3Schristos {
588ed0d50c3Schristos gold_assert(aligned);
589ed0d50c3Schristos
590ed0d50c3Schristos unsigned char* pbytes;
591ed0d50c3Schristos pbytes = static_cast<unsigned char*>(malloc(v->size() + byteshift));
592ed0d50c3Schristos if (pbytes == NULL)
593ed0d50c3Schristos gold_nomem();
594ed0d50c3Schristos memset(pbytes, 0, byteshift);
595ed0d50c3Schristos memcpy(pbytes + byteshift, v->data() + v->byteshift(), v->size());
596ed0d50c3Schristos
597ed0d50c3Schristos File_read::View* shifted_view =
598ed0d50c3Schristos new File_read::View(v->start(), v->size(), pbytes, byteshift,
599ed0d50c3Schristos cache, View::DATA_ALLOCATED_ARRAY);
600ed0d50c3Schristos
601ed0d50c3Schristos this->add_view(shifted_view);
602ed0d50c3Schristos return shifted_view;
603ed0d50c3Schristos }
604ed0d50c3Schristos
605ed0d50c3Schristos // Make a new view. If we don't need an aligned view, use a
606ed0d50c3Schristos // byteshift of 0, so that we can use mmap.
607ed0d50c3Schristos return this->make_view(offset + start, size,
608ed0d50c3Schristos aligned ? byteshift : 0,
609ed0d50c3Schristos cache);
610ed0d50c3Schristos }
611ed0d50c3Schristos
612ed0d50c3Schristos // Get a view into the file.
613ed0d50c3Schristos
614ed0d50c3Schristos const unsigned char*
get_view(off_t offset,off_t start,section_size_type size,bool aligned,bool cache)615ed0d50c3Schristos File_read::get_view(off_t offset, off_t start, section_size_type size,
616ed0d50c3Schristos bool aligned, bool cache)
617ed0d50c3Schristos {
618ed0d50c3Schristos File_read::View* pv = this->find_or_make_view(offset, start, size,
619ed0d50c3Schristos aligned, cache);
620ed0d50c3Schristos return pv->data() + (offset + start - pv->start() + pv->byteshift());
621ed0d50c3Schristos }
622ed0d50c3Schristos
623ed0d50c3Schristos File_view*
get_lasting_view(off_t offset,off_t start,section_size_type size,bool aligned,bool cache)624ed0d50c3Schristos File_read::get_lasting_view(off_t offset, off_t start, section_size_type size,
625ed0d50c3Schristos bool aligned, bool cache)
626ed0d50c3Schristos {
627ed0d50c3Schristos File_read::View* pv = this->find_or_make_view(offset, start, size,
628ed0d50c3Schristos aligned, cache);
629ed0d50c3Schristos pv->lock();
630ed0d50c3Schristos return new File_view(*this, pv,
631ed0d50c3Schristos (pv->data()
632ed0d50c3Schristos + (offset + start - pv->start() + pv->byteshift())));
633ed0d50c3Schristos }
634ed0d50c3Schristos
635ed0d50c3Schristos // Use readv to read COUNT entries from RM starting at START. BASE
636ed0d50c3Schristos // must be added to all file offsets in RM.
637ed0d50c3Schristos
638ed0d50c3Schristos void
do_readv(off_t base,const Read_multiple & rm,size_t start,size_t count)639ed0d50c3Schristos File_read::do_readv(off_t base, const Read_multiple& rm, size_t start,
640ed0d50c3Schristos size_t count)
641ed0d50c3Schristos {
642ed0d50c3Schristos unsigned char discard[File_read::page_size];
643ed0d50c3Schristos iovec iov[File_read::max_readv_entries * 2];
644ed0d50c3Schristos size_t iov_index = 0;
645ed0d50c3Schristos
646ed0d50c3Schristos off_t first_offset = rm[start].file_offset;
647ed0d50c3Schristos off_t last_offset = first_offset;
648ed0d50c3Schristos ssize_t want = 0;
649ed0d50c3Schristos for (size_t i = 0; i < count; ++i)
650ed0d50c3Schristos {
651ed0d50c3Schristos const Read_multiple_entry& i_entry(rm[start + i]);
652ed0d50c3Schristos
653ed0d50c3Schristos if (i_entry.file_offset > last_offset)
654ed0d50c3Schristos {
655ed0d50c3Schristos size_t skip = i_entry.file_offset - last_offset;
656ed0d50c3Schristos gold_assert(skip <= sizeof discard);
657ed0d50c3Schristos
658ed0d50c3Schristos iov[iov_index].iov_base = discard;
659ed0d50c3Schristos iov[iov_index].iov_len = skip;
660ed0d50c3Schristos ++iov_index;
661ed0d50c3Schristos
662ed0d50c3Schristos want += skip;
663ed0d50c3Schristos }
664ed0d50c3Schristos
665ed0d50c3Schristos iov[iov_index].iov_base = i_entry.buffer;
666ed0d50c3Schristos iov[iov_index].iov_len = i_entry.size;
667ed0d50c3Schristos ++iov_index;
668ed0d50c3Schristos
669ed0d50c3Schristos want += i_entry.size;
670ed0d50c3Schristos
671ed0d50c3Schristos last_offset = i_entry.file_offset + i_entry.size;
672ed0d50c3Schristos }
673ed0d50c3Schristos
674ed0d50c3Schristos this->reopen_descriptor();
675ed0d50c3Schristos
676ed0d50c3Schristos gold_assert(iov_index < sizeof iov / sizeof iov[0]);
677ed0d50c3Schristos
678ed0d50c3Schristos if (::lseek(this->descriptor_, base + first_offset, SEEK_SET) < 0)
679ed0d50c3Schristos gold_fatal(_("%s: lseek failed: %s"),
680ed0d50c3Schristos this->filename().c_str(), strerror(errno));
681ed0d50c3Schristos
682ed0d50c3Schristos ssize_t got = ::readv(this->descriptor_, iov, iov_index);
683ed0d50c3Schristos
684ed0d50c3Schristos if (got < 0)
685ed0d50c3Schristos gold_fatal(_("%s: readv failed: %s"),
686ed0d50c3Schristos this->filename().c_str(), strerror(errno));
687ed0d50c3Schristos if (got != want)
688ed0d50c3Schristos gold_fatal(_("%s: file too short: read only %zd of %zd bytes at %lld"),
689ed0d50c3Schristos this->filename().c_str(),
690ed0d50c3Schristos got, want, static_cast<long long>(base + first_offset));
691ed0d50c3Schristos }
692ed0d50c3Schristos
693ed0d50c3Schristos // Portable IOV_MAX.
694ed0d50c3Schristos
695ed0d50c3Schristos #if !defined(HAVE_READV)
696ed0d50c3Schristos #define GOLD_IOV_MAX 1
697ed0d50c3Schristos #elif defined(IOV_MAX)
698ed0d50c3Schristos #define GOLD_IOV_MAX IOV_MAX
699ed0d50c3Schristos #else
700ed0d50c3Schristos #define GOLD_IOV_MAX (File_read::max_readv_entries * 2)
701ed0d50c3Schristos #endif
702ed0d50c3Schristos
703ed0d50c3Schristos // Read several pieces of data from the file.
704ed0d50c3Schristos
705ed0d50c3Schristos void
read_multiple(off_t base,const Read_multiple & rm)706ed0d50c3Schristos File_read::read_multiple(off_t base, const Read_multiple& rm)
707ed0d50c3Schristos {
708ed0d50c3Schristos static size_t iov_max = GOLD_IOV_MAX;
709ed0d50c3Schristos size_t count = rm.size();
710ed0d50c3Schristos size_t i = 0;
711ed0d50c3Schristos while (i < count)
712ed0d50c3Schristos {
713ed0d50c3Schristos // Find up to MAX_READV_ENTRIES consecutive entries which are
714ed0d50c3Schristos // less than one page apart.
715ed0d50c3Schristos const Read_multiple_entry& i_entry(rm[i]);
716ed0d50c3Schristos off_t i_off = i_entry.file_offset;
717ed0d50c3Schristos off_t end_off = i_off + i_entry.size;
718ed0d50c3Schristos size_t j;
719ed0d50c3Schristos for (j = i + 1; j < count; ++j)
720ed0d50c3Schristos {
721ed0d50c3Schristos if (j - i >= File_read::max_readv_entries || j - i >= iov_max / 2)
722ed0d50c3Schristos break;
723ed0d50c3Schristos const Read_multiple_entry& j_entry(rm[j]);
724ed0d50c3Schristos off_t j_off = j_entry.file_offset;
725ed0d50c3Schristos gold_assert(j_off >= end_off);
726ed0d50c3Schristos off_t j_end_off = j_off + j_entry.size;
727ed0d50c3Schristos if (j_end_off - end_off >= File_read::page_size)
728ed0d50c3Schristos break;
729ed0d50c3Schristos end_off = j_end_off;
730ed0d50c3Schristos }
731ed0d50c3Schristos
732ed0d50c3Schristos if (j == i + 1)
733ed0d50c3Schristos this->read(base + i_off, i_entry.size, i_entry.buffer);
734ed0d50c3Schristos else
735ed0d50c3Schristos {
736ed0d50c3Schristos File_read::View* view = this->find_view(base + i_off,
737ed0d50c3Schristos end_off - i_off,
738ed0d50c3Schristos -1U, NULL);
739ed0d50c3Schristos if (view == NULL)
740ed0d50c3Schristos this->do_readv(base, rm, i, j - i);
741ed0d50c3Schristos else
742ed0d50c3Schristos {
743ed0d50c3Schristos const unsigned char* v = (view->data()
744ed0d50c3Schristos + (base + i_off - view->start()
745ed0d50c3Schristos + view->byteshift()));
746ed0d50c3Schristos for (size_t k = i; k < j; ++k)
747ed0d50c3Schristos {
748ed0d50c3Schristos const Read_multiple_entry& k_entry(rm[k]);
749ed0d50c3Schristos gold_assert((convert_to_section_size_type(k_entry.file_offset
750ed0d50c3Schristos - i_off)
751ed0d50c3Schristos + k_entry.size)
752ed0d50c3Schristos <= convert_to_section_size_type(end_off
753ed0d50c3Schristos - i_off));
754ed0d50c3Schristos memcpy(k_entry.buffer,
755ed0d50c3Schristos v + (k_entry.file_offset - i_off),
756ed0d50c3Schristos k_entry.size);
757ed0d50c3Schristos }
758ed0d50c3Schristos }
759ed0d50c3Schristos }
760ed0d50c3Schristos
761ed0d50c3Schristos i = j;
762ed0d50c3Schristos }
763ed0d50c3Schristos }
764ed0d50c3Schristos
765ed0d50c3Schristos // Mark all views as no longer cached.
766ed0d50c3Schristos
767ed0d50c3Schristos void
clear_view_cache_marks()768ed0d50c3Schristos File_read::clear_view_cache_marks()
769ed0d50c3Schristos {
770ed0d50c3Schristos // Just ignore this if there are multiple objects associated with
771ed0d50c3Schristos // the file. Otherwise we will wind up uncaching and freeing some
772ed0d50c3Schristos // views for other objects.
773ed0d50c3Schristos if (this->object_count_ > 1)
774ed0d50c3Schristos return;
775ed0d50c3Schristos
776ed0d50c3Schristos for (Views::iterator p = this->views_.begin();
777ed0d50c3Schristos p != this->views_.end();
778ed0d50c3Schristos ++p)
779ed0d50c3Schristos p->second->clear_cache();
780ed0d50c3Schristos for (Saved_views::iterator p = this->saved_views_.begin();
781ed0d50c3Schristos p != this->saved_views_.end();
782ed0d50c3Schristos ++p)
783ed0d50c3Schristos (*p)->clear_cache();
784ed0d50c3Schristos }
785ed0d50c3Schristos
786ed0d50c3Schristos // Remove all the file views. For a file which has multiple
787ed0d50c3Schristos // associated objects (i.e., an archive), we keep accessed views
788ed0d50c3Schristos // around until next time, in the hopes that they will be useful for
789ed0d50c3Schristos // the next object.
790ed0d50c3Schristos
791ed0d50c3Schristos void
clear_views(Clear_views_mode mode)792ed0d50c3Schristos File_read::clear_views(Clear_views_mode mode)
793ed0d50c3Schristos {
794ed0d50c3Schristos bool keep_files_mapped = (parameters->options_valid()
795ed0d50c3Schristos && parameters->options().keep_files_mapped());
796ed0d50c3Schristos Views::iterator p = this->views_.begin();
797ed0d50c3Schristos while (p != this->views_.end())
798ed0d50c3Schristos {
799ed0d50c3Schristos bool should_delete;
800ed0d50c3Schristos if (p->second->is_locked() || p->second->is_permanent_view())
801ed0d50c3Schristos should_delete = false;
802ed0d50c3Schristos else if (mode == CLEAR_VIEWS_ALL)
803ed0d50c3Schristos should_delete = true;
804ed0d50c3Schristos else if ((p->second->should_cache()
805ed0d50c3Schristos || p->second == this->whole_file_view_)
806ed0d50c3Schristos && keep_files_mapped)
807ed0d50c3Schristos should_delete = false;
808ed0d50c3Schristos else if (this->object_count_ > 1
809ed0d50c3Schristos && p->second->accessed()
810ed0d50c3Schristos && mode != CLEAR_VIEWS_ARCHIVE)
811ed0d50c3Schristos should_delete = false;
812ed0d50c3Schristos else
813ed0d50c3Schristos should_delete = true;
814ed0d50c3Schristos
815ed0d50c3Schristos if (should_delete)
816ed0d50c3Schristos {
817ed0d50c3Schristos if (p->second == this->whole_file_view_)
818ed0d50c3Schristos this->whole_file_view_ = NULL;
819ed0d50c3Schristos delete p->second;
820ed0d50c3Schristos
821ed0d50c3Schristos // map::erase invalidates only the iterator to the deleted
822ed0d50c3Schristos // element.
823ed0d50c3Schristos Views::iterator pe = p;
824ed0d50c3Schristos ++p;
825ed0d50c3Schristos this->views_.erase(pe);
826ed0d50c3Schristos }
827ed0d50c3Schristos else
828ed0d50c3Schristos {
829ed0d50c3Schristos p->second->clear_accessed();
830ed0d50c3Schristos ++p;
831ed0d50c3Schristos }
832ed0d50c3Schristos }
833ed0d50c3Schristos
834ed0d50c3Schristos Saved_views::iterator q = this->saved_views_.begin();
835ed0d50c3Schristos while (q != this->saved_views_.end())
836ed0d50c3Schristos {
837ed0d50c3Schristos if (!(*q)->is_locked())
838ed0d50c3Schristos {
839ed0d50c3Schristos delete *q;
840ed0d50c3Schristos q = this->saved_views_.erase(q);
841ed0d50c3Schristos }
842ed0d50c3Schristos else
843ed0d50c3Schristos {
844ed0d50c3Schristos gold_assert(mode != CLEAR_VIEWS_ALL);
845ed0d50c3Schristos ++q;
846ed0d50c3Schristos }
847ed0d50c3Schristos }
848ed0d50c3Schristos }
849ed0d50c3Schristos
850ed0d50c3Schristos // Print statistical information to stderr. This is used for --stats.
851ed0d50c3Schristos
852ed0d50c3Schristos void
print_stats()853ed0d50c3Schristos File_read::print_stats()
854ed0d50c3Schristos {
855ed0d50c3Schristos fprintf(stderr, _("%s: total bytes mapped for read: %llu\n"),
856ed0d50c3Schristos program_name, File_read::total_mapped_bytes);
857ed0d50c3Schristos fprintf(stderr, _("%s: maximum bytes mapped for read at one time: %llu\n"),
858ed0d50c3Schristos program_name, File_read::maximum_mapped_bytes);
859ed0d50c3Schristos }
860ed0d50c3Schristos
861ed0d50c3Schristos // Class File_view.
862ed0d50c3Schristos
~File_view()863ed0d50c3Schristos File_view::~File_view()
864ed0d50c3Schristos {
865ed0d50c3Schristos gold_assert(this->file_.is_locked());
866ed0d50c3Schristos this->view_->unlock();
867ed0d50c3Schristos }
868ed0d50c3Schristos
869ed0d50c3Schristos // Class Input_file.
870ed0d50c3Schristos
871ed0d50c3Schristos // Create a file given just the filename.
872ed0d50c3Schristos
Input_file(const char * name)873ed0d50c3Schristos Input_file::Input_file(const char* name)
874ed0d50c3Schristos : found_name_(), file_(), is_in_sysroot_(false), format_(FORMAT_NONE)
875ed0d50c3Schristos {
876ed0d50c3Schristos this->input_argument_ =
877ed0d50c3Schristos new Input_file_argument(name, Input_file_argument::INPUT_FILE_TYPE_FILE,
878ed0d50c3Schristos "", false, Position_dependent_options());
879ed0d50c3Schristos }
880ed0d50c3Schristos
881ed0d50c3Schristos // Create a file for testing.
882ed0d50c3Schristos
Input_file(const Task * task,const char * name,const unsigned char * contents,off_t size)883ed0d50c3Schristos Input_file::Input_file(const Task* task, const char* name,
884ed0d50c3Schristos const unsigned char* contents, off_t size)
885ed0d50c3Schristos : file_()
886ed0d50c3Schristos {
887ed0d50c3Schristos this->input_argument_ =
888ed0d50c3Schristos new Input_file_argument(name, Input_file_argument::INPUT_FILE_TYPE_FILE,
889ed0d50c3Schristos "", false, Position_dependent_options());
890ed0d50c3Schristos bool ok = this->file_.open(task, name, contents, size);
891ed0d50c3Schristos gold_assert(ok);
892ed0d50c3Schristos }
893ed0d50c3Schristos
894ed0d50c3Schristos // Return the position dependent options in force for this file.
895ed0d50c3Schristos
896ed0d50c3Schristos const Position_dependent_options&
options() const897ed0d50c3Schristos Input_file::options() const
898ed0d50c3Schristos {
899ed0d50c3Schristos return this->input_argument_->options();
900ed0d50c3Schristos }
901ed0d50c3Schristos
902ed0d50c3Schristos // Return the name given by the user. For -lc this will return "c".
903ed0d50c3Schristos
904ed0d50c3Schristos const char*
name() const905ed0d50c3Schristos Input_file::name() const
906ed0d50c3Schristos {
907ed0d50c3Schristos return this->input_argument_->name();
908ed0d50c3Schristos }
909ed0d50c3Schristos
910ed0d50c3Schristos // Return whether this file is in a system directory.
911ed0d50c3Schristos
912ed0d50c3Schristos bool
is_in_system_directory() const913ed0d50c3Schristos Input_file::is_in_system_directory() const
914ed0d50c3Schristos {
915ed0d50c3Schristos if (this->is_in_sysroot())
916ed0d50c3Schristos return true;
917ed0d50c3Schristos return parameters->options().is_in_system_directory(this->filename());
918ed0d50c3Schristos }
919ed0d50c3Schristos
920ed0d50c3Schristos // Return whether we are only reading symbols.
921ed0d50c3Schristos
922ed0d50c3Schristos bool
just_symbols() const923ed0d50c3Schristos Input_file::just_symbols() const
924ed0d50c3Schristos {
925ed0d50c3Schristos return this->input_argument_->just_symbols();
926ed0d50c3Schristos }
927ed0d50c3Schristos
928ed0d50c3Schristos // Return whether this is a file that we will search for in the list
929ed0d50c3Schristos // of directories.
930ed0d50c3Schristos
931ed0d50c3Schristos bool
will_search_for() const932ed0d50c3Schristos Input_file::will_search_for() const
933ed0d50c3Schristos {
934ed0d50c3Schristos return (!IS_ABSOLUTE_PATH(this->input_argument_->name())
935ed0d50c3Schristos && (this->input_argument_->is_lib()
936ed0d50c3Schristos || this->input_argument_->is_searched_file()
937ed0d50c3Schristos || this->input_argument_->extra_search_path() != NULL));
938ed0d50c3Schristos }
939ed0d50c3Schristos
940ed0d50c3Schristos // Return the file last modification time. Calls gold_fatal if the stat
941ed0d50c3Schristos // system call failed.
942ed0d50c3Schristos
943ed0d50c3Schristos Timespec
get_mtime()944ed0d50c3Schristos File_read::get_mtime()
945ed0d50c3Schristos {
946ed0d50c3Schristos struct stat file_stat;
947ed0d50c3Schristos this->reopen_descriptor();
948ed0d50c3Schristos
949ed0d50c3Schristos if (fstat(this->descriptor_, &file_stat) < 0)
950ed0d50c3Schristos gold_fatal(_("%s: stat failed: %s"), this->name_.c_str(),
951ed0d50c3Schristos strerror(errno));
952ed0d50c3Schristos #ifdef HAVE_STAT_ST_MTIM
953ed0d50c3Schristos return Timespec(file_stat.st_mtim.tv_sec, file_stat.st_mtim.tv_nsec);
954ed0d50c3Schristos #else
955ed0d50c3Schristos return Timespec(file_stat.st_mtime, 0);
956ed0d50c3Schristos #endif
957ed0d50c3Schristos }
958ed0d50c3Schristos
959ed0d50c3Schristos // Try to find a file in the extra search dirs. Returns true on success.
960ed0d50c3Schristos
961ed0d50c3Schristos bool
try_extra_search_path(int * pindex,const Input_file_argument * input_argument,std::string filename,std::string * found_name,std::string * namep)962ed0d50c3Schristos Input_file::try_extra_search_path(int* pindex,
963ed0d50c3Schristos const Input_file_argument* input_argument,
964ed0d50c3Schristos std::string filename, std::string* found_name,
965ed0d50c3Schristos std::string* namep)
966ed0d50c3Schristos {
967ed0d50c3Schristos if (input_argument->extra_search_path() == NULL)
968ed0d50c3Schristos return false;
969ed0d50c3Schristos
970ed0d50c3Schristos std::string name = input_argument->extra_search_path();
971ed0d50c3Schristos if (!IS_DIR_SEPARATOR(name[name.length() - 1]))
972ed0d50c3Schristos name += '/';
973ed0d50c3Schristos name += filename;
974ed0d50c3Schristos
975ed0d50c3Schristos struct stat dummy_stat;
976ed0d50c3Schristos if (*pindex > 0 || ::stat(name.c_str(), &dummy_stat) < 0)
977ed0d50c3Schristos return false;
978ed0d50c3Schristos
979ed0d50c3Schristos *found_name = filename;
980ed0d50c3Schristos *namep = name;
981ed0d50c3Schristos return true;
982ed0d50c3Schristos }
983ed0d50c3Schristos
984ed0d50c3Schristos // Find the actual file.
985ed0d50c3Schristos // If the filename is not absolute, we assume it is in the current
986ed0d50c3Schristos // directory *except* when:
987ed0d50c3Schristos // A) input_argument_->is_lib() is true;
988ed0d50c3Schristos // B) input_argument_->is_searched_file() is true; or
989ed0d50c3Schristos // C) input_argument_->extra_search_path() is not empty.
990ed0d50c3Schristos // In each, we look in extra_search_path + library_path to find
991ed0d50c3Schristos // the file location, rather than the current directory.
992ed0d50c3Schristos
993ed0d50c3Schristos bool
find_file(const Dirsearch & dirpath,int * pindex,const Input_file_argument * input_argument,bool * is_in_sysroot,std::string * found_name,std::string * namep)994ed0d50c3Schristos Input_file::find_file(const Dirsearch& dirpath, int* pindex,
995ed0d50c3Schristos const Input_file_argument* input_argument,
996ed0d50c3Schristos bool* is_in_sysroot,
997ed0d50c3Schristos std::string* found_name, std::string* namep)
998ed0d50c3Schristos {
999ed0d50c3Schristos std::string name;
1000ed0d50c3Schristos
1001ed0d50c3Schristos // Case 1: name is an absolute file, just try to open it
1002ed0d50c3Schristos // Case 2: name is relative but is_lib is false, is_searched_file is false,
1003ed0d50c3Schristos // and extra_search_path is empty
1004ed0d50c3Schristos if (IS_ABSOLUTE_PATH(input_argument->name())
1005ed0d50c3Schristos || (!input_argument->is_lib()
1006ed0d50c3Schristos && !input_argument->is_searched_file()
1007ed0d50c3Schristos && input_argument->extra_search_path() == NULL))
1008ed0d50c3Schristos {
1009ed0d50c3Schristos name = input_argument->name();
1010ed0d50c3Schristos *found_name = name;
1011ed0d50c3Schristos *namep = name;
1012ed0d50c3Schristos return true;
1013ed0d50c3Schristos }
1014ed0d50c3Schristos // Case 3: is_lib is true or is_searched_file is true
1015ed0d50c3Schristos else if (input_argument->is_lib()
1016ed0d50c3Schristos || input_argument->is_searched_file())
1017ed0d50c3Schristos {
1018ed0d50c3Schristos std::vector<std::string> names;
1019ed0d50c3Schristos names.reserve(2);
1020ed0d50c3Schristos if (input_argument->is_lib())
1021ed0d50c3Schristos {
1022ed0d50c3Schristos std::string prefix = "lib";
1023ed0d50c3Schristos prefix += input_argument->name();
1024ed0d50c3Schristos if (parameters->options().is_static()
1025ed0d50c3Schristos || !input_argument->options().Bdynamic())
1026ed0d50c3Schristos names.push_back(prefix + ".a");
1027ed0d50c3Schristos else
1028ed0d50c3Schristos {
1029ed0d50c3Schristos names.push_back(prefix + ".so");
1030ed0d50c3Schristos names.push_back(prefix + ".a");
1031ed0d50c3Schristos }
1032ed0d50c3Schristos }
1033ed0d50c3Schristos else
1034ed0d50c3Schristos names.push_back(input_argument->name());
1035ed0d50c3Schristos
1036ed0d50c3Schristos for (std::vector<std::string>::const_iterator n = names.begin();
1037ed0d50c3Schristos n != names.end();
1038ed0d50c3Schristos ++n)
1039ed0d50c3Schristos if (Input_file::try_extra_search_path(pindex, input_argument, *n,
1040ed0d50c3Schristos found_name, namep))
1041ed0d50c3Schristos return true;
1042ed0d50c3Schristos
1043ed0d50c3Schristos // It is not in the extra_search_path.
1044ed0d50c3Schristos name = dirpath.find(names, is_in_sysroot, pindex, found_name);
1045ed0d50c3Schristos if (name.empty())
1046ed0d50c3Schristos {
1047ed0d50c3Schristos gold_error(_("cannot find %s%s"),
1048ed0d50c3Schristos input_argument->is_lib() ? "-l" : "",
1049ed0d50c3Schristos input_argument->name());
1050ed0d50c3Schristos return false;
1051ed0d50c3Schristos }
1052ed0d50c3Schristos *namep = name;
1053ed0d50c3Schristos return true;
1054ed0d50c3Schristos }
1055ed0d50c3Schristos // Case 4: extra_search_path is not empty
1056ed0d50c3Schristos else
1057ed0d50c3Schristos {
1058ed0d50c3Schristos gold_assert(input_argument->extra_search_path() != NULL);
1059ed0d50c3Schristos
1060ed0d50c3Schristos if (try_extra_search_path(pindex, input_argument, input_argument->name(),
1061ed0d50c3Schristos found_name, namep))
1062ed0d50c3Schristos return true;
1063ed0d50c3Schristos
1064ed0d50c3Schristos // extra_search_path failed, so check the normal search-path.
1065ed0d50c3Schristos int index = *pindex;
1066ed0d50c3Schristos if (index > 0)
1067ed0d50c3Schristos --index;
1068ed0d50c3Schristos name = dirpath.find(std::vector<std::string>(1, input_argument->name()),
1069ed0d50c3Schristos is_in_sysroot, &index, found_name);
1070ed0d50c3Schristos if (name.empty())
1071ed0d50c3Schristos {
1072ed0d50c3Schristos gold_error(_("cannot find %s"),
1073ed0d50c3Schristos input_argument->name());
1074ed0d50c3Schristos return false;
1075ed0d50c3Schristos }
1076ed0d50c3Schristos *namep = name;
1077ed0d50c3Schristos *pindex = index + 1;
1078ed0d50c3Schristos return true;
1079ed0d50c3Schristos }
1080ed0d50c3Schristos }
1081ed0d50c3Schristos
1082ed0d50c3Schristos // Open the file.
1083ed0d50c3Schristos
1084ed0d50c3Schristos bool
open(const Dirsearch & dirpath,const Task * task,int * pindex)1085ed0d50c3Schristos Input_file::open(const Dirsearch& dirpath, const Task* task, int* pindex)
1086ed0d50c3Schristos {
1087ed0d50c3Schristos std::string name;
1088ed0d50c3Schristos if (!Input_file::find_file(dirpath, pindex, this->input_argument_,
1089ed0d50c3Schristos &this->is_in_sysroot_, &this->found_name_, &name))
1090ed0d50c3Schristos return false;
1091ed0d50c3Schristos
1092ed0d50c3Schristos // Now that we've figured out where the file lives, try to open it.
1093ed0d50c3Schristos
1094ed0d50c3Schristos General_options::Object_format format =
1095ed0d50c3Schristos this->input_argument_->options().format_enum();
1096ed0d50c3Schristos bool ok;
1097ed0d50c3Schristos if (format == General_options::OBJECT_FORMAT_ELF)
1098ed0d50c3Schristos {
1099ed0d50c3Schristos ok = this->file_.open(task, name);
1100ed0d50c3Schristos this->format_ = FORMAT_ELF;
1101ed0d50c3Schristos }
1102ed0d50c3Schristos else
1103ed0d50c3Schristos {
1104ed0d50c3Schristos gold_assert(format == General_options::OBJECT_FORMAT_BINARY);
1105ed0d50c3Schristos ok = this->open_binary(task, name);
1106ed0d50c3Schristos this->format_ = FORMAT_BINARY;
1107ed0d50c3Schristos }
1108ed0d50c3Schristos
1109ed0d50c3Schristos if (!ok)
1110ed0d50c3Schristos {
1111ed0d50c3Schristos gold_error(_("cannot open %s: %s"),
1112ed0d50c3Schristos name.c_str(), strerror(errno));
1113ed0d50c3Schristos this->format_ = FORMAT_NONE;
1114ed0d50c3Schristos return false;
1115ed0d50c3Schristos }
1116ed0d50c3Schristos
1117ed0d50c3Schristos return true;
1118ed0d50c3Schristos }
1119ed0d50c3Schristos
1120ed0d50c3Schristos // Open a file for --format binary.
1121ed0d50c3Schristos
1122ed0d50c3Schristos bool
open_binary(const Task * task,const std::string & name)1123ed0d50c3Schristos Input_file::open_binary(const Task* task, const std::string& name)
1124ed0d50c3Schristos {
1125ed0d50c3Schristos // In order to open a binary file, we need machine code, size, and
1126ed0d50c3Schristos // endianness. We may not have a valid target at this point, in
1127ed0d50c3Schristos // which case we use the default target.
1128ed0d50c3Schristos parameters_force_valid_target();
1129ed0d50c3Schristos const Target& target(parameters->target());
1130ed0d50c3Schristos
1131ed0d50c3Schristos Binary_to_elf binary_to_elf(target.machine_code(),
1132ed0d50c3Schristos target.get_size(),
1133ed0d50c3Schristos target.is_big_endian(),
1134ed0d50c3Schristos name);
1135ed0d50c3Schristos if (!binary_to_elf.convert(task))
1136ed0d50c3Schristos return false;
1137ed0d50c3Schristos return this->file_.open(task, name, binary_to_elf.converted_data_leak(),
1138ed0d50c3Schristos binary_to_elf.converted_size());
1139ed0d50c3Schristos }
1140ed0d50c3Schristos
1141ed0d50c3Schristos } // End namespace gold.
1142