1 // readsyms.h -- read input file symbols 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 #ifndef GOLD_READSYMS_H
24 #define GOLD_READSYMS_H
25
26 #include <vector>
27
28 #include "workqueue.h"
29 #include "object.h"
30 #include "incremental.h"
31
32 namespace gold
33 {
34
35 class Input_objects;
36 class Symbol_table;
37 class Input_group;
38 class Archive;
39 class Finish_group;
40
41 // This Task is responsible for reading the symbols from an input
42 // file. This also includes reading the relocations so that we can
43 // check for any that require a PLT and/or a GOT. After the data has
44 // been read, this queues up another task to actually add the symbols
45 // to the symbol table. The tasks are separated because the file
46 // reading can occur in parallel but adding the symbols must be done
47 // in the order of the input files.
48
49 class Read_symbols : public Task
50 {
51 public:
52 // DIRPATH is the list of directories to search for libraries.
53 // INPUT is the file to read. INPUT_GROUP is not NULL if we are in
54 // the middle of an input group. THIS_BLOCKER is used to prevent
55 // the associated Add_symbols task from running before the previous
56 // one has completed; it will be NULL for the first task.
57 // NEXT_BLOCKER is used to block the next input file from adding
58 // symbols.
59 Read_symbols(Input_objects* input_objects, Symbol_table* symtab,
60 Layout* layout, Dirsearch* dirpath, int dirindex,
61 Mapfile* mapfile, const Input_argument* input_argument,
62 Input_group* input_group, Archive_member* member,
63 Task_token* this_blocker, Task_token* next_blocker)
64 : input_objects_(input_objects), symtab_(symtab), layout_(layout),
65 dirpath_(dirpath), dirindex_(dirindex), mapfile_(mapfile),
66 input_argument_(input_argument), input_group_(input_group),
67 member_(member), this_blocker_(this_blocker),
68 next_blocker_(next_blocker)
69 { }
70
71 ~Read_symbols();
72
73 // If appropriate, issue a warning about skipping an incompatible
74 // object.
75 static void
76 incompatible_warning(const Input_argument*, const Input_file*);
77
78 // Requeue a Read_symbols task to search for the next object with
79 // the same name.
80 static void
81 requeue(Workqueue*, Input_objects*, Symbol_table*, Layout*, Dirsearch*,
82 int dirindex, Mapfile*, const Input_argument*, Input_group*,
83 Task_token* next_blocker);
84
85 // The standard Task methods.
86
87 Task_token*
88 is_runnable();
89
90 void
91 locks(Task_locker*);
92
93 void
94 run(Workqueue*);
95
96 std::string
97 get_name() const;
98
99 private:
100 // Handle an archive group.
101 void
102 do_group(Workqueue*);
103
104 // Handle --start-lib ... --end-lib
105 bool
106 do_lib_group(Workqueue*);
107
108 // Handle --whole-archive --start-lib ... --end-lib --no-whole-archive
109 bool
110 do_whole_lib_group(Workqueue*);
111
112 // Open and identify the file.
113 bool
114 do_read_symbols(Workqueue*);
115
116 Input_objects* input_objects_;
117 Symbol_table* symtab_;
118 Layout* layout_;
119 Dirsearch* dirpath_;
120 int dirindex_;
121 Mapfile* mapfile_;
122 const Input_argument* input_argument_;
123 Input_group* input_group_;
124 Archive_member* member_;
125 Task_token* this_blocker_;
126 Task_token* next_blocker_;
127 };
128
129 // This Task handles adding the symbols to the symbol table. These
130 // tasks must be run in the same order as the arguments appear on the
131 // command line.
132
133 class Add_symbols : public Task
134 {
135 public:
136 // THIS_BLOCKER is used to prevent this task from running before the
137 // one for the previous input file. NEXT_BLOCKER is used to prevent
138 // the next task from running.
139 Add_symbols(Input_objects* input_objects, Symbol_table* symtab,
140 Layout* layout, Dirsearch* /*dirpath*/, int /*dirindex*/,
141 Mapfile* /*mapfile*/, const Input_argument* input_argument,
142 Object* object, Incremental_library* library,
143 Read_symbols_data* sd, Task_token* this_blocker,
144 Task_token* next_blocker)
145 : input_objects_(input_objects), symtab_(symtab), layout_(layout),
146 input_argument_(input_argument), object_(object), library_(library),
147 sd_(sd), this_blocker_(this_blocker), next_blocker_(next_blocker)
148 { }
149
150 ~Add_symbols();
151
152 // The standard Task methods.
153
154 Task_token*
155 is_runnable();
156
157 void
158 locks(Task_locker*);
159
160 void
161 run(Workqueue*);
162
163 std::string
164 get_name() const
165 { return "Add_symbols " + this->object_->name(); }
166
167 private:
168 Input_objects* input_objects_;
169 Symbol_table* symtab_;
170 Layout* layout_;
171 const Input_argument* input_argument_;
172 Object* object_;
173 Incremental_library* library_;
174 Read_symbols_data* sd_;
175 Task_token* this_blocker_;
176 Task_token* next_blocker_;
177 };
178
179 // This Task is responsible for reading the symbols from an archive
180 // member that has changed since the last incremental link.
181
182 class Read_member : public Task
183 {
184 public:
185 // INPUT is the file to read. INPUT_GROUP is not NULL if we are in
186 // the middle of an input group. THIS_BLOCKER is used to prevent
187 // the associated Add_symbols task from running before the previous
188 // one has completed; it will be NULL for the first task.
189 // NEXT_BLOCKER is used to block the next input file from adding
190 // symbols.
191 Read_member(Input_objects* /*input_objects*/, Symbol_table* /*symtab*/,
192 Layout* /*layout*/, Mapfile* /*mapfile*/,
193 const Incremental_binary::Input_reader* input_reader,
194 Task_token* this_blocker, Task_token* next_blocker)
195 : input_reader_(input_reader),
196 this_blocker_(this_blocker), next_blocker_(next_blocker)
197 { }
198
199 ~Read_member();
200
201 // The standard Task methods.
202
203 Task_token*
204 is_runnable();
205
206 void
207 locks(Task_locker*);
208
209 void
210 run(Workqueue*);
211
212 std::string
213 get_name() const
214 {
215 return (std::string("Read_member ") + this->input_reader_->filename());
216 }
217
218 private:
219 const Incremental_binary::Input_reader* input_reader_;
220 Task_token* this_blocker_;
221 Task_token* next_blocker_;
222 };
223
224 // This Task is responsible for processing an input script file that has
225 // not changed since the last incremental link.
226
227 class Check_script : public Task
228 {
229 public:
230 Check_script(Layout* layout, Incremental_binary* ibase,
231 unsigned int input_file_index,
232 const Incremental_binary::Input_reader* input_reader,
233 Task_token* this_blocker, Task_token* next_blocker)
234 : layout_(layout), ibase_(ibase), input_file_index_(input_file_index),
235 input_reader_(input_reader), this_blocker_(this_blocker),
236 next_blocker_(next_blocker)
237 {
238 this->filename_ = std::string(this->input_reader_->filename());
239 }
240
241 ~Check_script();
242
243 // The standard Task methods.
244
245 Task_token*
246 is_runnable();
247
248 void
249 locks(Task_locker*);
250
251 void
252 run(Workqueue*);
253
254 std::string
255 get_name() const
256 {
257 return (std::string("Check_script ") + this->input_reader_->filename());
258 }
259
260 private:
261 std::string filename_;
262 Layout* layout_;
263 Incremental_binary* ibase_;
264 unsigned int input_file_index_;
265 const Incremental_binary::Input_reader* input_reader_;
266 Task_token* this_blocker_;
267 Task_token* next_blocker_;
268 };
269
270 // This Task is responsible for processing an archive library that has
271 // not changed since the last incremental link.
272
273 class Check_library : public Task
274 {
275 public:
276 Check_library(Symbol_table* /*symtab*/, Layout* layout,
277 Incremental_binary* ibase,
278 unsigned int input_file_index,
279 const Incremental_binary::Input_reader* input_reader,
280 Task_token* this_blocker, Task_token* next_blocker)
281 : layout_(layout), ibase_(ibase),
282 input_file_index_(input_file_index), input_reader_(input_reader),
283 this_blocker_(this_blocker), next_blocker_(next_blocker)
284 { }
285
286 ~Check_library();
287
288 // The standard Task methods.
289
290 Task_token*
291 is_runnable();
292
293 void
294 locks(Task_locker*);
295
296 void
297 run(Workqueue*);
298
299 std::string
300 get_name() const
301 {
302 return (std::string("Check_library ") + this->input_reader_->filename());
303 }
304
305 private:
306 Layout* layout_;
307 Incremental_binary* ibase_;
308 unsigned int input_file_index_;
309 const Incremental_binary::Input_reader* input_reader_;
310 Task_token* this_blocker_;
311 Task_token* next_blocker_;
312 };
313
314 // This class is used to track the archives in a group.
315
316 class Input_group
317 {
318 public:
319 typedef std::vector<Archive*> Archives;
320 typedef Archives::const_iterator const_iterator;
321
322 Input_group()
323 : archives_()
324 { }
325
326 ~Input_group();
327
328 // Add an archive to the group.
329 void
330 add_archive(Archive* arch)
331 { this->archives_.push_back(arch); }
332
333 // Loop over the archives in the group.
334
335 const_iterator
336 begin() const
337 { return this->archives_.begin(); }
338
339 const_iterator
340 end() const
341 { return this->archives_.end(); }
342
343 private:
344 Archives archives_;
345 };
346
347 // This class starts the handling of a group. It exists only to pick
348 // up the number of undefined symbols at that point, so that we only
349 // run back through the group if we saw a new undefined symbol.
350
351 class Start_group : public Task
352 {
353 public:
354 Start_group(Symbol_table* symtab, Finish_group* finish_group,
355 Task_token* this_blocker, Task_token* next_blocker)
356 : symtab_(symtab), finish_group_(finish_group),
357 this_blocker_(this_blocker), next_blocker_(next_blocker)
358 { }
359
360 ~Start_group();
361
362 // The standard Task methods.
363
364 Task_token*
365 is_runnable();
366
367 void
368 locks(Task_locker*);
369
370 void
371 run(Workqueue*);
372
373 std::string
374 get_name() const
375 { return "Start_group"; }
376
377 private:
378 Symbol_table* symtab_;
379 Finish_group* finish_group_;
380 Task_token* this_blocker_;
381 Task_token* next_blocker_;
382 };
383
384 // This class is used to finish up handling a group. It is just a
385 // closure.
386
387 class Finish_group : public Task
388 {
389 public:
390 Finish_group(Input_objects* input_objects, Symbol_table* symtab,
391 Layout* layout, Mapfile* mapfile, Input_group* input_group,
392 Task_token* next_blocker)
393 : input_objects_(input_objects), symtab_(symtab),
394 layout_(layout), mapfile_(mapfile), input_group_(input_group),
395 saw_undefined_(0), this_blocker_(NULL), next_blocker_(next_blocker)
396 { }
397
398 ~Finish_group();
399
400 // Set the number of undefined symbols when we start processing the
401 // group. This is called by the Start_group task.
402 void
403 set_saw_undefined(size_t saw_undefined)
404 { this->saw_undefined_ = saw_undefined; }
405
406 // Set the blocker to use for this task.
407 void
408 set_blocker(Task_token* this_blocker)
409 {
410 gold_assert(this->this_blocker_ == NULL);
411 this->this_blocker_ = this_blocker;
412 }
413
414 // The standard Task methods.
415
416 Task_token*
417 is_runnable();
418
419 void
420 locks(Task_locker*);
421
422 void
423 run(Workqueue*);
424
425 std::string
426 get_name() const
427 { return "Finish_group"; }
428
429 private:
430 Input_objects* input_objects_;
431 Symbol_table* symtab_;
432 Layout* layout_;
433 Mapfile* mapfile_;
434 Input_group* input_group_;
435 size_t saw_undefined_;
436 Task_token* this_blocker_;
437 Task_token* next_blocker_;
438 };
439
440 // This class is used to read a file which was not recognized as an
441 // object or archive. It tries to read it as a linker script, using
442 // the tokens to serialize with the calls to Add_symbols.
443
444 class Read_script : public Task
445 {
446 public:
447 Read_script(Symbol_table* symtab, Layout* layout, Dirsearch* dirpath,
448 int dirindex, Input_objects* input_objects, Mapfile* mapfile,
449 Input_group* input_group, const Input_argument* input_argument,
450 Input_file* input_file, Task_token* this_blocker,
451 Task_token* next_blocker)
452 : symtab_(symtab), layout_(layout), dirpath_(dirpath), dirindex_(dirindex),
453 input_objects_(input_objects), mapfile_(mapfile),
454 input_group_(input_group), input_argument_(input_argument),
455 input_file_(input_file), this_blocker_(this_blocker),
456 next_blocker_(next_blocker)
457 { }
458
459 ~Read_script();
460
461 // The standard Task methods.
462
463 Task_token*
464 is_runnable();
465
466 void
467 locks(Task_locker*);
468
469 void
470 run(Workqueue*);
471
472 std::string
473 get_name() const;
474
475 private:
476 Symbol_table* symtab_;
477 Layout* layout_;
478 Dirsearch* dirpath_;
479 int dirindex_;
480 Input_objects* input_objects_;
481 Mapfile* mapfile_;
482 Input_group* input_group_;
483 const Input_argument* input_argument_;
484 Input_file* input_file_;
485 Task_token* this_blocker_;
486 Task_token* next_blocker_;
487 };
488
489 } // end namespace gold
490
491 #endif // !defined(GOLD_READSYMS_H)