More dynamic object support, initial scripting support.
[external/binutils.git] / gold / reloc.cc
1 // reloc.cc -- relocate input files for gold.
2
3 #include "gold.h"
4
5 #include "workqueue.h"
6 #include "object.h"
7 #include "output.h"
8 #include "reloc.h"
9
10 namespace gold
11 {
12
13 // Read_relocs methods.
14
15 // These tasks just read the relocation information from the file.
16 // After reading it, the start another task to process the
17 // information.  These tasks requires access to the file.
18
19 Task::Is_runnable_type
20 Read_relocs::is_runnable(Workqueue*)
21 {
22   return this->object_->is_locked() ? IS_LOCKED : IS_RUNNABLE;
23 }
24
25 // Lock the file.
26
27 Task_locker*
28 Read_relocs::locks(Workqueue*)
29 {
30   return new Task_locker_obj<Object>(*this->object_);
31 }
32
33 // Read the relocations and then start a Scan_relocs_task.
34
35 void
36 Read_relocs::run(Workqueue* workqueue)
37 {
38   Read_relocs_data *rd = new Read_relocs_data;
39   this->object_->read_relocs(rd);
40   workqueue->queue_front(new Scan_relocs(this->options_, this->symtab_,
41                                          this->layout_, this->object_, rd,
42                                          this->symtab_lock_, this->blocker_));
43 }
44
45 // Scan_relocs methods.
46
47 // These tasks scan the relocations read by Read_relocs and mark up
48 // the symbol table to indicate which relocations are required.  We
49 // use a lock on the symbol table to keep them from interfering with
50 // each other.
51
52 Task::Is_runnable_type
53 Scan_relocs::is_runnable(Workqueue*)
54 {
55   if (!this->symtab_lock_->is_writable() || this->object_->is_locked())
56     return IS_LOCKED;
57   return IS_RUNNABLE;
58 }
59
60 // Return the locks we hold: one on the file, one on the symbol table
61 // and one blocker.
62
63 class Scan_relocs::Scan_relocs_locker : public Task_locker
64 {
65  public:
66   Scan_relocs_locker(Object* object, Task_token& symtab_lock, Task* task,
67                      Task_token& blocker, Workqueue* workqueue)
68     : objlock_(*object), symtab_locker_(symtab_lock, task),
69       blocker_(blocker, workqueue)
70   { }
71
72  private:
73   Task_locker_obj<Object> objlock_;
74   Task_locker_write symtab_locker_;
75   Task_locker_block blocker_;
76 };
77
78 Task_locker*
79 Scan_relocs::locks(Workqueue* workqueue)
80 {
81   return new Scan_relocs_locker(this->object_, *this->symtab_lock_, this,
82                                 *this->blocker_, workqueue);
83 }
84
85 // Scan the relocs.
86
87 void
88 Scan_relocs::run(Workqueue*)
89 {
90   this->object_->scan_relocs(this->options_, this->symtab_, this->layout_,
91                              this->rd_);
92   delete this->rd_;
93   this->rd_ = NULL;
94 }
95
96 // Relocate_task methods.
97
98 // These tasks are always runnable.
99
100 Task::Is_runnable_type
101 Relocate_task::is_runnable(Workqueue*)
102 {
103   return IS_RUNNABLE;
104 }
105
106 // We want to lock the file while we run.  We want to unblock
107 // FINAL_BLOCKER when we are done.
108
109 class Relocate_task::Relocate_locker : public Task_locker
110 {
111  public:
112   Relocate_locker(Task_token& token, Workqueue* workqueue,
113                   Object* object)
114     : blocker_(token, workqueue), objlock_(*object)
115   { }
116
117  private:
118   Task_locker_block blocker_;
119   Task_locker_obj<Object> objlock_;
120 };
121
122 Task_locker*
123 Relocate_task::locks(Workqueue* workqueue)
124 {
125   return new Relocate_locker(*this->final_blocker_, workqueue,
126                              this->object_);
127 }
128
129 // Run the task.
130
131 void
132 Relocate_task::run(Workqueue*)
133 {
134   this->object_->relocate(this->options_, this->symtab_, this->layout_,
135                           this->of_);
136 }
137
138 // Read the relocs and local symbols from the object file and store
139 // the information in RD.
140
141 template<int size, bool big_endian>
142 void
143 Sized_relobj<size, big_endian>::do_read_relocs(Read_relocs_data* rd)
144 {
145   rd->relocs.clear();
146
147   unsigned int shnum = this->shnum();
148   if (shnum == 0)
149     return;
150
151   rd->relocs.reserve(shnum / 2);
152
153   const unsigned char *pshdrs = this->get_view(this->elf_file_.shoff(),
154                                                shnum * This::shdr_size);
155   // Skip the first, dummy, section.
156   const unsigned char *ps = pshdrs + This::shdr_size;
157   for (unsigned int i = 1; i < shnum; ++i, ps += This::shdr_size)
158     {
159       typename This::Shdr shdr(ps);
160
161       unsigned int sh_type = shdr.get_sh_type();
162       if (sh_type != elfcpp::SHT_REL && sh_type != elfcpp::SHT_RELA)
163         continue;
164
165       unsigned int shndx = shdr.get_sh_info();
166       if (shndx >= shnum)
167         {
168           fprintf(stderr, _("%s: %s: relocation section %u has bad info %u\n"),
169                   program_name, this->name().c_str(), i, shndx);
170           gold_exit(false);
171         }
172
173       if (!this->is_section_included(shndx))
174         continue;
175
176       // We are scanning relocations in order to fill out the GOT and
177       // PLT sections.  Relocations for sections which are not
178       // allocated (typically debugging sections) should not add new
179       // GOT and PLT entries.  So we skip them.
180       typename This::Shdr secshdr(pshdrs + shndx * This::shdr_size);
181       if ((secshdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0)
182         continue;
183
184       if (shdr.get_sh_link() != this->symtab_shndx_)
185         {
186           fprintf(stderr,
187                   _("%s: %s: relocation section %u uses unexpected "
188                     "symbol table %u\n"),
189                   program_name, this->name().c_str(), i, shdr.get_sh_link());
190           gold_exit(false);
191         }
192
193       off_t sh_size = shdr.get_sh_size();
194
195       unsigned int reloc_size;
196       if (sh_type == elfcpp::SHT_REL)
197         reloc_size = elfcpp::Elf_sizes<size>::rel_size;
198       else
199         reloc_size = elfcpp::Elf_sizes<size>::rela_size;
200       if (reloc_size != shdr.get_sh_entsize())
201         {
202           fprintf(stderr,
203                   _("%s: %s: unexpected entsize for reloc section %u: "
204                     "%lu != %u"),
205                   program_name, this->name().c_str(), i,
206                   static_cast<unsigned long>(shdr.get_sh_entsize()),
207                   reloc_size);
208           gold_exit(false);
209         }
210
211       size_t reloc_count = sh_size / reloc_size;
212       if (reloc_count * reloc_size != sh_size)
213         {
214           fprintf(stderr, _("%s: %s: reloc section %u size %lu uneven"),
215                   program_name, this->name().c_str(), i,
216                   static_cast<unsigned long>(sh_size));
217           gold_exit(false);
218         }
219
220       rd->relocs.push_back(Section_relocs());
221       Section_relocs& sr(rd->relocs.back());
222       sr.reloc_shndx = i;
223       sr.data_shndx = shndx;
224       sr.contents = this->get_lasting_view(shdr.get_sh_offset(), sh_size);
225       sr.sh_type = sh_type;
226       sr.reloc_count = reloc_count;
227     }
228
229   // Read the local symbols.
230   assert(this->symtab_shndx_ != -1U);
231   if (this->symtab_shndx_ == 0 || this->local_symbol_count_ == 0)
232     rd->local_symbols = NULL;
233   else
234     {
235       typename This::Shdr symtabshdr(pshdrs
236                                      + this->symtab_shndx_ * This::shdr_size);
237       assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
238       const int sym_size = This::sym_size;
239       const unsigned int loccount = this->local_symbol_count_;
240       assert(loccount == symtabshdr.get_sh_info());
241       off_t locsize = loccount * sym_size;
242       rd->local_symbols = this->get_lasting_view(symtabshdr.get_sh_offset(),
243                                                  locsize);
244     }
245 }
246
247 // Scan the relocs and adjust the symbol table.  This looks for
248 // relocations which require GOT/PLT/COPY relocations.
249
250 template<int size, bool big_endian>
251 void
252 Sized_relobj<size, big_endian>::do_scan_relocs(const General_options& options,
253                                                Symbol_table* symtab,
254                                                Layout* layout,
255                                                Read_relocs_data* rd)
256 {
257   Sized_target<size, big_endian>* target = this->sized_target();
258
259   const unsigned char* local_symbols;
260   if (rd->local_symbols == NULL)
261     local_symbols = NULL;
262   else
263     local_symbols = rd->local_symbols->data();
264
265   for (Read_relocs_data::Relocs_list::iterator p = rd->relocs.begin();
266        p != rd->relocs.end();
267        ++p)
268     {
269       target->scan_relocs(options, symtab, layout, this, p->sh_type,
270                           p->contents->data(), p->reloc_count,
271                           this->local_symbol_count_,
272                           local_symbols,
273                           this->symbols_);
274       delete p->contents;
275       p->contents = NULL;
276     }
277
278   if (rd->local_symbols != NULL)
279     {
280       delete rd->local_symbols;
281       rd->local_symbols = NULL;
282     }
283 }
284
285 // Relocate the input sections and write out the local symbols.
286
287 template<int size, bool big_endian>
288 void
289 Sized_relobj<size, big_endian>::do_relocate(const General_options& options,
290                                             const Symbol_table* symtab,
291                                             const Layout* layout,
292                                             Output_file* of)
293 {
294   unsigned int shnum = this->shnum();
295
296   // Read the section headers.
297   const unsigned char* pshdrs = this->get_view(this->elf_file_.shoff(),
298                                                shnum * This::shdr_size);
299
300   Views views;
301   views.resize(shnum);
302
303   // Make two passes over the sections.  The first one copies the
304   // section data to the output file.  The second one applies
305   // relocations.
306
307   this->write_sections(pshdrs, of, &views);
308
309   // Apply relocations.
310
311   this->relocate_sections(options, symtab, layout, pshdrs, &views);
312
313   // Write out the accumulated views.
314   for (unsigned int i = 1; i < shnum; ++i)
315     {
316       if (views[i].view != NULL)
317         of->write_output_view(views[i].offset, views[i].view_size,
318                               views[i].view);
319     }
320
321   // Write out the local symbols.
322   this->write_local_symbols(of, layout->sympool());
323 }
324
325 // Write section data to the output file.  PSHDRS points to the
326 // section headers.  Record the views in *PVIEWS for use when
327 // relocating.
328
329 template<int size, bool big_endian>
330 void
331 Sized_relobj<size, big_endian>::write_sections(const unsigned char* pshdrs,
332                                                Output_file* of,
333                                                Views* pviews)
334 {
335   unsigned int shnum = this->shnum();
336   std::vector<Map_to_output>& map_sections(this->map_to_output());
337
338   const unsigned char* p = pshdrs + This::shdr_size;
339   for (unsigned int i = 1; i < shnum; ++i, p += This::shdr_size)
340     {
341       View_size* pvs = &(*pviews)[i];
342
343       pvs->view = NULL;
344
345       const Output_section* os = map_sections[i].output_section;
346       if (os == NULL)
347         continue;
348
349       typename This::Shdr shdr(p);
350
351       if (shdr.get_sh_type() == elfcpp::SHT_NOBITS)
352         continue;
353
354       off_t start = os->offset() + map_sections[i].offset;
355       off_t sh_size = shdr.get_sh_size();
356
357       if (sh_size == 0)
358         continue;
359
360       assert(map_sections[i].offset >= 0
361              && map_sections[i].offset + sh_size <= os->data_size());
362
363       unsigned char* view = of->get_output_view(start, sh_size);
364       this->read(shdr.get_sh_offset(), sh_size, view);
365
366       pvs->view = view;
367       pvs->address = os->address() + map_sections[i].offset;
368       pvs->offset = start;
369       pvs->view_size = sh_size;
370     }
371 }
372
373 // Relocate section data.  VIEWS points to the section data as views
374 // in the output file.
375
376 template<int size, bool big_endian>
377 void
378 Sized_relobj<size, big_endian>::relocate_sections(
379     const General_options& options,
380     const Symbol_table* symtab,
381     const Layout* layout,
382     const unsigned char* pshdrs,
383     Views* pviews)
384 {
385   unsigned int shnum = this->shnum();
386   Sized_target<size, big_endian>* target = this->sized_target();
387
388   Relocate_info<size, big_endian> relinfo;
389   relinfo.options = &options;
390   relinfo.symtab = symtab;
391   relinfo.layout = layout;
392   relinfo.object = this;
393   relinfo.local_symbol_count = this->local_symbol_count_;
394   relinfo.values = this->values_;
395   relinfo.symbols = this->symbols_;
396
397   const unsigned char* p = pshdrs + This::shdr_size;
398   for (unsigned int i = 1; i < shnum; ++i, p += This::shdr_size)
399     {
400       typename This::Shdr shdr(p);
401
402       unsigned int sh_type = shdr.get_sh_type();
403       if (sh_type != elfcpp::SHT_REL && sh_type != elfcpp::SHT_RELA)
404         continue;
405
406       unsigned int index = shdr.get_sh_info();
407       if (index >= this->shnum())
408         {
409           fprintf(stderr, _("%s: %s: relocation section %u has bad info %u\n"),
410                   program_name, this->name().c_str(), i, index);
411           gold_exit(false);
412         }
413
414       if (!this->is_section_included(index))
415         {
416           // This relocation section is against a section which we
417           // discarded.
418           continue;
419         }
420
421       assert((*pviews)[index].view != NULL);
422
423       if (shdr.get_sh_link() != this->symtab_shndx_)
424         {
425           fprintf(stderr,
426                   _("%s: %s: relocation section %u uses unexpected "
427                     "symbol table %u\n"),
428                   program_name, this->name().c_str(), i, shdr.get_sh_link());
429           gold_exit(false);
430         }
431
432       off_t sh_size = shdr.get_sh_size();
433       const unsigned char* prelocs = this->get_view(shdr.get_sh_offset(),
434                                                     sh_size);
435
436       unsigned int reloc_size;
437       if (sh_type == elfcpp::SHT_REL)
438         reloc_size = elfcpp::Elf_sizes<size>::rel_size;
439       else
440         reloc_size = elfcpp::Elf_sizes<size>::rela_size;
441
442       if (reloc_size != shdr.get_sh_entsize())
443         {
444           fprintf(stderr,
445                   _("%s: %s: unexpected entsize for reloc section %u: "
446                     "%lu != %u"),
447                   program_name, this->name().c_str(), i,
448                   static_cast<unsigned long>(shdr.get_sh_entsize()),
449                   reloc_size);
450           gold_exit(false);
451         }
452
453       size_t reloc_count = sh_size / reloc_size;
454       if (reloc_count * reloc_size != sh_size)
455         {
456           fprintf(stderr, _("%s: %s: reloc section %u size %lu uneven"),
457                   program_name, this->name().c_str(), i,
458                   static_cast<unsigned long>(sh_size));
459           gold_exit(false);
460         }
461
462       relinfo.reloc_shndx = i;
463       relinfo.data_shndx = index;
464       target->relocate_section(&relinfo,
465                                sh_type,
466                                prelocs,
467                                reloc_count,
468                                (*pviews)[index].view,
469                                (*pviews)[index].address,
470                                (*pviews)[index].view_size);
471     }
472 }
473
474 // Instantiate the templates we need.  We could use the configure
475 // script to restrict this to only the ones for implemented targets.
476
477 template
478 void
479 Sized_relobj<32, false>::do_read_relocs(Read_relocs_data* rd);
480
481 template
482 void
483 Sized_relobj<32, true>::do_read_relocs(Read_relocs_data* rd);
484
485 template
486 void
487 Sized_relobj<64, false>::do_read_relocs(Read_relocs_data* rd);
488
489 template
490 void
491 Sized_relobj<64, true>::do_read_relocs(Read_relocs_data* rd);
492
493 template
494 void
495 Sized_relobj<32, false>::do_scan_relocs(const General_options& options,
496                                         Symbol_table* symtab,
497                                         Layout* layout,
498                                         Read_relocs_data* rd);
499
500 template
501 void
502 Sized_relobj<32, true>::do_scan_relocs(const General_options& options,
503                                        Symbol_table* symtab,
504                                        Layout* layout,
505                                        Read_relocs_data* rd);
506
507 template
508 void
509 Sized_relobj<64, false>::do_scan_relocs(const General_options& options,
510                                         Symbol_table* symtab,
511                                         Layout* layout,
512                                         Read_relocs_data* rd);
513
514 template
515 void
516 Sized_relobj<64, true>::do_scan_relocs(const General_options& options,
517                                        Symbol_table* symtab,
518                                        Layout* layout,
519                                        Read_relocs_data* rd);
520
521 template
522 void
523 Sized_relobj<32, false>::do_relocate(const General_options& options,
524                                      const Symbol_table* symtab,
525                                      const Layout* layout,
526                                      Output_file* of);
527
528 template
529 void
530 Sized_relobj<32, true>::do_relocate(const General_options& options,
531                                     const Symbol_table* symtab,
532                                     const Layout* layout,
533                                     Output_file* of);
534
535 template
536 void
537 Sized_relobj<64, false>::do_relocate(const General_options& options,
538                                      const Symbol_table* symtab,
539                                      const Layout* layout,
540                                      Output_file* of);
541
542 template
543 void
544 Sized_relobj<64, true>::do_relocate(const General_options& options,
545                                     const Symbol_table* symtab,
546                                     const Layout* layout,
547                                     Output_file* of);
548
549
550 } // End namespace gold.