Commit | Line | Data |
---|---|---|
61ba1cf9 ILT |
1 | // archive.cc -- archive support for gold |
2 | ||
ebdbb458 | 3 | // Copyright 2006, 2007, 2008 Free Software Foundation, Inc. |
6cb15b7f ILT |
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 | ||
61ba1cf9 ILT |
23 | #include "gold.h" |
24 | ||
25 | #include <cerrno> | |
26 | #include <cstring> | |
27 | #include <climits> | |
28 | #include <vector> | |
a1207466 CC |
29 | #include "libiberty.h" |
30 | #include "filenames.h" | |
61ba1cf9 ILT |
31 | |
32 | #include "elfcpp.h" | |
7e1edb90 | 33 | #include "options.h" |
7d9e3d98 | 34 | #include "mapfile.h" |
61ba1cf9 | 35 | #include "fileread.h" |
ead1e424 | 36 | #include "readsyms.h" |
61ba1cf9 ILT |
37 | #include "symtab.h" |
38 | #include "object.h" | |
39 | #include "archive.h" | |
40 | ||
41 | namespace gold | |
42 | { | |
43 | ||
44 | // The header of an entry in the archive. This is all readable text, | |
45 | // padded with spaces where necesary. If the contents of an archive | |
46 | // are all text file, the entire archive is readable. | |
47 | ||
48 | struct Archive::Archive_header | |
49 | { | |
50 | // The entry name. | |
51 | char ar_name[16]; | |
52 | // The file modification time. | |
53 | char ar_date[12]; | |
54 | // The user's UID in decimal. | |
55 | char ar_uid[6]; | |
56 | // The user's GID in decimal. | |
57 | char ar_gid[6]; | |
58 | // The file mode in octal. | |
59 | char ar_mode[8]; | |
60 | // The file size in decimal. | |
61 | char ar_size[10]; | |
62 | // The final magic code. | |
63 | char ar_fmag[2]; | |
64 | }; | |
65 | ||
66 | // Archive methods. | |
67 | ||
68 | const char Archive::armag[sarmag] = | |
69 | { | |
70 | '!', '<', 'a', 'r', 'c', 'h', '>', '\n' | |
71 | }; | |
72 | ||
a1207466 CC |
73 | const char Archive::armagt[sarmag] = |
74 | { | |
75 | '!', '<', 't', 'h', 'i', 'n', '>', '\n' | |
76 | }; | |
77 | ||
61ba1cf9 ILT |
78 | const char Archive::arfmag[2] = { '`', '\n' }; |
79 | ||
61ba1cf9 ILT |
80 | // Set up the archive: read the symbol map and the extended name |
81 | // table. | |
82 | ||
83 | void | |
a1207466 | 84 | Archive::setup() |
61ba1cf9 | 85 | { |
3e95a404 ILT |
86 | // We need to ignore empty archives. |
87 | if (this->input_file_->file().filesize() == sarmag) | |
a1207466 | 88 | return; |
3e95a404 | 89 | |
61ba1cf9 ILT |
90 | // The first member of the archive should be the symbol table. |
91 | std::string armap_name; | |
8383303e | 92 | section_size_type armap_size = |
cb295612 | 93 | convert_to_section_size_type(this->read_header(sarmag, false, |
a1207466 | 94 | &armap_name, NULL)); |
75f2446e | 95 | off_t off = sarmag; |
4973341a ILT |
96 | if (armap_name.empty()) |
97 | { | |
98 | this->read_armap(sarmag + sizeof(Archive_header), armap_size); | |
99 | off = sarmag + sizeof(Archive_header) + armap_size; | |
100 | } | |
45aa233b | 101 | else if (!this->input_file_->options().whole_archive()) |
75f2446e ILT |
102 | gold_error(_("%s: no archive symbol table (run ranlib)"), |
103 | this->name().c_str()); | |
4973341a | 104 | |
cb295612 ILT |
105 | // See if there is an extended name table. We cache these views |
106 | // because it is likely that we will want to read the following | |
107 | // header in the add_symbols routine. | |
4973341a ILT |
108 | if ((off & 1) != 0) |
109 | ++off; | |
110 | std::string xname; | |
cb295612 | 111 | section_size_type extended_size = |
a1207466 | 112 | convert_to_section_size_type(this->read_header(off, true, &xname, NULL)); |
4973341a ILT |
113 | if (xname == "/") |
114 | { | |
115 | const unsigned char* p = this->get_view(off + sizeof(Archive_header), | |
39d0cb0e | 116 | extended_size, false, true); |
4973341a ILT |
117 | const char* px = reinterpret_cast<const char*>(p); |
118 | this->extended_names_.assign(px, extended_size); | |
119 | } | |
a1207466 CC |
120 | } |
121 | ||
122 | // Unlock any nested archives. | |
4973341a | 123 | |
a1207466 CC |
124 | void |
125 | Archive::unlock_nested_archives() | |
126 | { | |
127 | for (Nested_archive_table::iterator p = this->nested_archives_.begin(); | |
128 | p != this->nested_archives_.end(); | |
129 | ++p) | |
130 | { | |
131 | p->second->unlock(this->task_); | |
132 | } | |
4973341a | 133 | } |
61ba1cf9 | 134 | |
4973341a ILT |
135 | // Read the archive symbol map. |
136 | ||
137 | void | |
8383303e | 138 | Archive::read_armap(off_t start, section_size_type size) |
4973341a | 139 | { |
61ba1cf9 | 140 | // Read in the entire armap. |
39d0cb0e | 141 | const unsigned char* p = this->get_view(start, size, true, false); |
61ba1cf9 ILT |
142 | |
143 | // Numbers in the armap are always big-endian. | |
144 | const elfcpp::Elf_Word* pword = reinterpret_cast<const elfcpp::Elf_Word*>(p); | |
f6ce93d6 | 145 | unsigned int nsyms = elfcpp::Swap<32, true>::readval(pword); |
61ba1cf9 ILT |
146 | ++pword; |
147 | ||
148 | // Note that the addition is in units of sizeof(elfcpp::Elf_Word). | |
149 | const char* pnames = reinterpret_cast<const char*>(pword + nsyms); | |
8383303e ILT |
150 | section_size_type names_size = |
151 | reinterpret_cast<const char*>(p) + size - pnames; | |
9eb9fa57 | 152 | this->armap_names_.assign(pnames, names_size); |
61ba1cf9 ILT |
153 | |
154 | this->armap_.resize(nsyms); | |
155 | ||
8383303e | 156 | section_offset_type name_offset = 0; |
61ba1cf9 ILT |
157 | for (unsigned int i = 0; i < nsyms; ++i) |
158 | { | |
9eb9fa57 ILT |
159 | this->armap_[i].name_offset = name_offset; |
160 | this->armap_[i].file_offset = elfcpp::Swap<32, true>::readval(pword); | |
161 | name_offset += strlen(pnames + name_offset) + 1; | |
61ba1cf9 ILT |
162 | ++pword; |
163 | } | |
164 | ||
8383303e | 165 | if (static_cast<section_size_type>(name_offset) > names_size) |
75f2446e ILT |
166 | gold_error(_("%s: bad archive symbol table names"), |
167 | this->name().c_str()); | |
a93d6d07 ILT |
168 | |
169 | // This array keeps track of which symbols are for archive elements | |
170 | // which we have already included in the link. | |
171 | this->armap_checked_.resize(nsyms); | |
61ba1cf9 ILT |
172 | } |
173 | ||
174 | // Read the header of an archive member at OFF. Fail if something | |
175 | // goes wrong. Return the size of the member. Set *PNAME to the name | |
176 | // of the member. | |
177 | ||
178 | off_t | |
a1207466 CC |
179 | Archive::read_header(off_t off, bool cache, std::string* pname, |
180 | off_t* nested_off) | |
61ba1cf9 | 181 | { |
39d0cb0e ILT |
182 | const unsigned char* p = this->get_view(off, sizeof(Archive_header), true, |
183 | cache); | |
61ba1cf9 | 184 | const Archive_header* hdr = reinterpret_cast<const Archive_header*>(p); |
a1207466 | 185 | return this->interpret_header(hdr, off, pname, nested_off); |
4973341a | 186 | } |
61ba1cf9 | 187 | |
4973341a ILT |
188 | // Interpret the header of HDR, the header of the archive member at |
189 | // file offset OFF. Fail if something goes wrong. Return the size of | |
190 | // the member. Set *PNAME to the name of the member. | |
191 | ||
192 | off_t | |
193 | Archive::interpret_header(const Archive_header* hdr, off_t off, | |
a1207466 | 194 | std::string* pname, off_t* nested_off) |
4973341a | 195 | { |
61ba1cf9 ILT |
196 | if (memcmp(hdr->ar_fmag, arfmag, sizeof arfmag) != 0) |
197 | { | |
75f2446e ILT |
198 | gold_error(_("%s: malformed archive header at %zu"), |
199 | this->name().c_str(), static_cast<size_t>(off)); | |
200 | return this->input_file_->file().filesize() - off; | |
61ba1cf9 ILT |
201 | } |
202 | ||
203 | const int size_string_size = sizeof hdr->ar_size; | |
204 | char size_string[size_string_size + 1]; | |
205 | memcpy(size_string, hdr->ar_size, size_string_size); | |
206 | char* ps = size_string + size_string_size; | |
207 | while (ps[-1] == ' ') | |
208 | --ps; | |
209 | *ps = '\0'; | |
210 | ||
211 | errno = 0; | |
212 | char* end; | |
213 | off_t member_size = strtol(size_string, &end, 10); | |
214 | if (*end != '\0' | |
215 | || member_size < 0 | |
216 | || (member_size == LONG_MAX && errno == ERANGE)) | |
217 | { | |
75f2446e ILT |
218 | gold_error(_("%s: malformed archive header size at %zu"), |
219 | this->name().c_str(), static_cast<size_t>(off)); | |
220 | return this->input_file_->file().filesize() - off; | |
61ba1cf9 ILT |
221 | } |
222 | ||
223 | if (hdr->ar_name[0] != '/') | |
224 | { | |
225 | const char* name_end = strchr(hdr->ar_name, '/'); | |
226 | if (name_end == NULL | |
227 | || name_end - hdr->ar_name >= static_cast<int>(sizeof hdr->ar_name)) | |
228 | { | |
a0c4fb0a | 229 | gold_error(_("%s: malformed archive header name at %zu"), |
75f2446e ILT |
230 | this->name().c_str(), static_cast<size_t>(off)); |
231 | return this->input_file_->file().filesize() - off; | |
61ba1cf9 ILT |
232 | } |
233 | pname->assign(hdr->ar_name, name_end - hdr->ar_name); | |
a1207466 CC |
234 | if (nested_off != NULL) |
235 | *nested_off = 0; | |
61ba1cf9 ILT |
236 | } |
237 | else if (hdr->ar_name[1] == ' ') | |
238 | { | |
239 | // This is the symbol table. | |
240 | pname->clear(); | |
241 | } | |
242 | else if (hdr->ar_name[1] == '/') | |
243 | { | |
244 | // This is the extended name table. | |
245 | pname->assign(1, '/'); | |
246 | } | |
247 | else | |
248 | { | |
249 | errno = 0; | |
250 | long x = strtol(hdr->ar_name + 1, &end, 10); | |
a1207466 CC |
251 | long y = 0; |
252 | if (*end == ':') | |
253 | y = strtol(end + 1, &end, 10); | |
61ba1cf9 ILT |
254 | if (*end != ' ' |
255 | || x < 0 | |
256 | || (x == LONG_MAX && errno == ERANGE) | |
257 | || static_cast<size_t>(x) >= this->extended_names_.size()) | |
258 | { | |
75f2446e ILT |
259 | gold_error(_("%s: bad extended name index at %zu"), |
260 | this->name().c_str(), static_cast<size_t>(off)); | |
261 | return this->input_file_->file().filesize() - off; | |
61ba1cf9 ILT |
262 | } |
263 | ||
264 | const char* name = this->extended_names_.data() + x; | |
a1207466 | 265 | const char* name_end = strchr(name, '\n'); |
61ba1cf9 | 266 | if (static_cast<size_t>(name_end - name) > this->extended_names_.size() |
a1207466 | 267 | || name_end[-1] != '/') |
61ba1cf9 | 268 | { |
75f2446e ILT |
269 | gold_error(_("%s: bad extended name entry at header %zu"), |
270 | this->name().c_str(), static_cast<size_t>(off)); | |
271 | return this->input_file_->file().filesize() - off; | |
61ba1cf9 | 272 | } |
a1207466 CC |
273 | pname->assign(name, name_end - 1 - name); |
274 | if (nested_off != NULL) | |
275 | *nested_off = y; | |
61ba1cf9 ILT |
276 | } |
277 | ||
278 | return member_size; | |
279 | } | |
280 | ||
281 | // Select members from the archive and add them to the link. We walk | |
282 | // through the elements in the archive map, and look each one up in | |
283 | // the symbol table. If it exists as a strong undefined symbol, we | |
284 | // pull in the corresponding element. We have to do this in a loop, | |
285 | // since pulling in one element may create new undefined symbols which | |
286 | // may be satisfied by other objects in the archive. | |
287 | ||
288 | void | |
7e1edb90 | 289 | Archive::add_symbols(Symbol_table* symtab, Layout* layout, |
7d9e3d98 | 290 | Input_objects* input_objects, Mapfile* mapfile) |
61ba1cf9 | 291 | { |
45aa233b | 292 | if (this->input_file_->options().whole_archive()) |
7d9e3d98 ILT |
293 | return this->include_all_members(symtab, layout, input_objects, |
294 | mapfile); | |
4973341a | 295 | |
ead1e424 | 296 | const size_t armap_size = this->armap_.size(); |
61ba1cf9 | 297 | |
e243ffc6 | 298 | // This is a quick optimization, since we usually see many symbols |
8c838dbd ILT |
299 | // in a row with the same offset. last_seen_offset holds the last |
300 | // offset we saw that was present in the seen_offsets_ set. | |
a93d6d07 ILT |
301 | off_t last_seen_offset = -1; |
302 | ||
303 | // Track which symbols in the symbol table we've already found to be | |
304 | // defined. | |
e243ffc6 | 305 | |
61ba1cf9 ILT |
306 | bool added_new_object; |
307 | do | |
308 | { | |
309 | added_new_object = false; | |
61ba1cf9 ILT |
310 | for (size_t i = 0; i < armap_size; ++i) |
311 | { | |
a93d6d07 ILT |
312 | if (this->armap_checked_[i]) |
313 | continue; | |
9eb9fa57 | 314 | if (this->armap_[i].file_offset == last_seen_offset) |
a93d6d07 ILT |
315 | { |
316 | this->armap_checked_[i] = true; | |
317 | continue; | |
318 | } | |
9eb9fa57 | 319 | if (this->seen_offsets_.find(this->armap_[i].file_offset) |
a93d6d07 | 320 | != this->seen_offsets_.end()) |
61ba1cf9 | 321 | { |
a93d6d07 | 322 | this->armap_checked_[i] = true; |
9eb9fa57 | 323 | last_seen_offset = this->armap_[i].file_offset; |
61ba1cf9 ILT |
324 | continue; |
325 | } | |
326 | ||
9eb9fa57 ILT |
327 | const char* sym_name = (this->armap_names_.data() |
328 | + this->armap_[i].name_offset); | |
329 | Symbol* sym = symtab->lookup(sym_name); | |
61ba1cf9 | 330 | if (sym == NULL) |
f3e9c5c5 ILT |
331 | { |
332 | // Check whether the symbol was named in a -u option. | |
333 | if (!parameters->options().is_undefined(sym_name)) | |
334 | continue; | |
335 | } | |
ead1e424 | 336 | else if (!sym->is_undefined()) |
61ba1cf9 | 337 | { |
a93d6d07 | 338 | this->armap_checked_[i] = true; |
61ba1cf9 ILT |
339 | continue; |
340 | } | |
341 | else if (sym->binding() == elfcpp::STB_WEAK) | |
342 | continue; | |
343 | ||
344 | // We want to include this object in the link. | |
9eb9fa57 | 345 | last_seen_offset = this->armap_[i].file_offset; |
a93d6d07 ILT |
346 | this->seen_offsets_.insert(last_seen_offset); |
347 | this->armap_checked_[i] = true; | |
7d9e3d98 ILT |
348 | |
349 | std::string why; | |
350 | if (sym == NULL) | |
351 | { | |
352 | why = "-u "; | |
353 | why += sym_name; | |
354 | } | |
7e1edb90 | 355 | this->include_member(symtab, layout, input_objects, |
7d9e3d98 ILT |
356 | last_seen_offset, mapfile, sym, why.c_str()); |
357 | ||
61ba1cf9 ILT |
358 | added_new_object = true; |
359 | } | |
360 | } | |
361 | while (added_new_object); | |
362 | } | |
363 | ||
4973341a ILT |
364 | // Include all the archive members in the link. This is for --whole-archive. |
365 | ||
366 | void | |
7e1edb90 | 367 | Archive::include_all_members(Symbol_table* symtab, Layout* layout, |
7d9e3d98 | 368 | Input_objects* input_objects, Mapfile* mapfile) |
4973341a ILT |
369 | { |
370 | off_t off = sarmag; | |
82dcae9d | 371 | off_t filesize = this->input_file_->file().filesize(); |
4973341a ILT |
372 | while (true) |
373 | { | |
f5c3f225 | 374 | if (filesize - off < static_cast<off_t>(sizeof(Archive_header))) |
4973341a | 375 | { |
82dcae9d | 376 | if (filesize != off) |
75f2446e ILT |
377 | gold_error(_("%s: short archive header at %zu"), |
378 | this->name().c_str(), static_cast<size_t>(off)); | |
4973341a ILT |
379 | break; |
380 | } | |
381 | ||
82dcae9d ILT |
382 | unsigned char hdr_buf[sizeof(Archive_header)]; |
383 | this->input_file_->file().read(off, sizeof(Archive_header), hdr_buf); | |
384 | ||
bae3688d ILT |
385 | const Archive_header* hdr = |
386 | reinterpret_cast<const Archive_header*>(hdr_buf); | |
4973341a | 387 | std::string name; |
a1207466 | 388 | off_t size = this->interpret_header(hdr, off, &name, NULL); |
3e90f135 | 389 | bool special_member = false; |
4973341a ILT |
390 | if (name.empty()) |
391 | { | |
392 | // Symbol table. | |
3e90f135 | 393 | special_member = true; |
4973341a ILT |
394 | } |
395 | else if (name == "/") | |
396 | { | |
397 | // Extended name table. | |
3e90f135 | 398 | special_member = true; |
4973341a ILT |
399 | } |
400 | else | |
7d9e3d98 ILT |
401 | this->include_member(symtab, layout, input_objects, off, |
402 | mapfile, NULL, "--whole-archive"); | |
4973341a | 403 | |
a1207466 | 404 | off += sizeof(Archive_header); |
3e90f135 | 405 | if (special_member || !this->is_thin_archive_) |
a1207466 | 406 | off += size; |
4973341a ILT |
407 | if ((off & 1) != 0) |
408 | ++off; | |
409 | } | |
410 | } | |
411 | ||
61ba1cf9 | 412 | // Include an archive member in the link. OFF is the file offset of |
7d9e3d98 | 413 | // the member header. WHY is the reason we are including this member. |
61ba1cf9 ILT |
414 | |
415 | void | |
7e1edb90 | 416 | Archive::include_member(Symbol_table* symtab, Layout* layout, |
7d9e3d98 ILT |
417 | Input_objects* input_objects, off_t off, |
418 | Mapfile* mapfile, Symbol* sym, const char* why) | |
61ba1cf9 ILT |
419 | { |
420 | std::string n; | |
a1207466 CC |
421 | off_t nested_off; |
422 | this->read_header(off, false, &n, &nested_off); | |
61ba1cf9 | 423 | |
7d9e3d98 ILT |
424 | if (mapfile != NULL) |
425 | mapfile->report_include_archive_member(this, n, sym, why); | |
426 | ||
a1207466 CC |
427 | Input_file* input_file; |
428 | off_t memoff; | |
429 | ||
430 | if (!this->is_thin_archive_) | |
431 | { | |
432 | input_file = this->input_file_; | |
433 | memoff = off + static_cast<off_t>(sizeof(Archive_header)); | |
434 | } | |
435 | else | |
436 | { | |
437 | // Adjust a relative pathname so that it is relative | |
438 | // to the directory containing the archive. | |
439 | if (!IS_ABSOLUTE_PATH(n.c_str())) | |
440 | { | |
441 | const char *arch_path = this->name().c_str(); | |
442 | const char *basename = lbasename(arch_path); | |
443 | if (basename > arch_path) | |
444 | n.replace(0, 0, this->name().substr(0, basename - arch_path)); | |
445 | } | |
446 | if (nested_off > 0) | |
447 | { | |
448 | // This is a member of a nested archive. Open the containing | |
449 | // archive if we don't already have it open, then do a recursive | |
450 | // call to include the member from that archive. | |
451 | Archive* arch; | |
452 | Nested_archive_table::const_iterator p = | |
453 | this->nested_archives_.find(n); | |
454 | if (p != this->nested_archives_.end()) | |
455 | arch = p->second; | |
456 | else | |
457 | { | |
458 | Input_file_argument* input_file_arg = | |
459 | new Input_file_argument(n.c_str(), false, "", false, | |
460 | parameters->options()); | |
461 | input_file = new Input_file(input_file_arg); | |
462 | if (!input_file->open(parameters->options(), *this->dirpath_, | |
463 | this->task_)) | |
464 | return; | |
465 | arch = new Archive(n, input_file, false, this->dirpath_, | |
466 | this->task_); | |
467 | arch->setup(); | |
468 | std::pair<Nested_archive_table::iterator, bool> ins = | |
469 | this->nested_archives_.insert(std::make_pair(n, arch)); | |
470 | gold_assert(ins.second); | |
471 | } | |
7d9e3d98 ILT |
472 | arch->include_member(symtab, layout, input_objects, nested_off, |
473 | NULL, NULL, NULL); | |
a1207466 CC |
474 | return; |
475 | } | |
476 | // This is an external member of a thin archive. Open the | |
477 | // file as a regular relocatable object file. | |
478 | Input_file_argument* input_file_arg = | |
479 | new Input_file_argument(n.c_str(), false, "", false, | |
480 | this->input_file_->options()); | |
481 | input_file = new Input_file(input_file_arg); | |
482 | if (!input_file->open(parameters->options(), *this->dirpath_, | |
483 | this->task_)) | |
484 | { | |
485 | return; | |
486 | } | |
487 | memoff = 0; | |
488 | } | |
61ba1cf9 | 489 | |
a1207466 | 490 | off_t filesize = input_file->file().filesize(); |
82dcae9d ILT |
491 | int read_size = elfcpp::Elf_sizes<64>::ehdr_size; |
492 | if (filesize - memoff < read_size) | |
493 | read_size = filesize - memoff; | |
494 | ||
495 | if (read_size < 4) | |
61ba1cf9 | 496 | { |
75f2446e ILT |
497 | gold_error(_("%s: member at %zu is not an ELF object"), |
498 | this->name().c_str(), static_cast<size_t>(off)); | |
499 | return; | |
61ba1cf9 ILT |
500 | } |
501 | ||
7ef73768 ILT |
502 | const unsigned char* ehdr = input_file->file().get_view(memoff, 0, read_size, |
503 | true, false); | |
82dcae9d | 504 | |
61ba1cf9 ILT |
505 | static unsigned char elfmagic[4] = |
506 | { | |
507 | elfcpp::ELFMAG0, elfcpp::ELFMAG1, | |
508 | elfcpp::ELFMAG2, elfcpp::ELFMAG3 | |
509 | }; | |
7ef73768 | 510 | if (memcmp(ehdr, elfmagic, 4) != 0) |
61ba1cf9 | 511 | { |
75f2446e ILT |
512 | gold_error(_("%s: member at %zu is not an ELF object"), |
513 | this->name().c_str(), static_cast<size_t>(off)); | |
514 | return; | |
61ba1cf9 ILT |
515 | } |
516 | ||
92e059d8 | 517 | Object* obj = make_elf_object((std::string(this->input_file_->filename()) |
61ba1cf9 | 518 | + "(" + n + ")"), |
7ef73768 | 519 | input_file, memoff, ehdr, read_size); |
61ba1cf9 | 520 | |
019cdb1a ILT |
521 | if (input_objects->add_object(obj)) |
522 | { | |
523 | Read_symbols_data sd; | |
524 | obj->read_symbols(&sd); | |
525 | obj->layout(symtab, layout, &sd); | |
526 | obj->add_symbols(symtab, &sd); | |
527 | } | |
528 | else | |
529 | { | |
530 | // FIXME: We need to close the descriptor here. | |
531 | delete obj; | |
532 | } | |
61ba1cf9 | 533 | |
a1207466 CC |
534 | if (this->is_thin_archive_) |
535 | { | |
536 | // Opening the file locked it. Unlock it now. | |
537 | input_file->file().unlock(this->task_); | |
538 | } | |
61ba1cf9 ILT |
539 | } |
540 | ||
541 | // Add_archive_symbols methods. | |
542 | ||
543 | Add_archive_symbols::~Add_archive_symbols() | |
544 | { | |
545 | if (this->this_blocker_ != NULL) | |
546 | delete this->this_blocker_; | |
547 | // next_blocker_ is deleted by the task associated with the next | |
548 | // input file. | |
549 | } | |
550 | ||
551 | // Return whether we can add the archive symbols. We are blocked by | |
552 | // this_blocker_. We block next_blocker_. We also lock the file. | |
553 | ||
17a1d0a9 ILT |
554 | Task_token* |
555 | Add_archive_symbols::is_runnable() | |
61ba1cf9 ILT |
556 | { |
557 | if (this->this_blocker_ != NULL && this->this_blocker_->is_blocked()) | |
17a1d0a9 ILT |
558 | return this->this_blocker_; |
559 | return NULL; | |
61ba1cf9 ILT |
560 | } |
561 | ||
17a1d0a9 ILT |
562 | void |
563 | Add_archive_symbols::locks(Task_locker* tl) | |
61ba1cf9 | 564 | { |
17a1d0a9 ILT |
565 | tl->add(this, this->next_blocker_); |
566 | tl->add(this, this->archive_->token()); | |
61ba1cf9 ILT |
567 | } |
568 | ||
569 | void | |
570 | Add_archive_symbols::run(Workqueue*) | |
571 | { | |
7e1edb90 | 572 | this->archive_->add_symbols(this->symtab_, this->layout_, |
7d9e3d98 | 573 | this->input_objects_, this->mapfile_); |
ead1e424 | 574 | |
a1207466 CC |
575 | this->archive_->unlock_nested_archives(); |
576 | ||
17a1d0a9 | 577 | this->archive_->release(); |
39d0cb0e | 578 | this->archive_->clear_uncached_views(); |
17a1d0a9 | 579 | |
ead1e424 ILT |
580 | if (this->input_group_ != NULL) |
581 | this->input_group_->add_archive(this->archive_); | |
582 | else | |
583 | { | |
584 | // We no longer need to know about this archive. | |
585 | delete this->archive_; | |
c7912668 | 586 | this->archive_ = NULL; |
ead1e424 | 587 | } |
61ba1cf9 ILT |
588 | } |
589 | ||
590 | } // End namespace gold. |