OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [gold/] [archive.h] - Blame information for rev 862

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 205 julius
// archive.h -- archive support for gold      -*- C++ -*-
2
 
3
// Copyright 2006, 2007, 2008 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
#ifndef GOLD_ARCHIVE_H
24
#define GOLD_ARCHIVE_H
25
 
26
#include <string>
27
#include <vector>
28
 
29
#include "fileread.h"
30
#include "workqueue.h"
31
 
32
namespace gold
33
{
34
 
35
class Task;
36
class Input_argument;
37
class Input_file;
38
class Input_objects;
39
class Input_group;
40
class Layout;
41
class Symbol_table;
42
class Object;
43
class Read_symbols_data;
44
 
45
// This class represents an archive--generally a libNAME.a file.
46
// Archives have a symbol table and a list of objects.
47
 
48
class Archive
49
{
50
 public:
51
  Archive(const std::string& name, Input_file* input_file,
52
          bool is_thin_archive, Dirsearch* dirpath, Task* task);
53
 
54
  // The length of the magic string at the start of an archive.
55
  static const int sarmag = 8;
56
 
57
  // The magic string at the start of an archive.
58
  static const char armag[sarmag];
59
  static const char armagt[sarmag];
60
 
61
  // The string expected at the end of an archive member header.
62
  static const char arfmag[2];
63
 
64
  // The name of the object.  This is the name used on the command
65
  // line; e.g., if "-lgcc" is on the command line, this will be
66
  // "gcc".
67
  const std::string&
68
  name() const
69
  { return this->name_; }
70
 
71
  // The input file.
72
  const Input_file*
73
  input_file() const
74
  { return this->input_file_; }
75
 
76
  // The file name.
77
  const std::string&
78
  filename() const
79
  { return this->input_file_->filename(); }
80
 
81
  // Set up the archive: read the symbol map.
82
  void
83
  setup();
84
 
85
  // Get a reference to the underlying file.
86
  File_read&
87
  file()
88
  { return this->input_file_->file(); }
89
 
90
  const File_read&
91
  file() const
92
  { return this->input_file_->file(); }
93
 
94
  // Lock the underlying file.
95
  void
96
  lock(const Task* t)
97
  { this->input_file_->file().lock(t); }
98
 
99
  // Unlock the underlying file.
100
  void
101
  unlock(const Task* t)
102
  { this->input_file_->file().unlock(t); }
103
 
104
  // Return whether the underlying file is locked.
105
  bool
106
  is_locked() const
107
  { return this->input_file_->file().is_locked(); }
108
 
109
  // Return the token, so that the task can be queued.
110
  Task_token*
111
  token()
112
  { return this->input_file_->file().token(); }
113
 
114
  // Release the underlying file.
115
  void
116
  release()
117
  { this->input_file_->file().release(); }
118
 
119
  // Clear uncached views in the underlying file.
120
  void
121
  clear_uncached_views()
122
  { this->input_file_->file().clear_uncached_views(); }
123
 
124
  // Whether this is a thin archive.
125
  bool
126
  is_thin_archive() const
127
  { return this->is_thin_archive_; }
128
 
129
  // Unlock any nested archives.
130
  void
131
  unlock_nested_archives();
132
 
133
  // Select members from the archive as needed and add them to the
134
  // link.
135
  bool
136
  add_symbols(Symbol_table*, Layout*, Input_objects*, Mapfile*);
137
 
138
  // Dump statistical information to stderr.
139
  static void
140
  print_stats();
141
 
142
  // Return the number of members in the archive.
143
  size_t
144
  count_members();
145
 
146
  // Return the no-export flag.
147
  bool
148
  no_export()
149
  { return this->no_export_; }
150
 
151
 private:
152
  Archive(const Archive&);
153
  Archive& operator=(const Archive&);
154
 
155
  struct Archive_header;
156
 
157
  // Total number of archives seen.
158
  static unsigned int total_archives;
159
  // Total number of archive members seen.
160
  static unsigned int total_members;
161
  // Number of archive members loaded.
162
  static unsigned int total_members_loaded;
163
 
164
  // Get a view into the underlying file.
165
  const unsigned char*
166
  get_view(off_t start, section_size_type size, bool aligned, bool cache)
167
  { return this->input_file_->file().get_view(0, start, size, aligned, cache); }
168
 
169
  // Read the archive symbol map.
170
  void
171
  read_armap(off_t start, section_size_type size);
172
 
173
  // Read an archive member header at OFF.  CACHE is whether to cache
174
  // the file view.  Return the size of the member, and set *PNAME to
175
  // the name.
176
  off_t
177
  read_header(off_t off, bool cache, std::string* pname, off_t* nested_off);
178
 
179
  // Interpret an archive header HDR at OFF.  Return the size of the
180
  // member, and set *PNAME to the name.
181
  off_t
182
  interpret_header(const Archive_header* hdr, off_t off, std::string* pname,
183
                   off_t* nested_off) const;
184
 
185
  // Get the file and offset for an archive member, which may be an
186
  // external member of a thin archive.  Set *INPUT_FILE to the
187
  // file containing the actual member, *MEMOFF to the offset
188
  // within that file (0 if not a nested archive), and *MEMBER_NAME
189
  // to the name of the archive member.  Return TRUE on success.
190
  bool
191
  get_file_and_offset(off_t off, Input_file** input_file, off_t* memoff,
192
                      off_t* memsize, std::string* member_name);
193
 
194
  // Return an ELF object for the member at offset OFF.
195
  Object*
196
  get_elf_object_for_member(off_t off, bool*);
197
 
198
  // Read the symbols from all the archive members in the link.
199
  void
200
  read_all_symbols();
201
 
202
  // Read the symbols from an archive member in the link.  OFF is the file
203
  // offset of the member header.
204
  void
205
  read_symbols(off_t off);
206
 
207
  // Include all the archive members in the link.
208
  bool
209
  include_all_members(Symbol_table*, Layout*, Input_objects*, Mapfile*);
210
 
211
  // Include an archive member in the link.
212
  bool
213
  include_member(Symbol_table*, Layout*, Input_objects*, off_t off,
214
                 Mapfile*, Symbol*, const char* why);
215
 
216
  // Return whether we found this archive by searching a directory.
217
  bool
218
  searched_for() const
219
  { return this->input_file_->will_search_for(); }
220
 
221
  // Iterate over archive members.
222
  class const_iterator;
223
 
224
  const_iterator
225
  begin();
226
 
227
  const_iterator
228
  end();
229
 
230
  friend class const_iterator;
231
 
232
  // An entry in the archive map of symbols to object files.
233
  struct Armap_entry
234
  {
235
    // The offset to the symbol name in armap_names_.
236
    off_t name_offset;
237
    // The file offset to the object in the archive.
238
    off_t file_offset;
239
  };
240
 
241
  // An entry in the archive map of offsets to members.
242
  struct Archive_member
243
  {
244
    Archive_member()
245
      : obj_(NULL), sd_(NULL)
246
    { }
247
    Archive_member(Object* obj, Read_symbols_data* sd)
248
      : obj_(obj), sd_(sd)
249
    { }
250
    // The object file.
251
    Object* obj_;
252
    // The data to pass from read_symbols() to add_symbols().
253
    Read_symbols_data* sd_;
254
  };
255
 
256
  // A simple hash code for off_t values.
257
  class Seen_hash
258
  {
259
   public:
260
    size_t operator()(off_t val) const
261
    { return static_cast<size_t>(val); }
262
  };
263
 
264
  // For keeping track of open nested archives in a thin archive file.
265
  typedef Unordered_map<std::string, Archive*> Nested_archive_table;
266
 
267
  // Name of object as printed to user.
268
  std::string name_;
269
  // For reading the file.
270
  Input_file* input_file_;
271
  // The archive map.
272
  std::vector<Armap_entry> armap_;
273
  // The names in the archive map.
274
  std::string armap_names_;
275
  // The extended name table.
276
  std::string extended_names_;
277
  // Track which symbols in the archive map are for elements which are
278
  // defined or which have already been included in the link.
279
  std::vector<bool> armap_checked_;
280
  // Track which elements have been included by offset.
281
  Unordered_set<off_t, Seen_hash> seen_offsets_;
282
  // Table of objects whose symbols have been pre-read.
283
  std::map<off_t, Archive_member> members_;
284
  // True if this is a thin archive.
285
  const bool is_thin_archive_;
286
  // True if we have included at least one object from this archive.
287
  bool included_member_;
288
  // Table of nested archives, indexed by filename.
289
  Nested_archive_table nested_archives_;
290
  // The directory search path.
291
  Dirsearch* dirpath_;
292
  // The task reading this archive.
293
  Task *task_;
294
  // Number of members in this archive;
295
  unsigned int num_members_;
296
  // True if we exclude this library archive from automatic export.
297
  bool no_export_;
298
};
299
 
300
// This class is used to read an archive and pick out the desired
301
// elements and add them to the link.
302
 
303
class Add_archive_symbols : public Task
304
{
305
 public:
306
  Add_archive_symbols(Symbol_table* symtab, Layout* layout,
307
                      Input_objects* input_objects, Dirsearch* dirpath,
308
                      int dirindex, Mapfile* mapfile,
309
                      const Input_argument* input_argument,
310
                      Archive* archive, Input_group* input_group,
311
                      Task_token* this_blocker,
312
                      Task_token* next_blocker)
313
    : symtab_(symtab), layout_(layout), input_objects_(input_objects),
314
      dirpath_(dirpath), dirindex_(dirindex), mapfile_(mapfile),
315
      input_argument_(input_argument), archive_(archive),
316
      input_group_(input_group), this_blocker_(this_blocker),
317
      next_blocker_(next_blocker)
318
  { }
319
 
320
  ~Add_archive_symbols();
321
 
322
  // The standard Task methods.
323
 
324
  Task_token*
325
  is_runnable();
326
 
327
  void
328
  locks(Task_locker*);
329
 
330
  void
331
  run(Workqueue*);
332
 
333
  std::string
334
  get_name() const
335
  {
336
    if (this->archive_ == NULL)
337
      return "Add_archive_symbols";
338
    return "Add_archive_symbols " + this->archive_->file().filename();
339
  }
340
 
341
 private:
342
  Symbol_table* symtab_;
343
  Layout* layout_;
344
  Input_objects* input_objects_;
345
  Dirsearch* dirpath_;
346
  int dirindex_;
347
  Mapfile* mapfile_;
348
  const Input_argument* input_argument_;
349
  Archive* archive_;
350
  Input_group* input_group_;
351
  Task_token* this_blocker_;
352
  Task_token* next_blocker_;
353
};
354
 
355
} // End namespace gold.
356
 
357
#endif // !defined(GOLD_ARCHIVE_H)

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.