1 // fileread.h -- read files for gold -*- C++ -*-
2
3 // Copyright (C) 2006-2023 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 // Classes used to read data from binary input files.
24
25 #ifndef GOLD_FILEREAD_H
26 #define GOLD_FILEREAD_H
27
28 #include <list>
29 #include <map>
30 #include <string>
31 #include <vector>
32
33 #include "token.h"
34
35 namespace gold
36 {
37
38 // Since not all system supports stat.st_mtim and struct timespec,
39 // we define our own structure and fill the nanoseconds if we can.
40
41 struct Timespec
42 {
43 Timespec()
44 : seconds(0), nanoseconds(0)
45 { }
46
47 Timespec(time_t a_seconds, int a_nanoseconds)
48 : seconds(a_seconds), nanoseconds(a_nanoseconds)
49 { }
50
51 time_t seconds;
52 int nanoseconds;
53 };
54
55 // Get the last modified time of an unopened file. Returns false if the
56 // file does not exist.
57
58 bool
59 get_mtime(const char* filename, Timespec* mtime);
60
61 class Position_dependent_options;
62 class Input_file_argument;
63 class Dirsearch;
64 class File_view;
65
66 // File_read manages a file descriptor and mappings for a file we are
67 // reading.
68
69 class File_read
70 {
71 public:
72 File_read()
73 : name_(), descriptor_(-1), is_descriptor_opened_(false), object_count_(0),
74 size_(0), token_(false), views_(), saved_views_(), mapped_bytes_(0),
75 released_(true), whole_file_view_(NULL)
76 { }
77
78 ~File_read();
79
80 // Open a file.
81 bool
82 open(const Task*, const std::string& name);
83
84 // Pretend to open the file, but provide the file contents. No
85 // actual file system activity will occur. This is used for
86 // testing.
87 bool
88 open(const Task*, const std::string& name, const unsigned char* contents,
89 off_t size);
90
91 // Return the file name.
92 const std::string&
93 filename() const
94 { return this->name_; }
95
96 // Add an object associated with a file.
97 void
98 add_object()
99 { ++this->object_count_; }
100
101 // Remove an object associated with a file.
102 void
103 remove_object()
104 { --this->object_count_; }
105
106 // Lock the file for exclusive access within a particular Task::run
107 // execution. This routine may only be called when the workqueue
108 // lock is held.
109 void
110 lock(const Task* t);
111
112 // Unlock the file.
113 void
114 unlock(const Task* t);
115
116 // Test whether the object is locked.
117 bool
118 is_locked() const;
119
120 // Return the token, so that the task can be queued.
121 Task_token*
122 token()
123 { return &this->token_; }
124
125 // Release the file. This indicates that we aren't going to do
126 // anything further with it until it is unlocked. This is used
127 // because a Task which locks the file never calls either lock or
128 // unlock; it just locks the token. The basic rule is that a Task
129 // which locks a file via the Task::locks interface must explicitly
130 // call release() when it is done. This is not necessary for code
131 // which calls unlock() on the file.
132 void
133 release();
134
135 // Return the size of the file.
136 off_t
137 filesize() const
138 { return this->size_; }
139
140 // Return a view into the file starting at file offset START for
141 // SIZE bytes. OFFSET is the offset into the input file for the
142 // file we are reading; this is zero for a normal object file,
143 // non-zero for an object file in an archive. ALIGNED is true if
144 // the data must be naturally aligned (i.e., aligned to the size
145 // of a target word); this only matters when OFFSET is not zero.
146 // The pointer will remain valid until the File_read is unlocked.
147 // It is an error if we can not read enough data from the file.
148 // The CACHE parameter is a hint as to whether it will be useful
149 // to cache this data for later accesses--i.e., later calls to
150 // get_view, read, or get_lasting_view which retrieve the same
151 // data.
152 const unsigned char*
153 get_view(off_t offset, off_t start, section_size_type size, bool aligned,
154 bool cache);
155
156 // Read data from the file into the buffer P starting at file offset
157 // START for SIZE bytes.
158 void
159 read(off_t start, section_size_type size, void* p);
160
161 // Return a lasting view into the file starting at file offset START
162 // for SIZE bytes. This is allocated with new, and the caller is
163 // responsible for deleting it when done. The data associated with
164 // this view will remain valid until the view is deleted. It is an
165 // error if we can not read enough data from the file. The OFFSET,
166 // ALIGNED and CACHE parameters are as in get_view.
167 File_view*
168 get_lasting_view(off_t offset, off_t start, section_size_type size,
169 bool aligned, bool cache);
170
171 // Mark all views as no longer cached.
172 void
173 clear_view_cache_marks();
174
175 // Discard all uncached views. This is normally done by release(),
176 // but not for objects in archives. FIXME: This is a complicated
177 // interface, and it would be nice to have something more automatic.
178 void
179 clear_uncached_views()
180 { this->clear_views(CLEAR_VIEWS_ARCHIVE); }
181
182 // A struct used to do a multiple read.
183 struct Read_multiple_entry
184 {
185 // The file offset of the data to read.
186 off_t file_offset;
187 // The amount of data to read.
188 section_size_type size;
189 // The buffer where the data should be placed.
190 unsigned char* buffer;
191
192 Read_multiple_entry(off_t o, section_size_type s, unsigned char* b)
193 : file_offset(o), size(s), buffer(b)
194 { }
195 };
196
197 typedef std::vector<Read_multiple_entry> Read_multiple;
198
199 // Read a bunch of data from the file into various different
200 // locations. The vector must be sorted by ascending file_offset.
201 // BASE is a base offset to be added to all the offsets in the
202 // vector.
203 void
204 read_multiple(off_t base, const Read_multiple&);
205
206 // Dump statistical information to stderr.
207 static void
208 print_stats();
209
210 // Write the dependency file listing all files read.
211 static void
212 write_dependency_file(const char* dependency_file_name,
213 const char* output_file_name);
214
215 // Record that a file was read. File_read::open does this.
216 static void
217 record_file_read(const std::string& name);
218
219 // Return the open file descriptor (for plugins).
220 int
221 descriptor()
222 {
223 this->reopen_descriptor();
224 return this->descriptor_;
225 }
226
227 // Return the file last modification time. Calls gold_fatal if the stat
228 // system call failed.
229 Timespec
230 get_mtime();
231
232 private:
233 // Control for what views to clear.
234 enum Clear_views_mode
235 {
236 // Clear uncached views not used by an archive.
237 CLEAR_VIEWS_NORMAL,
238 // Clear all uncached views (including in an archive).
239 CLEAR_VIEWS_ARCHIVE,
240 // Clear all views (i.e., we're destroying the file).
241 CLEAR_VIEWS_ALL
242 };
243
244 // This class may not be copied.
245 File_read(const File_read&);
246 File_read& operator=(const File_read&);
247
248 // Total bytes mapped into memory during the link if --stats.
249 static unsigned long long total_mapped_bytes;
250
251 // Current number of bytes mapped into memory during the link if
252 // --stats.
253 static unsigned long long current_mapped_bytes;
254
255 // High water mark of bytes mapped into memory during the link if
256 // --stats.
257 static unsigned long long maximum_mapped_bytes;
258
259 // Set of names of all files read.
260 static std::vector<std::string> files_read;
261
262 // A view into the file.
263 class View
264 {
265 public:
266 // Specifies how to dispose the data on destruction of the view.
267 enum Data_ownership
268 {
269 // Data owned by File object - nothing done in destructor.
270 DATA_NOT_OWNED,
271 // Data allocated with new[] and owned by this object - should
272 // use delete[].
273 DATA_ALLOCATED_ARRAY,
274 // Data mmapped and owned by this object - should munmap.
275 DATA_MMAPPED
276 };
277
278 View(off_t start, section_size_type size, const unsigned char* data,
279 unsigned int byteshift, bool cache, Data_ownership data_ownership)
280 : start_(start), size_(size), data_(data), lock_count_(0),
281 byteshift_(byteshift), cache_(cache), data_ownership_(data_ownership),
282 accessed_(true)
283 { }
284
285 ~View();
286
287 off_t
288 start() const
289 { return this->start_; }
290
291 section_size_type
292 size() const
293 { return this->size_; }
294
295 const unsigned char*
296 data() const
297 { return this->data_; }
298
299 void
300 lock();
301
302 void
303 unlock();
304
305 bool
306 is_locked();
307
308 unsigned int
309 byteshift() const
310 { return this->byteshift_; }
311
312 void
313 set_cache()
314 { this->cache_ = true; }
315
316 void
317 clear_cache()
318 { this->cache_ = false; }
319
320 bool
321 should_cache() const
322 { return this->cache_; }
323
324 void
325 set_accessed()
326 { this->accessed_ = true; }
327
328 void
329 clear_accessed()
330 { this->accessed_= false; }
331
332 bool
333 accessed() const
334 { return this->accessed_; }
335
336 // Returns TRUE if this view contains permanent data -- e.g., data that
337 // was supplied by the owner of the File object.
338 bool
339 is_permanent_view() const
340 { return this->data_ownership_ == DATA_NOT_OWNED; }
341
342 private:
343 View(const View&);
344 View& operator=(const View&);
345
346 // The file offset of the start of the view.
347 off_t start_;
348 // The size of the view.
349 section_size_type size_;
350 // A pointer to the actual bytes.
351 const unsigned char* data_;
352 // The number of locks on this view.
353 int lock_count_;
354 // The number of bytes that the view is shifted relative to the
355 // underlying file. This is used to align data. This is normally
356 // zero, except possibly for an object in an archive.
357 unsigned int byteshift_;
358 // Whether the view is cached.
359 bool cache_;
360 // Whether the view is mapped into memory. If not, data_ points
361 // to memory allocated using new[].
362 Data_ownership data_ownership_;
363 // Whether the view has been accessed recently.
364 bool accessed_;
365 };
366
367 friend class View;
368 friend class File_view;
369
370 // The type of a mapping from page start and byte shift to views.
371 typedef std::map<std::pair<off_t, unsigned int>, View*> Views;
372
373 // A simple list of Views.
374 typedef std::list<View*> Saved_views;
375
376 // Open the descriptor if necessary.
377 void
378 reopen_descriptor();
379
380 // Find a view into the file.
381 View*
382 find_view(off_t start, section_size_type size, unsigned int byteshift,
383 View** vshifted) const;
384
385 // Read data from the file into a buffer.
386 void
387 do_read(off_t start, section_size_type size, void* p);
388
389 // Add a view.
390 void
391 add_view(View*);
392
393 // Make a view into the file.
394 View*
395 make_view(off_t start, section_size_type size, unsigned int byteshift,
396 bool cache);
397
398 // Find or make a view into the file.
399 View*
400 find_or_make_view(off_t offset, off_t start, section_size_type size,
401 bool aligned, bool cache);
402
403 // Clear the file views.
404 void
405 clear_views(Clear_views_mode);
406
407 // The size of a file page for buffering data.
408 static const off_t page_size = 8192;
409
410 // Given a file offset, return the page offset.
411 static off_t
412 page_offset(off_t file_offset)
413 { return file_offset & ~ (page_size - 1); }
414
415 // Given a file size, return the size to read integral pages.
416 static off_t
417 pages(off_t file_size)
418 { return (file_size + (page_size - 1)) & ~ (page_size - 1); }
419
420 // The maximum number of entries we will pass to ::readv.
421 static const size_t max_readv_entries = 128;
422
423 // Use readv to read data.
424 void
425 do_readv(off_t base, const Read_multiple&, size_t start, size_t count);
426
427 // File name.
428 std::string name_;
429 // File descriptor.
430 int descriptor_;
431 // Whether we have regained the descriptor after releasing the file.
432 bool is_descriptor_opened_;
433 // The number of objects associated with this file. This will be
434 // more than 1 in the case of an archive.
435 int object_count_;
436 // File size.
437 off_t size_;
438 // A token used to lock the file.
439 Task_token token_;
440 // Buffered views into the file.
441 Views views_;
442 // List of views which were locked but had to be removed from views_
443 // because they were not large enough.
444 Saved_views saved_views_;
445 // Total amount of space mapped into memory. This is only changed
446 // while the file is locked. When we unlock the file, we transfer
447 // the total to total_mapped_bytes, and reset this to zero.
448 size_t mapped_bytes_;
449 // Whether the file was released.
450 bool released_;
451 // A view containing the whole file. May be NULL if we mmap only
452 // the relevant parts of the file. Not NULL if:
453 // - Flag --mmap_whole_files is set (default on 64-bit hosts).
454 // - The contents was specified in the constructor. Used only for
455 // testing purposes).
456 View* whole_file_view_;
457 };
458
459 // A view of file data that persists even when the file is unlocked.
460 // Callers should destroy these when no longer required. These are
461 // obtained form File_read::get_lasting_view. They may only be
462 // destroyed when the underlying File_read is locked.
463
464 class File_view
465 {
466 public:
467 // This may only be called when the underlying File_read is locked.
468 ~File_view();
469
470 // Return a pointer to the data associated with this view.
471 const unsigned char*
472 data() const
473 { return this->data_; }
474
475 private:
476 File_view(const File_view&);
477 File_view& operator=(const File_view&);
478
479 friend class File_read;
480
481 // Callers have to get these via File_read::get_lasting_view.
482 File_view(File_read& file, File_read::View* view, const unsigned char* data)
483 : file_(file), view_(view), data_(data)
484 { }
485
486 File_read& file_;
487 File_read::View* view_;
488 const unsigned char* data_;
489 };
490
491 // All the information we hold for a single input file. This can be
492 // an object file, a shared library, or an archive.
493
494 class Input_file
495 {
496 public:
497 enum Format
498 {
499 FORMAT_NONE,
500 FORMAT_ELF,
501 FORMAT_BINARY
502 };
503
504 Input_file(const Input_file_argument* input_argument)
505 : input_argument_(input_argument), found_name_(), file_(),
506 is_in_sysroot_(false), format_(FORMAT_NONE)
507 { }
508
509 // Create an input file given just a filename.
510 Input_file(const char* name);
511
512 // Create an input file with the contents already provided. This is
513 // only used for testing. With this path, don't call the open
514 // method.
515 Input_file(const Task*, const char* name, const unsigned char* contents,
516 off_t size);
517
518 // Return the command line argument.
519 const Input_file_argument*
520 input_file_argument() const
521 { return this->input_argument_; }
522
523 // Return whether this is a file that we will search for in the list
524 // of directories.
525 bool
526 will_search_for() const;
527
528 // Open the file. If the open fails, this will report an error and
529 // return false. If there is a search, it starts at directory
530 // *PINDEX. *PINDEX should be initialized to zero. It may be
531 // restarted to find the next file with a matching name by
532 // incrementing the result and calling this again.
533 bool
534 open(const Dirsearch&, const Task*, int* pindex);
535
536 // Return the name given by the user. For -lc this will return "c".
537 const char*
538 name() const;
539
540 // Return the file name. For -lc this will return something like
541 // "/usr/lib/libc.so".
542 const std::string&
543 filename() const
544 { return this->file_.filename(); }
545
546 // Return the name under which we found the file, corresponding to
547 // the command line. For -lc this will return something like
548 // "libc.so".
549 const std::string&
550 found_name() const
551 { return this->found_name_; }
552
553 // Return the position dependent options.
554 const Position_dependent_options&
555 options() const;
556
557 // Return the file.
558 File_read&
559 file()
560 { return this->file_; }
561
562 const File_read&
563 file() const
564 { return this->file_; }
565
566 // Whether we found the file in a directory in the system root.
567 bool
568 is_in_sysroot() const
569 { return this->is_in_sysroot_; }
570
571 // Whether this file is in a system directory.
572 bool
573 is_in_system_directory() const;
574
575 // Return whether this file is to be read only for its symbols.
576 bool
577 just_symbols() const;
578
579 // Return the format of the unconverted input file.
580 Format
581 format() const
582 { return this->format_; }
583
584 // Try to find a file in the extra search dirs. Returns true on success.
585 static bool
586 try_extra_search_path(int* pindex,
587 const Input_file_argument* input_argument,
588 std::string filename, std::string* found_name,
589 std::string* namep);
590
591 // Find the actual file.
592 static bool
593 find_file(const Dirsearch& dirpath, int* pindex,
594 const Input_file_argument* input_argument,
595 bool* is_in_sysroot,
596 std::string* found_name, std::string* namep);
597
598 private:
599 Input_file(const Input_file&);
600 Input_file& operator=(const Input_file&);
601
602 // Open a binary file.
603 bool
604 open_binary(const Task* task, const std::string& name);
605
606 // The argument from the command line.
607 const Input_file_argument* input_argument_;
608 // The name under which we opened the file. This is like the name
609 // on the command line, but -lc turns into libc.so (or whatever).
610 // It only includes the full path if the path was on the command
611 // line.
612 std::string found_name_;
613 // The file after we open it.
614 File_read file_;
615 // Whether we found the file in a directory in the system root.
616 bool is_in_sysroot_;
617 // Format of unconverted input file.
618 Format format_;
619 };
620
621 } // end namespace gold
622
623 #endif // !defined(GOLD_FILEREAD_H)