1 // output.cc -- manage the output file for gold
2
3 // Copyright (C) 2006-2016 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 #include "gold.h"
24
25 #include <cstdlib>
26 #include <cstring>
27 #include <cerrno>
28 #include <fcntl.h>
29 #include <unistd.h>
30 #include <sys/stat.h>
31 #include <algorithm>
32
33 #ifdef HAVE_SYS_MMAN_H
34 #include <sys/mman.h>
35 #endif
36
37 #include "libiberty.h"
38
39 #include "dwarf.h"
40 #include "parameters.h"
41 #include "object.h"
42 #include "symtab.h"
43 #include "reloc.h"
44 #include "merge.h"
45 #include "descriptors.h"
46 #include "layout.h"
47 #include "output.h"
48
49 // For systems without mmap support.
50 #ifndef HAVE_MMAP
51 # define mmap gold_mmap
52 # define munmap gold_munmap
53 # define mremap gold_mremap
54 # ifndef MAP_FAILED
55 # define MAP_FAILED (reinterpret_cast<void*>(-1))
56 # endif
57 # ifndef PROT_READ
58 # define PROT_READ 0
59 # endif
60 # ifndef PROT_WRITE
61 # define PROT_WRITE 0
62 # endif
63 # ifndef MAP_PRIVATE
64 # define MAP_PRIVATE 0
65 # endif
66 # ifndef MAP_ANONYMOUS
67 # define MAP_ANONYMOUS 0
68 # endif
69 # ifndef MAP_SHARED
70 # define MAP_SHARED 0
71 # endif
72
73 # ifndef ENOSYS
74 # define ENOSYS EINVAL
75 # endif
76
77 static void *
gold_mmap(void *,size_t,int,int,int,off_t)78 gold_mmap(void *, size_t, int, int, int, off_t)
79 {
80 errno = ENOSYS;
81 return MAP_FAILED;
82 }
83
84 static int
gold_munmap(void *,size_t)85 gold_munmap(void *, size_t)
86 {
87 errno = ENOSYS;
88 return -1;
89 }
90
91 static void *
gold_mremap(void *,size_t,size_t,int)92 gold_mremap(void *, size_t, size_t, int)
93 {
94 errno = ENOSYS;
95 return MAP_FAILED;
96 }
97
98 #endif
99
100 #if defined(HAVE_MMAP) && !defined(HAVE_MREMAP)
101 # define mremap gold_mremap
102 extern "C" void *gold_mremap(void *, size_t, size_t, int);
103 #endif
104
105 // Some BSD systems still use MAP_ANON instead of MAP_ANONYMOUS
106 #ifndef MAP_ANONYMOUS
107 # define MAP_ANONYMOUS MAP_ANON
108 #endif
109
110 #ifndef MREMAP_MAYMOVE
111 # define MREMAP_MAYMOVE 1
112 #endif
113
114 // Mingw does not have S_ISLNK.
115 #ifndef S_ISLNK
116 # define S_ISLNK(mode) 0
117 #endif
118
119 namespace gold
120 {
121
122 // A wrapper around posix_fallocate. If we don't have posix_fallocate,
123 // or the --no-posix-fallocate option is set, we try the fallocate
124 // system call directly. If that fails, we use ftruncate to set
125 // the file size and hope that there is enough disk space.
126
127 static int
gold_fallocate(int o,off_t offset,off_t len)128 gold_fallocate(int o, off_t offset, off_t len)
129 {
130 #ifdef HAVE_POSIX_FALLOCATE
131 if (parameters->options().posix_fallocate())
132 return ::posix_fallocate(o, offset, len);
133 #endif // defined(HAVE_POSIX_FALLOCATE)
134 #ifdef HAVE_FALLOCATE
135 if (::fallocate(o, 0, offset, len) == 0)
136 return 0;
137 #endif // defined(HAVE_FALLOCATE)
138 if (::ftruncate(o, offset + len) < 0)
139 return errno;
140 return 0;
141 }
142
143 // Output_data variables.
144
145 bool Output_data::allocated_sizes_are_fixed;
146
147 // Output_data methods.
148
~Output_data()149 Output_data::~Output_data()
150 {
151 }
152
153 // Return the default alignment for the target size.
154
155 uint64_t
default_alignment()156 Output_data::default_alignment()
157 {
158 return Output_data::default_alignment_for_size(
159 parameters->target().get_size());
160 }
161
162 // Return the default alignment for a size--32 or 64.
163
164 uint64_t
default_alignment_for_size(int size)165 Output_data::default_alignment_for_size(int size)
166 {
167 if (size == 32)
168 return 4;
169 else if (size == 64)
170 return 8;
171 else
172 gold_unreachable();
173 }
174
175 // Output_section_header methods. This currently assumes that the
176 // segment and section lists are complete at construction time.
177
Output_section_headers(const Layout * layout,const Layout::Segment_list * segment_list,const Layout::Section_list * section_list,const Layout::Section_list * unattached_section_list,const Stringpool * secnamepool,const Output_section * shstrtab_section)178 Output_section_headers::Output_section_headers(
179 const Layout* layout,
180 const Layout::Segment_list* segment_list,
181 const Layout::Section_list* section_list,
182 const Layout::Section_list* unattached_section_list,
183 const Stringpool* secnamepool,
184 const Output_section* shstrtab_section)
185 : layout_(layout),
186 segment_list_(segment_list),
187 section_list_(section_list),
188 unattached_section_list_(unattached_section_list),
189 secnamepool_(secnamepool),
190 shstrtab_section_(shstrtab_section)
191 {
192 }
193
194 // Compute the current data size.
195
196 off_t
do_size() const197 Output_section_headers::do_size() const
198 {
199 // Count all the sections. Start with 1 for the null section.
200 off_t count = 1;
201 if (!parameters->options().relocatable())
202 {
203 for (Layout::Segment_list::const_iterator p =
204 this->segment_list_->begin();
205 p != this->segment_list_->end();
206 ++p)
207 if ((*p)->type() == elfcpp::PT_LOAD)
208 count += (*p)->output_section_count();
209 }
210 else
211 {
212 for (Layout::Section_list::const_iterator p =
213 this->section_list_->begin();
214 p != this->section_list_->end();
215 ++p)
216 if (((*p)->flags() & elfcpp::SHF_ALLOC) != 0)
217 ++count;
218 }
219 count += this->unattached_section_list_->size();
220
221 const int size = parameters->target().get_size();
222 int shdr_size;
223 if (size == 32)
224 shdr_size = elfcpp::Elf_sizes<32>::shdr_size;
225 else if (size == 64)
226 shdr_size = elfcpp::Elf_sizes<64>::shdr_size;
227 else
228 gold_unreachable();
229
230 return count * shdr_size;
231 }
232
233 // Write out the section headers.
234
235 void
do_write(Output_file * of)236 Output_section_headers::do_write(Output_file* of)
237 {
238 switch (parameters->size_and_endianness())
239 {
240 #ifdef HAVE_TARGET_32_LITTLE
241 case Parameters::TARGET_32_LITTLE:
242 this->do_sized_write<32, false>(of);
243 break;
244 #endif
245 #ifdef HAVE_TARGET_32_BIG
246 case Parameters::TARGET_32_BIG:
247 this->do_sized_write<32, true>(of);
248 break;
249 #endif
250 #ifdef HAVE_TARGET_64_LITTLE
251 case Parameters::TARGET_64_LITTLE:
252 this->do_sized_write<64, false>(of);
253 break;
254 #endif
255 #ifdef HAVE_TARGET_64_BIG
256 case Parameters::TARGET_64_BIG:
257 this->do_sized_write<64, true>(of);
258 break;
259 #endif
260 default:
261 gold_unreachable();
262 }
263 }
264
265 template<int size, bool big_endian>
266 void
do_sized_write(Output_file * of)267 Output_section_headers::do_sized_write(Output_file* of)
268 {
269 off_t all_shdrs_size = this->data_size();
270 unsigned char* view = of->get_output_view(this->offset(), all_shdrs_size);
271
272 const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
273 unsigned char* v = view;
274
275 {
276 typename elfcpp::Shdr_write<size, big_endian> oshdr(v);
277 oshdr.put_sh_name(0);
278 oshdr.put_sh_type(elfcpp::SHT_NULL);
279 oshdr.put_sh_flags(0);
280 oshdr.put_sh_addr(0);
281 oshdr.put_sh_offset(0);
282
283 size_t section_count = (this->data_size()
284 / elfcpp::Elf_sizes<size>::shdr_size);
285 if (section_count < elfcpp::SHN_LORESERVE)
286 oshdr.put_sh_size(0);
287 else
288 oshdr.put_sh_size(section_count);
289
290 unsigned int shstrndx = this->shstrtab_section_->out_shndx();
291 if (shstrndx < elfcpp::SHN_LORESERVE)
292 oshdr.put_sh_link(0);
293 else
294 oshdr.put_sh_link(shstrndx);
295
296 size_t segment_count = this->segment_list_->size();
297 oshdr.put_sh_info(segment_count >= elfcpp::PN_XNUM ? segment_count : 0);
298
299 oshdr.put_sh_addralign(0);
300 oshdr.put_sh_entsize(0);
301 }
302
303 v += shdr_size;
304
305 unsigned int shndx = 1;
306 if (!parameters->options().relocatable())
307 {
308 for (Layout::Segment_list::const_iterator p =
309 this->segment_list_->begin();
310 p != this->segment_list_->end();
311 ++p)
312 v = (*p)->write_section_headers<size, big_endian>(this->layout_,
313 this->secnamepool_,
314 v,
315 &shndx);
316 }
317 else
318 {
319 for (Layout::Section_list::const_iterator p =
320 this->section_list_->begin();
321 p != this->section_list_->end();
322 ++p)
323 {
324 // We do unallocated sections below, except that group
325 // sections have to come first.
326 if (((*p)->flags() & elfcpp::SHF_ALLOC) == 0
327 && (*p)->type() != elfcpp::SHT_GROUP)
328 continue;
329 gold_assert(shndx == (*p)->out_shndx());
330 elfcpp::Shdr_write<size, big_endian> oshdr(v);
331 (*p)->write_header(this->layout_, this->secnamepool_, &oshdr);
332 v += shdr_size;
333 ++shndx;
334 }
335 }
336
337 for (Layout::Section_list::const_iterator p =
338 this->unattached_section_list_->begin();
339 p != this->unattached_section_list_->end();
340 ++p)
341 {
342 // For a relocatable link, we did unallocated group sections
343 // above, since they have to come first.
344 if ((*p)->type() == elfcpp::SHT_GROUP
345 && parameters->options().relocatable())
346 continue;
347 gold_assert(shndx == (*p)->out_shndx());
348 elfcpp::Shdr_write<size, big_endian> oshdr(v);
349 (*p)->write_header(this->layout_, this->secnamepool_, &oshdr);
350 v += shdr_size;
351 ++shndx;
352 }
353
354 of->write_output_view(this->offset(), all_shdrs_size, view);
355 }
356
357 // Output_segment_header methods.
358
Output_segment_headers(const Layout::Segment_list & segment_list)359 Output_segment_headers::Output_segment_headers(
360 const Layout::Segment_list& segment_list)
361 : segment_list_(segment_list)
362 {
363 this->set_current_data_size_for_child(this->do_size());
364 }
365
366 void
do_write(Output_file * of)367 Output_segment_headers::do_write(Output_file* of)
368 {
369 switch (parameters->size_and_endianness())
370 {
371 #ifdef HAVE_TARGET_32_LITTLE
372 case Parameters::TARGET_32_LITTLE:
373 this->do_sized_write<32, false>(of);
374 break;
375 #endif
376 #ifdef HAVE_TARGET_32_BIG
377 case Parameters::TARGET_32_BIG:
378 this->do_sized_write<32, true>(of);
379 break;
380 #endif
381 #ifdef HAVE_TARGET_64_LITTLE
382 case Parameters::TARGET_64_LITTLE:
383 this->do_sized_write<64, false>(of);
384 break;
385 #endif
386 #ifdef HAVE_TARGET_64_BIG
387 case Parameters::TARGET_64_BIG:
388 this->do_sized_write<64, true>(of);
389 break;
390 #endif
391 default:
392 gold_unreachable();
393 }
394 }
395
396 template<int size, bool big_endian>
397 void
do_sized_write(Output_file * of)398 Output_segment_headers::do_sized_write(Output_file* of)
399 {
400 const int phdr_size = elfcpp::Elf_sizes<size>::phdr_size;
401 off_t all_phdrs_size = this->segment_list_.size() * phdr_size;
402 gold_assert(all_phdrs_size == this->data_size());
403 unsigned char* view = of->get_output_view(this->offset(),
404 all_phdrs_size);
405 unsigned char* v = view;
406 for (Layout::Segment_list::const_iterator p = this->segment_list_.begin();
407 p != this->segment_list_.end();
408 ++p)
409 {
410 elfcpp::Phdr_write<size, big_endian> ophdr(v);
411 (*p)->write_header(&ophdr);
412 v += phdr_size;
413 }
414
415 gold_assert(v - view == all_phdrs_size);
416
417 of->write_output_view(this->offset(), all_phdrs_size, view);
418 }
419
420 off_t
do_size() const421 Output_segment_headers::do_size() const
422 {
423 const int size = parameters->target().get_size();
424 int phdr_size;
425 if (size == 32)
426 phdr_size = elfcpp::Elf_sizes<32>::phdr_size;
427 else if (size == 64)
428 phdr_size = elfcpp::Elf_sizes<64>::phdr_size;
429 else
430 gold_unreachable();
431
432 return this->segment_list_.size() * phdr_size;
433 }
434
435 // Output_file_header methods.
436
Output_file_header(Target * target,const Symbol_table * symtab,const Output_segment_headers * osh)437 Output_file_header::Output_file_header(Target* target,
438 const Symbol_table* symtab,
439 const Output_segment_headers* osh)
440 : target_(target),
441 symtab_(symtab),
442 segment_header_(osh),
443 section_header_(NULL),
444 shstrtab_(NULL)
445 {
446 this->set_data_size(this->do_size());
447 }
448
449 // Set the section table information for a file header.
450
451 void
set_section_info(const Output_section_headers * shdrs,const Output_section * shstrtab)452 Output_file_header::set_section_info(const Output_section_headers* shdrs,
453 const Output_section* shstrtab)
454 {
455 this->section_header_ = shdrs;
456 this->shstrtab_ = shstrtab;
457 }
458
459 // Write out the file header.
460
461 void
do_write(Output_file * of)462 Output_file_header::do_write(Output_file* of)
463 {
464 gold_assert(this->offset() == 0);
465
466 switch (parameters->size_and_endianness())
467 {
468 #ifdef HAVE_TARGET_32_LITTLE
469 case Parameters::TARGET_32_LITTLE:
470 this->do_sized_write<32, false>(of);
471 break;
472 #endif
473 #ifdef HAVE_TARGET_32_BIG
474 case Parameters::TARGET_32_BIG:
475 this->do_sized_write<32, true>(of);
476 break;
477 #endif
478 #ifdef HAVE_TARGET_64_LITTLE
479 case Parameters::TARGET_64_LITTLE:
480 this->do_sized_write<64, false>(of);
481 break;
482 #endif
483 #ifdef HAVE_TARGET_64_BIG
484 case Parameters::TARGET_64_BIG:
485 this->do_sized_write<64, true>(of);
486 break;
487 #endif
488 default:
489 gold_unreachable();
490 }
491 }
492
493 // Write out the file header with appropriate size and endianness.
494
495 template<int size, bool big_endian>
496 void
do_sized_write(Output_file * of)497 Output_file_header::do_sized_write(Output_file* of)
498 {
499 gold_assert(this->offset() == 0);
500
501 int ehdr_size = elfcpp::Elf_sizes<size>::ehdr_size;
502 unsigned char* view = of->get_output_view(0, ehdr_size);
503 elfcpp::Ehdr_write<size, big_endian> oehdr(view);
504
505 unsigned char e_ident[elfcpp::EI_NIDENT];
506 memset(e_ident, 0, elfcpp::EI_NIDENT);
507 e_ident[elfcpp::EI_MAG0] = elfcpp::ELFMAG0;
508 e_ident[elfcpp::EI_MAG1] = elfcpp::ELFMAG1;
509 e_ident[elfcpp::EI_MAG2] = elfcpp::ELFMAG2;
510 e_ident[elfcpp::EI_MAG3] = elfcpp::ELFMAG3;
511 if (size == 32)
512 e_ident[elfcpp::EI_CLASS] = elfcpp::ELFCLASS32;
513 else if (size == 64)
514 e_ident[elfcpp::EI_CLASS] = elfcpp::ELFCLASS64;
515 else
516 gold_unreachable();
517 e_ident[elfcpp::EI_DATA] = (big_endian
518 ? elfcpp::ELFDATA2MSB
519 : elfcpp::ELFDATA2LSB);
520 e_ident[elfcpp::EI_VERSION] = elfcpp::EV_CURRENT;
521 oehdr.put_e_ident(e_ident);
522
523 elfcpp::ET e_type;
524 if (parameters->options().relocatable())
525 e_type = elfcpp::ET_REL;
526 else if (parameters->options().output_is_position_independent())
527 e_type = elfcpp::ET_DYN;
528 else
529 e_type = elfcpp::ET_EXEC;
530 oehdr.put_e_type(e_type);
531
532 oehdr.put_e_machine(this->target_->machine_code());
533 oehdr.put_e_version(elfcpp::EV_CURRENT);
534
535 oehdr.put_e_entry(this->entry<size>());
536
537 if (this->segment_header_ == NULL)
538 oehdr.put_e_phoff(0);
539 else
540 oehdr.put_e_phoff(this->segment_header_->offset());
541
542 oehdr.put_e_shoff(this->section_header_->offset());
543 oehdr.put_e_flags(this->target_->processor_specific_flags());
544 oehdr.put_e_ehsize(elfcpp::Elf_sizes<size>::ehdr_size);
545
546 if (this->segment_header_ == NULL)
547 {
548 oehdr.put_e_phentsize(0);
549 oehdr.put_e_phnum(0);
550 }
551 else
552 {
553 oehdr.put_e_phentsize(elfcpp::Elf_sizes<size>::phdr_size);
554 size_t phnum = (this->segment_header_->data_size()
555 / elfcpp::Elf_sizes<size>::phdr_size);
556 if (phnum > elfcpp::PN_XNUM)
557 phnum = elfcpp::PN_XNUM;
558 oehdr.put_e_phnum(phnum);
559 }
560
561 oehdr.put_e_shentsize(elfcpp::Elf_sizes<size>::shdr_size);
562 size_t section_count = (this->section_header_->data_size()
563 / elfcpp::Elf_sizes<size>::shdr_size);
564
565 if (section_count < elfcpp::SHN_LORESERVE)
566 oehdr.put_e_shnum(this->section_header_->data_size()
567 / elfcpp::Elf_sizes<size>::shdr_size);
568 else
569 oehdr.put_e_shnum(0);
570
571 unsigned int shstrndx = this->shstrtab_->out_shndx();
572 if (shstrndx < elfcpp::SHN_LORESERVE)
573 oehdr.put_e_shstrndx(this->shstrtab_->out_shndx());
574 else
575 oehdr.put_e_shstrndx(elfcpp::SHN_XINDEX);
576
577 // Let the target adjust the ELF header, e.g., to set EI_OSABI in
578 // the e_ident field.
579 this->target_->adjust_elf_header(view, ehdr_size);
580
581 of->write_output_view(0, ehdr_size, view);
582 }
583
584 // Return the value to use for the entry address.
585
586 template<int size>
587 typename elfcpp::Elf_types<size>::Elf_Addr
entry()588 Output_file_header::entry()
589 {
590 const bool should_issue_warning = (parameters->options().entry() != NULL
591 && !parameters->options().relocatable()
592 && !parameters->options().shared());
593 const char* entry = parameters->entry();
594 Symbol* sym = this->symtab_->lookup(entry);
595
596 typename Sized_symbol<size>::Value_type v;
597 if (sym != NULL)
598 {
599 Sized_symbol<size>* ssym;
600 ssym = this->symtab_->get_sized_symbol<size>(sym);
601 if (!ssym->is_defined() && should_issue_warning)
602 gold_warning("entry symbol '%s' exists but is not defined", entry);
603 v = ssym->value();
604 }
605 else
606 {
607 // We couldn't find the entry symbol. See if we can parse it as
608 // a number. This supports, e.g., -e 0x1000.
609 char* endptr;
610 v = strtoull(entry, &endptr, 0);
611 if (*endptr != '\0')
612 {
613 if (should_issue_warning)
614 gold_warning("cannot find entry symbol '%s'", entry);
615 v = 0;
616 }
617 }
618
619 return v;
620 }
621
622 // Compute the current data size.
623
624 off_t
do_size() const625 Output_file_header::do_size() const
626 {
627 const int size = parameters->target().get_size();
628 if (size == 32)
629 return elfcpp::Elf_sizes<32>::ehdr_size;
630 else if (size == 64)
631 return elfcpp::Elf_sizes<64>::ehdr_size;
632 else
633 gold_unreachable();
634 }
635
636 // Output_data_const methods.
637
638 void
do_write(Output_file * of)639 Output_data_const::do_write(Output_file* of)
640 {
641 of->write(this->offset(), this->data_.data(), this->data_.size());
642 }
643
644 // Output_data_const_buffer methods.
645
646 void
do_write(Output_file * of)647 Output_data_const_buffer::do_write(Output_file* of)
648 {
649 of->write(this->offset(), this->p_, this->data_size());
650 }
651
652 // Output_section_data methods.
653
654 // Record the output section, and set the entry size and such.
655
656 void
set_output_section(Output_section * os)657 Output_section_data::set_output_section(Output_section* os)
658 {
659 gold_assert(this->output_section_ == NULL);
660 this->output_section_ = os;
661 this->do_adjust_output_section(os);
662 }
663
664 // Return the section index of the output section.
665
666 unsigned int
do_out_shndx() const667 Output_section_data::do_out_shndx() const
668 {
669 gold_assert(this->output_section_ != NULL);
670 return this->output_section_->out_shndx();
671 }
672
673 // Set the alignment, which means we may need to update the alignment
674 // of the output section.
675
676 void
set_addralign(uint64_t addralign)677 Output_section_data::set_addralign(uint64_t addralign)
678 {
679 this->addralign_ = addralign;
680 if (this->output_section_ != NULL
681 && this->output_section_->addralign() < addralign)
682 this->output_section_->set_addralign(addralign);
683 }
684
685 // Output_data_strtab methods.
686
687 // Set the final data size.
688
689 void
set_final_data_size()690 Output_data_strtab::set_final_data_size()
691 {
692 this->strtab_->set_string_offsets();
693 this->set_data_size(this->strtab_->get_strtab_size());
694 }
695
696 // Write out a string table.
697
698 void
do_write(Output_file * of)699 Output_data_strtab::do_write(Output_file* of)
700 {
701 this->strtab_->write(of, this->offset());
702 }
703
704 // Output_reloc methods.
705
706 // A reloc against a global symbol.
707
708 template<bool dynamic, int size, bool big_endian>
Output_reloc(Symbol * gsym,unsigned int type,Output_data * od,Address address,bool is_relative,bool is_symbolless,bool use_plt_offset)709 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
710 Symbol* gsym,
711 unsigned int type,
712 Output_data* od,
713 Address address,
714 bool is_relative,
715 bool is_symbolless,
716 bool use_plt_offset)
717 : address_(address), local_sym_index_(GSYM_CODE), type_(type),
718 is_relative_(is_relative), is_symbolless_(is_symbolless),
719 is_section_symbol_(false), use_plt_offset_(use_plt_offset), shndx_(INVALID_CODE)
720 {
721 // this->type_ is a bitfield; make sure TYPE fits.
722 gold_assert(this->type_ == type);
723 this->u1_.gsym = gsym;
724 this->u2_.od = od;
725 if (dynamic)
726 this->set_needs_dynsym_index();
727 }
728
729 template<bool dynamic, int size, bool big_endian>
Output_reloc(Symbol * gsym,unsigned int type,Sized_relobj<size,big_endian> * relobj,unsigned int shndx,Address address,bool is_relative,bool is_symbolless,bool use_plt_offset)730 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
731 Symbol* gsym,
732 unsigned int type,
733 Sized_relobj<size, big_endian>* relobj,
734 unsigned int shndx,
735 Address address,
736 bool is_relative,
737 bool is_symbolless,
738 bool use_plt_offset)
739 : address_(address), local_sym_index_(GSYM_CODE), type_(type),
740 is_relative_(is_relative), is_symbolless_(is_symbolless),
741 is_section_symbol_(false), use_plt_offset_(use_plt_offset), shndx_(shndx)
742 {
743 gold_assert(shndx != INVALID_CODE);
744 // this->type_ is a bitfield; make sure TYPE fits.
745 gold_assert(this->type_ == type);
746 this->u1_.gsym = gsym;
747 this->u2_.relobj = relobj;
748 if (dynamic)
749 this->set_needs_dynsym_index();
750 }
751
752 // A reloc against a local symbol.
753
754 template<bool dynamic, int size, bool big_endian>
Output_reloc(Sized_relobj<size,big_endian> * relobj,unsigned int local_sym_index,unsigned int type,Output_data * od,Address address,bool is_relative,bool is_symbolless,bool is_section_symbol,bool use_plt_offset)755 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
756 Sized_relobj<size, big_endian>* relobj,
757 unsigned int local_sym_index,
758 unsigned int type,
759 Output_data* od,
760 Address address,
761 bool is_relative,
762 bool is_symbolless,
763 bool is_section_symbol,
764 bool use_plt_offset)
765 : address_(address), local_sym_index_(local_sym_index), type_(type),
766 is_relative_(is_relative), is_symbolless_(is_symbolless),
767 is_section_symbol_(is_section_symbol), use_plt_offset_(use_plt_offset),
768 shndx_(INVALID_CODE)
769 {
770 gold_assert(local_sym_index != GSYM_CODE
771 && local_sym_index != INVALID_CODE);
772 // this->type_ is a bitfield; make sure TYPE fits.
773 gold_assert(this->type_ == type);
774 this->u1_.relobj = relobj;
775 this->u2_.od = od;
776 if (dynamic)
777 this->set_needs_dynsym_index();
778 }
779
780 template<bool dynamic, int size, bool big_endian>
Output_reloc(Sized_relobj<size,big_endian> * relobj,unsigned int local_sym_index,unsigned int type,unsigned int shndx,Address address,bool is_relative,bool is_symbolless,bool is_section_symbol,bool use_plt_offset)781 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
782 Sized_relobj<size, big_endian>* relobj,
783 unsigned int local_sym_index,
784 unsigned int type,
785 unsigned int shndx,
786 Address address,
787 bool is_relative,
788 bool is_symbolless,
789 bool is_section_symbol,
790 bool use_plt_offset)
791 : address_(address), local_sym_index_(local_sym_index), type_(type),
792 is_relative_(is_relative), is_symbolless_(is_symbolless),
793 is_section_symbol_(is_section_symbol), use_plt_offset_(use_plt_offset),
794 shndx_(shndx)
795 {
796 gold_assert(local_sym_index != GSYM_CODE
797 && local_sym_index != INVALID_CODE);
798 gold_assert(shndx != INVALID_CODE);
799 // this->type_ is a bitfield; make sure TYPE fits.
800 gold_assert(this->type_ == type);
801 this->u1_.relobj = relobj;
802 this->u2_.relobj = relobj;
803 if (dynamic)
804 this->set_needs_dynsym_index();
805 }
806
807 // A reloc against the STT_SECTION symbol of an output section.
808
809 template<bool dynamic, int size, bool big_endian>
Output_reloc(Output_section * os,unsigned int type,Output_data * od,Address address,bool is_relative)810 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
811 Output_section* os,
812 unsigned int type,
813 Output_data* od,
814 Address address,
815 bool is_relative)
816 : address_(address), local_sym_index_(SECTION_CODE), type_(type),
817 is_relative_(is_relative), is_symbolless_(is_relative),
818 is_section_symbol_(true), use_plt_offset_(false), shndx_(INVALID_CODE)
819 {
820 // this->type_ is a bitfield; make sure TYPE fits.
821 gold_assert(this->type_ == type);
822 this->u1_.os = os;
823 this->u2_.od = od;
824 if (dynamic)
825 this->set_needs_dynsym_index();
826 else
827 os->set_needs_symtab_index();
828 }
829
830 template<bool dynamic, int size, bool big_endian>
Output_reloc(Output_section * os,unsigned int type,Sized_relobj<size,big_endian> * relobj,unsigned int shndx,Address address,bool is_relative)831 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
832 Output_section* os,
833 unsigned int type,
834 Sized_relobj<size, big_endian>* relobj,
835 unsigned int shndx,
836 Address address,
837 bool is_relative)
838 : address_(address), local_sym_index_(SECTION_CODE), type_(type),
839 is_relative_(is_relative), is_symbolless_(is_relative),
840 is_section_symbol_(true), use_plt_offset_(false), shndx_(shndx)
841 {
842 gold_assert(shndx != INVALID_CODE);
843 // this->type_ is a bitfield; make sure TYPE fits.
844 gold_assert(this->type_ == type);
845 this->u1_.os = os;
846 this->u2_.relobj = relobj;
847 if (dynamic)
848 this->set_needs_dynsym_index();
849 else
850 os->set_needs_symtab_index();
851 }
852
853 // An absolute or relative relocation.
854
855 template<bool dynamic, int size, bool big_endian>
Output_reloc(unsigned int type,Output_data * od,Address address,bool is_relative)856 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
857 unsigned int type,
858 Output_data* od,
859 Address address,
860 bool is_relative)
861 : address_(address), local_sym_index_(0), type_(type),
862 is_relative_(is_relative), is_symbolless_(false),
863 is_section_symbol_(false), use_plt_offset_(false), shndx_(INVALID_CODE)
864 {
865 // this->type_ is a bitfield; make sure TYPE fits.
866 gold_assert(this->type_ == type);
867 this->u1_.relobj = NULL;
868 this->u2_.od = od;
869 }
870
871 template<bool dynamic, int size, bool big_endian>
Output_reloc(unsigned int type,Sized_relobj<size,big_endian> * relobj,unsigned int shndx,Address address,bool is_relative)872 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
873 unsigned int type,
874 Sized_relobj<size, big_endian>* relobj,
875 unsigned int shndx,
876 Address address,
877 bool is_relative)
878 : address_(address), local_sym_index_(0), type_(type),
879 is_relative_(is_relative), is_symbolless_(false),
880 is_section_symbol_(false), use_plt_offset_(false), shndx_(shndx)
881 {
882 gold_assert(shndx != INVALID_CODE);
883 // this->type_ is a bitfield; make sure TYPE fits.
884 gold_assert(this->type_ == type);
885 this->u1_.relobj = NULL;
886 this->u2_.relobj = relobj;
887 }
888
889 // A target specific relocation.
890
891 template<bool dynamic, int size, bool big_endian>
Output_reloc(unsigned int type,void * arg,Output_data * od,Address address)892 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
893 unsigned int type,
894 void* arg,
895 Output_data* od,
896 Address address)
897 : address_(address), local_sym_index_(TARGET_CODE), type_(type),
898 is_relative_(false), is_symbolless_(false),
899 is_section_symbol_(false), use_plt_offset_(false), shndx_(INVALID_CODE)
900 {
901 // this->type_ is a bitfield; make sure TYPE fits.
902 gold_assert(this->type_ == type);
903 this->u1_.arg = arg;
904 this->u2_.od = od;
905 }
906
907 template<bool dynamic, int size, bool big_endian>
Output_reloc(unsigned int type,void * arg,Sized_relobj<size,big_endian> * relobj,unsigned int shndx,Address address)908 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
909 unsigned int type,
910 void* arg,
911 Sized_relobj<size, big_endian>* relobj,
912 unsigned int shndx,
913 Address address)
914 : address_(address), local_sym_index_(TARGET_CODE), type_(type),
915 is_relative_(false), is_symbolless_(false),
916 is_section_symbol_(false), use_plt_offset_(false), shndx_(shndx)
917 {
918 gold_assert(shndx != INVALID_CODE);
919 // this->type_ is a bitfield; make sure TYPE fits.
920 gold_assert(this->type_ == type);
921 this->u1_.arg = arg;
922 this->u2_.relobj = relobj;
923 }
924
925 // Record that we need a dynamic symbol index for this relocation.
926
927 template<bool dynamic, int size, bool big_endian>
928 void
929 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::
set_needs_dynsym_index()930 set_needs_dynsym_index()
931 {
932 if (this->is_symbolless_)
933 return;
934 switch (this->local_sym_index_)
935 {
936 case INVALID_CODE:
937 gold_unreachable();
938
939 case GSYM_CODE:
940 this->u1_.gsym->set_needs_dynsym_entry();
941 break;
942
943 case SECTION_CODE:
944 this->u1_.os->set_needs_dynsym_index();
945 break;
946
947 case TARGET_CODE:
948 // The target must take care of this if necessary.
949 break;
950
951 case 0:
952 break;
953
954 default:
955 {
956 const unsigned int lsi = this->local_sym_index_;
957 Sized_relobj_file<size, big_endian>* relobj =
958 this->u1_.relobj->sized_relobj();
959 gold_assert(relobj != NULL);
960 if (!this->is_section_symbol_)
961 relobj->set_needs_output_dynsym_entry(lsi);
962 else
963 relobj->output_section(lsi)->set_needs_dynsym_index();
964 }
965 break;
966 }
967 }
968
969 // Get the symbol index of a relocation.
970
971 template<bool dynamic, int size, bool big_endian>
972 unsigned int
get_symbol_index() const973 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::get_symbol_index()
974 const
975 {
976 unsigned int index;
977 if (this->is_symbolless_)
978 return 0;
979 switch (this->local_sym_index_)
980 {
981 case INVALID_CODE:
982 gold_unreachable();
983
984 case GSYM_CODE:
985 if (this->u1_.gsym == NULL)
986 index = 0;
987 else if (dynamic)
988 index = this->u1_.gsym->dynsym_index();
989 else
990 index = this->u1_.gsym->symtab_index();
991 break;
992
993 case SECTION_CODE:
994 if (dynamic)
995 index = this->u1_.os->dynsym_index();
996 else
997 index = this->u1_.os->symtab_index();
998 break;
999
1000 case TARGET_CODE:
1001 index = parameters->target().reloc_symbol_index(this->u1_.arg,
1002 this->type_);
1003 break;
1004
1005 case 0:
1006 // Relocations without symbols use a symbol index of 0.
1007 index = 0;
1008 break;
1009
1010 default:
1011 {
1012 const unsigned int lsi = this->local_sym_index_;
1013 Sized_relobj_file<size, big_endian>* relobj =
1014 this->u1_.relobj->sized_relobj();
1015 gold_assert(relobj != NULL);
1016 if (!this->is_section_symbol_)
1017 {
1018 if (dynamic)
1019 index = relobj->dynsym_index(lsi);
1020 else
1021 index = relobj->symtab_index(lsi);
1022 }
1023 else
1024 {
1025 Output_section* os = relobj->output_section(lsi);
1026 gold_assert(os != NULL);
1027 if (dynamic)
1028 index = os->dynsym_index();
1029 else
1030 index = os->symtab_index();
1031 }
1032 }
1033 break;
1034 }
1035 gold_assert(index != -1U);
1036 return index;
1037 }
1038
1039 // For a local section symbol, get the address of the offset ADDEND
1040 // within the input section.
1041
1042 template<bool dynamic, int size, bool big_endian>
1043 typename elfcpp::Elf_types<size>::Elf_Addr
1044 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::
local_section_offset(Addend addend) const1045 local_section_offset(Addend addend) const
1046 {
1047 gold_assert(this->local_sym_index_ != GSYM_CODE
1048 && this->local_sym_index_ != SECTION_CODE
1049 && this->local_sym_index_ != TARGET_CODE
1050 && this->local_sym_index_ != INVALID_CODE
1051 && this->local_sym_index_ != 0
1052 && this->is_section_symbol_);
1053 const unsigned int lsi = this->local_sym_index_;
1054 Output_section* os = this->u1_.relobj->output_section(lsi);
1055 gold_assert(os != NULL);
1056 Address offset = this->u1_.relobj->get_output_section_offset(lsi);
1057 if (offset != invalid_address)
1058 return offset + addend;
1059 // This is a merge section.
1060 Sized_relobj_file<size, big_endian>* relobj =
1061 this->u1_.relobj->sized_relobj();
1062 gold_assert(relobj != NULL);
1063 offset = os->output_address(relobj, lsi, addend);
1064 gold_assert(offset != invalid_address);
1065 return offset;
1066 }
1067
1068 // Get the output address of a relocation.
1069
1070 template<bool dynamic, int size, bool big_endian>
1071 typename elfcpp::Elf_types<size>::Elf_Addr
get_address() const1072 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::get_address() const
1073 {
1074 Address address = this->address_;
1075 if (this->shndx_ != INVALID_CODE)
1076 {
1077 Output_section* os = this->u2_.relobj->output_section(this->shndx_);
1078 gold_assert(os != NULL);
1079 Address off = this->u2_.relobj->get_output_section_offset(this->shndx_);
1080 if (off != invalid_address)
1081 address += os->address() + off;
1082 else
1083 {
1084 Sized_relobj_file<size, big_endian>* relobj =
1085 this->u2_.relobj->sized_relobj();
1086 gold_assert(relobj != NULL);
1087 address = os->output_address(relobj, this->shndx_, address);
1088 gold_assert(address != invalid_address);
1089 }
1090 }
1091 else if (this->u2_.od != NULL)
1092 address += this->u2_.od->address();
1093 return address;
1094 }
1095
1096 // Write out the offset and info fields of a Rel or Rela relocation
1097 // entry.
1098
1099 template<bool dynamic, int size, bool big_endian>
1100 template<typename Write_rel>
1101 void
write_rel(Write_rel * wr) const1102 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::write_rel(
1103 Write_rel* wr) const
1104 {
1105 wr->put_r_offset(this->get_address());
1106 unsigned int sym_index = this->get_symbol_index();
1107 wr->put_r_info(elfcpp::elf_r_info<size>(sym_index, this->type_));
1108 }
1109
1110 // Write out a Rel relocation.
1111
1112 template<bool dynamic, int size, bool big_endian>
1113 void
write(unsigned char * pov) const1114 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::write(
1115 unsigned char* pov) const
1116 {
1117 elfcpp::Rel_write<size, big_endian> orel(pov);
1118 this->write_rel(&orel);
1119 }
1120
1121 // Get the value of the symbol referred to by a Rel relocation.
1122
1123 template<bool dynamic, int size, bool big_endian>
1124 typename elfcpp::Elf_types<size>::Elf_Addr
symbol_value(Addend addend) const1125 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::symbol_value(
1126 Addend addend) const
1127 {
1128 if (this->local_sym_index_ == GSYM_CODE)
1129 {
1130 const Sized_symbol<size>* sym;
1131 sym = static_cast<const Sized_symbol<size>*>(this->u1_.gsym);
1132 if (this->use_plt_offset_ && sym->has_plt_offset())
1133 return parameters->target().plt_address_for_global(sym);
1134 else
1135 return sym->value() + addend;
1136 }
1137 if (this->local_sym_index_ == SECTION_CODE)
1138 {
1139 gold_assert(!this->use_plt_offset_);
1140 return this->u1_.os->address() + addend;
1141 }
1142 gold_assert(this->local_sym_index_ != TARGET_CODE
1143 && this->local_sym_index_ != INVALID_CODE
1144 && this->local_sym_index_ != 0
1145 && !this->is_section_symbol_);
1146 const unsigned int lsi = this->local_sym_index_;
1147 Sized_relobj_file<size, big_endian>* relobj =
1148 this->u1_.relobj->sized_relobj();
1149 gold_assert(relobj != NULL);
1150 if (this->use_plt_offset_)
1151 return parameters->target().plt_address_for_local(relobj, lsi);
1152 const Symbol_value<size>* symval = relobj->local_symbol(lsi);
1153 return symval->value(relobj, addend);
1154 }
1155
1156 // Reloc comparison. This function sorts the dynamic relocs for the
1157 // benefit of the dynamic linker. First we sort all relative relocs
1158 // to the front. Among relative relocs, we sort by output address.
1159 // Among non-relative relocs, we sort by symbol index, then by output
1160 // address.
1161
1162 template<bool dynamic, int size, bool big_endian>
1163 int
1164 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::
compare(const Output_reloc<elfcpp::SHT_REL,dynamic,size,big_endian> & r2) const1165 compare(const Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>& r2)
1166 const
1167 {
1168 if (this->is_relative_)
1169 {
1170 if (!r2.is_relative_)
1171 return -1;
1172 // Otherwise sort by reloc address below.
1173 }
1174 else if (r2.is_relative_)
1175 return 1;
1176 else
1177 {
1178 unsigned int sym1 = this->get_symbol_index();
1179 unsigned int sym2 = r2.get_symbol_index();
1180 if (sym1 < sym2)
1181 return -1;
1182 else if (sym1 > sym2)
1183 return 1;
1184 // Otherwise sort by reloc address.
1185 }
1186
1187 section_offset_type addr1 = this->get_address();
1188 section_offset_type addr2 = r2.get_address();
1189 if (addr1 < addr2)
1190 return -1;
1191 else if (addr1 > addr2)
1192 return 1;
1193
1194 // Final tie breaker, in order to generate the same output on any
1195 // host: reloc type.
1196 unsigned int type1 = this->type_;
1197 unsigned int type2 = r2.type_;
1198 if (type1 < type2)
1199 return -1;
1200 else if (type1 > type2)
1201 return 1;
1202
1203 // These relocs appear to be exactly the same.
1204 return 0;
1205 }
1206
1207 // Write out a Rela relocation.
1208
1209 template<bool dynamic, int size, bool big_endian>
1210 void
write(unsigned char * pov) const1211 Output_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian>::write(
1212 unsigned char* pov) const
1213 {
1214 elfcpp::Rela_write<size, big_endian> orel(pov);
1215 this->rel_.write_rel(&orel);
1216 Addend addend = this->addend_;
1217 if (this->rel_.is_target_specific())
1218 addend = parameters->target().reloc_addend(this->rel_.target_arg(),
1219 this->rel_.type(), addend);
1220 else if (this->rel_.is_symbolless())
1221 addend = this->rel_.symbol_value(addend);
1222 else if (this->rel_.is_local_section_symbol())
1223 addend = this->rel_.local_section_offset(addend);
1224 orel.put_r_addend(addend);
1225 }
1226
1227 // Write out a Relr relocation.
1228
1229 template<bool dynamic, int size, bool big_endian>
1230 void
write(unsigned char * pov) const1231 Output_reloc<elfcpp::SHT_RELR, dynamic, size, big_endian>::write(
1232 unsigned char* pov) const
1233 {
1234 elfcpp::Relr_write<size, big_endian> orel(pov);
1235 if (this->bits_ == 0)
1236 {
1237 // This is not a continuation entry. Output full address.
1238 orel.put_r_data(this->rel_.get_address());
1239 }
1240 else
1241 {
1242 // This is a continuation entry. Output the bitmap.
1243 orel.put_r_data((this->bits_<<1)|1);
1244 }
1245 }
1246
1247 // Output_data_reloc_base methods.
1248
1249 // Adjust the output section.
1250
1251 template<int sh_type, bool dynamic, int size, bool big_endian>
1252 void
1253 Output_data_reloc_base<sh_type, dynamic, size, big_endian>
do_adjust_output_section(Output_section * os)1254 ::do_adjust_output_section(Output_section* os)
1255 {
1256 if (sh_type == elfcpp::SHT_REL)
1257 os->set_entsize(elfcpp::Elf_sizes<size>::rel_size);
1258 else if (sh_type == elfcpp::SHT_RELA)
1259 os->set_entsize(elfcpp::Elf_sizes<size>::rela_size);
1260 else if (sh_type == elfcpp::SHT_RELR)
1261 os->set_entsize(elfcpp::Elf_sizes<size>::relr_size);
1262 else
1263 gold_unreachable();
1264
1265 // A STT_GNU_IFUNC symbol may require a IRELATIVE reloc when doing a
1266 // static link. The backends will generate a dynamic reloc section
1267 // to hold this. In that case we don't want to link to the dynsym
1268 // section, because there isn't one.
1269 if (!dynamic)
1270 os->set_should_link_to_symtab();
1271 else if (parameters->doing_static_link())
1272 ;
1273 else
1274 os->set_should_link_to_dynsym();
1275 }
1276
1277 // Standard relocation writer, which just calls Output_reloc::write().
1278
1279 template<int sh_type, bool dynamic, int size, bool big_endian>
1280 struct Output_reloc_writer
1281 {
1282 typedef Output_reloc<sh_type, dynamic, size, big_endian> Output_reloc_type;
1283 typedef std::vector<Output_reloc_type> Relocs;
1284
1285 static void
writegold::Output_reloc_writer1286 write(typename Relocs::const_iterator p, unsigned char* pov)
1287 { p->write(pov); }
1288 };
1289
1290 // Write out relocation data.
1291
1292 template<int sh_type, bool dynamic, int size, bool big_endian>
1293 void
do_write(Output_file * of)1294 Output_data_reloc_base<sh_type, dynamic, size, big_endian>::do_write(
1295 Output_file* of)
1296 {
1297 typedef Output_reloc_writer<sh_type, dynamic, size, big_endian> Writer;
1298 this->do_write_generic<Writer>(of);
1299 }
1300
1301 template<bool dynamic, int size, bool big_endian>
1302 void
do_write(Output_file * of)1303 Output_data_reloc<elfcpp::SHT_RELR, dynamic, size, big_endian>::do_write(
1304 Output_file* of)
1305 {
1306 typedef Output_reloc_writer<elfcpp::SHT_RELR, dynamic, size, big_endian> Writer;
1307 this->template do_write_generic<Writer>(of);
1308 }
1309
1310 // Class Output_relocatable_relocs.
1311
1312 template<int sh_type, int size, bool big_endian>
1313 void
set_final_data_size()1314 Output_relocatable_relocs<sh_type, size, big_endian>::set_final_data_size()
1315 {
1316 this->set_data_size(this->rr_->output_reloc_count()
1317 * Reloc_types<sh_type, size, big_endian>::reloc_size);
1318 }
1319
1320 // class Output_data_group.
1321
1322 template<int size, bool big_endian>
Output_data_group(Sized_relobj_file<size,big_endian> * relobj,section_size_type entry_count,elfcpp::Elf_Word flags,std::vector<unsigned int> * input_shndxes)1323 Output_data_group<size, big_endian>::Output_data_group(
1324 Sized_relobj_file<size, big_endian>* relobj,
1325 section_size_type entry_count,
1326 elfcpp::Elf_Word flags,
1327 std::vector<unsigned int>* input_shndxes)
1328 : Output_section_data(entry_count * 4, 4, false),
1329 relobj_(relobj),
1330 flags_(flags)
1331 {
1332 this->input_shndxes_.swap(*input_shndxes);
1333 }
1334
1335 // Write out the section group, which means translating the section
1336 // indexes to apply to the output file.
1337
1338 template<int size, bool big_endian>
1339 void
do_write(Output_file * of)1340 Output_data_group<size, big_endian>::do_write(Output_file* of)
1341 {
1342 const off_t off = this->offset();
1343 const section_size_type oview_size =
1344 convert_to_section_size_type(this->data_size());
1345 unsigned char* const oview = of->get_output_view(off, oview_size);
1346
1347 elfcpp::Elf_Word* contents = reinterpret_cast<elfcpp::Elf_Word*>(oview);
1348 elfcpp::Swap<32, big_endian>::writeval(contents, this->flags_);
1349 ++contents;
1350
1351 for (std::vector<unsigned int>::const_iterator p =
1352 this->input_shndxes_.begin();
1353 p != this->input_shndxes_.end();
1354 ++p, ++contents)
1355 {
1356 Output_section* os = this->relobj_->output_section(*p);
1357
1358 unsigned int output_shndx;
1359 if (os != NULL)
1360 output_shndx = os->out_shndx();
1361 else
1362 {
1363 this->relobj_->error(_("section group retained but "
1364 "group element discarded"));
1365 output_shndx = 0;
1366 }
1367
1368 elfcpp::Swap<32, big_endian>::writeval(contents, output_shndx);
1369 }
1370
1371 size_t wrote = reinterpret_cast<unsigned char*>(contents) - oview;
1372 gold_assert(wrote == oview_size);
1373
1374 of->write_output_view(off, oview_size, oview);
1375
1376 // We no longer need this information.
1377 this->input_shndxes_.clear();
1378 }
1379
1380 // Output_data_got::Got_entry methods.
1381
1382 // Write out the entry.
1383
1384 template<int got_size, bool big_endian>
1385 void
write(unsigned int got_indx,unsigned char * pov) const1386 Output_data_got<got_size, big_endian>::Got_entry::write(
1387 unsigned int got_indx,
1388 unsigned char* pov) const
1389 {
1390 Valtype val = 0;
1391
1392 switch (this->local_sym_index_)
1393 {
1394 case GSYM_CODE:
1395 {
1396 // If the symbol is resolved locally, we need to write out the
1397 // link-time value, which will be relocated dynamically by a
1398 // RELATIVE relocation.
1399 Symbol* gsym = this->u_.gsym;
1400 if (this->use_plt_or_tls_offset_ && gsym->has_plt_offset())
1401 val = parameters->target().plt_address_for_global(gsym);
1402 else
1403 {
1404 switch (parameters->size_and_endianness())
1405 {
1406 #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
1407 case Parameters::TARGET_32_LITTLE:
1408 case Parameters::TARGET_32_BIG:
1409 {
1410 // This cast is ugly. We don't want to put a
1411 // virtual method in Symbol, because we want Symbol
1412 // to be as small as possible.
1413 Sized_symbol<32>::Value_type v;
1414 v = static_cast<Sized_symbol<32>*>(gsym)->value();
1415 val = convert_types<Valtype, Sized_symbol<32>::Value_type>(v);
1416 }
1417 break;
1418 #endif
1419 #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
1420 case Parameters::TARGET_64_LITTLE:
1421 case Parameters::TARGET_64_BIG:
1422 {
1423 Sized_symbol<64>::Value_type v;
1424 v = static_cast<Sized_symbol<64>*>(gsym)->value();
1425 val = convert_types<Valtype, Sized_symbol<64>::Value_type>(v);
1426 }
1427 break;
1428 #endif
1429 default:
1430 gold_unreachable();
1431 }
1432 if (this->use_plt_or_tls_offset_
1433 && gsym->type() == elfcpp::STT_TLS)
1434 val += parameters->target().tls_offset_for_global(gsym,
1435 got_indx);
1436 }
1437 }
1438 break;
1439
1440 case CONSTANT_CODE:
1441 val = this->u_.constant;
1442 break;
1443
1444 case RESERVED_CODE:
1445 // If we're doing an incremental update, don't touch this GOT entry.
1446 if (parameters->incremental_update())
1447 return;
1448 val = this->u_.constant;
1449 break;
1450
1451 default:
1452 {
1453 const Relobj* object = this->u_.object;
1454 const unsigned int lsi = this->local_sym_index_;
1455 bool is_tls = object->local_is_tls(lsi);
1456 if (this->use_plt_or_tls_offset_ && !is_tls)
1457 val = parameters->target().plt_address_for_local(object, lsi);
1458 else
1459 {
1460 uint64_t lval = object->local_symbol_value(lsi, this->addend_);
1461 val = convert_types<Valtype, uint64_t>(lval);
1462 if (this->use_plt_or_tls_offset_ && is_tls)
1463 val += parameters->target().tls_offset_for_local(object, lsi,
1464 got_indx);
1465 }
1466 }
1467 break;
1468 }
1469
1470 elfcpp::Swap<got_size, big_endian>::writeval(pov, val);
1471 }
1472
1473 // Output_data_got methods.
1474
1475 // Add an entry for a global symbol to the GOT. This returns true if
1476 // this is a new GOT entry, false if the symbol already had a GOT
1477 // entry.
1478
1479 template<int got_size, bool big_endian>
1480 bool
add_global(Symbol * gsym,unsigned int got_type)1481 Output_data_got<got_size, big_endian>::add_global(
1482 Symbol* gsym,
1483 unsigned int got_type)
1484 {
1485 if (gsym->has_got_offset(got_type))
1486 return false;
1487
1488 unsigned int got_offset = this->add_got_entry(Got_entry(gsym, false));
1489 gsym->set_got_offset(got_type, got_offset);
1490 return true;
1491 }
1492
1493 // Like add_global, but use the PLT offset.
1494
1495 template<int got_size, bool big_endian>
1496 bool
add_global_plt(Symbol * gsym,unsigned int got_type)1497 Output_data_got<got_size, big_endian>::add_global_plt(Symbol* gsym,
1498 unsigned int got_type)
1499 {
1500 if (gsym->has_got_offset(got_type))
1501 return false;
1502
1503 unsigned int got_offset = this->add_got_entry(Got_entry(gsym, true));
1504 gsym->set_got_offset(got_type, got_offset);
1505 return true;
1506 }
1507
1508 // Add an entry for a global symbol to the GOT, and add a dynamic
1509 // relocation of type R_TYPE for the GOT entry.
1510
1511 template<int got_size, bool big_endian>
1512 void
add_global_with_rel(Symbol * gsym,unsigned int got_type,Output_data_reloc_generic * rel_dyn,unsigned int r_type)1513 Output_data_got<got_size, big_endian>::add_global_with_rel(
1514 Symbol* gsym,
1515 unsigned int got_type,
1516 Output_data_reloc_generic* rel_dyn,
1517 unsigned int r_type)
1518 {
1519 if (gsym->has_got_offset(got_type))
1520 return;
1521
1522 unsigned int got_offset = this->add_got_entry(Got_entry());
1523 gsym->set_got_offset(got_type, got_offset);
1524 rel_dyn->add_global_generic(gsym, r_type, this, got_offset, 0);
1525 }
1526
1527 // Add a pair of entries for a global symbol to the GOT, and add
1528 // dynamic relocations of type R_TYPE_1 and R_TYPE_2, respectively.
1529 // If R_TYPE_2 == 0, add the second entry with no relocation.
1530 template<int got_size, bool big_endian>
1531 void
add_global_pair_with_rel(Symbol * gsym,unsigned int got_type,Output_data_reloc_generic * rel_dyn,unsigned int r_type_1,unsigned int r_type_2)1532 Output_data_got<got_size, big_endian>::add_global_pair_with_rel(
1533 Symbol* gsym,
1534 unsigned int got_type,
1535 Output_data_reloc_generic* rel_dyn,
1536 unsigned int r_type_1,
1537 unsigned int r_type_2)
1538 {
1539 if (gsym->has_got_offset(got_type))
1540 return;
1541
1542 unsigned int got_offset = this->add_got_entry_pair(Got_entry(), Got_entry());
1543 gsym->set_got_offset(got_type, got_offset);
1544 rel_dyn->add_global_generic(gsym, r_type_1, this, got_offset, 0);
1545
1546 if (r_type_2 != 0)
1547 rel_dyn->add_global_generic(gsym, r_type_2, this,
1548 got_offset + got_size / 8, 0);
1549 }
1550
1551 // Add an entry for a local symbol to the GOT. This returns true if
1552 // this is a new GOT entry, false if the symbol already has a GOT
1553 // entry.
1554
1555 template<int got_size, bool big_endian>
1556 bool
add_local(Relobj * object,unsigned int symndx,unsigned int got_type)1557 Output_data_got<got_size, big_endian>::add_local(
1558 Relobj* object,
1559 unsigned int symndx,
1560 unsigned int got_type)
1561 {
1562 if (object->local_has_got_offset(symndx, got_type))
1563 return false;
1564
1565 unsigned int got_offset = this->add_got_entry(Got_entry(object, symndx,
1566 false));
1567 object->set_local_got_offset(symndx, got_type, got_offset);
1568 return true;
1569 }
1570
1571 // Add an entry for a local symbol plus ADDEND to the GOT. This returns
1572 // true if this is a new GOT entry, false if the symbol already has a GOT
1573 // entry.
1574
1575 template<int got_size, bool big_endian>
1576 bool
add_local(Relobj * object,unsigned int symndx,unsigned int got_type,uint64_t addend)1577 Output_data_got<got_size, big_endian>::add_local(
1578 Relobj* object,
1579 unsigned int symndx,
1580 unsigned int got_type,
1581 uint64_t addend)
1582 {
1583 if (object->local_has_got_offset(symndx, got_type, addend))
1584 return false;
1585
1586 unsigned int got_offset = this->add_got_entry(Got_entry(object, symndx,
1587 false, addend));
1588 object->set_local_got_offset(symndx, got_type, got_offset, addend);
1589 return true;
1590 }
1591
1592 // Like add_local, but use the PLT offset.
1593
1594 template<int got_size, bool big_endian>
1595 bool
add_local_plt(Relobj * object,unsigned int symndx,unsigned int got_type)1596 Output_data_got<got_size, big_endian>::add_local_plt(
1597 Relobj* object,
1598 unsigned int symndx,
1599 unsigned int got_type)
1600 {
1601 if (object->local_has_got_offset(symndx, got_type))
1602 return false;
1603
1604 unsigned int got_offset = this->add_got_entry(Got_entry(object, symndx,
1605 true));
1606 object->set_local_got_offset(symndx, got_type, got_offset);
1607 return true;
1608 }
1609
1610 // Add an entry for a local symbol to the GOT, and add a dynamic
1611 // relocation of type R_TYPE for the GOT entry.
1612
1613 template<int got_size, bool big_endian>
1614 void
add_local_with_rel(Relobj * object,unsigned int symndx,unsigned int got_type,Output_data_reloc_generic * rel_dyn,unsigned int r_type)1615 Output_data_got<got_size, big_endian>::add_local_with_rel(
1616 Relobj* object,
1617 unsigned int symndx,
1618 unsigned int got_type,
1619 Output_data_reloc_generic* rel_dyn,
1620 unsigned int r_type)
1621 {
1622 if (object->local_has_got_offset(symndx, got_type))
1623 return;
1624
1625 unsigned int got_offset = this->add_got_entry(Got_entry());
1626 object->set_local_got_offset(symndx, got_type, got_offset);
1627 rel_dyn->add_local_generic(object, symndx, r_type, this, got_offset, 0);
1628 }
1629
1630 // Add an entry for a local symbol plus ADDEND to the GOT, and add a dynamic
1631 // relocation of type R_TYPE for the GOT entry.
1632
1633 template<int got_size, bool big_endian>
1634 void
add_local_with_rel(Relobj * object,unsigned int symndx,unsigned int got_type,Output_data_reloc_generic * rel_dyn,unsigned int r_type,uint64_t addend)1635 Output_data_got<got_size, big_endian>::add_local_with_rel(
1636 Relobj* object,
1637 unsigned int symndx,
1638 unsigned int got_type,
1639 Output_data_reloc_generic* rel_dyn,
1640 unsigned int r_type, uint64_t addend)
1641 {
1642 if (object->local_has_got_offset(symndx, got_type, addend))
1643 return;
1644
1645 unsigned int got_offset = this->add_got_entry(Got_entry());
1646 object->set_local_got_offset(symndx, got_type, got_offset, addend);
1647 rel_dyn->add_local_generic(object, symndx, r_type, this, got_offset,
1648 addend);
1649 }
1650
1651 // Add a pair of entries for a local symbol to the GOT, and add
1652 // a dynamic relocation of type R_TYPE using the section symbol of
1653 // the output section to which input section SHNDX maps, on the first.
1654 // The first got entry will have a value of zero, the second the
1655 // value of the local symbol.
1656 template<int got_size, bool big_endian>
1657 void
add_local_pair_with_rel(Relobj * object,unsigned int symndx,unsigned int shndx,unsigned int got_type,Output_data_reloc_generic * rel_dyn,unsigned int r_type)1658 Output_data_got<got_size, big_endian>::add_local_pair_with_rel(
1659 Relobj* object,
1660 unsigned int symndx,
1661 unsigned int shndx,
1662 unsigned int got_type,
1663 Output_data_reloc_generic* rel_dyn,
1664 unsigned int r_type)
1665 {
1666 if (object->local_has_got_offset(symndx, got_type))
1667 return;
1668
1669 unsigned int got_offset =
1670 this->add_got_entry_pair(Got_entry(),
1671 Got_entry(object, symndx, false));
1672 object->set_local_got_offset(symndx, got_type, got_offset);
1673 Output_section* os = object->output_section(shndx);
1674 rel_dyn->add_output_section_generic(os, r_type, this, got_offset, 0);
1675 }
1676
1677 // Add a pair of entries for a local symbol plus ADDEND to the GOT, and add
1678 // a dynamic relocation of type R_TYPE using the section symbol of
1679 // the output section to which input section SHNDX maps, on the first.
1680 // The first got entry will have a value of zero, the second the
1681 // value of the local symbol.
1682 template<int got_size, bool big_endian>
1683 void
add_local_pair_with_rel(Relobj * object,unsigned int symndx,unsigned int shndx,unsigned int got_type,Output_data_reloc_generic * rel_dyn,unsigned int r_type,uint64_t addend)1684 Output_data_got<got_size, big_endian>::add_local_pair_with_rel(
1685 Relobj* object,
1686 unsigned int symndx,
1687 unsigned int shndx,
1688 unsigned int got_type,
1689 Output_data_reloc_generic* rel_dyn,
1690 unsigned int r_type, uint64_t addend)
1691 {
1692 if (object->local_has_got_offset(symndx, got_type, addend))
1693 return;
1694
1695 unsigned int got_offset =
1696 this->add_got_entry_pair(Got_entry(),
1697 Got_entry(object, symndx, false, addend));
1698 object->set_local_got_offset(symndx, got_type, got_offset, addend);
1699 Output_section* os = object->output_section(shndx);
1700 rel_dyn->add_output_section_generic(os, r_type, this, got_offset, addend);
1701 }
1702
1703 // Add a pair of entries for a local symbol to the GOT, and add
1704 // a dynamic relocation of type R_TYPE using STN_UNDEF on the first.
1705 // The first got entry will have a value of zero, the second the
1706 // value of the local symbol offset by Target::tls_offset_for_local.
1707 template<int got_size, bool big_endian>
1708 void
add_local_tls_pair(Relobj * object,unsigned int symndx,unsigned int got_type,Output_data_reloc_generic * rel_dyn,unsigned int r_type)1709 Output_data_got<got_size, big_endian>::add_local_tls_pair(
1710 Relobj* object,
1711 unsigned int symndx,
1712 unsigned int got_type,
1713 Output_data_reloc_generic* rel_dyn,
1714 unsigned int r_type)
1715 {
1716 if (object->local_has_got_offset(symndx, got_type))
1717 return;
1718
1719 unsigned int got_offset
1720 = this->add_got_entry_pair(Got_entry(),
1721 Got_entry(object, symndx, true));
1722 object->set_local_got_offset(symndx, got_type, got_offset);
1723 rel_dyn->add_local_generic(object, 0, r_type, this, got_offset, 0);
1724 }
1725
1726 // Reserve a slot in the GOT for a local symbol or the second slot of a pair.
1727
1728 template<int got_size, bool big_endian>
1729 void
reserve_local(unsigned int i,Relobj * object,unsigned int sym_index,unsigned int got_type)1730 Output_data_got<got_size, big_endian>::reserve_local(
1731 unsigned int i,
1732 Relobj* object,
1733 unsigned int sym_index,
1734 unsigned int got_type)
1735 {
1736 this->do_reserve_slot(i);
1737 object->set_local_got_offset(sym_index, got_type, this->got_offset(i));
1738 }
1739
1740 // Reserve a slot in the GOT for a global symbol.
1741
1742 template<int got_size, bool big_endian>
1743 void
reserve_global(unsigned int i,Symbol * gsym,unsigned int got_type)1744 Output_data_got<got_size, big_endian>::reserve_global(
1745 unsigned int i,
1746 Symbol* gsym,
1747 unsigned int got_type)
1748 {
1749 this->do_reserve_slot(i);
1750 gsym->set_got_offset(got_type, this->got_offset(i));
1751 }
1752
1753 // Write out the GOT.
1754
1755 template<int got_size, bool big_endian>
1756 void
do_write(Output_file * of)1757 Output_data_got<got_size, big_endian>::do_write(Output_file* of)
1758 {
1759 const int add = got_size / 8;
1760
1761 const off_t off = this->offset();
1762 const off_t oview_size = this->data_size();
1763 unsigned char* const oview = of->get_output_view(off, oview_size);
1764
1765 unsigned char* pov = oview;
1766 for (unsigned int i = 0; i < this->entries_.size(); ++i)
1767 {
1768 this->entries_[i].write(i, pov);
1769 pov += add;
1770 }
1771
1772 gold_assert(pov - oview == oview_size);
1773
1774 of->write_output_view(off, oview_size, oview);
1775
1776 // We no longer need the GOT entries.
1777 this->entries_.clear();
1778 }
1779
1780 // Create a new GOT entry and return its offset.
1781
1782 template<int got_size, bool big_endian>
1783 unsigned int
add_got_entry(Got_entry got_entry)1784 Output_data_got<got_size, big_endian>::add_got_entry(Got_entry got_entry)
1785 {
1786 if (!this->is_data_size_valid())
1787 {
1788 this->entries_.push_back(got_entry);
1789 this->set_got_size();
1790 return this->last_got_offset();
1791 }
1792 else
1793 {
1794 // For an incremental update, find an available slot.
1795 off_t got_offset = this->free_list_.allocate(got_size / 8,
1796 got_size / 8, 0);
1797 if (got_offset == -1)
1798 gold_fallback(_("out of patch space (GOT);"
1799 " relink with --incremental-full"));
1800 unsigned int got_index = got_offset / (got_size / 8);
1801 gold_assert(got_index < this->entries_.size());
1802 this->entries_[got_index] = got_entry;
1803 return static_cast<unsigned int>(got_offset);
1804 }
1805 }
1806
1807 // Create a pair of new GOT entries and return the offset of the first.
1808
1809 template<int got_size, bool big_endian>
1810 unsigned int
add_got_entry_pair(Got_entry got_entry_1,Got_entry got_entry_2)1811 Output_data_got<got_size, big_endian>::add_got_entry_pair(
1812 Got_entry got_entry_1,
1813 Got_entry got_entry_2)
1814 {
1815 if (!this->is_data_size_valid())
1816 {
1817 unsigned int got_offset;
1818 this->entries_.push_back(got_entry_1);
1819 got_offset = this->last_got_offset();
1820 this->entries_.push_back(got_entry_2);
1821 this->set_got_size();
1822 return got_offset;
1823 }
1824 else
1825 {
1826 // For an incremental update, find an available pair of slots.
1827 off_t got_offset = this->free_list_.allocate(2 * got_size / 8,
1828 got_size / 8, 0);
1829 if (got_offset == -1)
1830 gold_fallback(_("out of patch space (GOT);"
1831 " relink with --incremental-full"));
1832 unsigned int got_index = got_offset / (got_size / 8);
1833 gold_assert(got_index < this->entries_.size());
1834 this->entries_[got_index] = got_entry_1;
1835 this->entries_[got_index + 1] = got_entry_2;
1836 return static_cast<unsigned int>(got_offset);
1837 }
1838 }
1839
1840 // Replace GOT entry I with a new value.
1841
1842 template<int got_size, bool big_endian>
1843 void
replace_got_entry(unsigned int i,Got_entry got_entry)1844 Output_data_got<got_size, big_endian>::replace_got_entry(
1845 unsigned int i,
1846 Got_entry got_entry)
1847 {
1848 gold_assert(i < this->entries_.size());
1849 this->entries_[i] = got_entry;
1850 }
1851
1852 // Output_data_dynamic::Dynamic_entry methods.
1853
1854 // Write out the entry.
1855
1856 template<int size, bool big_endian>
1857 void
write(unsigned char * pov,const Stringpool * pool) const1858 Output_data_dynamic::Dynamic_entry::write(
1859 unsigned char* pov,
1860 const Stringpool* pool) const
1861 {
1862 typename elfcpp::Elf_types<size>::Elf_WXword val;
1863 switch (this->offset_)
1864 {
1865 case DYNAMIC_NUMBER:
1866 val = this->u_.val;
1867 break;
1868
1869 case DYNAMIC_SECTION_SIZE:
1870 val = this->u_.od->data_size();
1871 if (this->od2 != NULL)
1872 val += this->od2->data_size();
1873 break;
1874
1875 case DYNAMIC_SYMBOL:
1876 {
1877 const Sized_symbol<size>* s =
1878 static_cast<const Sized_symbol<size>*>(this->u_.sym);
1879 val = s->value();
1880 }
1881 break;
1882
1883 case DYNAMIC_STRING:
1884 val = pool->get_offset(this->u_.str);
1885 break;
1886
1887 case DYNAMIC_CUSTOM:
1888 val = parameters->target().dynamic_tag_custom_value(this->tag_);
1889 break;
1890
1891 default:
1892 val = this->u_.od->address() + this->offset_;
1893 break;
1894 }
1895
1896 elfcpp::Dyn_write<size, big_endian> dw(pov);
1897 dw.put_d_tag(this->tag_);
1898 dw.put_d_val(val);
1899 }
1900
1901 // Output_data_dynamic methods.
1902
1903 // Adjust the output section to set the entry size.
1904
1905 void
do_adjust_output_section(Output_section * os)1906 Output_data_dynamic::do_adjust_output_section(Output_section* os)
1907 {
1908 if (parameters->target().get_size() == 32)
1909 os->set_entsize(elfcpp::Elf_sizes<32>::dyn_size);
1910 else if (parameters->target().get_size() == 64)
1911 os->set_entsize(elfcpp::Elf_sizes<64>::dyn_size);
1912 else
1913 gold_unreachable();
1914 }
1915
1916 // Get a dynamic entry offset.
1917
1918 unsigned int
get_entry_offset(elfcpp::DT tag) const1919 Output_data_dynamic::get_entry_offset(elfcpp::DT tag) const
1920 {
1921 int dyn_size;
1922
1923 if (parameters->target().get_size() == 32)
1924 dyn_size = elfcpp::Elf_sizes<32>::dyn_size;
1925 else if (parameters->target().get_size() == 64)
1926 dyn_size = elfcpp::Elf_sizes<64>::dyn_size;
1927 else
1928 gold_unreachable();
1929
1930 for (size_t i = 0; i < entries_.size(); ++i)
1931 if (entries_[i].tag() == tag)
1932 return i * dyn_size;
1933
1934 return -1U;
1935 }
1936
1937 // Set the final data size.
1938
1939 void
set_final_data_size()1940 Output_data_dynamic::set_final_data_size()
1941 {
1942 // Add the terminating entry if it hasn't been added.
1943 // Because of relaxation, we can run this multiple times.
1944 if (this->entries_.empty() || this->entries_.back().tag() != elfcpp::DT_NULL)
1945 {
1946 int extra = parameters->options().spare_dynamic_tags();
1947 for (int i = 0; i < extra; ++i)
1948 this->add_constant(elfcpp::DT_NULL, 0);
1949 this->add_constant(elfcpp::DT_NULL, 0);
1950 }
1951
1952 int dyn_size;
1953 if (parameters->target().get_size() == 32)
1954 dyn_size = elfcpp::Elf_sizes<32>::dyn_size;
1955 else if (parameters->target().get_size() == 64)
1956 dyn_size = elfcpp::Elf_sizes<64>::dyn_size;
1957 else
1958 gold_unreachable();
1959 this->set_data_size(this->entries_.size() * dyn_size);
1960 }
1961
1962 // Write out the dynamic entries.
1963
1964 void
do_write(Output_file * of)1965 Output_data_dynamic::do_write(Output_file* of)
1966 {
1967 switch (parameters->size_and_endianness())
1968 {
1969 #ifdef HAVE_TARGET_32_LITTLE
1970 case Parameters::TARGET_32_LITTLE:
1971 this->sized_write<32, false>(of);
1972 break;
1973 #endif
1974 #ifdef HAVE_TARGET_32_BIG
1975 case Parameters::TARGET_32_BIG:
1976 this->sized_write<32, true>(of);
1977 break;
1978 #endif
1979 #ifdef HAVE_TARGET_64_LITTLE
1980 case Parameters::TARGET_64_LITTLE:
1981 this->sized_write<64, false>(of);
1982 break;
1983 #endif
1984 #ifdef HAVE_TARGET_64_BIG
1985 case Parameters::TARGET_64_BIG:
1986 this->sized_write<64, true>(of);
1987 break;
1988 #endif
1989 default:
1990 gold_unreachable();
1991 }
1992 }
1993
1994 template<int size, bool big_endian>
1995 void
sized_write(Output_file * of)1996 Output_data_dynamic::sized_write(Output_file* of)
1997 {
1998 const int dyn_size = elfcpp::Elf_sizes<size>::dyn_size;
1999
2000 const off_t offset = this->offset();
2001 const off_t oview_size = this->data_size();
2002 unsigned char* const oview = of->get_output_view(offset, oview_size);
2003
2004 unsigned char* pov = oview;
2005 for (typename Dynamic_entries::const_iterator p = this->entries_.begin();
2006 p != this->entries_.end();
2007 ++p)
2008 {
2009 p->write<size, big_endian>(pov, this->pool_);
2010 pov += dyn_size;
2011 }
2012
2013 gold_assert(pov - oview == oview_size);
2014
2015 of->write_output_view(offset, oview_size, oview);
2016
2017 // We no longer need the dynamic entries.
2018 this->entries_.clear();
2019 }
2020
2021 // Class Output_symtab_xindex.
2022
2023 void
do_write(Output_file * of)2024 Output_symtab_xindex::do_write(Output_file* of)
2025 {
2026 const off_t offset = this->offset();
2027 const off_t oview_size = this->data_size();
2028 unsigned char* const oview = of->get_output_view(offset, oview_size);
2029
2030 memset(oview, 0, oview_size);
2031
2032 if (parameters->target().is_big_endian())
2033 this->endian_do_write<true>(oview);
2034 else
2035 this->endian_do_write<false>(oview);
2036
2037 of->write_output_view(offset, oview_size, oview);
2038
2039 // We no longer need the data.
2040 this->entries_.clear();
2041 }
2042
2043 template<bool big_endian>
2044 void
endian_do_write(unsigned char * const oview)2045 Output_symtab_xindex::endian_do_write(unsigned char* const oview)
2046 {
2047 for (Xindex_entries::const_iterator p = this->entries_.begin();
2048 p != this->entries_.end();
2049 ++p)
2050 {
2051 unsigned int symndx = p->first;
2052 gold_assert(static_cast<off_t>(symndx) * 4 < this->data_size());
2053 elfcpp::Swap<32, big_endian>::writeval(oview + symndx * 4, p->second);
2054 }
2055 }
2056
2057 // Output_fill_debug_info methods.
2058
2059 // Return the minimum size needed for a dummy compilation unit header.
2060
2061 size_t
do_minimum_hole_size() const2062 Output_fill_debug_info::do_minimum_hole_size() const
2063 {
2064 // Compile unit header fields: unit_length, version, debug_abbrev_offset,
2065 // address_size.
2066 const size_t len = 4 + 2 + 4 + 1;
2067 // For type units, add type_signature, type_offset.
2068 if (this->is_debug_types_)
2069 return len + 8 + 4;
2070 return len;
2071 }
2072
2073 // Write a dummy compilation unit header to fill a hole in the
2074 // .debug_info or .debug_types section.
2075
2076 void
do_write(Output_file * of,off_t off,size_t len) const2077 Output_fill_debug_info::do_write(Output_file* of, off_t off, size_t len) const
2078 {
2079 gold_debug(DEBUG_INCREMENTAL, "fill_debug_info(%08lx, %08lx)",
2080 static_cast<long>(off), static_cast<long>(len));
2081
2082 gold_assert(len >= this->do_minimum_hole_size());
2083
2084 unsigned char* const oview = of->get_output_view(off, len);
2085 unsigned char* pov = oview;
2086
2087 // Write header fields: unit_length, version, debug_abbrev_offset,
2088 // address_size.
2089 if (this->is_big_endian())
2090 {
2091 elfcpp::Swap_unaligned<32, true>::writeval(pov, len - 4);
2092 elfcpp::Swap_unaligned<16, true>::writeval(pov + 4, this->version);
2093 elfcpp::Swap_unaligned<32, true>::writeval(pov + 6, 0);
2094 }
2095 else
2096 {
2097 elfcpp::Swap_unaligned<32, false>::writeval(pov, len - 4);
2098 elfcpp::Swap_unaligned<16, false>::writeval(pov + 4, this->version);
2099 elfcpp::Swap_unaligned<32, false>::writeval(pov + 6, 0);
2100 }
2101 pov += 4 + 2 + 4;
2102 *pov++ = 4;
2103
2104 // For type units, the additional header fields -- type_signature,
2105 // type_offset -- can be filled with zeroes.
2106
2107 // Fill the remainder of the free space with zeroes. The first
2108 // zero should tell the consumer there are no DIEs to read in this
2109 // compilation unit.
2110 if (pov < oview + len)
2111 memset(pov, 0, oview + len - pov);
2112
2113 of->write_output_view(off, len, oview);
2114 }
2115
2116 // Output_fill_debug_line methods.
2117
2118 // Return the minimum size needed for a dummy line number program header.
2119
2120 size_t
do_minimum_hole_size() const2121 Output_fill_debug_line::do_minimum_hole_size() const
2122 {
2123 // Line number program header fields: unit_length, version, header_length,
2124 // minimum_instruction_length, default_is_stmt, line_base, line_range,
2125 // opcode_base, standard_opcode_lengths[], include_directories, filenames.
2126 const size_t len = 4 + 2 + 4 + this->header_length;
2127 return len;
2128 }
2129
2130 // Write a dummy line number program header to fill a hole in the
2131 // .debug_line section.
2132
2133 void
do_write(Output_file * of,off_t off,size_t len) const2134 Output_fill_debug_line::do_write(Output_file* of, off_t off, size_t len) const
2135 {
2136 gold_debug(DEBUG_INCREMENTAL, "fill_debug_line(%08lx, %08lx)",
2137 static_cast<long>(off), static_cast<long>(len));
2138
2139 gold_assert(len >= this->do_minimum_hole_size());
2140
2141 unsigned char* const oview = of->get_output_view(off, len);
2142 unsigned char* pov = oview;
2143
2144 // Write header fields: unit_length, version, header_length,
2145 // minimum_instruction_length, default_is_stmt, line_base, line_range,
2146 // opcode_base, standard_opcode_lengths[], include_directories, filenames.
2147 // We set the header_length field to cover the entire hole, so the
2148 // line number program is empty.
2149 if (this->is_big_endian())
2150 {
2151 elfcpp::Swap_unaligned<32, true>::writeval(pov, len - 4);
2152 elfcpp::Swap_unaligned<16, true>::writeval(pov + 4, this->version);
2153 elfcpp::Swap_unaligned<32, true>::writeval(pov + 6, len - (4 + 2 + 4));
2154 }
2155 else
2156 {
2157 elfcpp::Swap_unaligned<32, false>::writeval(pov, len - 4);
2158 elfcpp::Swap_unaligned<16, false>::writeval(pov + 4, this->version);
2159 elfcpp::Swap_unaligned<32, false>::writeval(pov + 6, len - (4 + 2 + 4));
2160 }
2161 pov += 4 + 2 + 4;
2162 *pov++ = 1; // minimum_instruction_length
2163 *pov++ = 0; // default_is_stmt
2164 *pov++ = 0; // line_base
2165 *pov++ = 5; // line_range
2166 *pov++ = 13; // opcode_base
2167 *pov++ = 0; // standard_opcode_lengths[1]
2168 *pov++ = 1; // standard_opcode_lengths[2]
2169 *pov++ = 1; // standard_opcode_lengths[3]
2170 *pov++ = 1; // standard_opcode_lengths[4]
2171 *pov++ = 1; // standard_opcode_lengths[5]
2172 *pov++ = 0; // standard_opcode_lengths[6]
2173 *pov++ = 0; // standard_opcode_lengths[7]
2174 *pov++ = 0; // standard_opcode_lengths[8]
2175 *pov++ = 1; // standard_opcode_lengths[9]
2176 *pov++ = 0; // standard_opcode_lengths[10]
2177 *pov++ = 0; // standard_opcode_lengths[11]
2178 *pov++ = 1; // standard_opcode_lengths[12]
2179 *pov++ = 0; // include_directories (empty)
2180 *pov++ = 0; // filenames (empty)
2181
2182 // Some consumers don't check the header_length field, and simply
2183 // start reading the line number program immediately following the
2184 // header. For those consumers, we fill the remainder of the free
2185 // space with DW_LNS_set_basic_block opcodes. These are effectively
2186 // no-ops: the resulting line table program will not create any rows.
2187 if (pov < oview + len)
2188 memset(pov, elfcpp::DW_LNS_set_basic_block, oview + len - pov);
2189
2190 of->write_output_view(off, len, oview);
2191 }
2192
2193 // Output_section::Input_section methods.
2194
2195 // Return the current data size. For an input section we store the size here.
2196 // For an Output_section_data, we have to ask it for the size.
2197
2198 off_t
current_data_size() const2199 Output_section::Input_section::current_data_size() const
2200 {
2201 if (this->is_input_section())
2202 return this->u1_.data_size;
2203 else
2204 {
2205 this->u2_.posd->pre_finalize_data_size();
2206 return this->u2_.posd->current_data_size();
2207 }
2208 }
2209
2210 // Return the data size. For an input section we store the size here.
2211 // For an Output_section_data, we have to ask it for the size.
2212
2213 off_t
data_size() const2214 Output_section::Input_section::data_size() const
2215 {
2216 if (this->is_input_section())
2217 return this->u1_.data_size;
2218 else
2219 return this->u2_.posd->data_size();
2220 }
2221
2222 // Return the object for an input section.
2223
2224 Relobj*
relobj() const2225 Output_section::Input_section::relobj() const
2226 {
2227 if (this->is_input_section())
2228 return this->u2_.object;
2229 else if (this->is_merge_section())
2230 {
2231 gold_assert(this->u2_.pomb->first_relobj() != NULL);
2232 return this->u2_.pomb->first_relobj();
2233 }
2234 else if (this->is_relaxed_input_section())
2235 return this->u2_.poris->relobj();
2236 else
2237 gold_unreachable();
2238 }
2239
2240 // Return the input section index for an input section.
2241
2242 unsigned int
shndx() const2243 Output_section::Input_section::shndx() const
2244 {
2245 if (this->is_input_section())
2246 return this->shndx_;
2247 else if (this->is_merge_section())
2248 {
2249 gold_assert(this->u2_.pomb->first_relobj() != NULL);
2250 return this->u2_.pomb->first_shndx();
2251 }
2252 else if (this->is_relaxed_input_section())
2253 return this->u2_.poris->shndx();
2254 else
2255 gold_unreachable();
2256 }
2257
2258 // Set the address and file offset.
2259
2260 void
set_address_and_file_offset(uint64_t address,off_t file_offset,off_t section_file_offset)2261 Output_section::Input_section::set_address_and_file_offset(
2262 uint64_t address,
2263 off_t file_offset,
2264 off_t section_file_offset)
2265 {
2266 if (this->is_input_section())
2267 this->u2_.object->set_section_offset(this->shndx_,
2268 file_offset - section_file_offset);
2269 else
2270 this->u2_.posd->set_address_and_file_offset(address, file_offset);
2271 }
2272
2273 // Reset the address and file offset.
2274
2275 void
reset_address_and_file_offset()2276 Output_section::Input_section::reset_address_and_file_offset()
2277 {
2278 if (!this->is_input_section())
2279 this->u2_.posd->reset_address_and_file_offset();
2280 }
2281
2282 // Finalize the data size.
2283
2284 void
finalize_data_size()2285 Output_section::Input_section::finalize_data_size()
2286 {
2287 if (!this->is_input_section())
2288 this->u2_.posd->finalize_data_size();
2289 }
2290
2291 // Try to turn an input offset into an output offset. We want to
2292 // return the output offset relative to the start of this
2293 // Input_section in the output section.
2294
2295 inline bool
output_offset(const Relobj * object,unsigned int shndx,section_offset_type offset,section_offset_type * poutput) const2296 Output_section::Input_section::output_offset(
2297 const Relobj* object,
2298 unsigned int shndx,
2299 section_offset_type offset,
2300 section_offset_type* poutput) const
2301 {
2302 if (!this->is_input_section())
2303 return this->u2_.posd->output_offset(object, shndx, offset, poutput);
2304 else
2305 {
2306 if (this->shndx_ != shndx || this->u2_.object != object)
2307 return false;
2308 *poutput = offset;
2309 return true;
2310 }
2311 }
2312
2313 // Write out the data. We don't have to do anything for an input
2314 // section--they are handled via Object::relocate--but this is where
2315 // we write out the data for an Output_section_data.
2316
2317 void
write(Output_file * of)2318 Output_section::Input_section::write(Output_file* of)
2319 {
2320 if (!this->is_input_section())
2321 this->u2_.posd->write(of);
2322 }
2323
2324 // Write the data to a buffer. As for write(), we don't have to do
2325 // anything for an input section.
2326
2327 void
write_to_buffer(unsigned char * buffer)2328 Output_section::Input_section::write_to_buffer(unsigned char* buffer)
2329 {
2330 if (!this->is_input_section())
2331 this->u2_.posd->write_to_buffer(buffer);
2332 }
2333
2334 // Print to a map file.
2335
2336 void
print_to_mapfile(Mapfile * mapfile) const2337 Output_section::Input_section::print_to_mapfile(Mapfile* mapfile) const
2338 {
2339 switch (this->shndx_)
2340 {
2341 case OUTPUT_SECTION_CODE:
2342 case MERGE_DATA_SECTION_CODE:
2343 case MERGE_STRING_SECTION_CODE:
2344 this->u2_.posd->print_to_mapfile(mapfile);
2345 break;
2346
2347 case RELAXED_INPUT_SECTION_CODE:
2348 {
2349 Output_relaxed_input_section* relaxed_section =
2350 this->relaxed_input_section();
2351 mapfile->print_input_section(relaxed_section->relobj(),
2352 relaxed_section->shndx());
2353 }
2354 break;
2355 default:
2356 mapfile->print_input_section(this->u2_.object, this->shndx_);
2357 break;
2358 }
2359 }
2360
2361 // Output_section methods.
2362
2363 // Construct an Output_section. NAME will point into a Stringpool.
2364
Output_section(const char * name,elfcpp::Elf_Word type,elfcpp::Elf_Xword flags)2365 Output_section::Output_section(const char* name, elfcpp::Elf_Word type,
2366 elfcpp::Elf_Xword flags)
2367 : name_(name),
2368 addralign_(0),
2369 entsize_(0),
2370 load_address_(0),
2371 link_section_(NULL),
2372 link_(0),
2373 info_section_(NULL),
2374 info_symndx_(NULL),
2375 info_(0),
2376 type_(type),
2377 flags_(flags),
2378 order_(ORDER_INVALID),
2379 out_shndx_(-1U),
2380 symtab_index_(0),
2381 dynsym_index_(0),
2382 input_sections_(),
2383 first_input_offset_(0),
2384 fills_(),
2385 postprocessing_buffer_(NULL),
2386 needs_symtab_index_(false),
2387 needs_dynsym_index_(false),
2388 should_link_to_symtab_(false),
2389 should_link_to_dynsym_(false),
2390 after_input_sections_(false),
2391 requires_postprocessing_(false),
2392 found_in_sections_clause_(false),
2393 has_load_address_(false),
2394 info_uses_section_index_(false),
2395 input_section_order_specified_(false),
2396 may_sort_attached_input_sections_(false),
2397 must_sort_attached_input_sections_(false),
2398 attached_input_sections_are_sorted_(false),
2399 is_relro_(false),
2400 is_small_section_(false),
2401 is_large_section_(false),
2402 generate_code_fills_at_write_(false),
2403 is_entsize_zero_(false),
2404 section_offsets_need_adjustment_(false),
2405 is_noload_(false),
2406 always_keeps_input_sections_(false),
2407 has_fixed_layout_(false),
2408 is_patch_space_allowed_(false),
2409 is_unique_segment_(false),
2410 tls_offset_(0),
2411 extra_segment_flags_(0),
2412 segment_alignment_(0),
2413 checkpoint_(NULL),
2414 lookup_maps_(new Output_section_lookup_maps),
2415 free_list_(),
2416 free_space_fill_(NULL),
2417 patch_space_(0)
2418 {
2419 // An unallocated section has no address. Forcing this means that
2420 // we don't need special treatment for symbols defined in debug
2421 // sections.
2422 if ((flags & elfcpp::SHF_ALLOC) == 0)
2423 this->set_address(0);
2424 }
2425
~Output_section()2426 Output_section::~Output_section()
2427 {
2428 delete this->checkpoint_;
2429 }
2430
2431 // Set the entry size.
2432
2433 void
set_entsize(uint64_t v)2434 Output_section::set_entsize(uint64_t v)
2435 {
2436 if (this->is_entsize_zero_)
2437 ;
2438 else if (this->entsize_ == 0)
2439 this->entsize_ = v;
2440 else if (this->entsize_ != v)
2441 {
2442 this->entsize_ = 0;
2443 this->is_entsize_zero_ = 1;
2444 }
2445 }
2446
2447 // Add the input section SHNDX, with header SHDR, named SECNAME, in
2448 // OBJECT, to the Output_section. RELOC_SHNDX is the index of a
2449 // relocation section which applies to this section, or 0 if none, or
2450 // -1U if more than one. Return the offset of the input section
2451 // within the output section. Return -1 if the input section will
2452 // receive special handling. In the normal case we don't always keep
2453 // track of input sections for an Output_section. Instead, each
2454 // Object keeps track of the Output_section for each of its input
2455 // sections. However, if HAVE_SECTIONS_SCRIPT is true, we do keep
2456 // track of input sections here; this is used when SECTIONS appears in
2457 // a linker script.
2458
2459 template<int size, bool big_endian>
2460 off_t
add_input_section(Layout * layout,Sized_relobj_file<size,big_endian> * object,unsigned int shndx,const char * secname,const elfcpp::Shdr<size,big_endian> & shdr,unsigned int reloc_shndx,bool have_sections_script)2461 Output_section::add_input_section(Layout* layout,
2462 Sized_relobj_file<size, big_endian>* object,
2463 unsigned int shndx,
2464 const char* secname,
2465 const elfcpp::Shdr<size, big_endian>& shdr,
2466 unsigned int reloc_shndx,
2467 bool have_sections_script)
2468 {
2469 elfcpp::Elf_Xword addralign = shdr.get_sh_addralign();
2470 if ((addralign & (addralign - 1)) != 0)
2471 {
2472 object->error(_("invalid alignment %lu for section \"%s\""),
2473 static_cast<unsigned long>(addralign), secname);
2474 addralign = 1;
2475 }
2476
2477 if (addralign > this->addralign_)
2478 this->addralign_ = addralign;
2479
2480 typename elfcpp::Elf_types<size>::Elf_WXword sh_flags = shdr.get_sh_flags();
2481 uint64_t entsize = shdr.get_sh_entsize();
2482
2483 // .debug_str is a mergeable string section, but is not always so
2484 // marked by compilers. Mark manually here so we can optimize.
2485 if (strcmp(secname, ".debug_str") == 0)
2486 {
2487 sh_flags |= (elfcpp::SHF_MERGE | elfcpp::SHF_STRINGS);
2488 entsize = 1;
2489 }
2490
2491 this->update_flags_for_input_section(sh_flags);
2492 this->set_entsize(entsize);
2493
2494 // If this is a SHF_MERGE section, we pass all the input sections to
2495 // a Output_data_merge. We don't try to handle relocations for such
2496 // a section. We don't try to handle empty merge sections--they
2497 // mess up the mappings, and are useless anyhow.
2498 // FIXME: Need to handle merge sections during incremental update.
2499 if ((sh_flags & elfcpp::SHF_MERGE) != 0
2500 && reloc_shndx == 0
2501 && shdr.get_sh_size() > 0
2502 && !parameters->incremental())
2503 {
2504 // Keep information about merged input sections for rebuilding fast
2505 // lookup maps if we have sections-script or we do relaxation.
2506 bool keeps_input_sections = (this->always_keeps_input_sections_
2507 || have_sections_script
2508 || parameters->target().may_relax());
2509
2510 if (this->add_merge_input_section(object, shndx, sh_flags, entsize,
2511 addralign, keeps_input_sections))
2512 {
2513 // Tell the relocation routines that they need to call the
2514 // output_offset method to determine the final address.
2515 return -1;
2516 }
2517 }
2518
2519 section_size_type input_section_size = shdr.get_sh_size();
2520 section_size_type uncompressed_size;
2521 if (object->section_is_compressed(shndx, &uncompressed_size))
2522 input_section_size = uncompressed_size;
2523
2524 off_t offset_in_section;
2525
2526 if (this->has_fixed_layout())
2527 {
2528 // For incremental updates, find a chunk of unused space in the section.
2529 offset_in_section = this->free_list_.allocate(input_section_size,
2530 addralign, 0);
2531 if (offset_in_section == -1)
2532 gold_fallback(_("out of patch space in section %s; "
2533 "relink with --incremental-full"),
2534 this->name());
2535 return offset_in_section;
2536 }
2537
2538 offset_in_section = this->current_data_size_for_child();
2539 off_t aligned_offset_in_section = align_address(offset_in_section,
2540 addralign);
2541 this->set_current_data_size_for_child(aligned_offset_in_section
2542 + input_section_size);
2543
2544 // Determine if we want to delay code-fill generation until the output
2545 // section is written. When the target is relaxing, we want to delay fill
2546 // generating to avoid adjusting them during relaxation. Also, if we are
2547 // sorting input sections we must delay fill generation.
2548 if (!this->generate_code_fills_at_write_
2549 && !have_sections_script
2550 && (sh_flags & elfcpp::SHF_EXECINSTR) != 0
2551 && parameters->target().has_code_fill()
2552 && (parameters->target().may_relax()
2553 || layout->is_section_ordering_specified()))
2554 {
2555 gold_assert(this->fills_.empty());
2556 this->generate_code_fills_at_write_ = true;
2557 }
2558
2559 if (aligned_offset_in_section > offset_in_section
2560 && !this->generate_code_fills_at_write_
2561 && !have_sections_script
2562 && (sh_flags & elfcpp::SHF_EXECINSTR) != 0
2563 && parameters->target().has_code_fill())
2564 {
2565 // We need to add some fill data. Using fill_list_ when
2566 // possible is an optimization, since we will often have fill
2567 // sections without input sections.
2568 off_t fill_len = aligned_offset_in_section - offset_in_section;
2569 if (this->input_sections_.empty())
2570 this->fills_.push_back(Fill(offset_in_section, fill_len));
2571 else
2572 {
2573 std::string fill_data(parameters->target().code_fill(fill_len));
2574 Output_data_const* odc = new Output_data_const(fill_data, 1);
2575 this->input_sections_.push_back(Input_section(odc));
2576 }
2577 }
2578
2579 // We need to keep track of this section if we are already keeping
2580 // track of sections, or if we are relaxing. Also, if this is a
2581 // section which requires sorting, or which may require sorting in
2582 // the future, we keep track of the sections. If the
2583 // --section-ordering-file option is used to specify the order of
2584 // sections, we need to keep track of sections.
2585 if (this->always_keeps_input_sections_
2586 || have_sections_script
2587 || !this->input_sections_.empty()
2588 || this->may_sort_attached_input_sections()
2589 || this->must_sort_attached_input_sections()
2590 || parameters->options().user_set_Map()
2591 || parameters->target().may_relax()
2592 || layout->is_section_ordering_specified())
2593 {
2594 Input_section isecn(object, shndx, input_section_size, addralign);
2595 /* If section ordering is requested by specifying a ordering file,
2596 using --section-ordering-file, match the section name with
2597 a pattern. */
2598 if (parameters->options().section_ordering_file())
2599 {
2600 unsigned int section_order_index =
2601 layout->find_section_order_index(std::string(secname));
2602 if (section_order_index != 0)
2603 {
2604 isecn.set_section_order_index(section_order_index);
2605 this->set_input_section_order_specified();
2606 }
2607 }
2608 this->input_sections_.push_back(isecn);
2609 }
2610
2611 return aligned_offset_in_section;
2612 }
2613
2614 // Add arbitrary data to an output section.
2615
2616 void
add_output_section_data(Output_section_data * posd)2617 Output_section::add_output_section_data(Output_section_data* posd)
2618 {
2619 Input_section inp(posd);
2620 this->add_output_section_data(&inp);
2621
2622 if (posd->is_data_size_valid())
2623 {
2624 off_t offset_in_section;
2625 if (this->has_fixed_layout())
2626 {
2627 // For incremental updates, find a chunk of unused space.
2628 offset_in_section = this->free_list_.allocate(posd->data_size(),
2629 posd->addralign(), 0);
2630 if (offset_in_section == -1)
2631 gold_fallback(_("out of patch space in section %s; "
2632 "relink with --incremental-full"),
2633 this->name());
2634 // Finalize the address and offset now.
2635 uint64_t addr = this->address();
2636 off_t offset = this->offset();
2637 posd->set_address_and_file_offset(addr + offset_in_section,
2638 offset + offset_in_section);
2639 }
2640 else
2641 {
2642 offset_in_section = this->current_data_size_for_child();
2643 off_t aligned_offset_in_section = align_address(offset_in_section,
2644 posd->addralign());
2645 this->set_current_data_size_for_child(aligned_offset_in_section
2646 + posd->data_size());
2647 }
2648 }
2649 else if (this->has_fixed_layout())
2650 {
2651 // For incremental updates, arrange for the data to have a fixed layout.
2652 // This will mean that additions to the data must be allocated from
2653 // free space within the containing output section.
2654 uint64_t addr = this->address();
2655 posd->set_address(addr);
2656 posd->set_file_offset(0);
2657 // FIXME: This should eventually be unreachable.
2658 // gold_unreachable();
2659 }
2660 }
2661
2662 // Add a relaxed input section.
2663
2664 void
add_relaxed_input_section(Layout * layout,Output_relaxed_input_section * poris,const std::string & name)2665 Output_section::add_relaxed_input_section(Layout* layout,
2666 Output_relaxed_input_section* poris,
2667 const std::string& name)
2668 {
2669 Input_section inp(poris);
2670
2671 // If the --section-ordering-file option is used to specify the order of
2672 // sections, we need to keep track of sections.
2673 if (layout->is_section_ordering_specified())
2674 {
2675 unsigned int section_order_index =
2676 layout->find_section_order_index(name);
2677 if (section_order_index != 0)
2678 {
2679 inp.set_section_order_index(section_order_index);
2680 this->set_input_section_order_specified();
2681 }
2682 }
2683
2684 this->add_output_section_data(&inp);
2685 if (this->lookup_maps_->is_valid())
2686 this->lookup_maps_->add_relaxed_input_section(poris->relobj(),
2687 poris->shndx(), poris);
2688
2689 // For a relaxed section, we use the current data size. Linker scripts
2690 // get all the input sections, including relaxed one from an output
2691 // section and add them back to the same output section to compute the
2692 // output section size. If we do not account for sizes of relaxed input
2693 // sections, an output section would be incorrectly sized.
2694 off_t offset_in_section = this->current_data_size_for_child();
2695 off_t aligned_offset_in_section = align_address(offset_in_section,
2696 poris->addralign());
2697 this->set_current_data_size_for_child(aligned_offset_in_section
2698 + poris->current_data_size());
2699 }
2700
2701 // Add arbitrary data to an output section by Input_section.
2702
2703 void
add_output_section_data(Input_section * inp)2704 Output_section::add_output_section_data(Input_section* inp)
2705 {
2706 if (this->input_sections_.empty())
2707 this->first_input_offset_ = this->current_data_size_for_child();
2708
2709 this->input_sections_.push_back(*inp);
2710
2711 uint64_t addralign = inp->addralign();
2712 if (addralign > this->addralign_)
2713 this->addralign_ = addralign;
2714
2715 inp->set_output_section(this);
2716 }
2717
2718 // Add a merge section to an output section.
2719
2720 void
add_output_merge_section(Output_section_data * posd,bool is_string,uint64_t entsize)2721 Output_section::add_output_merge_section(Output_section_data* posd,
2722 bool is_string, uint64_t entsize)
2723 {
2724 Input_section inp(posd, is_string, entsize);
2725 this->add_output_section_data(&inp);
2726 }
2727
2728 // Add an input section to a SHF_MERGE section.
2729
2730 bool
add_merge_input_section(Relobj * object,unsigned int shndx,uint64_t flags,uint64_t entsize,uint64_t addralign,bool keeps_input_sections)2731 Output_section::add_merge_input_section(Relobj* object, unsigned int shndx,
2732 uint64_t flags, uint64_t entsize,
2733 uint64_t addralign,
2734 bool keeps_input_sections)
2735 {
2736 // We cannot merge sections with entsize == 0.
2737 if (entsize == 0)
2738 return false;
2739
2740 bool is_string = (flags & elfcpp::SHF_STRINGS) != 0;
2741
2742 // We cannot restore merged input section states.
2743 gold_assert(this->checkpoint_ == NULL);
2744
2745 // Look up merge sections by required properties.
2746 // Currently, we only invalidate the lookup maps in script processing
2747 // and relaxation. We should not have done either when we reach here.
2748 // So we assume that the lookup maps are valid to simply code.
2749 gold_assert(this->lookup_maps_->is_valid());
2750 Merge_section_properties msp(is_string, entsize, addralign);
2751 Output_merge_base* pomb = this->lookup_maps_->find_merge_section(msp);
2752 bool is_new = false;
2753 if (pomb != NULL)
2754 {
2755 gold_assert(pomb->is_string() == is_string
2756 && pomb->entsize() == entsize
2757 && pomb->addralign() == addralign);
2758 }
2759 else
2760 {
2761 // Create a new Output_merge_data or Output_merge_string_data.
2762 if (!is_string)
2763 pomb = new Output_merge_data(entsize, addralign);
2764 else
2765 {
2766 switch (entsize)
2767 {
2768 case 1:
2769 pomb = new Output_merge_string<char>(addralign);
2770 break;
2771 case 2:
2772 pomb = new Output_merge_string<uint16_t>(addralign);
2773 break;
2774 case 4:
2775 pomb = new Output_merge_string<uint32_t>(addralign);
2776 break;
2777 default:
2778 return false;
2779 }
2780 }
2781 // If we need to do script processing or relaxation, we need to keep
2782 // the original input sections to rebuild the fast lookup maps.
2783 if (keeps_input_sections)
2784 pomb->set_keeps_input_sections();
2785 is_new = true;
2786 }
2787
2788 if (pomb->add_input_section(object, shndx))
2789 {
2790 // Add new merge section to this output section and link merge
2791 // section properties to new merge section in map.
2792 if (is_new)
2793 {
2794 this->add_output_merge_section(pomb, is_string, entsize);
2795 this->lookup_maps_->add_merge_section(msp, pomb);
2796 }
2797
2798 return true;
2799 }
2800 else
2801 {
2802 // If add_input_section failed, delete new merge section to avoid
2803 // exporting empty merge sections in Output_section::get_input_section.
2804 if (is_new)
2805 delete pomb;
2806 return false;
2807 }
2808 }
2809
2810 // Build a relaxation map to speed up relaxation of existing input sections.
2811 // Look up to the first LIMIT elements in INPUT_SECTIONS.
2812
2813 void
build_relaxation_map(const Input_section_list & input_sections,size_t limit,Relaxation_map * relaxation_map) const2814 Output_section::build_relaxation_map(
2815 const Input_section_list& input_sections,
2816 size_t limit,
2817 Relaxation_map* relaxation_map) const
2818 {
2819 for (size_t i = 0; i < limit; ++i)
2820 {
2821 const Input_section& is(input_sections[i]);
2822 if (is.is_input_section() || is.is_relaxed_input_section())
2823 {
2824 Section_id sid(is.relobj(), is.shndx());
2825 (*relaxation_map)[sid] = i;
2826 }
2827 }
2828 }
2829
2830 // Convert regular input sections in INPUT_SECTIONS into relaxed input
2831 // sections in RELAXED_SECTIONS. MAP is a prebuilt map from section id
2832 // indices of INPUT_SECTIONS.
2833
2834 void
convert_input_sections_in_list_to_relaxed_sections(const std::vector<Output_relaxed_input_section * > & relaxed_sections,const Relaxation_map & map,Input_section_list * input_sections)2835 Output_section::convert_input_sections_in_list_to_relaxed_sections(
2836 const std::vector<Output_relaxed_input_section*>& relaxed_sections,
2837 const Relaxation_map& map,
2838 Input_section_list* input_sections)
2839 {
2840 for (size_t i = 0; i < relaxed_sections.size(); ++i)
2841 {
2842 Output_relaxed_input_section* poris = relaxed_sections[i];
2843 Section_id sid(poris->relobj(), poris->shndx());
2844 Relaxation_map::const_iterator p = map.find(sid);
2845 gold_assert(p != map.end());
2846 gold_assert((*input_sections)[p->second].is_input_section());
2847
2848 // Remember section order index of original input section
2849 // if it is set. Copy it to the relaxed input section.
2850 unsigned int soi =
2851 (*input_sections)[p->second].section_order_index();
2852 (*input_sections)[p->second] = Input_section(poris);
2853 (*input_sections)[p->second].set_section_order_index(soi);
2854 }
2855 }
2856
2857 // Convert regular input sections into relaxed input sections. RELAXED_SECTIONS
2858 // is a vector of pointers to Output_relaxed_input_section or its derived
2859 // classes. The relaxed sections must correspond to existing input sections.
2860
2861 void
convert_input_sections_to_relaxed_sections(const std::vector<Output_relaxed_input_section * > & relaxed_sections)2862 Output_section::convert_input_sections_to_relaxed_sections(
2863 const std::vector<Output_relaxed_input_section*>& relaxed_sections)
2864 {
2865 gold_assert(parameters->target().may_relax());
2866
2867 // We want to make sure that restore_states does not undo the effect of
2868 // this. If there is no checkpoint active, just search the current
2869 // input section list and replace the sections there. If there is
2870 // a checkpoint, also replace the sections there.
2871
2872 // By default, we look at the whole list.
2873 size_t limit = this->input_sections_.size();
2874
2875 if (this->checkpoint_ != NULL)
2876 {
2877 // Replace input sections with relaxed input section in the saved
2878 // copy of the input section list.
2879 if (this->checkpoint_->input_sections_saved())
2880 {
2881 Relaxation_map map;
2882 this->build_relaxation_map(
2883 *(this->checkpoint_->input_sections()),
2884 this->checkpoint_->input_sections()->size(),
2885 &map);
2886 this->convert_input_sections_in_list_to_relaxed_sections(
2887 relaxed_sections,
2888 map,
2889 this->checkpoint_->input_sections());
2890 }
2891 else
2892 {
2893 // We have not copied the input section list yet. Instead, just
2894 // look at the portion that would be saved.
2895 limit = this->checkpoint_->input_sections_size();
2896 }
2897 }
2898
2899 // Convert input sections in input_section_list.
2900 Relaxation_map map;
2901 this->build_relaxation_map(this->input_sections_, limit, &map);
2902 this->convert_input_sections_in_list_to_relaxed_sections(
2903 relaxed_sections,
2904 map,
2905 &this->input_sections_);
2906
2907 // Update fast look-up map.
2908 if (this->lookup_maps_->is_valid())
2909 for (size_t i = 0; i < relaxed_sections.size(); ++i)
2910 {
2911 Output_relaxed_input_section* poris = relaxed_sections[i];
2912 this->lookup_maps_->add_relaxed_input_section(poris->relobj(),
2913 poris->shndx(), poris);
2914 }
2915 }
2916
2917 // Update the output section flags based on input section flags.
2918
2919 void
update_flags_for_input_section(elfcpp::Elf_Xword flags)2920 Output_section::update_flags_for_input_section(elfcpp::Elf_Xword flags)
2921 {
2922 // If we created the section with SHF_ALLOC clear, we set the
2923 // address. If we are now setting the SHF_ALLOC flag, we need to
2924 // undo that.
2925 if ((this->flags_ & elfcpp::SHF_ALLOC) == 0
2926 && (flags & elfcpp::SHF_ALLOC) != 0)
2927 this->mark_address_invalid();
2928
2929 this->flags_ |= (flags
2930 & (elfcpp::SHF_WRITE
2931 | elfcpp::SHF_ALLOC
2932 | elfcpp::SHF_EXECINSTR));
2933
2934 if ((flags & elfcpp::SHF_MERGE) == 0)
2935 this->flags_ &=~ elfcpp::SHF_MERGE;
2936 else
2937 {
2938 if (this->current_data_size_for_child() == 0)
2939 this->flags_ |= elfcpp::SHF_MERGE;
2940 }
2941
2942 if ((flags & elfcpp::SHF_STRINGS) == 0)
2943 this->flags_ &=~ elfcpp::SHF_STRINGS;
2944 else
2945 {
2946 if (this->current_data_size_for_child() == 0)
2947 this->flags_ |= elfcpp::SHF_STRINGS;
2948 }
2949 }
2950
2951 // Find the merge section into which an input section with index SHNDX in
2952 // OBJECT has been added. Return NULL if none found.
2953
2954 const Output_section_data*
find_merge_section(const Relobj * object,unsigned int shndx) const2955 Output_section::find_merge_section(const Relobj* object,
2956 unsigned int shndx) const
2957 {
2958 return object->find_merge_section(shndx);
2959 }
2960
2961 // Build the lookup maps for relaxed sections. This needs
2962 // to be declared as a const method so that it is callable with a const
2963 // Output_section pointer. The method only updates states of the maps.
2964
2965 void
build_lookup_maps() const2966 Output_section::build_lookup_maps() const
2967 {
2968 this->lookup_maps_->clear();
2969 for (Input_section_list::const_iterator p = this->input_sections_.begin();
2970 p != this->input_sections_.end();
2971 ++p)
2972 {
2973 if (p->is_relaxed_input_section())
2974 {
2975 Output_relaxed_input_section* poris = p->relaxed_input_section();
2976 this->lookup_maps_->add_relaxed_input_section(poris->relobj(),
2977 poris->shndx(), poris);
2978 }
2979 }
2980 }
2981
2982 // Find an relaxed input section corresponding to an input section
2983 // in OBJECT with index SHNDX.
2984
2985 const Output_relaxed_input_section*
find_relaxed_input_section(const Relobj * object,unsigned int shndx) const2986 Output_section::find_relaxed_input_section(const Relobj* object,
2987 unsigned int shndx) const
2988 {
2989 if (!this->lookup_maps_->is_valid())
2990 this->build_lookup_maps();
2991 return this->lookup_maps_->find_relaxed_input_section(object, shndx);
2992 }
2993
2994 // Given an address OFFSET relative to the start of input section
2995 // SHNDX in OBJECT, return whether this address is being included in
2996 // the final link. This should only be called if SHNDX in OBJECT has
2997 // a special mapping.
2998
2999 bool
is_input_address_mapped(const Relobj * object,unsigned int shndx,off_t offset) const3000 Output_section::is_input_address_mapped(const Relobj* object,
3001 unsigned int shndx,
3002 off_t offset) const
3003 {
3004 // Look at the Output_section_data_maps first.
3005 const Output_section_data* posd = this->find_merge_section(object, shndx);
3006 if (posd == NULL)
3007 posd = this->find_relaxed_input_section(object, shndx);
3008
3009 if (posd != NULL)
3010 {
3011 section_offset_type output_offset;
3012 bool found = posd->output_offset(object, shndx, offset, &output_offset);
3013 // By default we assume that the address is mapped. See comment at the
3014 // end.
3015 if (!found)
3016 return true;
3017 return output_offset != -1;
3018 }
3019
3020 // Fall back to the slow look-up.
3021 for (Input_section_list::const_iterator p = this->input_sections_.begin();
3022 p != this->input_sections_.end();
3023 ++p)
3024 {
3025 section_offset_type output_offset;
3026 if (p->output_offset(object, shndx, offset, &output_offset))
3027 return output_offset != -1;
3028 }
3029
3030 // By default we assume that the address is mapped. This should
3031 // only be called after we have passed all sections to Layout. At
3032 // that point we should know what we are discarding.
3033 return true;
3034 }
3035
3036 // Given an address OFFSET relative to the start of input section
3037 // SHNDX in object OBJECT, return the output offset relative to the
3038 // start of the input section in the output section. This should only
3039 // be called if SHNDX in OBJECT has a special mapping.
3040
3041 section_offset_type
output_offset(const Relobj * object,unsigned int shndx,section_offset_type offset) const3042 Output_section::output_offset(const Relobj* object, unsigned int shndx,
3043 section_offset_type offset) const
3044 {
3045 // This can only be called meaningfully when we know the data size
3046 // of this.
3047 gold_assert(this->is_data_size_valid());
3048
3049 // Look at the Output_section_data_maps first.
3050 const Output_section_data* posd = this->find_merge_section(object, shndx);
3051 if (posd == NULL)
3052 posd = this->find_relaxed_input_section(object, shndx);
3053 if (posd != NULL)
3054 {
3055 section_offset_type output_offset;
3056 bool found = posd->output_offset(object, shndx, offset, &output_offset);
3057 gold_assert(found);
3058 return output_offset;
3059 }
3060
3061 // Fall back to the slow look-up.
3062 for (Input_section_list::const_iterator p = this->input_sections_.begin();
3063 p != this->input_sections_.end();
3064 ++p)
3065 {
3066 section_offset_type output_offset;
3067 if (p->output_offset(object, shndx, offset, &output_offset))
3068 return output_offset;
3069 }
3070 gold_unreachable();
3071 }
3072
3073 // Return the output virtual address of OFFSET relative to the start
3074 // of input section SHNDX in object OBJECT.
3075
3076 uint64_t
output_address(const Relobj * object,unsigned int shndx,off_t offset) const3077 Output_section::output_address(const Relobj* object, unsigned int shndx,
3078 off_t offset) const
3079 {
3080 uint64_t addr = this->address() + this->first_input_offset_;
3081
3082 // Look at the Output_section_data_maps first.
3083 const Output_section_data* posd = this->find_merge_section(object, shndx);
3084 if (posd == NULL)
3085 posd = this->find_relaxed_input_section(object, shndx);
3086 if (posd != NULL && posd->is_address_valid())
3087 {
3088 section_offset_type output_offset;
3089 bool found = posd->output_offset(object, shndx, offset, &output_offset);
3090 gold_assert(found);
3091 return posd->address() + output_offset;
3092 }
3093
3094 // Fall back to the slow look-up.
3095 for (Input_section_list::const_iterator p = this->input_sections_.begin();
3096 p != this->input_sections_.end();
3097 ++p)
3098 {
3099 addr = align_address(addr, p->addralign());
3100 section_offset_type output_offset;
3101 if (p->output_offset(object, shndx, offset, &output_offset))
3102 {
3103 if (output_offset == -1)
3104 return -1ULL;
3105 return addr + output_offset;
3106 }
3107 addr += p->data_size();
3108 }
3109
3110 // If we get here, it means that we don't know the mapping for this
3111 // input section. This might happen in principle if
3112 // add_input_section were called before add_output_section_data.
3113 // But it should never actually happen.
3114
3115 gold_unreachable();
3116 }
3117
3118 // Find the output address of the start of the merged section for
3119 // input section SHNDX in object OBJECT.
3120
3121 bool
find_starting_output_address(const Relobj * object,unsigned int shndx,uint64_t * paddr) const3122 Output_section::find_starting_output_address(const Relobj* object,
3123 unsigned int shndx,
3124 uint64_t* paddr) const
3125 {
3126 const Output_section_data* data = this->find_merge_section(object, shndx);
3127 if (data == NULL)
3128 return false;
3129
3130 // FIXME: This becomes a bottle-neck if we have many relaxed sections.
3131 // Looking up the merge section map does not always work as we sometimes
3132 // find a merge section without its address set.
3133 uint64_t addr = this->address() + this->first_input_offset_;
3134 for (Input_section_list::const_iterator p = this->input_sections_.begin();
3135 p != this->input_sections_.end();
3136 ++p)
3137 {
3138 addr = align_address(addr, p->addralign());
3139
3140 // It would be nice if we could use the existing output_offset
3141 // method to get the output offset of input offset 0.
3142 // Unfortunately we don't know for sure that input offset 0 is
3143 // mapped at all.
3144 if (!p->is_input_section() && p->output_section_data() == data)
3145 {
3146 *paddr = addr;
3147 return true;
3148 }
3149
3150 addr += p->data_size();
3151 }
3152
3153 // We couldn't find a merge output section for this input section.
3154 return false;
3155 }
3156
3157 // Update the data size of an Output_section.
3158
3159 void
update_data_size()3160 Output_section::update_data_size()
3161 {
3162 if (this->input_sections_.empty())
3163 return;
3164
3165 if (this->must_sort_attached_input_sections()
3166 || this->input_section_order_specified())
3167 this->sort_attached_input_sections();
3168
3169 off_t off = this->first_input_offset_;
3170 for (Input_section_list::iterator p = this->input_sections_.begin();
3171 p != this->input_sections_.end();
3172 ++p)
3173 {
3174 off = align_address(off, p->addralign());
3175 off += p->current_data_size();
3176 }
3177
3178 this->set_current_data_size_for_child(off);
3179 }
3180
3181 // Set the data size of an Output_section. This is where we handle
3182 // setting the addresses of any Output_section_data objects.
3183
3184 void
set_final_data_size()3185 Output_section::set_final_data_size()
3186 {
3187 off_t data_size;
3188
3189 if (this->input_sections_.empty())
3190 data_size = this->current_data_size_for_child();
3191 else
3192 {
3193 if (this->must_sort_attached_input_sections()
3194 || this->input_section_order_specified())
3195 this->sort_attached_input_sections();
3196
3197 uint64_t address = this->address();
3198 off_t startoff = this->offset();
3199 off_t off = startoff + this->first_input_offset_;
3200 for (Input_section_list::iterator p = this->input_sections_.begin();
3201 p != this->input_sections_.end();
3202 ++p)
3203 {
3204 off = align_address(off, p->addralign());
3205 p->set_address_and_file_offset(address + (off - startoff), off,
3206 startoff);
3207 off += p->data_size();
3208 }
3209 data_size = off - startoff;
3210 }
3211
3212 // For full incremental links, we want to allocate some patch space
3213 // in most sections for subsequent incremental updates.
3214 if (this->is_patch_space_allowed_ && parameters->incremental_full())
3215 {
3216 double pct = parameters->options().incremental_patch();
3217 size_t extra = static_cast<size_t>(data_size * pct);
3218 if (this->free_space_fill_ != NULL
3219 && this->free_space_fill_->minimum_hole_size() > extra)
3220 extra = this->free_space_fill_->minimum_hole_size();
3221 off_t new_size = align_address(data_size + extra, this->addralign());
3222 this->patch_space_ = new_size - data_size;
3223 gold_debug(DEBUG_INCREMENTAL,
3224 "set_final_data_size: %08lx + %08lx: section %s",
3225 static_cast<long>(data_size),
3226 static_cast<long>(this->patch_space_),
3227 this->name());
3228 data_size = new_size;
3229 }
3230
3231 this->set_data_size(data_size);
3232 }
3233
3234 // Reset the address and file offset.
3235
3236 void
do_reset_address_and_file_offset()3237 Output_section::do_reset_address_and_file_offset()
3238 {
3239 // An unallocated section has no address. Forcing this means that
3240 // we don't need special treatment for symbols defined in debug
3241 // sections. We do the same in the constructor. This does not
3242 // apply to NOLOAD sections though.
3243 if (((this->flags_ & elfcpp::SHF_ALLOC) == 0) && !this->is_noload_)
3244 this->set_address(0);
3245
3246 for (Input_section_list::iterator p = this->input_sections_.begin();
3247 p != this->input_sections_.end();
3248 ++p)
3249 p->reset_address_and_file_offset();
3250
3251 // Remove any patch space that was added in set_final_data_size.
3252 if (this->patch_space_ > 0)
3253 {
3254 this->set_current_data_size_for_child(this->current_data_size_for_child()
3255 - this->patch_space_);
3256 this->patch_space_ = 0;
3257 }
3258 }
3259
3260 // Return true if address and file offset have the values after reset.
3261
3262 bool
do_address_and_file_offset_have_reset_values() const3263 Output_section::do_address_and_file_offset_have_reset_values() const
3264 {
3265 if (this->is_offset_valid())
3266 return false;
3267
3268 // An unallocated section has address 0 after its construction or a reset.
3269 if ((this->flags_ & elfcpp::SHF_ALLOC) == 0)
3270 return this->is_address_valid() && this->address() == 0;
3271 else
3272 return !this->is_address_valid();
3273 }
3274
3275 // Set the TLS offset. Called only for SHT_TLS sections.
3276
3277 void
do_set_tls_offset(uint64_t tls_base)3278 Output_section::do_set_tls_offset(uint64_t tls_base)
3279 {
3280 this->tls_offset_ = this->address() - tls_base;
3281 }
3282
3283 // In a few cases we need to sort the input sections attached to an
3284 // output section. This is used to implement the type of constructor
3285 // priority ordering implemented by the GNU linker, in which the
3286 // priority becomes part of the section name and the sections are
3287 // sorted by name. We only do this for an output section if we see an
3288 // attached input section matching ".ctors.*", ".dtors.*",
3289 // ".init_array.*" or ".fini_array.*".
3290
3291 class Output_section::Input_section_sort_entry
3292 {
3293 public:
Input_section_sort_entry()3294 Input_section_sort_entry()
3295 : input_section_(), index_(-1U), section_name_()
3296 { }
3297
Input_section_sort_entry(const Input_section & input_section,unsigned int index,bool must_sort_attached_input_sections,const char * output_section_name)3298 Input_section_sort_entry(const Input_section& input_section,
3299 unsigned int index,
3300 bool must_sort_attached_input_sections,
3301 const char* output_section_name)
3302 : input_section_(input_section), index_(index), section_name_()
3303 {
3304 if ((input_section.is_input_section()
3305 || input_section.is_relaxed_input_section())
3306 && must_sort_attached_input_sections)
3307 {
3308 // This is only called single-threaded from Layout::finalize,
3309 // so it is OK to lock. Unfortunately we have no way to pass
3310 // in a Task token.
3311 const Task* dummy_task = reinterpret_cast<const Task*>(-1);
3312 Object* obj = (input_section.is_input_section()
3313 ? input_section.relobj()
3314 : input_section.relaxed_input_section()->relobj());
3315 Task_lock_obj<Object> tl(dummy_task, obj);
3316
3317 // This is a slow operation, which should be cached in
3318 // Layout::layout if this becomes a speed problem.
3319 this->section_name_ = obj->section_name(input_section.shndx());
3320 }
3321 else if (input_section.is_output_section_data()
3322 && must_sort_attached_input_sections)
3323 {
3324 // For linker-generated sections, use the output section name.
3325 this->section_name_.assign(output_section_name);
3326 }
3327 }
3328
3329 // Return the Input_section.
3330 const Input_section&
input_section() const3331 input_section() const
3332 {
3333 gold_assert(this->index_ != -1U);
3334 return this->input_section_;
3335 }
3336
3337 // The index of this entry in the original list. This is used to
3338 // make the sort stable.
3339 unsigned int
index() const3340 index() const
3341 {
3342 gold_assert(this->index_ != -1U);
3343 return this->index_;
3344 }
3345
3346 // The section name.
3347 const std::string&
section_name() const3348 section_name() const
3349 {
3350 return this->section_name_;
3351 }
3352
3353 // Return true if the section name has a priority. This is assumed
3354 // to be true if it has a dot after the initial dot.
3355 bool
has_priority() const3356 has_priority() const
3357 {
3358 return this->section_name_.find('.', 1) != std::string::npos;
3359 }
3360
3361 // Return the priority. Believe it or not, gcc encodes the priority
3362 // differently for .ctors/.dtors and .init_array/.fini_array
3363 // sections.
3364 unsigned int
get_priority() const3365 get_priority() const
3366 {
3367 bool is_ctors;
3368 if (is_prefix_of(".ctors.", this->section_name_.c_str())
3369 || is_prefix_of(".dtors.", this->section_name_.c_str()))
3370 is_ctors = true;
3371 else if (is_prefix_of(".init_array.", this->section_name_.c_str())
3372 || is_prefix_of(".fini_array.", this->section_name_.c_str()))
3373 is_ctors = false;
3374 else
3375 return 0;
3376 char* end;
3377 unsigned long prio = strtoul((this->section_name_.c_str()
3378 + (is_ctors ? 7 : 12)),
3379 &end, 10);
3380 if (*end != '\0')
3381 return 0;
3382 else if (is_ctors)
3383 return 65535 - prio;
3384 else
3385 return prio;
3386 }
3387
3388 // Return true if this an input file whose base name matches
3389 // FILE_NAME. The base name must have an extension of ".o", and
3390 // must be exactly FILE_NAME.o or FILE_NAME, one character, ".o".
3391 // This is to match crtbegin.o as well as crtbeginS.o without
3392 // getting confused by other possibilities. Overall matching the
3393 // file name this way is a dreadful hack, but the GNU linker does it
3394 // in order to better support gcc, and we need to be compatible.
3395 bool
match_file_name(const char * file_name) const3396 match_file_name(const char* file_name) const
3397 {
3398 if (this->input_section_.is_output_section_data())
3399 return false;
3400 return Layout::match_file_name(this->input_section_.relobj(), file_name);
3401 }
3402
3403 // Returns 1 if THIS should appear before S in section order, -1 if S
3404 // appears before THIS and 0 if they are not comparable.
3405 int
compare_section_ordering(const Input_section_sort_entry & s) const3406 compare_section_ordering(const Input_section_sort_entry& s) const
3407 {
3408 unsigned int this_secn_index = this->input_section_.section_order_index();
3409 unsigned int s_secn_index = s.input_section().section_order_index();
3410 if (this_secn_index > 0 && s_secn_index > 0)
3411 {
3412 if (this_secn_index < s_secn_index)
3413 return 1;
3414 else if (this_secn_index > s_secn_index)
3415 return -1;
3416 }
3417 return 0;
3418 }
3419
3420 private:
3421 // The Input_section we are sorting.
3422 Input_section input_section_;
3423 // The index of this Input_section in the original list.
3424 unsigned int index_;
3425 // The section name if there is one.
3426 std::string section_name_;
3427 };
3428
3429 // Return true if S1 should come before S2 in the output section.
3430
3431 bool
operator ()(const Output_section::Input_section_sort_entry & s1,const Output_section::Input_section_sort_entry & s2) const3432 Output_section::Input_section_sort_compare::operator()(
3433 const Output_section::Input_section_sort_entry& s1,
3434 const Output_section::Input_section_sort_entry& s2) const
3435 {
3436 // crtbegin.o must come first.
3437 bool s1_begin = s1.match_file_name("crtbegin");
3438 bool s2_begin = s2.match_file_name("crtbegin");
3439 if (s1_begin || s2_begin)
3440 {
3441 if (!s1_begin)
3442 return false;
3443 if (!s2_begin)
3444 return true;
3445 return s1.index() < s2.index();
3446 }
3447
3448 // crtend.o must come last.
3449 bool s1_end = s1.match_file_name("crtend");
3450 bool s2_end = s2.match_file_name("crtend");
3451 if (s1_end || s2_end)
3452 {
3453 if (!s1_end)
3454 return true;
3455 if (!s2_end)
3456 return false;
3457 return s1.index() < s2.index();
3458 }
3459
3460 // A section with a priority follows a section without a priority.
3461 bool s1_has_priority = s1.has_priority();
3462 bool s2_has_priority = s2.has_priority();
3463 if (s1_has_priority && !s2_has_priority)
3464 return false;
3465 if (!s1_has_priority && s2_has_priority)
3466 return true;
3467
3468 // Check if a section order exists for these sections through a section
3469 // ordering file. If sequence_num is 0, an order does not exist.
3470 int sequence_num = s1.compare_section_ordering(s2);
3471 if (sequence_num != 0)
3472 return sequence_num == 1;
3473
3474 // Otherwise we sort by name.
3475 int compare = s1.section_name().compare(s2.section_name());
3476 if (compare != 0)
3477 return compare < 0;
3478
3479 // Otherwise we keep the input order.
3480 return s1.index() < s2.index();
3481 }
3482
3483 // Return true if S1 should come before S2 in an .init_array or .fini_array
3484 // output section.
3485
3486 bool
operator ()(const Output_section::Input_section_sort_entry & s1,const Output_section::Input_section_sort_entry & s2) const3487 Output_section::Input_section_sort_init_fini_compare::operator()(
3488 const Output_section::Input_section_sort_entry& s1,
3489 const Output_section::Input_section_sort_entry& s2) const
3490 {
3491 // A section without a priority follows a section with a priority.
3492 // This is the reverse of .ctors and .dtors sections.
3493 bool s1_has_priority = s1.has_priority();
3494 bool s2_has_priority = s2.has_priority();
3495 if (s1_has_priority && !s2_has_priority)
3496 return true;
3497 if (!s1_has_priority && s2_has_priority)
3498 return false;
3499
3500 // .ctors and .dtors sections without priority come after
3501 // .init_array and .fini_array sections without priority.
3502 if (!s1_has_priority
3503 && (s1.section_name() == ".ctors" || s1.section_name() == ".dtors")
3504 && s1.section_name() != s2.section_name())
3505 return false;
3506 if (!s2_has_priority
3507 && (s2.section_name() == ".ctors" || s2.section_name() == ".dtors")
3508 && s2.section_name() != s1.section_name())
3509 return true;
3510
3511 // Sort by priority if we can.
3512 if (s1_has_priority)
3513 {
3514 unsigned int s1_prio = s1.get_priority();
3515 unsigned int s2_prio = s2.get_priority();
3516 if (s1_prio < s2_prio)
3517 return true;
3518 else if (s1_prio > s2_prio)
3519 return false;
3520 }
3521
3522 // Check if a section order exists for these sections through a section
3523 // ordering file. If sequence_num is 0, an order does not exist.
3524 int sequence_num = s1.compare_section_ordering(s2);
3525 if (sequence_num != 0)
3526 return sequence_num == 1;
3527
3528 // Otherwise we sort by name.
3529 int compare = s1.section_name().compare(s2.section_name());
3530 if (compare != 0)
3531 return compare < 0;
3532
3533 // Otherwise we keep the input order.
3534 return s1.index() < s2.index();
3535 }
3536
3537 // Return true if S1 should come before S2. Sections that do not match
3538 // any pattern in the section ordering file are placed ahead of the sections
3539 // that match some pattern.
3540
3541 bool
operator ()(const Output_section::Input_section_sort_entry & s1,const Output_section::Input_section_sort_entry & s2) const3542 Output_section::Input_section_sort_section_order_index_compare::operator()(
3543 const Output_section::Input_section_sort_entry& s1,
3544 const Output_section::Input_section_sort_entry& s2) const
3545 {
3546 unsigned int s1_secn_index = s1.input_section().section_order_index();
3547 unsigned int s2_secn_index = s2.input_section().section_order_index();
3548
3549 // Keep input order if section ordering cannot determine order.
3550 if (s1_secn_index == s2_secn_index)
3551 return s1.index() < s2.index();
3552
3553 return s1_secn_index < s2_secn_index;
3554 }
3555
3556 // Return true if S1 should come before S2. This is the sort comparison
3557 // function for .text to sort sections with prefixes
3558 // .text.{unlikely,exit,startup,hot} before other sections.
3559
3560 bool
3561 Output_section::Input_section_sort_section_prefix_special_ordering_compare
operator ()(const Output_section::Input_section_sort_entry & s1,const Output_section::Input_section_sort_entry & s2) const3562 ::operator()(
3563 const Output_section::Input_section_sort_entry& s1,
3564 const Output_section::Input_section_sort_entry& s2) const
3565 {
3566 // Some input section names have special ordering requirements.
3567 int o1 = Layout::special_ordering_of_input_section(s1.section_name().c_str());
3568 int o2 = Layout::special_ordering_of_input_section(s2.section_name().c_str());
3569 if (o1 != o2)
3570 {
3571 if (o1 < 0)
3572 return false;
3573 else if (o2 < 0)
3574 return true;
3575 else
3576 return o1 < o2;
3577 }
3578
3579 // Keep input order otherwise.
3580 return s1.index() < s2.index();
3581 }
3582
3583 // Return true if S1 should come before S2. This is the sort comparison
3584 // function for sections to sort them by name.
3585
3586 bool
3587 Output_section::Input_section_sort_section_name_compare
operator ()(const Output_section::Input_section_sort_entry & s1,const Output_section::Input_section_sort_entry & s2) const3588 ::operator()(
3589 const Output_section::Input_section_sort_entry& s1,
3590 const Output_section::Input_section_sort_entry& s2) const
3591 {
3592 // We sort by name.
3593 int compare = s1.section_name().compare(s2.section_name());
3594 if (compare != 0)
3595 return compare < 0;
3596
3597 // Keep input order otherwise.
3598 return s1.index() < s2.index();
3599 }
3600
3601 // This updates the section order index of input sections according to the
3602 // the order specified in the mapping from Section id to order index.
3603
3604 void
update_section_layout(const Section_layout_order * order_map)3605 Output_section::update_section_layout(
3606 const Section_layout_order* order_map)
3607 {
3608 for (Input_section_list::iterator p = this->input_sections_.begin();
3609 p != this->input_sections_.end();
3610 ++p)
3611 {
3612 if (p->is_input_section()
3613 || p->is_relaxed_input_section())
3614 {
3615 Relobj* obj = (p->is_input_section()
3616 ? p->relobj()
3617 : p->relaxed_input_section()->relobj());
3618 unsigned int shndx = p->shndx();
3619 Section_layout_order::const_iterator it
3620 = order_map->find(Section_id(obj, shndx));
3621 if (it == order_map->end())
3622 continue;
3623 unsigned int section_order_index = it->second;
3624 if (section_order_index != 0)
3625 {
3626 p->set_section_order_index(section_order_index);
3627 this->set_input_section_order_specified();
3628 }
3629 }
3630 }
3631 }
3632
3633 // Sort the input sections attached to an output section.
3634
3635 void
sort_attached_input_sections()3636 Output_section::sort_attached_input_sections()
3637 {
3638 if (this->attached_input_sections_are_sorted_)
3639 return;
3640
3641 if (this->checkpoint_ != NULL
3642 && !this->checkpoint_->input_sections_saved())
3643 this->checkpoint_->save_input_sections();
3644
3645 // The only thing we know about an input section is the object and
3646 // the section index. We need the section name. Recomputing this
3647 // is slow but this is an unusual case. If this becomes a speed
3648 // problem we can cache the names as required in Layout::layout.
3649
3650 // We start by building a larger vector holding a copy of each
3651 // Input_section, plus its current index in the list and its name.
3652 std::vector<Input_section_sort_entry> sort_list;
3653
3654 unsigned int i = 0;
3655 for (Input_section_list::iterator p = this->input_sections_.begin();
3656 p != this->input_sections_.end();
3657 ++p, ++i)
3658 sort_list.push_back(Input_section_sort_entry(*p, i,
3659 this->must_sort_attached_input_sections(),
3660 this->name()));
3661
3662 // Sort the input sections.
3663 if (this->must_sort_attached_input_sections())
3664 {
3665 if (this->type() == elfcpp::SHT_PREINIT_ARRAY
3666 || this->type() == elfcpp::SHT_INIT_ARRAY
3667 || this->type() == elfcpp::SHT_FINI_ARRAY)
3668 std::sort(sort_list.begin(), sort_list.end(),
3669 Input_section_sort_init_fini_compare());
3670 else if (strcmp(parameters->options().sort_section(), "name") == 0)
3671 std::sort(sort_list.begin(), sort_list.end(),
3672 Input_section_sort_section_name_compare());
3673 else if (strcmp(this->name(), ".text") == 0)
3674 std::sort(sort_list.begin(), sort_list.end(),
3675 Input_section_sort_section_prefix_special_ordering_compare());
3676 else
3677 std::sort(sort_list.begin(), sort_list.end(),
3678 Input_section_sort_compare());
3679 }
3680 else
3681 {
3682 gold_assert(this->input_section_order_specified());
3683 std::sort(sort_list.begin(), sort_list.end(),
3684 Input_section_sort_section_order_index_compare());
3685 }
3686
3687 // Copy the sorted input sections back to our list.
3688 this->input_sections_.clear();
3689 for (std::vector<Input_section_sort_entry>::iterator p = sort_list.begin();
3690 p != sort_list.end();
3691 ++p)
3692 this->input_sections_.push_back(p->input_section());
3693 sort_list.clear();
3694
3695 // Remember that we sorted the input sections, since we might get
3696 // called again.
3697 this->attached_input_sections_are_sorted_ = true;
3698 }
3699
3700 // Write the section header to *OSHDR.
3701
3702 template<int size, bool big_endian>
3703 void
write_header(const Layout * layout,const Stringpool * secnamepool,elfcpp::Shdr_write<size,big_endian> * oshdr) const3704 Output_section::write_header(const Layout* layout,
3705 const Stringpool* secnamepool,
3706 elfcpp::Shdr_write<size, big_endian>* oshdr) const
3707 {
3708 oshdr->put_sh_name(secnamepool->get_offset(this->name_));
3709 oshdr->put_sh_type(this->type_);
3710
3711 elfcpp::Elf_Xword flags = this->flags_;
3712 if (this->info_section_ != NULL && this->info_uses_section_index_)
3713 flags |= elfcpp::SHF_INFO_LINK;
3714 oshdr->put_sh_flags(flags);
3715
3716 oshdr->put_sh_addr(this->address());
3717 oshdr->put_sh_offset(this->offset());
3718 oshdr->put_sh_size(this->data_size());
3719 if (this->link_section_ != NULL)
3720 oshdr->put_sh_link(this->link_section_->out_shndx());
3721 else if (this->should_link_to_symtab_)
3722 oshdr->put_sh_link(layout->symtab_section_shndx());
3723 else if (this->should_link_to_dynsym_)
3724 oshdr->put_sh_link(layout->dynsym_section()->out_shndx());
3725 else
3726 oshdr->put_sh_link(this->link_);
3727
3728 elfcpp::Elf_Word info;
3729 if (this->info_section_ != NULL)
3730 {
3731 if (this->info_uses_section_index_)
3732 info = this->info_section_->out_shndx();
3733 else
3734 info = this->info_section_->symtab_index();
3735 }
3736 else if (this->info_symndx_ != NULL)
3737 info = this->info_symndx_->symtab_index();
3738 else
3739 info = this->info_;
3740 oshdr->put_sh_info(info);
3741
3742 oshdr->put_sh_addralign(this->addralign_);
3743 oshdr->put_sh_entsize(this->entsize_);
3744 }
3745
3746 // Write out the data. For input sections the data is written out by
3747 // Object::relocate, but we have to handle Output_section_data objects
3748 // here.
3749
3750 void
do_write(Output_file * of)3751 Output_section::do_write(Output_file* of)
3752 {
3753 gold_assert(!this->requires_postprocessing());
3754
3755 // If the target performs relaxation, we delay filler generation until now.
3756 gold_assert(!this->generate_code_fills_at_write_ || this->fills_.empty());
3757
3758 off_t output_section_file_offset = this->offset();
3759 for (Fill_list::iterator p = this->fills_.begin();
3760 p != this->fills_.end();
3761 ++p)
3762 {
3763 std::string fill_data(parameters->target().code_fill(p->length()));
3764 of->write(output_section_file_offset + p->section_offset(),
3765 fill_data.data(), fill_data.size());
3766 }
3767
3768 off_t off = this->offset() + this->first_input_offset_;
3769 for (Input_section_list::iterator p = this->input_sections_.begin();
3770 p != this->input_sections_.end();
3771 ++p)
3772 {
3773 off_t aligned_off = align_address(off, p->addralign());
3774 if (this->generate_code_fills_at_write_ && (off != aligned_off))
3775 {
3776 size_t fill_len = aligned_off - off;
3777 std::string fill_data(parameters->target().code_fill(fill_len));
3778 of->write(off, fill_data.data(), fill_data.size());
3779 }
3780
3781 p->write(of);
3782 off = aligned_off + p->data_size();
3783 }
3784
3785 // For incremental links, fill in unused chunks in debug sections
3786 // with dummy compilation unit headers.
3787 if (this->free_space_fill_ != NULL)
3788 {
3789 for (Free_list::Const_iterator p = this->free_list_.begin();
3790 p != this->free_list_.end();
3791 ++p)
3792 {
3793 off_t off = p->start_;
3794 size_t len = p->end_ - off;
3795 this->free_space_fill_->write(of, this->offset() + off, len);
3796 }
3797 if (this->patch_space_ > 0)
3798 {
3799 off_t off = this->current_data_size_for_child() - this->patch_space_;
3800 this->free_space_fill_->write(of, this->offset() + off,
3801 this->patch_space_);
3802 }
3803 }
3804 }
3805
3806 // If a section requires postprocessing, create the buffer to use.
3807
3808 void
create_postprocessing_buffer()3809 Output_section::create_postprocessing_buffer()
3810 {
3811 gold_assert(this->requires_postprocessing());
3812
3813 if (this->postprocessing_buffer_ != NULL)
3814 return;
3815
3816 if (!this->input_sections_.empty())
3817 {
3818 off_t off = this->first_input_offset_;
3819 for (Input_section_list::iterator p = this->input_sections_.begin();
3820 p != this->input_sections_.end();
3821 ++p)
3822 {
3823 off = align_address(off, p->addralign());
3824 p->finalize_data_size();
3825 off += p->data_size();
3826 }
3827 this->set_current_data_size_for_child(off);
3828 }
3829
3830 off_t buffer_size = this->current_data_size_for_child();
3831 this->postprocessing_buffer_ = new unsigned char[buffer_size];
3832 }
3833
3834 // Write all the data of an Output_section into the postprocessing
3835 // buffer. This is used for sections which require postprocessing,
3836 // such as compression. Input sections are handled by
3837 // Object::Relocate.
3838
3839 void
write_to_postprocessing_buffer()3840 Output_section::write_to_postprocessing_buffer()
3841 {
3842 gold_assert(this->requires_postprocessing());
3843
3844 // If the target performs relaxation, we delay filler generation until now.
3845 gold_assert(!this->generate_code_fills_at_write_ || this->fills_.empty());
3846
3847 unsigned char* buffer = this->postprocessing_buffer();
3848 for (Fill_list::iterator p = this->fills_.begin();
3849 p != this->fills_.end();
3850 ++p)
3851 {
3852 std::string fill_data(parameters->target().code_fill(p->length()));
3853 memcpy(buffer + p->section_offset(), fill_data.data(),
3854 fill_data.size());
3855 }
3856
3857 off_t off = this->first_input_offset_;
3858 for (Input_section_list::iterator p = this->input_sections_.begin();
3859 p != this->input_sections_.end();
3860 ++p)
3861 {
3862 off_t aligned_off = align_address(off, p->addralign());
3863 if (this->generate_code_fills_at_write_ && (off != aligned_off))
3864 {
3865 size_t fill_len = aligned_off - off;
3866 std::string fill_data(parameters->target().code_fill(fill_len));
3867 memcpy(buffer + off, fill_data.data(), fill_data.size());
3868 }
3869
3870 p->write_to_buffer(buffer + aligned_off);
3871 off = aligned_off + p->data_size();
3872 }
3873 }
3874
3875 // Get the input sections for linker script processing. We leave
3876 // behind the Output_section_data entries. Note that this may be
3877 // slightly incorrect for merge sections. We will leave them behind,
3878 // but it is possible that the script says that they should follow
3879 // some other input sections, as in:
3880 // .rodata { *(.rodata) *(.rodata.cst*) }
3881 // For that matter, we don't handle this correctly:
3882 // .rodata { foo.o(.rodata.cst*) *(.rodata.cst*) }
3883 // With luck this will never matter.
3884
3885 uint64_t
get_input_sections(uint64_t address,const std::string & fill,std::list<Input_section> * input_sections)3886 Output_section::get_input_sections(
3887 uint64_t address,
3888 const std::string& fill,
3889 std::list<Input_section>* input_sections)
3890 {
3891 if (this->checkpoint_ != NULL
3892 && !this->checkpoint_->input_sections_saved())
3893 this->checkpoint_->save_input_sections();
3894
3895 // Invalidate fast look-up maps.
3896 this->lookup_maps_->invalidate();
3897
3898 uint64_t orig_address = address;
3899
3900 address = align_address(address, this->addralign());
3901
3902 Input_section_list remaining;
3903 for (Input_section_list::iterator p = this->input_sections_.begin();
3904 p != this->input_sections_.end();
3905 ++p)
3906 {
3907 if (p->is_input_section()
3908 || p->is_relaxed_input_section()
3909 || p->is_merge_section())
3910 input_sections->push_back(*p);
3911 else
3912 {
3913 uint64_t aligned_address = align_address(address, p->addralign());
3914 if (aligned_address != address && !fill.empty())
3915 {
3916 section_size_type length =
3917 convert_to_section_size_type(aligned_address - address);
3918 std::string this_fill;
3919 this_fill.reserve(length);
3920 while (this_fill.length() + fill.length() <= length)
3921 this_fill += fill;
3922 if (this_fill.length() < length)
3923 this_fill.append(fill, 0, length - this_fill.length());
3924
3925 Output_section_data* posd = new Output_data_const(this_fill, 0);
3926 remaining.push_back(Input_section(posd));
3927 }
3928 address = aligned_address;
3929
3930 remaining.push_back(*p);
3931
3932 p->finalize_data_size();
3933 address += p->data_size();
3934 }
3935 }
3936
3937 this->input_sections_.swap(remaining);
3938 this->first_input_offset_ = 0;
3939
3940 uint64_t data_size = address - orig_address;
3941 this->set_current_data_size_for_child(data_size);
3942 return data_size;
3943 }
3944
3945 // Add a script input section. SIS is an Output_section::Input_section,
3946 // which can be either a plain input section or a special input section like
3947 // a relaxed input section. For a special input section, its size must be
3948 // finalized.
3949
3950 void
add_script_input_section(const Input_section & sis)3951 Output_section::add_script_input_section(const Input_section& sis)
3952 {
3953 uint64_t data_size = sis.data_size();
3954 uint64_t addralign = sis.addralign();
3955 if (addralign > this->addralign_)
3956 this->addralign_ = addralign;
3957
3958 off_t offset_in_section = this->current_data_size_for_child();
3959 off_t aligned_offset_in_section = align_address(offset_in_section,
3960 addralign);
3961
3962 this->set_current_data_size_for_child(aligned_offset_in_section
3963 + data_size);
3964
3965 this->input_sections_.push_back(sis);
3966
3967 // Update fast lookup maps if necessary.
3968 if (this->lookup_maps_->is_valid())
3969 {
3970 if (sis.is_relaxed_input_section())
3971 {
3972 Output_relaxed_input_section* poris = sis.relaxed_input_section();
3973 this->lookup_maps_->add_relaxed_input_section(poris->relobj(),
3974 poris->shndx(), poris);
3975 }
3976 }
3977 }
3978
3979 // Save states for relaxation.
3980
3981 void
save_states()3982 Output_section::save_states()
3983 {
3984 gold_assert(this->checkpoint_ == NULL);
3985 Checkpoint_output_section* checkpoint =
3986 new Checkpoint_output_section(this->addralign_, this->flags_,
3987 this->input_sections_,
3988 this->first_input_offset_,
3989 this->attached_input_sections_are_sorted_);
3990 this->checkpoint_ = checkpoint;
3991 gold_assert(this->fills_.empty());
3992 }
3993
3994 void
discard_states()3995 Output_section::discard_states()
3996 {
3997 gold_assert(this->checkpoint_ != NULL);
3998 delete this->checkpoint_;
3999 this->checkpoint_ = NULL;
4000 gold_assert(this->fills_.empty());
4001
4002 // Simply invalidate the fast lookup maps since we do not keep
4003 // track of them.
4004 this->lookup_maps_->invalidate();
4005 }
4006
4007 void
restore_states()4008 Output_section::restore_states()
4009 {
4010 gold_assert(this->checkpoint_ != NULL);
4011 Checkpoint_output_section* checkpoint = this->checkpoint_;
4012
4013 this->addralign_ = checkpoint->addralign();
4014 this->flags_ = checkpoint->flags();
4015 this->first_input_offset_ = checkpoint->first_input_offset();
4016
4017 if (!checkpoint->input_sections_saved())
4018 {
4019 // If we have not copied the input sections, just resize it.
4020 size_t old_size = checkpoint->input_sections_size();
4021 gold_assert(this->input_sections_.size() >= old_size);
4022 this->input_sections_.resize(old_size);
4023 }
4024 else
4025 {
4026 // We need to copy the whole list. This is not efficient for
4027 // extremely large output with hundreads of thousands of input
4028 // objects. We may need to re-think how we should pass sections
4029 // to scripts.
4030 this->input_sections_ = *checkpoint->input_sections();
4031 }
4032
4033 this->attached_input_sections_are_sorted_ =
4034 checkpoint->attached_input_sections_are_sorted();
4035
4036 // Simply invalidate the fast lookup maps since we do not keep
4037 // track of them.
4038 this->lookup_maps_->invalidate();
4039 }
4040
4041 // Update the section offsets of input sections in this. This is required if
4042 // relaxation causes some input sections to change sizes.
4043
4044 void
adjust_section_offsets()4045 Output_section::adjust_section_offsets()
4046 {
4047 if (!this->section_offsets_need_adjustment_)
4048 return;
4049
4050 off_t off = 0;
4051 for (Input_section_list::iterator p = this->input_sections_.begin();
4052 p != this->input_sections_.end();
4053 ++p)
4054 {
4055 off = align_address(off, p->addralign());
4056 if (p->is_input_section())
4057 p->relobj()->set_section_offset(p->shndx(), off);
4058 off += p->data_size();
4059 }
4060
4061 this->section_offsets_need_adjustment_ = false;
4062 }
4063
4064 // Print to the map file.
4065
4066 void
do_print_to_mapfile(Mapfile * mapfile) const4067 Output_section::do_print_to_mapfile(Mapfile* mapfile) const
4068 {
4069 mapfile->print_output_section(this);
4070
4071 for (Input_section_list::const_iterator p = this->input_sections_.begin();
4072 p != this->input_sections_.end();
4073 ++p)
4074 p->print_to_mapfile(mapfile);
4075 }
4076
4077 // Print stats for merge sections to stderr.
4078
4079 void
print_merge_stats()4080 Output_section::print_merge_stats()
4081 {
4082 Input_section_list::iterator p;
4083 for (p = this->input_sections_.begin();
4084 p != this->input_sections_.end();
4085 ++p)
4086 p->print_merge_stats(this->name_);
4087 }
4088
4089 // Set a fixed layout for the section. Used for incremental update links.
4090
4091 void
set_fixed_layout(uint64_t sh_addr,off_t sh_offset,off_t sh_size,uint64_t sh_addralign)4092 Output_section::set_fixed_layout(uint64_t sh_addr, off_t sh_offset,
4093 off_t sh_size, uint64_t sh_addralign)
4094 {
4095 this->addralign_ = sh_addralign;
4096 this->set_current_data_size(sh_size);
4097 if ((this->flags_ & elfcpp::SHF_ALLOC) != 0)
4098 this->set_address(sh_addr);
4099 this->set_file_offset(sh_offset);
4100 this->finalize_data_size();
4101 this->free_list_.init(sh_size, false);
4102 this->has_fixed_layout_ = true;
4103 }
4104
4105 // Reserve space within the fixed layout for the section. Used for
4106 // incremental update links.
4107
4108 void
reserve(uint64_t sh_offset,uint64_t sh_size)4109 Output_section::reserve(uint64_t sh_offset, uint64_t sh_size)
4110 {
4111 this->free_list_.remove(sh_offset, sh_offset + sh_size);
4112 }
4113
4114 // Allocate space from the free list for the section. Used for
4115 // incremental update links.
4116
4117 off_t
allocate(off_t len,uint64_t addralign)4118 Output_section::allocate(off_t len, uint64_t addralign)
4119 {
4120 return this->free_list_.allocate(len, addralign, 0);
4121 }
4122
4123 // Output segment methods.
4124
Output_segment(elfcpp::Elf_Word type,elfcpp::Elf_Word flags)4125 Output_segment::Output_segment(elfcpp::Elf_Word type, elfcpp::Elf_Word flags)
4126 : vaddr_(0),
4127 paddr_(0),
4128 memsz_(0),
4129 max_align_(0),
4130 min_p_align_(0),
4131 offset_(0),
4132 filesz_(0),
4133 type_(type),
4134 flags_(flags),
4135 is_max_align_known_(false),
4136 are_addresses_set_(false),
4137 is_large_data_segment_(false),
4138 is_unique_segment_(false)
4139 {
4140 // The ELF ABI specifies that a PT_TLS segment always has PF_R as
4141 // the flags.
4142 if (type == elfcpp::PT_TLS)
4143 this->flags_ = elfcpp::PF_R;
4144 }
4145
4146 // Add an Output_section to a PT_LOAD Output_segment.
4147
4148 void
add_output_section_to_load(Layout * layout,Output_section * os,elfcpp::Elf_Word seg_flags)4149 Output_segment::add_output_section_to_load(Layout* layout,
4150 Output_section* os,
4151 elfcpp::Elf_Word seg_flags)
4152 {
4153 gold_assert(this->type() == elfcpp::PT_LOAD);
4154 gold_assert((os->flags() & elfcpp::SHF_ALLOC) != 0);
4155 gold_assert(!this->is_max_align_known_);
4156 gold_assert(os->is_large_data_section() == this->is_large_data_segment());
4157
4158 this->update_flags_for_output_section(seg_flags);
4159
4160 // We don't want to change the ordering if we have a linker script
4161 // with a SECTIONS clause.
4162 Output_section_order order = os->order();
4163 if (layout->script_options()->saw_sections_clause())
4164 order = static_cast<Output_section_order>(0);
4165 else
4166 gold_assert(order != ORDER_INVALID);
4167
4168 this->output_lists_[order].push_back(os);
4169 }
4170
4171 // Add an Output_section to a non-PT_LOAD Output_segment.
4172
4173 void
add_output_section_to_nonload(Output_section * os,elfcpp::Elf_Word seg_flags)4174 Output_segment::add_output_section_to_nonload(Output_section* os,
4175 elfcpp::Elf_Word seg_flags)
4176 {
4177 gold_assert(this->type() != elfcpp::PT_LOAD);
4178 gold_assert((os->flags() & elfcpp::SHF_ALLOC) != 0);
4179 gold_assert(!this->is_max_align_known_);
4180
4181 this->update_flags_for_output_section(seg_flags);
4182
4183 this->output_lists_[0].push_back(os);
4184 }
4185
4186 // Remove an Output_section from this segment. It is an error if it
4187 // is not present.
4188
4189 void
remove_output_section(Output_section * os)4190 Output_segment::remove_output_section(Output_section* os)
4191 {
4192 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4193 {
4194 Output_data_list* pdl = &this->output_lists_[i];
4195 for (Output_data_list::iterator p = pdl->begin(); p != pdl->end(); ++p)
4196 {
4197 if (*p == os)
4198 {
4199 pdl->erase(p);
4200 return;
4201 }
4202 }
4203 }
4204 gold_unreachable();
4205 }
4206
4207 // Add an Output_data (which need not be an Output_section) to the
4208 // start of a segment.
4209
4210 void
add_initial_output_data(Output_data * od)4211 Output_segment::add_initial_output_data(Output_data* od)
4212 {
4213 gold_assert(!this->is_max_align_known_);
4214 Output_data_list::iterator p = this->output_lists_[0].begin();
4215 this->output_lists_[0].insert(p, od);
4216 }
4217
4218 // Return true if this segment has any sections which hold actual
4219 // data, rather than being a BSS section.
4220
4221 bool
has_any_data_sections() const4222 Output_segment::has_any_data_sections() const
4223 {
4224 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4225 {
4226 const Output_data_list* pdl = &this->output_lists_[i];
4227 for (Output_data_list::const_iterator p = pdl->begin();
4228 p != pdl->end();
4229 ++p)
4230 {
4231 if (!(*p)->is_section())
4232 return true;
4233 if ((*p)->output_section()->type() != elfcpp::SHT_NOBITS)
4234 return true;
4235 }
4236 }
4237 return false;
4238 }
4239
4240 // Return whether the first data section (not counting TLS sections)
4241 // is a relro section.
4242
4243 bool
is_first_section_relro() const4244 Output_segment::is_first_section_relro() const
4245 {
4246 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4247 {
4248 if (i == static_cast<int>(ORDER_TLS_BSS))
4249 continue;
4250 const Output_data_list* pdl = &this->output_lists_[i];
4251 if (!pdl->empty())
4252 {
4253 Output_data* p = pdl->front();
4254 return p->is_section() && p->output_section()->is_relro();
4255 }
4256 }
4257 return false;
4258 }
4259
4260 // Return the maximum alignment of the Output_data in Output_segment.
4261
4262 uint64_t
maximum_alignment()4263 Output_segment::maximum_alignment()
4264 {
4265 if (!this->is_max_align_known_)
4266 {
4267 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4268 {
4269 const Output_data_list* pdl = &this->output_lists_[i];
4270 uint64_t addralign = Output_segment::maximum_alignment_list(pdl);
4271 if (addralign > this->max_align_)
4272 this->max_align_ = addralign;
4273 }
4274 this->is_max_align_known_ = true;
4275 }
4276
4277 return this->max_align_;
4278 }
4279
4280 // Return the maximum alignment of a list of Output_data.
4281
4282 uint64_t
maximum_alignment_list(const Output_data_list * pdl)4283 Output_segment::maximum_alignment_list(const Output_data_list* pdl)
4284 {
4285 uint64_t ret = 0;
4286 for (Output_data_list::const_iterator p = pdl->begin();
4287 p != pdl->end();
4288 ++p)
4289 {
4290 uint64_t addralign = (*p)->addralign();
4291 if (addralign > ret)
4292 ret = addralign;
4293 }
4294 return ret;
4295 }
4296
4297 // Return whether this segment has any dynamic relocs.
4298
4299 bool
has_dynamic_reloc() const4300 Output_segment::has_dynamic_reloc() const
4301 {
4302 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4303 if (this->has_dynamic_reloc_list(&this->output_lists_[i]))
4304 return true;
4305 return false;
4306 }
4307
4308 // Return whether this Output_data_list has any dynamic relocs.
4309
4310 bool
has_dynamic_reloc_list(const Output_data_list * pdl) const4311 Output_segment::has_dynamic_reloc_list(const Output_data_list* pdl) const
4312 {
4313 for (Output_data_list::const_iterator p = pdl->begin();
4314 p != pdl->end();
4315 ++p)
4316 if ((*p)->has_dynamic_reloc())
4317 return true;
4318 return false;
4319 }
4320
4321 // Set the section addresses for an Output_segment. If RESET is true,
4322 // reset the addresses first. ADDR is the address and *POFF is the
4323 // file offset. Set the section indexes starting with *PSHNDX.
4324 // INCREASE_RELRO is the size of the portion of the first non-relro
4325 // section that should be included in the PT_GNU_RELRO segment.
4326 // If this segment has relro sections, and has been aligned for
4327 // that purpose, set *HAS_RELRO to TRUE. Return the address of
4328 // the immediately following segment. Update *HAS_RELRO, *POFF,
4329 // and *PSHNDX.
4330
4331 uint64_t
set_section_addresses(const Target * target,Layout * layout,bool reset,uint64_t addr,unsigned int * increase_relro,bool * has_relro,off_t * poff,unsigned int * pshndx)4332 Output_segment::set_section_addresses(const Target* target,
4333 Layout* layout, bool reset,
4334 uint64_t addr,
4335 unsigned int* increase_relro,
4336 bool* has_relro,
4337 off_t* poff,
4338 unsigned int* pshndx)
4339 {
4340 gold_assert(this->type_ == elfcpp::PT_LOAD);
4341
4342 uint64_t last_relro_pad = 0;
4343 off_t orig_off = *poff;
4344
4345 bool in_tls = false;
4346
4347 // If we have relro sections, we need to pad forward now so that the
4348 // relro sections plus INCREASE_RELRO end on an abi page boundary.
4349 if (parameters->options().relro()
4350 && this->is_first_section_relro()
4351 && (!this->are_addresses_set_ || reset))
4352 {
4353 uint64_t relro_size = 0;
4354 off_t off = *poff;
4355 uint64_t max_align = 0;
4356 for (int i = 0; i <= static_cast<int>(ORDER_RELRO_LAST); ++i)
4357 {
4358 Output_data_list* pdl = &this->output_lists_[i];
4359 Output_data_list::iterator p;
4360 for (p = pdl->begin(); p != pdl->end(); ++p)
4361 {
4362 if (!(*p)->is_section())
4363 break;
4364 uint64_t align = (*p)->addralign();
4365 if (align > max_align)
4366 max_align = align;
4367 if ((*p)->is_section_flag_set(elfcpp::SHF_TLS))
4368 in_tls = true;
4369 else if (in_tls)
4370 {
4371 // Align the first non-TLS section to the alignment
4372 // of the TLS segment.
4373 align = max_align;
4374 in_tls = false;
4375 }
4376 // Ignore the size of the .tbss section.
4377 if ((*p)->is_section_flag_set(elfcpp::SHF_TLS)
4378 && (*p)->is_section_type(elfcpp::SHT_NOBITS))
4379 continue;
4380 relro_size = align_address(relro_size, align);
4381 if ((*p)->is_address_valid())
4382 relro_size += (*p)->data_size();
4383 else
4384 {
4385 // FIXME: This could be faster.
4386 (*p)->set_address_and_file_offset(relro_size,
4387 relro_size);
4388 relro_size += (*p)->data_size();
4389 (*p)->reset_address_and_file_offset();
4390 }
4391 }
4392 if (p != pdl->end())
4393 break;
4394 }
4395 relro_size += *increase_relro;
4396 // Pad the total relro size to a multiple of the maximum
4397 // section alignment seen.
4398 uint64_t aligned_size = align_address(relro_size, max_align);
4399 // Note the amount of padding added after the last relro section.
4400 last_relro_pad = aligned_size - relro_size;
4401 *has_relro = true;
4402
4403 uint64_t page_align = parameters->target().abi_pagesize();
4404
4405 // Align to offset N such that (N + RELRO_SIZE) % PAGE_ALIGN == 0.
4406 uint64_t desired_align = page_align - (aligned_size % page_align);
4407 if (desired_align < off % page_align)
4408 off += page_align;
4409 off += desired_align - off % page_align;
4410 addr += off - orig_off;
4411 orig_off = off;
4412 *poff = off;
4413 }
4414
4415 if (!reset && this->are_addresses_set_)
4416 {
4417 gold_assert(this->paddr_ == addr);
4418 addr = this->vaddr_;
4419 }
4420 else
4421 {
4422 this->vaddr_ = addr;
4423 this->paddr_ = addr;
4424 this->are_addresses_set_ = true;
4425 }
4426
4427 in_tls = false;
4428
4429 this->offset_ = orig_off;
4430
4431 off_t off = 0;
4432 uint64_t ret;
4433 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4434 {
4435 if (i == static_cast<int>(ORDER_RELRO_LAST))
4436 {
4437 *poff += last_relro_pad;
4438 addr += last_relro_pad;
4439 if (this->output_lists_[i].empty())
4440 {
4441 // If there is nothing in the ORDER_RELRO_LAST list,
4442 // the padding will occur at the end of the relro
4443 // segment, and we need to add it to *INCREASE_RELRO.
4444 *increase_relro += last_relro_pad;
4445 }
4446 }
4447 addr = this->set_section_list_addresses(layout, reset,
4448 &this->output_lists_[i],
4449 addr, poff, pshndx, &in_tls);
4450 if (i < static_cast<int>(ORDER_SMALL_BSS))
4451 {
4452 this->filesz_ = *poff - orig_off;
4453 off = *poff;
4454 }
4455
4456 ret = addr;
4457 }
4458
4459 // If the last section was a TLS section, align upward to the
4460 // alignment of the TLS segment, so that the overall size of the TLS
4461 // segment is aligned.
4462 if (in_tls)
4463 {
4464 uint64_t segment_align = layout->tls_segment()->maximum_alignment();
4465 *poff = align_address(*poff, segment_align);
4466 }
4467
4468 this->memsz_ = *poff - orig_off;
4469
4470 // Ignore the file offset adjustments made by the BSS Output_data
4471 // objects.
4472 *poff = off;
4473
4474 // If code segments must contain only code, and this code segment is
4475 // page-aligned in the file, then fill it out to a whole page with
4476 // code fill (the tail of the segment will not be within any section).
4477 // Thus the entire code segment can be mapped from the file as whole
4478 // pages and that mapping will contain only valid instructions.
4479 if (target->isolate_execinstr() && (this->flags() & elfcpp::PF_X) != 0)
4480 {
4481 uint64_t abi_pagesize = target->abi_pagesize();
4482 if (orig_off % abi_pagesize == 0 && off % abi_pagesize != 0)
4483 {
4484 size_t fill_size = abi_pagesize - (off % abi_pagesize);
4485
4486 std::string fill_data;
4487 if (target->has_code_fill())
4488 fill_data = target->code_fill(fill_size);
4489 else
4490 fill_data.resize(fill_size); // Zero fill.
4491
4492 Output_data_const* fill = new Output_data_const(fill_data, 0);
4493 fill->set_address(this->vaddr_ + this->memsz_);
4494 fill->set_file_offset(off);
4495 layout->add_relax_output(fill);
4496
4497 off += fill_size;
4498 gold_assert(off % abi_pagesize == 0);
4499 ret += fill_size;
4500 gold_assert(ret % abi_pagesize == 0);
4501
4502 gold_assert((uint64_t) this->filesz_ == this->memsz_);
4503 this->memsz_ = this->filesz_ += fill_size;
4504
4505 *poff = off;
4506 }
4507 }
4508
4509 return ret;
4510 }
4511
4512 // Set the addresses and file offsets in a list of Output_data
4513 // structures.
4514
4515 uint64_t
set_section_list_addresses(Layout * layout,bool reset,Output_data_list * pdl,uint64_t addr,off_t * poff,unsigned int * pshndx,bool * in_tls)4516 Output_segment::set_section_list_addresses(Layout* layout, bool reset,
4517 Output_data_list* pdl,
4518 uint64_t addr, off_t* poff,
4519 unsigned int* pshndx,
4520 bool* in_tls)
4521 {
4522 off_t startoff = *poff;
4523 // For incremental updates, we may allocate non-fixed sections from
4524 // free space in the file. This keeps track of the high-water mark.
4525 off_t maxoff = startoff;
4526
4527 off_t off = startoff;
4528 for (Output_data_list::iterator p = pdl->begin();
4529 p != pdl->end();
4530 ++p)
4531 {
4532 if (reset)
4533 (*p)->reset_address_and_file_offset();
4534
4535 // When doing an incremental update or when using a linker script,
4536 // the section will most likely already have an address.
4537 if (!(*p)->is_address_valid())
4538 {
4539 uint64_t align = (*p)->addralign();
4540
4541 if ((*p)->is_section_flag_set(elfcpp::SHF_TLS))
4542 {
4543 // Give the first TLS section the alignment of the
4544 // entire TLS segment. Otherwise the TLS segment as a
4545 // whole may be misaligned.
4546 if (!*in_tls)
4547 {
4548 Output_segment* tls_segment = layout->tls_segment();
4549 gold_assert(tls_segment != NULL);
4550 uint64_t segment_align = tls_segment->maximum_alignment();
4551 gold_assert(segment_align >= align);
4552 align = segment_align;
4553
4554 *in_tls = true;
4555 }
4556 }
4557 else
4558 {
4559 // If this is the first section after the TLS segment,
4560 // align it to at least the alignment of the TLS
4561 // segment, so that the size of the overall TLS segment
4562 // is aligned.
4563 if (*in_tls)
4564 {
4565 uint64_t segment_align =
4566 layout->tls_segment()->maximum_alignment();
4567 if (segment_align > align)
4568 align = segment_align;
4569
4570 *in_tls = false;
4571 }
4572 }
4573
4574 if (!parameters->incremental_update())
4575 {
4576 off = align_address(off, align);
4577 (*p)->set_address_and_file_offset(addr + (off - startoff), off);
4578 }
4579 else
4580 {
4581 // Incremental update: allocate file space from free list.
4582 (*p)->pre_finalize_data_size();
4583 off_t current_size = (*p)->current_data_size();
4584 off = layout->allocate(current_size, align, startoff);
4585 if (off == -1)
4586 {
4587 gold_assert((*p)->output_section() != NULL);
4588 gold_fallback(_("out of patch space for section %s; "
4589 "relink with --incremental-full"),
4590 (*p)->output_section()->name());
4591 }
4592 (*p)->set_address_and_file_offset(addr + (off - startoff), off);
4593 if ((*p)->data_size() > current_size)
4594 {
4595 gold_assert((*p)->output_section() != NULL);
4596 gold_fallback(_("%s: section changed size; "
4597 "relink with --incremental-full"),
4598 (*p)->output_section()->name());
4599 }
4600 }
4601 }
4602 else if (parameters->incremental_update())
4603 {
4604 // For incremental updates, use the fixed offset for the
4605 // high-water mark computation.
4606 off = (*p)->offset();
4607 }
4608 else
4609 {
4610 // The script may have inserted a skip forward, but it
4611 // better not have moved backward.
4612 if ((*p)->address() >= addr + (off - startoff))
4613 off += (*p)->address() - (addr + (off - startoff));
4614 else
4615 {
4616 if (!layout->script_options()->saw_sections_clause())
4617 gold_unreachable();
4618 else
4619 {
4620 Output_section* os = (*p)->output_section();
4621
4622 // Cast to unsigned long long to avoid format warnings.
4623 unsigned long long previous_dot =
4624 static_cast<unsigned long long>(addr + (off - startoff));
4625 unsigned long long dot =
4626 static_cast<unsigned long long>((*p)->address());
4627
4628 if (os == NULL)
4629 gold_error(_("dot moves backward in linker script "
4630 "from 0x%llx to 0x%llx"), previous_dot, dot);
4631 else
4632 gold_error(_("address of section '%s' moves backward "
4633 "from 0x%llx to 0x%llx"),
4634 os->name(), previous_dot, dot);
4635 }
4636 }
4637 (*p)->set_file_offset(off);
4638 (*p)->finalize_data_size();
4639 }
4640
4641 if (parameters->incremental_update())
4642 gold_debug(DEBUG_INCREMENTAL,
4643 "set_section_list_addresses: %08lx %08lx %s",
4644 static_cast<long>(off),
4645 static_cast<long>((*p)->data_size()),
4646 ((*p)->output_section() != NULL
4647 ? (*p)->output_section()->name() : "(special)"));
4648
4649 // We want to ignore the size of a SHF_TLS SHT_NOBITS
4650 // section. Such a section does not affect the size of a
4651 // PT_LOAD segment.
4652 if (!(*p)->is_section_flag_set(elfcpp::SHF_TLS)
4653 || !(*p)->is_section_type(elfcpp::SHT_NOBITS))
4654 off += (*p)->data_size();
4655
4656 if (off > maxoff)
4657 maxoff = off;
4658
4659 if ((*p)->is_section())
4660 {
4661 (*p)->set_out_shndx(*pshndx);
4662 ++*pshndx;
4663 }
4664 }
4665
4666 *poff = maxoff;
4667 return addr + (maxoff - startoff);
4668 }
4669
4670 // For a non-PT_LOAD segment, set the offset from the sections, if
4671 // any. Add INCREASE to the file size and the memory size.
4672
4673 void
set_offset(unsigned int increase)4674 Output_segment::set_offset(unsigned int increase)
4675 {
4676 gold_assert(this->type_ != elfcpp::PT_LOAD);
4677
4678 gold_assert(!this->are_addresses_set_);
4679
4680 // A non-load section only uses output_lists_[0].
4681
4682 Output_data_list* pdl = &this->output_lists_[0];
4683
4684 if (pdl->empty())
4685 {
4686 gold_assert(increase == 0);
4687 this->vaddr_ = 0;
4688 this->paddr_ = 0;
4689 this->are_addresses_set_ = true;
4690 this->memsz_ = 0;
4691 this->min_p_align_ = 0;
4692 this->offset_ = 0;
4693 this->filesz_ = 0;
4694 return;
4695 }
4696
4697 // Find the first and last section by address.
4698 const Output_data* first = NULL;
4699 const Output_data* last_data = NULL;
4700 const Output_data* last_bss = NULL;
4701 for (Output_data_list::const_iterator p = pdl->begin();
4702 p != pdl->end();
4703 ++p)
4704 {
4705 if (first == NULL
4706 || (*p)->address() < first->address()
4707 || ((*p)->address() == first->address()
4708 && (*p)->data_size() < first->data_size()))
4709 first = *p;
4710 const Output_data** plast;
4711 if ((*p)->is_section()
4712 && (*p)->output_section()->type() == elfcpp::SHT_NOBITS)
4713 plast = &last_bss;
4714 else
4715 plast = &last_data;
4716 if (*plast == NULL
4717 || (*p)->address() > (*plast)->address()
4718 || ((*p)->address() == (*plast)->address()
4719 && (*p)->data_size() > (*plast)->data_size()))
4720 *plast = *p;
4721 }
4722
4723 this->vaddr_ = first->address();
4724 this->paddr_ = (first->has_load_address()
4725 ? first->load_address()
4726 : this->vaddr_);
4727 this->are_addresses_set_ = true;
4728 this->offset_ = first->offset();
4729
4730 if (last_data == NULL)
4731 this->filesz_ = 0;
4732 else
4733 this->filesz_ = (last_data->address()
4734 + last_data->data_size()
4735 - this->vaddr_);
4736
4737 const Output_data* last = last_bss != NULL ? last_bss : last_data;
4738 this->memsz_ = (last->address()
4739 + last->data_size()
4740 - this->vaddr_);
4741
4742 this->filesz_ += increase;
4743 this->memsz_ += increase;
4744
4745 // If this is a RELRO segment, verify that the segment ends at a
4746 // page boundary.
4747 if (this->type_ == elfcpp::PT_GNU_RELRO)
4748 {
4749 uint64_t page_align = parameters->target().abi_pagesize();
4750 uint64_t segment_end = this->vaddr_ + this->memsz_;
4751 if (parameters->incremental_update())
4752 {
4753 // The INCREASE_RELRO calculation is bypassed for an incremental
4754 // update, so we need to adjust the segment size manually here.
4755 segment_end = align_address(segment_end, page_align);
4756 this->memsz_ = segment_end - this->vaddr_;
4757 }
4758 else
4759 gold_assert(segment_end == align_address(segment_end, page_align));
4760 }
4761
4762 // If this is a TLS segment, align the memory size. The code in
4763 // set_section_list ensures that the section after the TLS segment
4764 // is aligned to give us room.
4765 if (this->type_ == elfcpp::PT_TLS)
4766 {
4767 uint64_t segment_align = this->maximum_alignment();
4768 gold_assert(this->vaddr_ == align_address(this->vaddr_, segment_align));
4769 this->memsz_ = align_address(this->memsz_, segment_align);
4770 }
4771 }
4772
4773 // Set the TLS offsets of the sections in the PT_TLS segment.
4774
4775 void
set_tls_offsets()4776 Output_segment::set_tls_offsets()
4777 {
4778 gold_assert(this->type_ == elfcpp::PT_TLS);
4779
4780 for (Output_data_list::iterator p = this->output_lists_[0].begin();
4781 p != this->output_lists_[0].end();
4782 ++p)
4783 (*p)->set_tls_offset(this->vaddr_);
4784 }
4785
4786 // Return the first section.
4787
4788 Output_section*
first_section() const4789 Output_segment::first_section() const
4790 {
4791 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4792 {
4793 const Output_data_list* pdl = &this->output_lists_[i];
4794 for (Output_data_list::const_iterator p = pdl->begin();
4795 p != pdl->end();
4796 ++p)
4797 {
4798 if ((*p)->is_section())
4799 return (*p)->output_section();
4800 }
4801 }
4802 gold_unreachable();
4803 }
4804
4805 // Return the number of Output_sections in an Output_segment.
4806
4807 unsigned int
output_section_count() const4808 Output_segment::output_section_count() const
4809 {
4810 unsigned int ret = 0;
4811 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4812 ret += this->output_section_count_list(&this->output_lists_[i]);
4813 return ret;
4814 }
4815
4816 // Return the number of Output_sections in an Output_data_list.
4817
4818 unsigned int
output_section_count_list(const Output_data_list * pdl) const4819 Output_segment::output_section_count_list(const Output_data_list* pdl) const
4820 {
4821 unsigned int count = 0;
4822 for (Output_data_list::const_iterator p = pdl->begin();
4823 p != pdl->end();
4824 ++p)
4825 {
4826 if ((*p)->is_section())
4827 ++count;
4828 }
4829 return count;
4830 }
4831
4832 // Return the section attached to the list segment with the lowest
4833 // load address. This is used when handling a PHDRS clause in a
4834 // linker script.
4835
4836 Output_section*
section_with_lowest_load_address() const4837 Output_segment::section_with_lowest_load_address() const
4838 {
4839 Output_section* found = NULL;
4840 uint64_t found_lma = 0;
4841 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4842 this->lowest_load_address_in_list(&this->output_lists_[i], &found,
4843 &found_lma);
4844 return found;
4845 }
4846
4847 // Look through a list for a section with a lower load address.
4848
4849 void
lowest_load_address_in_list(const Output_data_list * pdl,Output_section ** found,uint64_t * found_lma) const4850 Output_segment::lowest_load_address_in_list(const Output_data_list* pdl,
4851 Output_section** found,
4852 uint64_t* found_lma) const
4853 {
4854 for (Output_data_list::const_iterator p = pdl->begin();
4855 p != pdl->end();
4856 ++p)
4857 {
4858 if (!(*p)->is_section())
4859 continue;
4860 Output_section* os = static_cast<Output_section*>(*p);
4861 uint64_t lma = (os->has_load_address()
4862 ? os->load_address()
4863 : os->address());
4864 if (*found == NULL || lma < *found_lma)
4865 {
4866 *found = os;
4867 *found_lma = lma;
4868 }
4869 }
4870 }
4871
4872 // Write the segment data into *OPHDR.
4873
4874 template<int size, bool big_endian>
4875 void
write_header(elfcpp::Phdr_write<size,big_endian> * ophdr)4876 Output_segment::write_header(elfcpp::Phdr_write<size, big_endian>* ophdr)
4877 {
4878 ophdr->put_p_type(this->type_);
4879 ophdr->put_p_offset(this->offset_);
4880 ophdr->put_p_vaddr(this->vaddr_);
4881 ophdr->put_p_paddr(this->paddr_);
4882 ophdr->put_p_filesz(this->filesz_);
4883 ophdr->put_p_memsz(this->memsz_);
4884 ophdr->put_p_flags(this->flags_);
4885 ophdr->put_p_align(std::max(this->min_p_align_, this->maximum_alignment()));
4886 }
4887
4888 // Write the section headers into V.
4889
4890 template<int size, bool big_endian>
4891 unsigned char*
write_section_headers(const Layout * layout,const Stringpool * secnamepool,unsigned char * v,unsigned int * pshndx) const4892 Output_segment::write_section_headers(const Layout* layout,
4893 const Stringpool* secnamepool,
4894 unsigned char* v,
4895 unsigned int* pshndx) const
4896 {
4897 // Every section that is attached to a segment must be attached to a
4898 // PT_LOAD segment, so we only write out section headers for PT_LOAD
4899 // segments.
4900 if (this->type_ != elfcpp::PT_LOAD)
4901 return v;
4902
4903 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4904 {
4905 const Output_data_list* pdl = &this->output_lists_[i];
4906 v = this->write_section_headers_list<size, big_endian>(layout,
4907 secnamepool,
4908 pdl,
4909 v, pshndx);
4910 }
4911
4912 return v;
4913 }
4914
4915 template<int size, bool big_endian>
4916 unsigned char*
write_section_headers_list(const Layout * layout,const Stringpool * secnamepool,const Output_data_list * pdl,unsigned char * v,unsigned int * pshndx) const4917 Output_segment::write_section_headers_list(const Layout* layout,
4918 const Stringpool* secnamepool,
4919 const Output_data_list* pdl,
4920 unsigned char* v,
4921 unsigned int* pshndx) const
4922 {
4923 const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
4924 for (Output_data_list::const_iterator p = pdl->begin();
4925 p != pdl->end();
4926 ++p)
4927 {
4928 if ((*p)->is_section())
4929 {
4930 const Output_section* ps = static_cast<const Output_section*>(*p);
4931 gold_assert(*pshndx == ps->out_shndx());
4932 elfcpp::Shdr_write<size, big_endian> oshdr(v);
4933 ps->write_header(layout, secnamepool, &oshdr);
4934 v += shdr_size;
4935 ++*pshndx;
4936 }
4937 }
4938 return v;
4939 }
4940
4941 // Print the output sections to the map file.
4942
4943 void
print_sections_to_mapfile(Mapfile * mapfile) const4944 Output_segment::print_sections_to_mapfile(Mapfile* mapfile) const
4945 {
4946 if (this->type() != elfcpp::PT_LOAD)
4947 return;
4948 for (int i = 0; i < static_cast<int>(ORDER_MAX); ++i)
4949 this->print_section_list_to_mapfile(mapfile, &this->output_lists_[i]);
4950 }
4951
4952 // Print an output section list to the map file.
4953
4954 void
print_section_list_to_mapfile(Mapfile * mapfile,const Output_data_list * pdl) const4955 Output_segment::print_section_list_to_mapfile(Mapfile* mapfile,
4956 const Output_data_list* pdl) const
4957 {
4958 for (Output_data_list::const_iterator p = pdl->begin();
4959 p != pdl->end();
4960 ++p)
4961 (*p)->print_to_mapfile(mapfile);
4962 }
4963
4964 // Output_file methods.
4965
Output_file(const char * name)4966 Output_file::Output_file(const char* name)
4967 : name_(name),
4968 o_(-1),
4969 file_size_(0),
4970 base_(NULL),
4971 map_is_anonymous_(false),
4972 map_is_allocated_(false),
4973 is_temporary_(false)
4974 {
4975 }
4976
4977 // Try to open an existing file. Returns false if the file doesn't
4978 // exist, has a size of 0 or can't be mmapped. If BASE_NAME is not
4979 // NULL, open that file as the base for incremental linking, and
4980 // copy its contents to the new output file. This routine can
4981 // be called for incremental updates, in which case WRITABLE should
4982 // be true, or by the incremental-dump utility, in which case
4983 // WRITABLE should be false.
4984
4985 bool
open_base_file(const char * base_name,bool writable)4986 Output_file::open_base_file(const char* base_name, bool writable)
4987 {
4988 // The name "-" means "stdout".
4989 if (strcmp(this->name_, "-") == 0)
4990 return false;
4991
4992 bool use_base_file = base_name != NULL;
4993 if (!use_base_file)
4994 base_name = this->name_;
4995 else if (strcmp(base_name, this->name_) == 0)
4996 gold_fatal(_("%s: incremental base and output file name are the same"),
4997 base_name);
4998
4999 // Don't bother opening files with a size of zero.
5000 struct stat s;
5001 if (::stat(base_name, &s) != 0)
5002 {
5003 gold_info(_("%s: stat: %s"), base_name, strerror(errno));
5004 return false;
5005 }
5006 if (s.st_size == 0)
5007 {
5008 gold_info(_("%s: incremental base file is empty"), base_name);
5009 return false;
5010 }
5011
5012 // If we're using a base file, we want to open it read-only.
5013 if (use_base_file)
5014 writable = false;
5015
5016 int oflags = writable ? O_RDWR : O_RDONLY;
5017 int o = open_descriptor(-1, base_name, oflags, 0);
5018 if (o < 0)
5019 {
5020 gold_info(_("%s: open: %s"), base_name, strerror(errno));
5021 return false;
5022 }
5023
5024 // If the base file and the output file are different, open a
5025 // new output file and read the contents from the base file into
5026 // the newly-mapped region.
5027 if (use_base_file)
5028 {
5029 this->open(s.st_size);
5030 ssize_t bytes_to_read = s.st_size;
5031 unsigned char* p = this->base_;
5032 while (bytes_to_read > 0)
5033 {
5034 ssize_t len = ::read(o, p, bytes_to_read);
5035 if (len < 0)
5036 {
5037 gold_info(_("%s: read failed: %s"), base_name, strerror(errno));
5038 return false;
5039 }
5040 if (len == 0)
5041 {
5042 gold_info(_("%s: file too short: read only %lld of %lld bytes"),
5043 base_name,
5044 static_cast<long long>(s.st_size - bytes_to_read),
5045 static_cast<long long>(s.st_size));
5046 return false;
5047 }
5048 p += len;
5049 bytes_to_read -= len;
5050 }
5051 ::close(o);
5052 return true;
5053 }
5054
5055 this->o_ = o;
5056 this->file_size_ = s.st_size;
5057
5058 if (!this->map_no_anonymous(writable))
5059 {
5060 release_descriptor(o, true);
5061 this->o_ = -1;
5062 this->file_size_ = 0;
5063 return false;
5064 }
5065
5066 return true;
5067 }
5068
5069 // Open the output file.
5070
5071 void
open(off_t file_size)5072 Output_file::open(off_t file_size)
5073 {
5074 this->file_size_ = file_size;
5075
5076 // Unlink the file first; otherwise the open() may fail if the file
5077 // is busy (e.g. it's an executable that's currently being executed).
5078 //
5079 // However, the linker may be part of a system where a zero-length
5080 // file is created for it to write to, with tight permissions (gcc
5081 // 2.95 did something like this). Unlinking the file would work
5082 // around those permission controls, so we only unlink if the file
5083 // has a non-zero size. We also unlink only regular files to avoid
5084 // trouble with directories/etc.
5085 //
5086 // If we fail, continue; this command is merely a best-effort attempt
5087 // to improve the odds for open().
5088
5089 // We let the name "-" mean "stdout"
5090 if (!this->is_temporary_)
5091 {
5092 if (strcmp(this->name_, "-") == 0)
5093 this->o_ = STDOUT_FILENO;
5094 else
5095 {
5096 struct stat s;
5097 if (::stat(this->name_, &s) == 0
5098 && (S_ISREG (s.st_mode) || S_ISLNK (s.st_mode)))
5099 {
5100 if (s.st_size != 0)
5101 ::unlink(this->name_);
5102 else if (!parameters->options().relocatable())
5103 {
5104 // If we don't unlink the existing file, add execute
5105 // permission where read permissions already exist
5106 // and where the umask permits.
5107 int mask = ::umask(0);
5108 ::umask(mask);
5109 s.st_mode |= (s.st_mode & 0444) >> 2;
5110 ::chmod(this->name_, s.st_mode & ~mask);
5111 }
5112 }
5113
5114 int mode = parameters->options().relocatable() ? 0666 : 0777;
5115 int o = open_descriptor(-1, this->name_, O_RDWR | O_CREAT | O_TRUNC,
5116 mode);
5117 if (o < 0)
5118 gold_fatal(_("%s: open: %s"), this->name_, strerror(errno));
5119 this->o_ = o;
5120 }
5121 }
5122
5123 this->map();
5124 }
5125
5126 // Resize the output file.
5127
5128 void
resize(off_t file_size)5129 Output_file::resize(off_t file_size)
5130 {
5131 // If the mmap is mapping an anonymous memory buffer, this is easy:
5132 // just mremap to the new size. If it's mapping to a file, we want
5133 // to unmap to flush to the file, then remap after growing the file.
5134 if (this->map_is_anonymous_)
5135 {
5136 void* base;
5137 if (!this->map_is_allocated_)
5138 {
5139 base = ::mremap(this->base_, this->file_size_, file_size,
5140 MREMAP_MAYMOVE);
5141 if (base == MAP_FAILED)
5142 gold_fatal(_("%s: mremap: %s"), this->name_, strerror(errno));
5143 }
5144 else
5145 {
5146 base = realloc(this->base_, file_size);
5147 if (base == NULL)
5148 gold_nomem();
5149 if (file_size > this->file_size_)
5150 memset(static_cast<char*>(base) + this->file_size_, 0,
5151 file_size - this->file_size_);
5152 }
5153 this->base_ = static_cast<unsigned char*>(base);
5154 this->file_size_ = file_size;
5155 }
5156 else
5157 {
5158 this->unmap();
5159 this->file_size_ = file_size;
5160 if (!this->map_no_anonymous(true))
5161 gold_fatal(_("%s: mmap: %s"), this->name_, strerror(errno));
5162 }
5163 }
5164
5165 // Map an anonymous block of memory which will later be written to the
5166 // file. Return whether the map succeeded.
5167
5168 bool
map_anonymous()5169 Output_file::map_anonymous()
5170 {
5171 void* base = ::mmap(NULL, this->file_size_, PROT_READ | PROT_WRITE,
5172 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
5173 if (base == MAP_FAILED)
5174 {
5175 base = malloc(this->file_size_);
5176 if (base == NULL)
5177 return false;
5178 memset(base, 0, this->file_size_);
5179 this->map_is_allocated_ = true;
5180 }
5181 this->base_ = static_cast<unsigned char*>(base);
5182 this->map_is_anonymous_ = true;
5183 return true;
5184 }
5185
5186 // Map the file into memory. Return whether the mapping succeeded.
5187 // If WRITABLE is true, map with write access.
5188
5189 bool
map_no_anonymous(bool writable)5190 Output_file::map_no_anonymous(bool writable)
5191 {
5192 const int o = this->o_;
5193
5194 // If the output file is not a regular file, don't try to mmap it;
5195 // instead, we'll mmap a block of memory (an anonymous buffer), and
5196 // then later write the buffer to the file.
5197 void* base;
5198 struct stat statbuf;
5199 if (o == STDOUT_FILENO || o == STDERR_FILENO
5200 || ::fstat(o, &statbuf) != 0
5201 || !S_ISREG(statbuf.st_mode)
5202 || this->is_temporary_)
5203 return false;
5204
5205 // Ensure that we have disk space available for the file. If we
5206 // don't do this, it is possible that we will call munmap, close,
5207 // and exit with dirty buffers still in the cache with no assigned
5208 // disk blocks. If the disk is out of space at that point, the
5209 // output file will wind up incomplete, but we will have already
5210 // exited. The alternative to fallocate would be to use fdatasync,
5211 // but that would be a more significant performance hit.
5212 if (writable)
5213 {
5214 int err = gold_fallocate(o, 0, this->file_size_);
5215 if (err != 0)
5216 gold_fatal(_("%s: %s"), this->name_, strerror(err));
5217 }
5218
5219 // Map the file into memory.
5220 int prot = PROT_READ;
5221 if (writable)
5222 prot |= PROT_WRITE;
5223 base = ::mmap(NULL, this->file_size_, prot, MAP_SHARED, o, 0);
5224
5225 // The mmap call might fail because of file system issues: the file
5226 // system might not support mmap at all, or it might not support
5227 // mmap with PROT_WRITE.
5228 if (base == MAP_FAILED)
5229 return false;
5230
5231 this->map_is_anonymous_ = false;
5232 this->base_ = static_cast<unsigned char*>(base);
5233 return true;
5234 }
5235
5236 // Map the file into memory.
5237
5238 void
map()5239 Output_file::map()
5240 {
5241 if (parameters->options().mmap_output_file()
5242 && this->map_no_anonymous(true))
5243 return;
5244
5245 // The mmap call might fail because of file system issues: the file
5246 // system might not support mmap at all, or it might not support
5247 // mmap with PROT_WRITE. I'm not sure which errno values we will
5248 // see in all cases, so if the mmap fails for any reason and we
5249 // don't care about file contents, try for an anonymous map.
5250 if (this->map_anonymous())
5251 return;
5252
5253 gold_fatal(_("%s: mmap: failed to allocate %lu bytes for output file: %s"),
5254 this->name_, static_cast<unsigned long>(this->file_size_),
5255 strerror(errno));
5256 }
5257
5258 // Unmap the file from memory.
5259
5260 void
unmap()5261 Output_file::unmap()
5262 {
5263 if (this->map_is_anonymous_)
5264 {
5265 // We've already written out the data, so there is no reason to
5266 // waste time unmapping or freeing the memory.
5267 }
5268 else
5269 {
5270 if (::munmap(this->base_, this->file_size_) < 0)
5271 gold_error(_("%s: munmap: %s"), this->name_, strerror(errno));
5272 }
5273 this->base_ = NULL;
5274 }
5275
5276 // Close the output file.
5277
5278 void
close()5279 Output_file::close()
5280 {
5281 // If the map isn't file-backed, we need to write it now.
5282 if (this->map_is_anonymous_ && !this->is_temporary_)
5283 {
5284 size_t bytes_to_write = this->file_size_;
5285 size_t offset = 0;
5286 while (bytes_to_write > 0)
5287 {
5288 ssize_t bytes_written = ::write(this->o_, this->base_ + offset,
5289 bytes_to_write);
5290 if (bytes_written == 0)
5291 gold_error(_("%s: write: unexpected 0 return-value"), this->name_);
5292 else if (bytes_written < 0)
5293 gold_error(_("%s: write: %s"), this->name_, strerror(errno));
5294 else
5295 {
5296 bytes_to_write -= bytes_written;
5297 offset += bytes_written;
5298 }
5299 }
5300 }
5301 this->unmap();
5302
5303 // We don't close stdout or stderr
5304 if (this->o_ != STDOUT_FILENO
5305 && this->o_ != STDERR_FILENO
5306 && !this->is_temporary_)
5307 if (::close(this->o_) < 0)
5308 gold_error(_("%s: close: %s"), this->name_, strerror(errno));
5309 this->o_ = -1;
5310 }
5311
5312 // Instantiate the templates we need. We could use the configure
5313 // script to restrict this to only the ones for implemented targets.
5314
5315 #ifdef HAVE_TARGET_32_LITTLE
5316 template
5317 off_t
5318 Output_section::add_input_section<32, false>(
5319 Layout* layout,
5320 Sized_relobj_file<32, false>* object,
5321 unsigned int shndx,
5322 const char* secname,
5323 const elfcpp::Shdr<32, false>& shdr,
5324 unsigned int reloc_shndx,
5325 bool have_sections_script);
5326 #endif
5327
5328 #ifdef HAVE_TARGET_32_BIG
5329 template
5330 off_t
5331 Output_section::add_input_section<32, true>(
5332 Layout* layout,
5333 Sized_relobj_file<32, true>* object,
5334 unsigned int shndx,
5335 const char* secname,
5336 const elfcpp::Shdr<32, true>& shdr,
5337 unsigned int reloc_shndx,
5338 bool have_sections_script);
5339 #endif
5340
5341 #ifdef HAVE_TARGET_64_LITTLE
5342 template
5343 off_t
5344 Output_section::add_input_section<64, false>(
5345 Layout* layout,
5346 Sized_relobj_file<64, false>* object,
5347 unsigned int shndx,
5348 const char* secname,
5349 const elfcpp::Shdr<64, false>& shdr,
5350 unsigned int reloc_shndx,
5351 bool have_sections_script);
5352 #endif
5353
5354 #ifdef HAVE_TARGET_64_BIG
5355 template
5356 off_t
5357 Output_section::add_input_section<64, true>(
5358 Layout* layout,
5359 Sized_relobj_file<64, true>* object,
5360 unsigned int shndx,
5361 const char* secname,
5362 const elfcpp::Shdr<64, true>& shdr,
5363 unsigned int reloc_shndx,
5364 bool have_sections_script);
5365 #endif
5366
5367 #ifdef HAVE_TARGET_32_LITTLE
5368 template
5369 class Output_reloc<elfcpp::SHT_REL, false, 32, false>;
5370 #endif
5371
5372 #ifdef HAVE_TARGET_32_BIG
5373 template
5374 class Output_reloc<elfcpp::SHT_REL, false, 32, true>;
5375 #endif
5376
5377 #ifdef HAVE_TARGET_64_LITTLE
5378 template
5379 class Output_reloc<elfcpp::SHT_REL, false, 64, false>;
5380 #endif
5381
5382 #ifdef HAVE_TARGET_64_BIG
5383 template
5384 class Output_reloc<elfcpp::SHT_REL, false, 64, true>;
5385 #endif
5386
5387 #ifdef HAVE_TARGET_32_LITTLE
5388 template
5389 class Output_reloc<elfcpp::SHT_REL, true, 32, false>;
5390 #endif
5391
5392 #ifdef HAVE_TARGET_32_BIG
5393 template
5394 class Output_reloc<elfcpp::SHT_REL, true, 32, true>;
5395 #endif
5396
5397 #ifdef HAVE_TARGET_64_LITTLE
5398 template
5399 class Output_reloc<elfcpp::SHT_REL, true, 64, false>;
5400 #endif
5401
5402 #ifdef HAVE_TARGET_64_BIG
5403 template
5404 class Output_reloc<elfcpp::SHT_REL, true, 64, true>;
5405 #endif
5406
5407 #ifdef HAVE_TARGET_32_LITTLE
5408 template
5409 class Output_reloc<elfcpp::SHT_RELA, false, 32, false>;
5410 #endif
5411
5412 #ifdef HAVE_TARGET_32_BIG
5413 template
5414 class Output_reloc<elfcpp::SHT_RELA, false, 32, true>;
5415 #endif
5416
5417 #ifdef HAVE_TARGET_64_LITTLE
5418 template
5419 class Output_reloc<elfcpp::SHT_RELA, false, 64, false>;
5420 #endif
5421
5422 #ifdef HAVE_TARGET_64_BIG
5423 template
5424 class Output_reloc<elfcpp::SHT_RELA, false, 64, true>;
5425 #endif
5426
5427 #ifdef HAVE_TARGET_32_LITTLE
5428 template
5429 class Output_reloc<elfcpp::SHT_RELA, true, 32, false>;
5430 #endif
5431
5432 #ifdef HAVE_TARGET_32_BIG
5433 template
5434 class Output_reloc<elfcpp::SHT_RELA, true, 32, true>;
5435 #endif
5436
5437 #ifdef HAVE_TARGET_64_LITTLE
5438 template
5439 class Output_reloc<elfcpp::SHT_RELA, true, 64, false>;
5440 #endif
5441
5442 #ifdef HAVE_TARGET_64_BIG
5443 template
5444 class Output_reloc<elfcpp::SHT_RELA, true, 64, true>;
5445 #endif
5446
5447 #ifdef HAVE_TARGET_32_LITTLE
5448 template
5449 class Output_data_reloc<elfcpp::SHT_REL, false, 32, false>;
5450 #endif
5451
5452 #ifdef HAVE_TARGET_32_BIG
5453 template
5454 class Output_data_reloc<elfcpp::SHT_REL, false, 32, true>;
5455 #endif
5456
5457 #ifdef HAVE_TARGET_64_LITTLE
5458 template
5459 class Output_data_reloc<elfcpp::SHT_REL, false, 64, false>;
5460 #endif
5461
5462 #ifdef HAVE_TARGET_64_BIG
5463 template
5464 class Output_data_reloc<elfcpp::SHT_REL, false, 64, true>;
5465 #endif
5466
5467 #ifdef HAVE_TARGET_32_LITTLE
5468 template
5469 class Output_data_reloc<elfcpp::SHT_REL, true, 32, false>;
5470 #endif
5471
5472 #ifdef HAVE_TARGET_32_BIG
5473 template
5474 class Output_data_reloc<elfcpp::SHT_REL, true, 32, true>;
5475 #endif
5476
5477 #ifdef HAVE_TARGET_64_LITTLE
5478 template
5479 class Output_data_reloc<elfcpp::SHT_REL, true, 64, false>;
5480 #endif
5481
5482 #ifdef HAVE_TARGET_64_BIG
5483 template
5484 class Output_data_reloc<elfcpp::SHT_REL, true, 64, true>;
5485 #endif
5486
5487 #ifdef HAVE_TARGET_32_LITTLE
5488 template
5489 class Output_data_reloc<elfcpp::SHT_RELA, false, 32, false>;
5490 #endif
5491
5492 #ifdef HAVE_TARGET_32_BIG
5493 template
5494 class Output_data_reloc<elfcpp::SHT_RELA, false, 32, true>;
5495 #endif
5496
5497 #ifdef HAVE_TARGET_64_LITTLE
5498 template
5499 class Output_data_reloc<elfcpp::SHT_RELA, false, 64, false>;
5500 #endif
5501
5502 #ifdef HAVE_TARGET_64_BIG
5503 template
5504 class Output_data_reloc<elfcpp::SHT_RELA, false, 64, true>;
5505 #endif
5506
5507 #ifdef HAVE_TARGET_32_LITTLE
5508 template
5509 class Output_data_reloc<elfcpp::SHT_RELA, true, 32, false>;
5510 #endif
5511
5512 #ifdef HAVE_TARGET_32_BIG
5513 template
5514 class Output_data_reloc<elfcpp::SHT_RELA, true, 32, true>;
5515 #endif
5516
5517 #ifdef HAVE_TARGET_64_LITTLE
5518 template
5519 class Output_data_reloc<elfcpp::SHT_RELA, true, 64, false>;
5520 #endif
5521
5522 #ifdef HAVE_TARGET_64_BIG
5523 template
5524 class Output_data_reloc<elfcpp::SHT_RELA, true, 64, true>;
5525 #endif
5526
5527 #ifdef HAVE_TARGET_32_LITTLE
5528 template
5529 class Output_data_reloc<elfcpp::SHT_RELR, true, 32, false>;
5530 #endif
5531
5532 #ifdef HAVE_TARGET_32_BIG
5533 template
5534 class Output_data_reloc<elfcpp::SHT_RELR, true, 32, true>;
5535 #endif
5536
5537 #ifdef HAVE_TARGET_64_LITTLE
5538 template
5539 class Output_data_reloc<elfcpp::SHT_RELR, true, 64, false>;
5540 #endif
5541
5542 #ifdef HAVE_TARGET_64_BIG
5543 template
5544 class Output_data_reloc<elfcpp::SHT_RELR, true, 64, true>;
5545 #endif
5546
5547 #ifdef HAVE_TARGET_32_LITTLE
5548 template
5549 class Output_relocatable_relocs<elfcpp::SHT_REL, 32, false>;
5550 #endif
5551
5552 #ifdef HAVE_TARGET_32_BIG
5553 template
5554 class Output_relocatable_relocs<elfcpp::SHT_REL, 32, true>;
5555 #endif
5556
5557 #ifdef HAVE_TARGET_64_LITTLE
5558 template
5559 class Output_relocatable_relocs<elfcpp::SHT_REL, 64, false>;
5560 #endif
5561
5562 #ifdef HAVE_TARGET_64_BIG
5563 template
5564 class Output_relocatable_relocs<elfcpp::SHT_REL, 64, true>;
5565 #endif
5566
5567 #ifdef HAVE_TARGET_32_LITTLE
5568 template
5569 class Output_relocatable_relocs<elfcpp::SHT_RELA, 32, false>;
5570 #endif
5571
5572 #ifdef HAVE_TARGET_32_BIG
5573 template
5574 class Output_relocatable_relocs<elfcpp::SHT_RELA, 32, true>;
5575 #endif
5576
5577 #ifdef HAVE_TARGET_64_LITTLE
5578 template
5579 class Output_relocatable_relocs<elfcpp::SHT_RELA, 64, false>;
5580 #endif
5581
5582 #ifdef HAVE_TARGET_64_BIG
5583 template
5584 class Output_relocatable_relocs<elfcpp::SHT_RELA, 64, true>;
5585 #endif
5586
5587 #ifdef HAVE_TARGET_32_LITTLE
5588 template
5589 class Output_data_group<32, false>;
5590 #endif
5591
5592 #ifdef HAVE_TARGET_32_BIG
5593 template
5594 class Output_data_group<32, true>;
5595 #endif
5596
5597 #ifdef HAVE_TARGET_64_LITTLE
5598 template
5599 class Output_data_group<64, false>;
5600 #endif
5601
5602 #ifdef HAVE_TARGET_64_BIG
5603 template
5604 class Output_data_group<64, true>;
5605 #endif
5606
5607 template
5608 class Output_data_got<32, false>;
5609
5610 template
5611 class Output_data_got<32, true>;
5612
5613 template
5614 class Output_data_got<64, false>;
5615
5616 template
5617 class Output_data_got<64, true>;
5618
5619 } // End namespace gold.
5620