1 // fileread.cc -- read files for gold
3 // Copyright 2006, 2007, 2008 Free Software Foundation, Inc.
4 // Written by Ian Lance Taylor <iant@google.com>.
6 // This file is part of gold.
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.
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.
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.
31 #include "filenames.h"
34 #include "parameters.h"
36 #include "dirsearch.h"
39 #include "descriptors.h"
45 // Class File_read::View.
47 File_read::View::~View()
49 gold_assert(!this->is_locked());
54 if (::munmap(const_cast<unsigned char*>(this->data_
), this->size_
) != 0)
55 gold_warning(_("munmap failed: %s"), strerror(errno
));
57 File_read::current_mapped_bytes
-= this->size_
;
62 File_read::View::lock()
68 File_read::View::unlock()
70 gold_assert(this->lock_count_
> 0);
75 File_read::View::is_locked()
77 return this->lock_count_
> 0;
82 // The File_read static variables.
83 unsigned long long File_read::total_mapped_bytes
;
84 unsigned long long File_read::current_mapped_bytes
;
85 unsigned long long File_read::maximum_mapped_bytes
;
87 File_read::~File_read()
89 gold_assert(this->token_
.is_writable());
90 if (this->is_descriptor_opened_
)
92 release_descriptor(this->descriptor_
, true);
93 this->descriptor_
= -1;
94 this->is_descriptor_opened_
= false;
97 this->clear_views(true);
103 File_read::open(const Task
* task
, const std::string
& name
)
105 gold_assert(this->token_
.is_writable()
106 && this->descriptor_
< 0
107 && !this->is_descriptor_opened_
108 && this->name_
.empty());
111 this->descriptor_
= open_descriptor(-1, this->name_
.c_str(),
114 if (this->descriptor_
>= 0)
116 this->is_descriptor_opened_
= true;
118 if (::fstat(this->descriptor_
, &s
) < 0)
119 gold_error(_("%s: fstat failed: %s"),
120 this->name_
.c_str(), strerror(errno
));
121 this->size_
= s
.st_size
;
122 gold_debug(DEBUG_FILES
, "Attempt to open %s succeeded",
123 this->name_
.c_str());
125 this->token_
.add_writer(task
);
128 return this->descriptor_
>= 0;
131 // Open the file with the contents in memory.
134 File_read::open(const Task
* task
, const std::string
& name
,
135 const unsigned char* contents
, off_t size
)
137 gold_assert(this->token_
.is_writable()
138 && this->descriptor_
< 0
139 && !this->is_descriptor_opened_
140 && this->name_
.empty());
142 this->contents_
= contents
;
144 this->token_
.add_writer(task
);
148 // Reopen a descriptor if necessary.
151 File_read::reopen_descriptor()
153 if (!this->is_descriptor_opened_
)
155 this->descriptor_
= open_descriptor(this->descriptor_
,
158 if (this->descriptor_
< 0)
159 gold_fatal(_("could not reopen file %s"), this->name_
.c_str());
160 this->is_descriptor_opened_
= true;
164 // Release the file. This is called when we are done with the file in
170 gold_assert(this->is_locked());
172 File_read::total_mapped_bytes
+= this->mapped_bytes_
;
173 File_read::current_mapped_bytes
+= this->mapped_bytes_
;
174 this->mapped_bytes_
= 0;
175 if (File_read::current_mapped_bytes
> File_read::maximum_mapped_bytes
)
176 File_read::maximum_mapped_bytes
= File_read::current_mapped_bytes
;
178 // Only clear views if there is only one attached object. Otherwise
179 // we waste time trying to clear cached archive views. Similarly
180 // for releasing the descriptor.
181 if (this->object_count_
<= 1)
183 this->clear_views(false);
184 if (this->is_descriptor_opened_
)
186 release_descriptor(this->descriptor_
, false);
187 this->is_descriptor_opened_
= false;
191 this->released_
= true;
197 File_read::lock(const Task
* task
)
199 gold_assert(this->released_
);
200 this->token_
.add_writer(task
);
201 this->released_
= false;
207 File_read::unlock(const Task
* task
)
210 this->token_
.remove_writer(task
);
213 // Return whether the file is locked.
216 File_read::is_locked() const
218 if (!this->token_
.is_writable())
220 // The file is not locked, so it should have been released.
221 gold_assert(this->released_
);
225 // See if we have a view which covers the file starting at START for
226 // SIZE bytes. Return a pointer to the View if found, NULL if not.
227 // If BYTESHIFT is not -1U, the returned View must have the specified
228 // byte shift; otherwise, it may have any byte shift. If VSHIFTED is
229 // not NULL, this sets *VSHIFTED to a view which would have worked if
230 // not for the requested BYTESHIFT.
232 inline File_read::View
*
233 File_read::find_view(off_t start
, section_size_type size
,
234 unsigned int byteshift
, File_read::View
** vshifted
) const
236 if (vshifted
!= NULL
)
239 off_t page
= File_read::page_offset(start
);
241 unsigned int bszero
= 0;
242 Views::const_iterator p
= this->views_
.upper_bound(std::make_pair(page
- 1,
245 while (p
!= this->views_
.end() && p
->first
.first
<= page
)
247 if (p
->second
->start() <= start
248 && (p
->second
->start() + static_cast<off_t
>(p
->second
->size())
249 >= start
+ static_cast<off_t
>(size
)))
251 if (byteshift
== -1U || byteshift
== p
->second
->byteshift())
253 p
->second
->set_accessed();
257 if (vshifted
!= NULL
&& *vshifted
== NULL
)
258 *vshifted
= p
->second
;
267 // Read SIZE bytes from the file starting at offset START. Read into
271 File_read::do_read(off_t start
, section_size_type size
, void* p
)
274 if (this->contents_
!= NULL
)
276 bytes
= this->size_
- start
;
277 if (static_cast<section_size_type
>(bytes
) >= size
)
279 memcpy(p
, this->contents_
+ start
, size
);
285 this->reopen_descriptor();
286 bytes
= ::pread(this->descriptor_
, p
, size
, start
);
287 if (static_cast<section_size_type
>(bytes
) == size
)
292 gold_fatal(_("%s: pread failed: %s"),
293 this->filename().c_str(), strerror(errno
));
298 gold_fatal(_("%s: file too short: read only %lld of %lld bytes at %lld"),
299 this->filename().c_str(),
300 static_cast<long long>(bytes
),
301 static_cast<long long>(size
),
302 static_cast<long long>(start
));
305 // Read data from the file.
308 File_read::read(off_t start
, section_size_type size
, void* p
)
310 const File_read::View
* pv
= this->find_view(start
, size
, -1U, NULL
);
313 memcpy(p
, pv
->data() + (start
- pv
->start() + pv
->byteshift()), size
);
317 this->do_read(start
, size
, p
);
320 // Add a new view. There may already be an existing view at this
321 // offset. If there is, the new view will be larger, and should
322 // replace the old view.
325 File_read::add_view(File_read::View
* v
)
327 std::pair
<Views::iterator
, bool> ins
=
328 this->views_
.insert(std::make_pair(std::make_pair(v
->start(),
334 // There was an existing view at this offset. It must not be large
335 // enough. We can't delete it here, since something might be using
336 // it; we put it on a list to be deleted when the file is unlocked.
337 File_read::View
* vold
= ins
.first
->second
;
338 gold_assert(vold
->size() < v
->size());
339 if (vold
->should_cache())
344 this->saved_views_
.push_back(vold
);
346 ins
.first
->second
= v
;
349 // Make a new view with a specified byteshift, reading the data from
353 File_read::make_view(off_t start
, section_size_type size
,
354 unsigned int byteshift
, bool cache
)
356 gold_assert(size
> 0);
358 // Check that start and end of the view are within the file.
359 if (start
> this->size_
|| size
> this->size_
- start
)
360 gold_fatal(_("%s: attempt to map %lld bytes at offset %lld exceeds "
361 "size of file; the file may be corrupt"),
362 this->filename().c_str(),
363 static_cast<long long>(size
),
364 static_cast<long long>(start
));
366 off_t poff
= File_read::page_offset(start
);
368 section_size_type psize
= File_read::pages(size
+ (start
- poff
));
370 if (poff
+ static_cast<off_t
>(psize
) >= this->size_
)
372 psize
= this->size_
- poff
;
373 gold_assert(psize
>= size
);
377 if (this->contents_
!= NULL
|| byteshift
!= 0)
379 unsigned char* p
= new unsigned char[psize
+ byteshift
];
380 memset(p
, 0, byteshift
);
381 this->do_read(poff
, psize
, p
+ byteshift
);
382 v
= new File_read::View(poff
, psize
, p
, byteshift
, cache
, false);
386 this->reopen_descriptor();
387 void* p
= ::mmap(NULL
, psize
, PROT_READ
, MAP_PRIVATE
,
388 this->descriptor_
, poff
);
390 gold_fatal(_("%s: mmap offset %lld size %lld failed: %s"),
391 this->filename().c_str(),
392 static_cast<long long>(poff
),
393 static_cast<long long>(psize
),
396 this->mapped_bytes_
+= psize
;
398 const unsigned char* pbytes
= static_cast<const unsigned char*>(p
);
399 v
= new File_read::View(poff
, psize
, pbytes
, 0, cache
, true);
407 // Find a View or make a new one, shifted as required by the file
408 // offset OFFSET and ALIGNED.
411 File_read::find_or_make_view(off_t offset
, off_t start
,
412 section_size_type size
, bool aligned
, bool cache
)
414 unsigned int byteshift
;
419 unsigned int target_size
= (!parameters
->target_valid()
421 : parameters
->target().get_size());
422 byteshift
= offset
& ((target_size
/ 8) - 1);
424 // Set BYTESHIFT to the number of dummy bytes which must be
425 // inserted before the data in order for this data to be
428 byteshift
= (target_size
/ 8) - byteshift
;
431 // Try to find a View with the required BYTESHIFT.
432 File_read::View
* vshifted
;
433 File_read::View
* v
= this->find_view(offset
+ start
, size
,
434 aligned
? byteshift
: -1U,
443 // If VSHIFTED is not NULL, then it has the data we need, but with
444 // the wrong byteshift.
448 gold_assert(aligned
);
450 unsigned char* pbytes
= new unsigned char[v
->size() + byteshift
];
451 memset(pbytes
, 0, byteshift
);
452 memcpy(pbytes
+ byteshift
, v
->data() + v
->byteshift(), v
->size());
454 File_read::View
* shifted_view
= new File_read::View(v
->start(), v
->size(),
458 this->add_view(shifted_view
);
462 // Make a new view. If we don't need an aligned view, use a
463 // byteshift of 0, so that we can use mmap.
464 return this->make_view(offset
+ start
, size
,
465 aligned
? byteshift
: 0,
469 // Get a view into the file.
472 File_read::get_view(off_t offset
, off_t start
, section_size_type size
,
473 bool aligned
, bool cache
)
475 File_read::View
* pv
= this->find_or_make_view(offset
, start
, size
,
477 return pv
->data() + (offset
+ start
- pv
->start() + pv
->byteshift());
481 File_read::get_lasting_view(off_t offset
, off_t start
, section_size_type size
,
482 bool aligned
, bool cache
)
484 File_read::View
* pv
= this->find_or_make_view(offset
, start
, size
,
487 return new File_view(*this, pv
,
489 + (offset
+ start
- pv
->start() + pv
->byteshift())));
492 // Use readv to read COUNT entries from RM starting at START. BASE
493 // must be added to all file offsets in RM.
496 File_read::do_readv(off_t base
, const Read_multiple
& rm
, size_t start
,
499 unsigned char discard
[File_read::page_size
];
500 iovec iov
[File_read::max_readv_entries
* 2];
501 size_t iov_index
= 0;
503 off_t first_offset
= rm
[start
].file_offset
;
504 off_t last_offset
= first_offset
;
506 for (size_t i
= 0; i
< count
; ++i
)
508 const Read_multiple_entry
& i_entry(rm
[start
+ i
]);
510 if (i_entry
.file_offset
> last_offset
)
512 size_t skip
= i_entry
.file_offset
- last_offset
;
513 gold_assert(skip
<= sizeof discard
);
515 iov
[iov_index
].iov_base
= discard
;
516 iov
[iov_index
].iov_len
= skip
;
522 iov
[iov_index
].iov_base
= i_entry
.buffer
;
523 iov
[iov_index
].iov_len
= i_entry
.size
;
526 want
+= i_entry
.size
;
528 last_offset
= i_entry
.file_offset
+ i_entry
.size
;
531 this->reopen_descriptor();
533 gold_assert(iov_index
< sizeof iov
/ sizeof iov
[0]);
535 if (::lseek(this->descriptor_
, base
+ first_offset
, SEEK_SET
) < 0)
536 gold_fatal(_("%s: lseek failed: %s"),
537 this->filename().c_str(), strerror(errno
));
539 ssize_t got
= ::readv(this->descriptor_
, iov
, iov_index
);
542 gold_fatal(_("%s: readv failed: %s"),
543 this->filename().c_str(), strerror(errno
));
545 gold_fatal(_("%s: file too short: read only %zd of %zd bytes at %lld"),
546 this->filename().c_str(),
547 got
, want
, static_cast<long long>(base
+ first_offset
));
550 // Read several pieces of data from the file.
553 File_read::read_multiple(off_t base
, const Read_multiple
& rm
)
555 size_t count
= rm
.size();
559 // Find up to MAX_READV_ENTRIES consecutive entries which are
560 // less than one page apart.
561 const Read_multiple_entry
& i_entry(rm
[i
]);
562 off_t i_off
= i_entry
.file_offset
;
563 off_t end_off
= i_off
+ i_entry
.size
;
565 for (j
= i
+ 1; j
< count
; ++j
)
567 if (j
- i
>= File_read::max_readv_entries
)
569 const Read_multiple_entry
& j_entry(rm
[j
]);
570 off_t j_off
= j_entry
.file_offset
;
571 gold_assert(j_off
>= end_off
);
572 off_t j_end_off
= j_off
+ j_entry
.size
;
573 if (j_end_off
- end_off
>= File_read::page_size
)
579 this->read(base
+ i_off
, i_entry
.size
, i_entry
.buffer
);
582 File_read::View
* view
= this->find_view(base
+ i_off
,
586 this->do_readv(base
, rm
, i
, j
- i
);
589 const unsigned char* v
= (view
->data()
590 + (base
+ i_off
- view
->start()
591 + view
->byteshift()));
592 for (size_t k
= i
; k
< j
; ++k
)
594 const Read_multiple_entry
& k_entry(rm
[k
]);
595 gold_assert((convert_to_section_size_type(k_entry
.file_offset
598 <= convert_to_section_size_type(end_off
600 memcpy(k_entry
.buffer
,
601 v
+ (k_entry
.file_offset
- i_off
),
611 // Mark all views as no longer cached.
614 File_read::clear_view_cache_marks()
616 // Just ignore this if there are multiple objects associated with
617 // the file. Otherwise we will wind up uncaching and freeing some
618 // views for other objects.
619 if (this->object_count_
> 1)
622 for (Views::iterator p
= this->views_
.begin();
623 p
!= this->views_
.end();
625 p
->second
->clear_cache();
626 for (Saved_views::iterator p
= this->saved_views_
.begin();
627 p
!= this->saved_views_
.end();
632 // Remove all the file views. For a file which has multiple
633 // associated objects (i.e., an archive), we keep accessed views
634 // around until next time, in the hopes that they will be useful for
638 File_read::clear_views(bool destroying
)
640 Views::iterator p
= this->views_
.begin();
641 while (p
!= this->views_
.end())
644 if (p
->second
->is_locked())
645 should_delete
= false;
647 should_delete
= true;
648 else if (p
->second
->should_cache())
649 should_delete
= false;
650 else if (this->object_count_
> 1 && p
->second
->accessed())
651 should_delete
= false;
653 should_delete
= true;
659 // map::erase invalidates only the iterator to the deleted
661 Views::iterator pe
= p
;
663 this->views_
.erase(pe
);
667 gold_assert(!destroying
);
668 p
->second
->clear_accessed();
673 Saved_views::iterator q
= this->saved_views_
.begin();
674 while (q
!= this->saved_views_
.end())
676 if (!(*q
)->is_locked())
679 q
= this->saved_views_
.erase(q
);
683 gold_assert(!destroying
);
689 // Print statistical information to stderr. This is used for --stats.
692 File_read::print_stats()
694 fprintf(stderr
, _("%s: total bytes mapped for read: %llu\n"),
695 program_name
, File_read::total_mapped_bytes
);
696 fprintf(stderr
, _("%s: maximum bytes mapped for read at one time: %llu\n"),
697 program_name
, File_read::maximum_mapped_bytes
);
702 File_view::~File_view()
704 gold_assert(this->file_
.is_locked());
705 this->view_
->unlock();
710 // Create a file for testing.
712 Input_file::Input_file(const Task
* task
, const char* name
,
713 const unsigned char* contents
, off_t size
)
716 this->input_argument_
=
717 new Input_file_argument(name
, false, "", false,
718 Position_dependent_options());
719 bool ok
= file_
.open(task
, name
, contents
, size
);
723 // Return the position dependent options in force for this file.
725 const Position_dependent_options
&
726 Input_file::options() const
728 return this->input_argument_
->options();
731 // Return the name given by the user. For -lc this will return "c".
734 Input_file::name() const
736 return this->input_argument_
->name();
739 // Return whether we are only reading symbols.
742 Input_file::just_symbols() const
744 return this->input_argument_
->just_symbols();
749 // If the filename is not absolute, we assume it is in the current
750 // directory *except* when:
751 // A) input_argument_->is_lib() is true; or
752 // B) input_argument_->extra_search_path() is not empty.
753 // In both cases, we look in extra_search_path + library_path to find
754 // the file location, rather than the current directory.
757 Input_file::open(const General_options
& options
, const Dirsearch
& dirpath
,
762 // Case 1: name is an absolute file, just try to open it
763 // Case 2: name is relative but is_lib is false and extra_search_path
765 if (IS_ABSOLUTE_PATH (this->input_argument_
->name())
766 || (!this->input_argument_
->is_lib()
767 && this->input_argument_
->extra_search_path() == NULL
))
769 name
= this->input_argument_
->name();
770 this->found_name_
= name
;
772 // Case 3: is_lib is true
773 else if (this->input_argument_
->is_lib())
775 // We don't yet support extra_search_path with -l.
776 gold_assert(this->input_argument_
->extra_search_path() == NULL
);
777 std::string
n1("lib");
778 n1
+= this->input_argument_
->name();
780 if (options
.is_static()
781 || !this->input_argument_
->options().Bdynamic())
788 name
= dirpath
.find(n1
, n2
, &this->is_in_sysroot_
);
791 gold_error(_("cannot find -l%s"),
792 this->input_argument_
->name());
795 if (n2
.empty() || name
[name
.length() - 1] == 'o')
796 this->found_name_
= n1
;
798 this->found_name_
= n2
;
800 // Case 4: extra_search_path is not empty
803 gold_assert(this->input_argument_
->extra_search_path() != NULL
);
805 // First, check extra_search_path.
806 name
= this->input_argument_
->extra_search_path();
807 if (!IS_DIR_SEPARATOR (name
[name
.length() - 1]))
809 name
+= this->input_argument_
->name();
810 struct stat dummy_stat
;
811 if (::stat(name
.c_str(), &dummy_stat
) < 0)
813 // extra_search_path failed, so check the normal search-path.
814 name
= dirpath
.find(this->input_argument_
->name(), "",
815 &this->is_in_sysroot_
);
818 gold_error(_("cannot find %s"),
819 this->input_argument_
->name());
823 this->found_name_
= this->input_argument_
->name();
826 // Now that we've figured out where the file lives, try to open it.
828 General_options::Object_format format
=
829 this->input_argument_
->options().format_enum();
831 if (format
== General_options::OBJECT_FORMAT_ELF
)
832 ok
= this->file_
.open(task
, name
);
835 gold_assert(format
== General_options::OBJECT_FORMAT_BINARY
);
836 ok
= this->open_binary(options
, task
, name
);
841 gold_error(_("cannot open %s: %s"),
842 name
.c_str(), strerror(errno
));
849 // Open a file for --format binary.
852 Input_file::open_binary(const General_options
&,
853 const Task
* task
, const std::string
& name
)
855 // In order to open a binary file, we need machine code, size, and
856 // endianness. We may not have a valid target at this point, in
857 // which case we use the default target.
858 const Target
* target
;
859 if (parameters
->target_valid())
860 target
= ¶meters
->target();
862 target
= ¶meters
->default_target();
864 Binary_to_elf
binary_to_elf(target
->machine_code(),
866 target
->is_big_endian(),
868 if (!binary_to_elf
.convert(task
))
870 return this->file_
.open(task
, name
, binary_to_elf
.converted_data_leak(),
871 binary_to_elf
.converted_size());
874 } // End namespace gold.