*** empty log message ***
[deliverable/binutils-gdb.git] / gold / script-sections.cc
CommitLineData
494e05f4
ILT
1// script-sections.cc -- linker script SECTIONS for gold
2
0aa45fac 3// Copyright 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
494e05f4
ILT
4// Written by Ian Lance Taylor <iant@google.com>.
5
6// This file is part of gold.
7
8// This program is free software; you can redistribute it and/or modify
9// it under the terms of the GNU General Public License as published by
10// the Free Software Foundation; either version 3 of the License, or
11// (at your option) any later version.
12
13// This program is distributed in the hope that it will be useful,
14// but WITHOUT ANY WARRANTY; without even the implied warranty of
15// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16// GNU General Public License for more details.
17
18// You should have received a copy of the GNU General Public License
19// along with this program; if not, write to the Free Software
20// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21// MA 02110-1301, USA.
22
23#include "gold.h"
24
a445fddf
ILT
25#include <cstring>
26#include <algorithm>
27#include <list>
1c4f3631 28#include <map>
494e05f4
ILT
29#include <string>
30#include <vector>
a445fddf 31#include <fnmatch.h>
494e05f4 32
a445fddf
ILT
33#include "parameters.h"
34#include "object.h"
35#include "layout.h"
36#include "output.h"
494e05f4
ILT
37#include "script-c.h"
38#include "script.h"
39#include "script-sections.h"
40
41// Support for the SECTIONS clause in linker scripts.
42
43namespace gold
44{
45
7f8cd844
NC
46// A region of memory.
47class Memory_region
48{
49 public:
50 Memory_region(const char* name, size_t namelen, unsigned int attributes,
51 Expression* start, Expression* length)
52 : name_(name, namelen),
53 attributes_(attributes),
54 start_(start),
55 length_(length),
ea5cae92 56 current_offset_(0),
4ef28648 57 vma_sections_(),
ea5cae92
NC
58 lma_sections_(),
59 last_section_(NULL)
7f8cd844
NC
60 { }
61
62 // Return the name of this region.
63 const std::string&
64 name() const
65 { return this->name_; }
66
67 // Return the start address of this region.
68 Expression*
69 start_address() const
70 { return this->start_; }
71
72 // Return the length of this region.
73 Expression*
74 length() const
75 { return this->length_; }
76
77 // Print the region (when debugging).
78 void
79 print(FILE*) const;
80
81 // Return true if <name,namelen> matches this region.
82 bool
83 name_match(const char* name, size_t namelen)
84 {
85 return (this->name_.length() == namelen
86 && strncmp(this->name_.c_str(), name, namelen) == 0);
87 }
88
89 Expression*
ea5cae92 90 get_current_address() const
7f8cd844
NC
91 {
92 return
93 script_exp_binary_add(this->start_,
ea5cae92 94 script_exp_integer(this->current_offset_));
7f8cd844
NC
95 }
96
97 void
ea5cae92
NC
98 increment_offset(std::string section_name, uint64_t amount,
99 const Symbol_table* symtab, const Layout* layout)
7f8cd844 100 {
ea5cae92 101 this->current_offset_ += amount;
7f8cd844 102
ea5cae92 103 if (this->current_offset_
7f8cd844 104 > this->length_->eval(symtab, layout, false))
ea5cae92
NC
105 gold_error(_("section %s overflows end of region %s"),
106 section_name.c_str(), this->name_.c_str());
7f8cd844
NC
107 }
108
ea5cae92
NC
109 // Returns true iff there is room left in this region
110 // for AMOUNT more bytes of data.
111 bool
112 has_room_for(const Symbol_table* symtab, const Layout* layout,
113 uint64_t amount) const
7f8cd844 114 {
ea5cae92
NC
115 return (this->current_offset_ + amount
116 < this->length_->eval(symtab, layout, false));
7f8cd844
NC
117 }
118
ea5cae92
NC
119 // Return true if the provided section flags
120 // are compatible with this region's attributes.
121 bool
122 attributes_compatible(elfcpp::Elf_Xword flags, elfcpp::Elf_Xword type) const;
123
7f8cd844
NC
124 void
125 add_section(Output_section_definition* sec, bool vma)
126 {
127 if (vma)
128 this->vma_sections_.push_back(sec);
129 else
130 this->lma_sections_.push_back(sec);
131 }
132
133 typedef std::vector<Output_section_definition*> Section_list;
134
135 // Return the start of the list of sections
136 // whose VMAs are taken from this region.
137 Section_list::const_iterator
ea5cae92 138 get_vma_section_list_start() const
7f8cd844
NC
139 { return this->vma_sections_.begin(); }
140
141 // Return the start of the list of sections
142 // whose LMAs are taken from this region.
143 Section_list::const_iterator
ea5cae92 144 get_lma_section_list_start() const
7f8cd844
NC
145 { return this->lma_sections_.begin(); }
146
147 // Return the end of the list of sections
148 // whose VMAs are taken from this region.
149 Section_list::const_iterator
ea5cae92 150 get_vma_section_list_end() const
7f8cd844
NC
151 { return this->vma_sections_.end(); }
152
153 // Return the end of the list of sections
154 // whose LMAs are taken from this region.
155 Section_list::const_iterator
ea5cae92 156 get_lma_section_list_end() const
7f8cd844
NC
157 { return this->lma_sections_.end(); }
158
ea5cae92
NC
159 Output_section_definition*
160 get_last_section() const
161 { return this->last_section_; }
162
163 void
164 set_last_section(Output_section_definition* sec)
165 { this->last_section_ = sec; }
166
7f8cd844
NC
167 private:
168
169 std::string name_;
170 unsigned int attributes_;
171 Expression* start_;
172 Expression* length_;
ea5cae92
NC
173 // The offset to the next free byte in the region.
174 // Note - for compatibility with GNU LD we only maintain one offset
175 // regardless of whether the region is being used for VMA values,
176 // LMA values, or both.
177 uint64_t current_offset_;
7f8cd844
NC
178 // A list of sections whose VMAs are set inside this region.
179 Section_list vma_sections_;
180 // A list of sections whose LMAs are set inside this region.
181 Section_list lma_sections_;
ea5cae92
NC
182 // The latest section to make use of this region.
183 Output_section_definition* last_section_;
7f8cd844
NC
184};
185
ea5cae92
NC
186// Return true if the provided section flags
187// are compatible with this region's attributes.
188
189bool
190Memory_region::attributes_compatible(elfcpp::Elf_Xword flags,
191 elfcpp::Elf_Xword type) const
192{
193 unsigned int attrs = this->attributes_;
194
195 // No attributes means that this region is not compatible with anything.
196 if (attrs == 0)
197 return false;
198
199 bool match = true;
200 do
201 {
202 switch (attrs & - attrs)
203 {
204 case MEM_EXECUTABLE:
205 if ((flags & elfcpp::SHF_EXECINSTR) == 0)
206 match = false;
207 break;
208
209 case MEM_WRITEABLE:
210 if ((flags & elfcpp::SHF_WRITE) == 0)
211 match = false;
212 break;
213
214 case MEM_READABLE:
215 // All sections are presumed readable.
216 break;
217
218 case MEM_ALLOCATABLE:
219 if ((flags & elfcpp::SHF_ALLOC) == 0)
220 match = false;
221 break;
222
223 case MEM_INITIALIZED:
224 if ((type & elfcpp::SHT_NOBITS) != 0)
225 match = false;
226 break;
227 }
228 attrs &= ~ (attrs & - attrs);
229 }
230 while (attrs != 0);
231
232 return match;
233}
234
7f8cd844
NC
235// Print a memory region.
236
237void
238Memory_region::print(FILE* f) const
239{
240 fprintf(f, " %s", this->name_.c_str());
241
242 unsigned int attrs = this->attributes_;
243 if (attrs != 0)
244 {
245 fprintf(f, " (");
246 do
247 {
248 switch (attrs & - attrs)
249 {
250 case MEM_EXECUTABLE: fputc('x', f); break;
251 case MEM_WRITEABLE: fputc('w', f); break;
252 case MEM_READABLE: fputc('r', f); break;
253 case MEM_ALLOCATABLE: fputc('a', f); break;
254 case MEM_INITIALIZED: fputc('i', f); break;
255 default:
256 gold_unreachable();
257 }
258 attrs &= ~ (attrs & - attrs);
259 }
260 while (attrs != 0);
261 fputc(')', f);
262 }
263
264 fprintf(f, " : origin = ");
265 this->start_->print(f);
266 fprintf(f, ", length = ");
267 this->length_->print(f);
268 fprintf(f, "\n");
269}
270
0d371ad3
ILT
271// Manage orphan sections. This is intended to be largely compatible
272// with the GNU linker. The Linux kernel implicitly relies on
273// something similar to the GNU linker's orphan placement. We
274// originally used a simpler scheme here, but it caused the kernel
275// build to fail, and was also rather inefficient.
276
277class Orphan_section_placement
278{
279 private:
280 typedef Script_sections::Elements_iterator Elements_iterator;
281
282 public:
283 Orphan_section_placement();
284
285 // Handle an output section during initialization of this mapping.
286 void
287 output_section_init(const std::string& name, Output_section*,
288 Elements_iterator location);
289
290 // Initialize the last location.
291 void
292 last_init(Elements_iterator location);
293
294 // Set *PWHERE to the address of an iterator pointing to the
295 // location to use for an orphan section. Return true if the
296 // iterator has a value, false otherwise.
297 bool
298 find_place(Output_section*, Elements_iterator** pwhere);
299
300 // Return the iterator being used for sections at the very end of
301 // the linker script.
302 Elements_iterator
303 last_place() const;
304
305 private:
306 // The places that we specifically recognize. This list is copied
307 // from the GNU linker.
308 enum Place_index
309 {
310 PLACE_TEXT,
311 PLACE_RODATA,
312 PLACE_DATA,
6c93b22c
ILT
313 PLACE_TLS,
314 PLACE_TLS_BSS,
0d371ad3
ILT
315 PLACE_BSS,
316 PLACE_REL,
317 PLACE_INTERP,
318 PLACE_NONALLOC,
319 PLACE_LAST,
320 PLACE_MAX
321 };
322
323 // The information we keep for a specific place.
324 struct Place
325 {
326 // The name of sections for this place.
327 const char* name;
328 // Whether we have a location for this place.
329 bool have_location;
330 // The iterator for this place.
331 Elements_iterator location;
332 };
333
334 // Initialize one place element.
335 void
336 initialize_place(Place_index, const char*);
337
338 // The places.
339 Place places_[PLACE_MAX];
340 // True if this is the first call to output_section_init.
341 bool first_init_;
342};
343
344// Initialize Orphan_section_placement.
345
346Orphan_section_placement::Orphan_section_placement()
347 : first_init_(true)
348{
349 this->initialize_place(PLACE_TEXT, ".text");
350 this->initialize_place(PLACE_RODATA, ".rodata");
351 this->initialize_place(PLACE_DATA, ".data");
6c93b22c
ILT
352 this->initialize_place(PLACE_TLS, NULL);
353 this->initialize_place(PLACE_TLS_BSS, NULL);
0d371ad3
ILT
354 this->initialize_place(PLACE_BSS, ".bss");
355 this->initialize_place(PLACE_REL, NULL);
356 this->initialize_place(PLACE_INTERP, ".interp");
357 this->initialize_place(PLACE_NONALLOC, NULL);
358 this->initialize_place(PLACE_LAST, NULL);
359}
360
361// Initialize one place element.
362
363void
364Orphan_section_placement::initialize_place(Place_index index, const char* name)
365{
366 this->places_[index].name = name;
367 this->places_[index].have_location = false;
368}
369
370// While initializing the Orphan_section_placement information, this
371// is called once for each output section named in the linker script.
372// If we found an output section during the link, it will be passed in
373// OS.
374
375void
376Orphan_section_placement::output_section_init(const std::string& name,
377 Output_section* os,
378 Elements_iterator location)
379{
380 bool first_init = this->first_init_;
381 this->first_init_ = false;
382
383 for (int i = 0; i < PLACE_MAX; ++i)
384 {
385 if (this->places_[i].name != NULL && this->places_[i].name == name)
386 {
387 if (this->places_[i].have_location)
388 {
389 // We have already seen a section with this name.
390 return;
391 }
392
393 this->places_[i].location = location;
394 this->places_[i].have_location = true;
395
396 // If we just found the .bss section, restart the search for
397 // an unallocated section. This follows the GNU linker's
398 // behaviour.
399 if (i == PLACE_BSS)
400 this->places_[PLACE_NONALLOC].have_location = false;
401
402 return;
403 }
404 }
405
406 // Relocation sections.
407 if (!this->places_[PLACE_REL].have_location
408 && os != NULL
409 && (os->type() == elfcpp::SHT_REL || os->type() == elfcpp::SHT_RELA)
410 && (os->flags() & elfcpp::SHF_ALLOC) != 0)
411 {
412 this->places_[PLACE_REL].location = location;
413 this->places_[PLACE_REL].have_location = true;
414 }
415
416 // We find the location for unallocated sections by finding the
417 // first debugging or comment section after the BSS section (if
418 // there is one).
419 if (!this->places_[PLACE_NONALLOC].have_location
420 && (name == ".comment" || Layout::is_debug_info_section(name.c_str())))
421 {
422 // We add orphan sections after the location in PLACES_. We
423 // want to store unallocated sections before LOCATION. If this
424 // is the very first section, we can't use it.
425 if (!first_init)
426 {
427 --location;
428 this->places_[PLACE_NONALLOC].location = location;
429 this->places_[PLACE_NONALLOC].have_location = true;
430 }
431 }
432}
433
434// Initialize the last location.
435
436void
437Orphan_section_placement::last_init(Elements_iterator location)
438{
439 this->places_[PLACE_LAST].location = location;
440 this->places_[PLACE_LAST].have_location = true;
441}
442
443// Set *PWHERE to the address of an iterator pointing to the location
444// to use for an orphan section. Return true if the iterator has a
445// value, false otherwise.
446
447bool
448Orphan_section_placement::find_place(Output_section* os,
449 Elements_iterator** pwhere)
450{
451 // Figure out where OS should go. This is based on the GNU linker
452 // code. FIXME: The GNU linker handles small data sections
453 // specially, but we don't.
454 elfcpp::Elf_Word type = os->type();
455 elfcpp::Elf_Xword flags = os->flags();
456 Place_index index;
457 if ((flags & elfcpp::SHF_ALLOC) == 0
458 && !Layout::is_debug_info_section(os->name()))
459 index = PLACE_NONALLOC;
460 else if ((flags & elfcpp::SHF_ALLOC) == 0)
461 index = PLACE_LAST;
462 else if (type == elfcpp::SHT_NOTE)
463 index = PLACE_INTERP;
6c93b22c
ILT
464 else if ((flags & elfcpp::SHF_TLS) != 0)
465 {
466 if (type == elfcpp::SHT_NOBITS)
467 index = PLACE_TLS_BSS;
468 else
469 index = PLACE_TLS;
470 }
0d371ad3
ILT
471 else if (type == elfcpp::SHT_NOBITS)
472 index = PLACE_BSS;
473 else if ((flags & elfcpp::SHF_WRITE) != 0)
474 index = PLACE_DATA;
475 else if (type == elfcpp::SHT_REL || type == elfcpp::SHT_RELA)
476 index = PLACE_REL;
477 else if ((flags & elfcpp::SHF_EXECINSTR) == 0)
478 index = PLACE_RODATA;
479 else
480 index = PLACE_TEXT;
481
482 // If we don't have a location yet, try to find one based on a
483 // plausible ordering of sections.
484 if (!this->places_[index].have_location)
485 {
486 Place_index follow;
487 switch (index)
488 {
489 default:
490 follow = PLACE_MAX;
491 break;
492 case PLACE_RODATA:
493 follow = PLACE_TEXT;
494 break;
495 case PLACE_BSS:
496 follow = PLACE_DATA;
497 break;
498 case PLACE_REL:
499 follow = PLACE_TEXT;
500 break;
501 case PLACE_INTERP:
502 follow = PLACE_TEXT;
503 break;
6c93b22c
ILT
504 case PLACE_TLS:
505 follow = PLACE_DATA;
506 break;
507 case PLACE_TLS_BSS:
508 follow = PLACE_TLS;
509 if (!this->places_[PLACE_TLS].have_location)
510 follow = PLACE_DATA;
511 break;
0d371ad3
ILT
512 }
513 if (follow != PLACE_MAX && this->places_[follow].have_location)
514 {
515 // Set the location of INDEX to the location of FOLLOW. The
516 // location of INDEX will then be incremented by the caller,
517 // so anything in INDEX will continue to be after anything
518 // in FOLLOW.
519 this->places_[index].location = this->places_[follow].location;
520 this->places_[index].have_location = true;
521 }
522 }
523
524 *pwhere = &this->places_[index].location;
525 bool ret = this->places_[index].have_location;
526
527 // The caller will set the location.
528 this->places_[index].have_location = true;
529
530 return ret;
531}
532
533// Return the iterator being used for sections at the very end of the
534// linker script.
535
536Orphan_section_placement::Elements_iterator
537Orphan_section_placement::last_place() const
538{
539 gold_assert(this->places_[PLACE_LAST].have_location);
540 return this->places_[PLACE_LAST].location;
541}
542
494e05f4
ILT
543// An element in a SECTIONS clause.
544
545class Sections_element
546{
547 public:
548 Sections_element()
549 { }
550
551 virtual ~Sections_element()
552 { }
553
0d371ad3
ILT
554 // Return whether an output section is relro.
555 virtual bool
556 is_relro() const
557 { return false; }
558
2d924fd9
ILT
559 // Record that an output section is relro.
560 virtual void
561 set_is_relro()
562 { }
563
919ed24c
ILT
564 // Create any required output sections. The only real
565 // implementation is in Output_section_definition.
566 virtual void
567 create_sections(Layout*)
568 { }
569
a445fddf
ILT
570 // Add any symbol being defined to the symbol table.
571 virtual void
572 add_symbols_to_table(Symbol_table*)
573 { }
574
575 // Finalize symbols and check assertions.
576 virtual void
77e65537 577 finalize_symbols(Symbol_table*, const Layout*, uint64_t*)
a445fddf
ILT
578 { }
579
580 // Return the output section name to use for an input file name and
581 // section name. This only real implementation is in
582 // Output_section_definition.
583 virtual const char*
1e5d2fb1 584 output_section_name(const char*, const char*, Output_section***,
b9b2ae8b 585 Script_sections::Section_type*, bool*)
a445fddf
ILT
586 { return NULL; }
587
0d371ad3
ILT
588 // Initialize OSP with an output section.
589 virtual void
590 orphan_section_init(Orphan_section_placement*,
591 Script_sections::Elements_iterator)
592 { }
a445fddf
ILT
593
594 // Set section addresses. This includes applying assignments if the
9b547ce6 595 // expression is an absolute value.
a445fddf 596 virtual void
f6973bdc
ILT
597 set_section_addresses(Symbol_table*, Layout*, uint64_t*, uint64_t*,
598 uint64_t*)
a445fddf
ILT
599 { }
600
3802b2dd
ILT
601 // Check a constraint (ONLY_IF_RO, etc.) on an output section. If
602 // this section is constrained, and the input sections do not match,
603 // return the constraint, and set *POSD.
604 virtual Section_constraint
605 check_constraint(Output_section_definition**)
606 { return CONSTRAINT_NONE; }
607
608 // See if this is the alternate output section for a constrained
609 // output section. If it is, transfer the Output_section and return
610 // true. Otherwise return false.
611 virtual bool
612 alternate_constraint(Output_section_definition*, Section_constraint)
613 { return false; }
614
1c4f3631
ILT
615 // Get the list of segments to use for an allocated section when
616 // using a PHDRS clause. If this is an allocated section, return
2cefc357
ILT
617 // the Output_section, and set *PHDRS_LIST (the first parameter) to
618 // the list of PHDRS to which it should be attached. If the PHDRS
619 // were not specified, don't change *PHDRS_LIST. When not returning
620 // NULL, set *ORPHAN (the second parameter) according to whether
621 // this is an orphan section--one that is not mentioned in the
622 // linker script.
1c4f3631 623 virtual Output_section*
2cefc357 624 allocate_to_segment(String_list**, bool*)
1c4f3631
ILT
625 { return NULL; }
626
8f2eb564
ILT
627 // Look for an output section by name and return the address, the
628 // load address, the alignment, and the size. This is used when an
629 // expression refers to an output section which was not actually
630 // created. This returns true if the section was found, false
631 // otherwise. The only real definition is for
632 // Output_section_definition.
633 virtual bool
634 get_output_section_info(const char*, uint64_t*, uint64_t*, uint64_t*,
635 uint64_t*) const
636 { return false; }
637
2d924fd9
ILT
638 // Return the associated Output_section if there is one.
639 virtual Output_section*
640 get_output_section() const
641 { return NULL; }
642
7f8cd844
NC
643 // Set the section's memory regions.
644 virtual void
645 set_memory_region(Memory_region*, bool)
646 { gold_error(_("Attempt to set a memory region for a non-output section")); }
647
a445fddf 648 // Print the element for debugging purposes.
494e05f4
ILT
649 virtual void
650 print(FILE* f) const = 0;
651};
652
653// An assignment in a SECTIONS clause outside of an output section.
654
655class Sections_element_assignment : public Sections_element
656{
657 public:
658 Sections_element_assignment(const char* name, size_t namelen,
659 Expression* val, bool provide, bool hidden)
99fff23b 660 : assignment_(name, namelen, false, val, provide, hidden)
494e05f4
ILT
661 { }
662
a445fddf
ILT
663 // Add the symbol to the symbol table.
664 void
665 add_symbols_to_table(Symbol_table* symtab)
666 { this->assignment_.add_to_table(symtab); }
667
668 // Finalize the symbol.
669 void
670 finalize_symbols(Symbol_table* symtab, const Layout* layout,
77e65537 671 uint64_t* dot_value)
a445fddf 672 {
77e65537 673 this->assignment_.finalize_with_dot(symtab, layout, *dot_value, NULL);
a445fddf
ILT
674 }
675
676 // Set the section address. There is no section here, but if the
677 // value is absolute, we set the symbol. This permits us to use
678 // absolute symbols when setting dot.
679 void
680 set_section_addresses(Symbol_table* symtab, Layout* layout,
f6973bdc 681 uint64_t* dot_value, uint64_t*, uint64_t*)
a445fddf 682 {
286adcf4 683 this->assignment_.set_if_absolute(symtab, layout, true, *dot_value, NULL);
a445fddf
ILT
684 }
685
686 // Print for debugging.
494e05f4
ILT
687 void
688 print(FILE* f) const
689 {
690 fprintf(f, " ");
691 this->assignment_.print(f);
692 }
693
694 private:
695 Symbol_assignment assignment_;
696};
697
a445fddf
ILT
698// An assignment to the dot symbol in a SECTIONS clause outside of an
699// output section.
700
701class Sections_element_dot_assignment : public Sections_element
702{
703 public:
704 Sections_element_dot_assignment(Expression* val)
705 : val_(val)
706 { }
707
708 // Finalize the symbol.
709 void
710 finalize_symbols(Symbol_table* symtab, const Layout* layout,
77e65537 711 uint64_t* dot_value)
a445fddf 712 {
77e65537
ILT
713 // We ignore the section of the result because outside of an
714 // output section definition the dot symbol is always considered
715 // to be absolute.
919ed24c 716 *dot_value = this->val_->eval_with_dot(symtab, layout, true, *dot_value,
286adcf4 717 NULL, NULL, NULL, false);
a445fddf
ILT
718 }
719
720 // Update the dot symbol while setting section addresses.
721 void
722 set_section_addresses(Symbol_table* symtab, Layout* layout,
f6973bdc
ILT
723 uint64_t* dot_value, uint64_t* dot_alignment,
724 uint64_t* load_address)
a445fddf 725 {
919ed24c 726 *dot_value = this->val_->eval_with_dot(symtab, layout, false, *dot_value,
286adcf4 727 NULL, NULL, dot_alignment, false);
fd247bfe 728 *load_address = *dot_value;
a445fddf
ILT
729 }
730
731 // Print for debugging.
732 void
733 print(FILE* f) const
734 {
735 fprintf(f, " . = ");
736 this->val_->print(f);
737 fprintf(f, "\n");
738 }
739
740 private:
741 Expression* val_;
742};
743
494e05f4
ILT
744// An assertion in a SECTIONS clause outside of an output section.
745
746class Sections_element_assertion : public Sections_element
747{
748 public:
749 Sections_element_assertion(Expression* check, const char* message,
750 size_t messagelen)
751 : assertion_(check, message, messagelen)
752 { }
753
a445fddf
ILT
754 // Check the assertion.
755 void
77e65537 756 finalize_symbols(Symbol_table* symtab, const Layout* layout, uint64_t*)
a445fddf
ILT
757 { this->assertion_.check(symtab, layout); }
758
759 // Print for debugging.
494e05f4
ILT
760 void
761 print(FILE* f) const
762 {
763 fprintf(f, " ");
764 this->assertion_.print(f);
765 }
766
767 private:
768 Script_assertion assertion_;
769};
770
771// An element in an output section in a SECTIONS clause.
772
773class Output_section_element
774{
775 public:
a445fddf 776 // A list of input sections.
6625d24e 777 typedef std::list<Output_section::Input_section> Input_section_list;
a445fddf 778
494e05f4
ILT
779 Output_section_element()
780 { }
781
782 virtual ~Output_section_element()
783 { }
784
919ed24c
ILT
785 // Return whether this element requires an output section to exist.
786 virtual bool
787 needs_output_section() const
788 { return false; }
789
a445fddf
ILT
790 // Add any symbol being defined to the symbol table.
791 virtual void
792 add_symbols_to_table(Symbol_table*)
793 { }
794
795 // Finalize symbols and check assertions.
796 virtual void
77e65537 797 finalize_symbols(Symbol_table*, const Layout*, uint64_t*, Output_section**)
a445fddf
ILT
798 { }
799
800 // Return whether this element matches FILE_NAME and SECTION_NAME.
801 // The only real implementation is in Output_section_element_input.
802 virtual bool
b9b2ae8b 803 match_name(const char*, const char*, bool *) const
a445fddf
ILT
804 { return false; }
805
806 // Set section addresses. This includes applying assignments if the
9b547ce6 807 // expression is an absolute value.
a445fddf
ILT
808 virtual void
809 set_section_addresses(Symbol_table*, Layout*, Output_section*, uint64_t,
f6973bdc 810 uint64_t*, uint64_t*, Output_section**, std::string*,
77e65537 811 Input_section_list*)
a445fddf
ILT
812 { }
813
814 // Print the element for debugging purposes.
494e05f4
ILT
815 virtual void
816 print(FILE* f) const = 0;
a445fddf
ILT
817
818 protected:
819 // Return a fill string that is LENGTH bytes long, filling it with
820 // FILL.
821 std::string
822 get_fill_string(const std::string* fill, section_size_type length) const;
494e05f4
ILT
823};
824
a445fddf
ILT
825std::string
826Output_section_element::get_fill_string(const std::string* fill,
827 section_size_type length) const
828{
829 std::string this_fill;
830 this_fill.reserve(length);
831 while (this_fill.length() + fill->length() <= length)
832 this_fill += *fill;
833 if (this_fill.length() < length)
834 this_fill.append(*fill, 0, length - this_fill.length());
835 return this_fill;
836}
837
494e05f4
ILT
838// A symbol assignment in an output section.
839
840class Output_section_element_assignment : public Output_section_element
841{
842 public:
843 Output_section_element_assignment(const char* name, size_t namelen,
844 Expression* val, bool provide,
845 bool hidden)
99fff23b 846 : assignment_(name, namelen, false, val, provide, hidden)
494e05f4
ILT
847 { }
848
a445fddf
ILT
849 // Add the symbol to the symbol table.
850 void
851 add_symbols_to_table(Symbol_table* symtab)
852 { this->assignment_.add_to_table(symtab); }
853
854 // Finalize the symbol.
855 void
856 finalize_symbols(Symbol_table* symtab, const Layout* layout,
77e65537 857 uint64_t* dot_value, Output_section** dot_section)
a445fddf 858 {
77e65537
ILT
859 this->assignment_.finalize_with_dot(symtab, layout, *dot_value,
860 *dot_section);
a445fddf
ILT
861 }
862
863 // Set the section address. There is no section here, but if the
864 // value is absolute, we set the symbol. This permits us to use
865 // absolute symbols when setting dot.
866 void
867 set_section_addresses(Symbol_table* symtab, Layout* layout, Output_section*,
f6973bdc 868 uint64_t, uint64_t* dot_value, uint64_t*,
286adcf4
CC
869 Output_section** dot_section, std::string*,
870 Input_section_list*)
a445fddf 871 {
286adcf4
CC
872 this->assignment_.set_if_absolute(symtab, layout, true, *dot_value,
873 *dot_section);
a445fddf
ILT
874 }
875
876 // Print for debugging.
494e05f4
ILT
877 void
878 print(FILE* f) const
879 {
880 fprintf(f, " ");
881 this->assignment_.print(f);
882 }
883
884 private:
885 Symbol_assignment assignment_;
886};
887
a445fddf
ILT
888// An assignment to the dot symbol in an output section.
889
890class Output_section_element_dot_assignment : public Output_section_element
891{
892 public:
893 Output_section_element_dot_assignment(Expression* val)
894 : val_(val)
895 { }
896
bfc34b3f
ILT
897 // An assignment to dot within an output section is enough to force
898 // the output section to exist.
899 bool
900 needs_output_section() const
901 { return true; }
902
a445fddf
ILT
903 // Finalize the symbol.
904 void
905 finalize_symbols(Symbol_table* symtab, const Layout* layout,
77e65537 906 uint64_t* dot_value, Output_section** dot_section)
a445fddf 907 {
919ed24c 908 *dot_value = this->val_->eval_with_dot(symtab, layout, true, *dot_value,
286adcf4
CC
909 *dot_section, dot_section, NULL,
910 true);
a445fddf
ILT
911 }
912
913 // Update the dot symbol while setting section addresses.
914 void
915 set_section_addresses(Symbol_table* symtab, Layout* layout, Output_section*,
f6973bdc 916 uint64_t, uint64_t* dot_value, uint64_t*,
286adcf4
CC
917 Output_section** dot_section, std::string*,
918 Input_section_list*);
a445fddf
ILT
919
920 // Print for debugging.
921 void
922 print(FILE* f) const
923 {
924 fprintf(f, " . = ");
925 this->val_->print(f);
926 fprintf(f, "\n");
927 }
928
929 private:
930 Expression* val_;
931};
932
933// Update the dot symbol while setting section addresses.
934
935void
936Output_section_element_dot_assignment::set_section_addresses(
937 Symbol_table* symtab,
938 Layout* layout,
939 Output_section* output_section,
940 uint64_t,
941 uint64_t* dot_value,
f6973bdc 942 uint64_t* dot_alignment,
77e65537 943 Output_section** dot_section,
a445fddf
ILT
944 std::string* fill,
945 Input_section_list*)
946{
919ed24c
ILT
947 uint64_t next_dot = this->val_->eval_with_dot(symtab, layout, false,
948 *dot_value, *dot_section,
286adcf4
CC
949 dot_section, dot_alignment,
950 true);
a445fddf
ILT
951 if (next_dot < *dot_value)
952 gold_error(_("dot may not move backward"));
953 if (next_dot > *dot_value && output_section != NULL)
954 {
955 section_size_type length = convert_to_section_size_type(next_dot
956 - *dot_value);
957 Output_section_data* posd;
958 if (fill->empty())
7d9e3d98 959 posd = new Output_data_zero_fill(length, 0);
a445fddf
ILT
960 else
961 {
962 std::string this_fill = this->get_fill_string(fill, length);
963 posd = new Output_data_const(this_fill, 0);
964 }
965 output_section->add_output_section_data(posd);
20e6d0d6 966 layout->new_output_section_data_from_script(posd);
a445fddf
ILT
967 }
968 *dot_value = next_dot;
969}
970
494e05f4
ILT
971// An assertion in an output section.
972
973class Output_section_element_assertion : public Output_section_element
974{
975 public:
976 Output_section_element_assertion(Expression* check, const char* message,
977 size_t messagelen)
978 : assertion_(check, message, messagelen)
979 { }
980
981 void
982 print(FILE* f) const
983 {
984 fprintf(f, " ");
985 this->assertion_.print(f);
986 }
987
988 private:
989 Script_assertion assertion_;
990};
991
77e65537
ILT
992// We use a special instance of Output_section_data to handle BYTE,
993// SHORT, etc. This permits forward references to symbols in the
994// expressions.
494e05f4 995
77e65537 996class Output_data_expression : public Output_section_data
494e05f4
ILT
997{
998 public:
77e65537
ILT
999 Output_data_expression(int size, bool is_signed, Expression* val,
1000 const Symbol_table* symtab, const Layout* layout,
1001 uint64_t dot_value, Output_section* dot_section)
20e6d0d6 1002 : Output_section_data(size, 0, true),
77e65537
ILT
1003 is_signed_(is_signed), val_(val), symtab_(symtab),
1004 layout_(layout), dot_value_(dot_value), dot_section_(dot_section)
494e05f4
ILT
1005 { }
1006
77e65537
ILT
1007 protected:
1008 // Write the data to the output file.
a445fddf 1009 void
77e65537 1010 do_write(Output_file*);
a445fddf 1011
77e65537 1012 // Write the data to a buffer.
494e05f4 1013 void
77e65537 1014 do_write_to_buffer(unsigned char*);
494e05f4 1015
7d9e3d98
ILT
1016 // Write to a map file.
1017 void
1018 do_print_to_mapfile(Mapfile* mapfile) const
1019 { mapfile->print_output_data(this, _("** expression")); }
1020
494e05f4 1021 private:
a445fddf 1022 template<bool big_endian>
77e65537
ILT
1023 void
1024 endian_write_to_buffer(uint64_t, unsigned char*);
a445fddf 1025
494e05f4 1026 bool is_signed_;
494e05f4 1027 Expression* val_;
77e65537
ILT
1028 const Symbol_table* symtab_;
1029 const Layout* layout_;
1030 uint64_t dot_value_;
1031 Output_section* dot_section_;
494e05f4
ILT
1032};
1033
77e65537 1034// Write the data element to the output file.
a445fddf
ILT
1035
1036void
77e65537 1037Output_data_expression::do_write(Output_file* of)
a445fddf 1038{
77e65537
ILT
1039 unsigned char* view = of->get_output_view(this->offset(), this->data_size());
1040 this->write_to_buffer(view);
1041 of->write_output_view(this->offset(), this->data_size(), view);
1042}
a445fddf 1043
77e65537
ILT
1044// Write the data element to a buffer.
1045
1046void
1047Output_data_expression::do_write_to_buffer(unsigned char* buf)
1048{
77e65537 1049 uint64_t val = this->val_->eval_with_dot(this->symtab_, this->layout_,
919ed24c 1050 true, this->dot_value_,
286adcf4
CC
1051 this->dot_section_, NULL, NULL,
1052 false);
a445fddf 1053
8851ecca 1054 if (parameters->target().is_big_endian())
77e65537 1055 this->endian_write_to_buffer<true>(val, buf);
a445fddf 1056 else
77e65537 1057 this->endian_write_to_buffer<false>(val, buf);
a445fddf
ILT
1058}
1059
a445fddf 1060template<bool big_endian>
77e65537
ILT
1061void
1062Output_data_expression::endian_write_to_buffer(uint64_t val,
1063 unsigned char* buf)
a445fddf 1064{
77e65537 1065 switch (this->data_size())
a445fddf
ILT
1066 {
1067 case 1:
1068 elfcpp::Swap_unaligned<8, big_endian>::writeval(buf, val);
a445fddf
ILT
1069 break;
1070 case 2:
1071 elfcpp::Swap_unaligned<16, big_endian>::writeval(buf, val);
a445fddf
ILT
1072 break;
1073 case 4:
1074 elfcpp::Swap_unaligned<32, big_endian>::writeval(buf, val);
a445fddf
ILT
1075 break;
1076 case 8:
8851ecca 1077 if (parameters->target().get_size() == 32)
a445fddf
ILT
1078 {
1079 val &= 0xffffffff;
1080 if (this->is_signed_ && (val & 0x80000000) != 0)
1081 val |= 0xffffffff00000000LL;
1082 }
1083 elfcpp::Swap_unaligned<64, big_endian>::writeval(buf, val);
a445fddf
ILT
1084 break;
1085 default:
1086 gold_unreachable();
1087 }
77e65537
ILT
1088}
1089
1090// A data item in an output section.
1091
1092class Output_section_element_data : public Output_section_element
1093{
1094 public:
1095 Output_section_element_data(int size, bool is_signed, Expression* val)
1096 : size_(size), is_signed_(is_signed), val_(val)
1097 { }
1098
919ed24c
ILT
1099 // If there is a data item, then we must create an output section.
1100 bool
1101 needs_output_section() const
1102 { return true; }
1103
77e65537
ILT
1104 // Finalize symbols--we just need to update dot.
1105 void
1106 finalize_symbols(Symbol_table*, const Layout*, uint64_t* dot_value,
1107 Output_section**)
1108 { *dot_value += this->size_; }
1109
1110 // Store the value in the section.
1111 void
1112 set_section_addresses(Symbol_table*, Layout*, Output_section*, uint64_t,
f6973bdc
ILT
1113 uint64_t* dot_value, uint64_t*, Output_section**,
1114 std::string*, Input_section_list*);
77e65537
ILT
1115
1116 // Print for debugging.
1117 void
1118 print(FILE*) const;
1119
1120 private:
1121 // The size in bytes.
1122 int size_;
1123 // Whether the value is signed.
1124 bool is_signed_;
1125 // The value.
1126 Expression* val_;
1127};
1128
1129// Store the value in the section.
1130
1131void
1132Output_section_element_data::set_section_addresses(
1133 Symbol_table* symtab,
1134 Layout* layout,
1135 Output_section* os,
1136 uint64_t,
1137 uint64_t* dot_value,
f6973bdc 1138 uint64_t*,
77e65537
ILT
1139 Output_section** dot_section,
1140 std::string*,
1141 Input_section_list*)
1142{
1143 gold_assert(os != NULL);
20e6d0d6
DK
1144 Output_data_expression* expression =
1145 new Output_data_expression(this->size_, this->is_signed_, this->val_,
1146 symtab, layout, *dot_value, *dot_section);
1147 os->add_output_section_data(expression);
1148 layout->new_output_section_data_from_script(expression);
77e65537 1149 *dot_value += this->size_;
a445fddf
ILT
1150}
1151
494e05f4
ILT
1152// Print for debugging.
1153
1154void
1155Output_section_element_data::print(FILE* f) const
1156{
1157 const char* s;
1158 switch (this->size_)
1159 {
1160 case 1:
1161 s = "BYTE";
1162 break;
1163 case 2:
1164 s = "SHORT";
1165 break;
1166 case 4:
1167 s = "LONG";
1168 break;
1169 case 8:
1170 if (this->is_signed_)
1171 s = "SQUAD";
1172 else
1173 s = "QUAD";
1174 break;
1175 default:
1176 gold_unreachable();
1177 }
1178 fprintf(f, " %s(", s);
1179 this->val_->print(f);
1180 fprintf(f, ")\n");
1181}
1182
1183// A fill value setting in an output section.
1184
1185class Output_section_element_fill : public Output_section_element
1186{
1187 public:
1188 Output_section_element_fill(Expression* val)
1189 : val_(val)
1190 { }
1191
a445fddf
ILT
1192 // Update the fill value while setting section addresses.
1193 void
1194 set_section_addresses(Symbol_table* symtab, Layout* layout, Output_section*,
f6973bdc 1195 uint64_t, uint64_t* dot_value, uint64_t*,
77e65537
ILT
1196 Output_section** dot_section,
1197 std::string* fill, Input_section_list*)
a445fddf 1198 {
77e65537 1199 Output_section* fill_section;
919ed24c 1200 uint64_t fill_val = this->val_->eval_with_dot(symtab, layout, false,
77e65537 1201 *dot_value, *dot_section,
286adcf4 1202 &fill_section, NULL, false);
77e65537
ILT
1203 if (fill_section != NULL)
1204 gold_warning(_("fill value is not absolute"));
a445fddf
ILT
1205 // FIXME: The GNU linker supports fill values of arbitrary length.
1206 unsigned char fill_buff[4];
1207 elfcpp::Swap_unaligned<32, true>::writeval(fill_buff, fill_val);
1208 fill->assign(reinterpret_cast<char*>(fill_buff), 4);
1209 }
1210
1211 // Print for debugging.
494e05f4
ILT
1212 void
1213 print(FILE* f) const
1214 {
1215 fprintf(f, " FILL(");
1216 this->val_->print(f);
1217 fprintf(f, ")\n");
1218 }
1219
1220 private:
1221 // The new fill value.
1222 Expression* val_;
1223};
1224
1225// An input section specification in an output section
1226
1227class Output_section_element_input : public Output_section_element
1228{
1229 public:
494e05f4
ILT
1230 Output_section_element_input(const Input_section_spec* spec, bool keep);
1231
a445fddf
ILT
1232 // Finalize symbols--just update the value of the dot symbol.
1233 void
77e65537
ILT
1234 finalize_symbols(Symbol_table*, const Layout*, uint64_t* dot_value,
1235 Output_section** dot_section)
a445fddf
ILT
1236 {
1237 *dot_value = this->final_dot_value_;
77e65537 1238 *dot_section = this->final_dot_section_;
a445fddf
ILT
1239 }
1240
b9b2ae8b
NC
1241 // See whether we match FILE_NAME and SECTION_NAME as an input section.
1242 // If we do then also indicate whether the section should be KEPT.
a445fddf 1243 bool
b9b2ae8b 1244 match_name(const char* file_name, const char* section_name, bool* keep) const;
a445fddf
ILT
1245
1246 // Set the section address.
1247 void
1248 set_section_addresses(Symbol_table* symtab, Layout* layout, Output_section*,
f6973bdc 1249 uint64_t subalign, uint64_t* dot_value, uint64_t*,
77e65537
ILT
1250 Output_section**, std::string* fill,
1251 Input_section_list*);
a445fddf
ILT
1252
1253 // Print for debugging.
494e05f4
ILT
1254 void
1255 print(FILE* f) const;
1256
1257 private:
1258 // An input section pattern.
1259 struct Input_section_pattern
1260 {
1261 std::string pattern;
a445fddf 1262 bool pattern_is_wildcard;
494e05f4
ILT
1263 Sort_wildcard sort;
1264
1265 Input_section_pattern(const char* patterna, size_t patternlena,
1266 Sort_wildcard sorta)
a445fddf 1267 : pattern(patterna, patternlena),
6e9ba2ca 1268 pattern_is_wildcard(is_wildcard_string(this->pattern.c_str())),
a445fddf 1269 sort(sorta)
494e05f4
ILT
1270 { }
1271 };
1272
1273 typedef std::vector<Input_section_pattern> Input_section_patterns;
1274
a445fddf
ILT
1275 // Filename_exclusions is a pair of filename pattern and a bool
1276 // indicating whether the filename is a wildcard.
1277 typedef std::vector<std::pair<std::string, bool> > Filename_exclusions;
1278
1279 // Return whether STRING matches PATTERN, where IS_WILDCARD_PATTERN
1280 // indicates whether this is a wildcard pattern.
1281 static inline bool
1282 match(const char* string, const char* pattern, bool is_wildcard_pattern)
1283 {
1284 return (is_wildcard_pattern
1285 ? fnmatch(pattern, string, 0) == 0
1286 : strcmp(string, pattern) == 0);
1287 }
494e05f4 1288
a445fddf
ILT
1289 // See if we match a file name.
1290 bool
1291 match_file_name(const char* file_name) const;
1292
1293 // The file name pattern. If this is the empty string, we match all
1294 // files.
494e05f4 1295 std::string filename_pattern_;
a445fddf
ILT
1296 // Whether the file name pattern is a wildcard.
1297 bool filename_is_wildcard_;
494e05f4
ILT
1298 // How the file names should be sorted. This may only be
1299 // SORT_WILDCARD_NONE or SORT_WILDCARD_BY_NAME.
1300 Sort_wildcard filename_sort_;
1301 // The list of file names to exclude.
1302 Filename_exclusions filename_exclusions_;
1303 // The list of input section patterns.
1304 Input_section_patterns input_section_patterns_;
1305 // Whether to keep this section when garbage collecting.
1306 bool keep_;
a445fddf
ILT
1307 // The value of dot after including all matching sections.
1308 uint64_t final_dot_value_;
77e65537
ILT
1309 // The section where dot is defined after including all matching
1310 // sections.
1311 Output_section* final_dot_section_;
494e05f4
ILT
1312};
1313
1314// Construct Output_section_element_input. The parser records strings
1315// as pointers into a copy of the script file, which will go away when
1316// parsing is complete. We make sure they are in std::string objects.
1317
1318Output_section_element_input::Output_section_element_input(
1319 const Input_section_spec* spec,
1320 bool keep)
a445fddf
ILT
1321 : filename_pattern_(),
1322 filename_is_wildcard_(false),
494e05f4
ILT
1323 filename_sort_(spec->file.sort),
1324 filename_exclusions_(),
1325 input_section_patterns_(),
a445fddf 1326 keep_(keep),
77e65537
ILT
1327 final_dot_value_(0),
1328 final_dot_section_(NULL)
494e05f4 1329{
a445fddf
ILT
1330 // The filename pattern "*" is common, and matches all files. Turn
1331 // it into the empty string.
1332 if (spec->file.name.length != 1 || spec->file.name.value[0] != '*')
1333 this->filename_pattern_.assign(spec->file.name.value,
1334 spec->file.name.length);
6e9ba2ca 1335 this->filename_is_wildcard_ = is_wildcard_string(this->filename_pattern_.c_str());
a445fddf 1336
494e05f4
ILT
1337 if (spec->input_sections.exclude != NULL)
1338 {
1339 for (String_list::const_iterator p =
1340 spec->input_sections.exclude->begin();
1341 p != spec->input_sections.exclude->end();
1342 ++p)
a445fddf 1343 {
6e9ba2ca 1344 bool is_wildcard = is_wildcard_string((*p).c_str());
a445fddf
ILT
1345 this->filename_exclusions_.push_back(std::make_pair(*p,
1346 is_wildcard));
1347 }
494e05f4
ILT
1348 }
1349
1350 if (spec->input_sections.sections != NULL)
1351 {
1352 Input_section_patterns& isp(this->input_section_patterns_);
1353 for (String_sort_list::const_iterator p =
1354 spec->input_sections.sections->begin();
1355 p != spec->input_sections.sections->end();
1356 ++p)
1357 isp.push_back(Input_section_pattern(p->name.value, p->name.length,
1358 p->sort));
1359 }
1360}
1361
a445fddf
ILT
1362// See whether we match FILE_NAME.
1363
1364bool
1365Output_section_element_input::match_file_name(const char* file_name) const
1366{
1367 if (!this->filename_pattern_.empty())
1368 {
1369 // If we were called with no filename, we refuse to match a
1370 // pattern which requires a file name.
1371 if (file_name == NULL)
1372 return false;
1373
1374 if (!match(file_name, this->filename_pattern_.c_str(),
1375 this->filename_is_wildcard_))
1376 return false;
1377 }
1378
1379 if (file_name != NULL)
1380 {
1381 // Now we have to see whether FILE_NAME matches one of the
1382 // exclusion patterns, if any.
1383 for (Filename_exclusions::const_iterator p =
1384 this->filename_exclusions_.begin();
1385 p != this->filename_exclusions_.end();
1386 ++p)
1387 {
1388 if (match(file_name, p->first.c_str(), p->second))
1389 return false;
1390 }
1391 }
1392
1393 return true;
1394}
1395
b9b2ae8b
NC
1396// See whether we match FILE_NAME and SECTION_NAME. If we do then
1397// KEEP indicates whether the section should survive garbage collection.
a445fddf
ILT
1398
1399bool
1400Output_section_element_input::match_name(const char* file_name,
b9b2ae8b
NC
1401 const char* section_name,
1402 bool *keep) const
a445fddf
ILT
1403{
1404 if (!this->match_file_name(file_name))
1405 return false;
1406
b9b2ae8b
NC
1407 *keep = this->keep_;
1408
a445fddf
ILT
1409 // If there are no section name patterns, then we match.
1410 if (this->input_section_patterns_.empty())
1411 return true;
1412
1413 // See whether we match the section name patterns.
1414 for (Input_section_patterns::const_iterator p =
1415 this->input_section_patterns_.begin();
1416 p != this->input_section_patterns_.end();
1417 ++p)
1418 {
1419 if (match(section_name, p->pattern.c_str(), p->pattern_is_wildcard))
1420 return true;
1421 }
1422
1423 // We didn't match any section names, so we didn't match.
1424 return false;
1425}
1426
1427// Information we use to sort the input sections.
1428
20e6d0d6 1429class Input_section_info
a445fddf 1430{
20e6d0d6 1431 public:
6625d24e 1432 Input_section_info(const Output_section::Input_section& input_section)
2ea97941 1433 : input_section_(input_section), section_name_(),
20e6d0d6
DK
1434 size_(0), addralign_(1)
1435 { }
1436
1437 // Return the simple input section.
6625d24e 1438 const Output_section::Input_section&
20e6d0d6
DK
1439 input_section() const
1440 { return this->input_section_; }
1441
1442 // Return the object.
1443 Relobj*
1444 relobj() const
1445 { return this->input_section_.relobj(); }
1446
1447 // Return the section index.
1448 unsigned int
1449 shndx()
1450 { return this->input_section_.shndx(); }
1451
1452 // Return the section name.
1453 const std::string&
1454 section_name() const
1455 { return this->section_name_; }
1456
1457 // Set the section name.
1458 void
2ea97941
ILT
1459 set_section_name(const std::string name)
1460 { this->section_name_ = name; }
20e6d0d6
DK
1461
1462 // Return the section size.
1463 uint64_t
1464 size() const
1465 { return this->size_; }
1466
1467 // Set the section size.
1468 void
2ea97941
ILT
1469 set_size(uint64_t size)
1470 { this->size_ = size; }
20e6d0d6
DK
1471
1472 // Return the address alignment.
1473 uint64_t
1474 addralign() const
1475 { return this->addralign_; }
1476
1477 // Set the address alignment.
1478 void
2ea97941
ILT
1479 set_addralign(uint64_t addralign)
1480 { this->addralign_ = addralign; }
20e6d0d6
DK
1481
1482 private:
1483 // Input section, can be a relaxed section.
6625d24e 1484 Output_section::Input_section input_section_;
20e6d0d6
DK
1485 // Name of the section.
1486 std::string section_name_;
1487 // Section size.
1488 uint64_t size_;
1489 // Address alignment.
1490 uint64_t addralign_;
a445fddf
ILT
1491};
1492
1493// A class to sort the input sections.
1494
1495class Input_section_sorter
1496{
1497 public:
1498 Input_section_sorter(Sort_wildcard filename_sort, Sort_wildcard section_sort)
1499 : filename_sort_(filename_sort), section_sort_(section_sort)
1500 { }
1501
1502 bool
1503 operator()(const Input_section_info&, const Input_section_info&) const;
1504
1505 private:
1506 Sort_wildcard filename_sort_;
1507 Sort_wildcard section_sort_;
1508};
1509
1510bool
1511Input_section_sorter::operator()(const Input_section_info& isi1,
1512 const Input_section_info& isi2) const
1513{
1514 if (this->section_sort_ == SORT_WILDCARD_BY_NAME
1515 || this->section_sort_ == SORT_WILDCARD_BY_NAME_BY_ALIGNMENT
1516 || (this->section_sort_ == SORT_WILDCARD_BY_ALIGNMENT_BY_NAME
20e6d0d6 1517 && isi1.addralign() == isi2.addralign()))
a445fddf 1518 {
20e6d0d6
DK
1519 if (isi1.section_name() != isi2.section_name())
1520 return isi1.section_name() < isi2.section_name();
a445fddf
ILT
1521 }
1522 if (this->section_sort_ == SORT_WILDCARD_BY_ALIGNMENT
1523 || this->section_sort_ == SORT_WILDCARD_BY_NAME_BY_ALIGNMENT
1524 || this->section_sort_ == SORT_WILDCARD_BY_ALIGNMENT_BY_NAME)
1525 {
20e6d0d6
DK
1526 if (isi1.addralign() != isi2.addralign())
1527 return isi1.addralign() < isi2.addralign();
a445fddf
ILT
1528 }
1529 if (this->filename_sort_ == SORT_WILDCARD_BY_NAME)
1530 {
20e6d0d6
DK
1531 if (isi1.relobj()->name() != isi2.relobj()->name())
1532 return (isi1.relobj()->name() < isi2.relobj()->name());
a445fddf
ILT
1533 }
1534
1535 // Otherwise we leave them in the same order.
1536 return false;
1537}
1538
1539// Set the section address. Look in INPUT_SECTIONS for sections which
1540// match this spec, sort them as specified, and add them to the output
1541// section.
1542
1543void
1544Output_section_element_input::set_section_addresses(
1545 Symbol_table*,
20e6d0d6 1546 Layout* layout,
a445fddf
ILT
1547 Output_section* output_section,
1548 uint64_t subalign,
1549 uint64_t* dot_value,
f6973bdc 1550 uint64_t*,
77e65537 1551 Output_section** dot_section,
a445fddf
ILT
1552 std::string* fill,
1553 Input_section_list* input_sections)
1554{
1555 // We build a list of sections which match each
1556 // Input_section_pattern.
1557
1558 typedef std::vector<std::vector<Input_section_info> > Matching_sections;
1559 size_t input_pattern_count = this->input_section_patterns_.size();
1560 if (input_pattern_count == 0)
1561 input_pattern_count = 1;
1562 Matching_sections matching_sections(input_pattern_count);
1563
1564 // Look through the list of sections for this output section. Add
1565 // each one which matches to one of the elements of
1566 // MATCHING_SECTIONS.
1567
1568 Input_section_list::iterator p = input_sections->begin();
1569 while (p != input_sections->end())
1570 {
20e6d0d6
DK
1571 Relobj* relobj = p->relobj();
1572 unsigned int shndx = p->shndx();
1573 Input_section_info isi(*p);
1574
a445fddf
ILT
1575 // Calling section_name and section_addralign is not very
1576 // efficient.
a445fddf
ILT
1577
1578 // Lock the object so that we can get information about the
1579 // section. This is OK since we know we are single-threaded
1580 // here.
1581 {
1582 const Task* task = reinterpret_cast<const Task*>(-1);
20e6d0d6
DK
1583 Task_lock_obj<Object> tl(task, relobj);
1584
1585 isi.set_section_name(relobj->section_name(shndx));
1586 if (p->is_relaxed_input_section())
c0a62865 1587 {
ea5cae92 1588 // We use current data size because relaxed section sizes may not
c0a62865
DK
1589 // have finalized yet.
1590 isi.set_size(p->relaxed_input_section()->current_data_size());
1591 isi.set_addralign(p->relaxed_input_section()->addralign());
1592 }
20e6d0d6 1593 else
c0a62865
DK
1594 {
1595 isi.set_size(relobj->section_size(shndx));
1596 isi.set_addralign(relobj->section_addralign(shndx));
1597 }
a445fddf
ILT
1598 }
1599
20e6d0d6 1600 if (!this->match_file_name(relobj->name().c_str()))
a445fddf
ILT
1601 ++p;
1602 else if (this->input_section_patterns_.empty())
1603 {
1604 matching_sections[0].push_back(isi);
1605 p = input_sections->erase(p);
1606 }
1607 else
1608 {
1609 size_t i;
1610 for (i = 0; i < input_pattern_count; ++i)
1611 {
1612 const Input_section_pattern&
1613 isp(this->input_section_patterns_[i]);
20e6d0d6 1614 if (match(isi.section_name().c_str(), isp.pattern.c_str(),
a445fddf
ILT
1615 isp.pattern_is_wildcard))
1616 break;
1617 }
1618
1619 if (i >= this->input_section_patterns_.size())
1620 ++p;
1621 else
1622 {
1623 matching_sections[i].push_back(isi);
1624 p = input_sections->erase(p);
1625 }
1626 }
1627 }
1628
1629 // Look through MATCHING_SECTIONS. Sort each one as specified,
1630 // using a stable sort so that we get the default order when
1631 // sections are otherwise equal. Add each input section to the
1632 // output section.
1633
661be1e2 1634 uint64_t dot = *dot_value;
a445fddf
ILT
1635 for (size_t i = 0; i < input_pattern_count; ++i)
1636 {
1637 if (matching_sections[i].empty())
1638 continue;
1639
1640 gold_assert(output_section != NULL);
1641
1642 const Input_section_pattern& isp(this->input_section_patterns_[i]);
1643 if (isp.sort != SORT_WILDCARD_NONE
1644 || this->filename_sort_ != SORT_WILDCARD_NONE)
1645 std::stable_sort(matching_sections[i].begin(),
1646 matching_sections[i].end(),
1647 Input_section_sorter(this->filename_sort_,
1648 isp.sort));
1649
2ea97941 1650 for (std::vector<Input_section_info>::const_iterator p =
a445fddf 1651 matching_sections[i].begin();
2ea97941
ILT
1652 p != matching_sections[i].end();
1653 ++p)
a445fddf 1654 {
6625d24e
DK
1655 // Override the original address alignment if SUBALIGN is specified
1656 // and is greater than the original alignment. We need to make a
1657 // copy of the input section to modify the alignment.
1658 Output_section::Input_section sis(p->input_section());
1659
1660 uint64_t this_subalign = sis.addralign();
1661 if (!sis.is_input_section())
1662 sis.output_section_data()->finalize_data_size();
1663 uint64_t data_size = sis.data_size();
a445fddf 1664 if (this_subalign < subalign)
6625d24e
DK
1665 {
1666 this_subalign = subalign;
1667 sis.set_addralign(subalign);
1668 }
a445fddf 1669
661be1e2 1670 uint64_t address = align_address(dot, this_subalign);
a445fddf 1671
661be1e2 1672 if (address > dot && !fill->empty())
a445fddf
ILT
1673 {
1674 section_size_type length =
661be1e2 1675 convert_to_section_size_type(address - dot);
a445fddf
ILT
1676 std::string this_fill = this->get_fill_string(fill, length);
1677 Output_section_data* posd = new Output_data_const(this_fill, 0);
1678 output_section->add_output_section_data(posd);
20e6d0d6 1679 layout->new_output_section_data_from_script(posd);
a445fddf
ILT
1680 }
1681
6625d24e
DK
1682 output_section->add_script_input_section(sis);
1683 dot = address + data_size;
a445fddf
ILT
1684 }
1685 }
1686
661be1e2
ILT
1687 // An SHF_TLS/SHT_NOBITS section does not take up any
1688 // address space.
1689 if (output_section == NULL
1690 || (output_section->flags() & elfcpp::SHF_TLS) == 0
1691 || output_section->type() != elfcpp::SHT_NOBITS)
1692 *dot_value = dot;
1693
a445fddf 1694 this->final_dot_value_ = *dot_value;
77e65537 1695 this->final_dot_section_ = *dot_section;
a445fddf
ILT
1696}
1697
494e05f4
ILT
1698// Print for debugging.
1699
1700void
1701Output_section_element_input::print(FILE* f) const
1702{
1703 fprintf(f, " ");
1704
1705 if (this->keep_)
1706 fprintf(f, "KEEP(");
1707
1708 if (!this->filename_pattern_.empty())
1709 {
1710 bool need_close_paren = false;
1711 switch (this->filename_sort_)
1712 {
1713 case SORT_WILDCARD_NONE:
1714 break;
1715 case SORT_WILDCARD_BY_NAME:
1716 fprintf(f, "SORT_BY_NAME(");
1717 need_close_paren = true;
1718 break;
1719 default:
1720 gold_unreachable();
1721 }
1722
1723 fprintf(f, "%s", this->filename_pattern_.c_str());
1724
1725 if (need_close_paren)
1726 fprintf(f, ")");
1727 }
1728
1729 if (!this->input_section_patterns_.empty()
1730 || !this->filename_exclusions_.empty())
1731 {
1732 fprintf(f, "(");
1733
1734 bool need_space = false;
1735 if (!this->filename_exclusions_.empty())
1736 {
1737 fprintf(f, "EXCLUDE_FILE(");
1738 bool need_comma = false;
1739 for (Filename_exclusions::const_iterator p =
1740 this->filename_exclusions_.begin();
1741 p != this->filename_exclusions_.end();
1742 ++p)
1743 {
1744 if (need_comma)
1745 fprintf(f, ", ");
a445fddf 1746 fprintf(f, "%s", p->first.c_str());
494e05f4
ILT
1747 need_comma = true;
1748 }
1749 fprintf(f, ")");
1750 need_space = true;
1751 }
1752
1753 for (Input_section_patterns::const_iterator p =
1754 this->input_section_patterns_.begin();
1755 p != this->input_section_patterns_.end();
1756 ++p)
1757 {
1758 if (need_space)
1759 fprintf(f, " ");
1760
1761 int close_parens = 0;
1762 switch (p->sort)
1763 {
1764 case SORT_WILDCARD_NONE:
1765 break;
1766 case SORT_WILDCARD_BY_NAME:
1767 fprintf(f, "SORT_BY_NAME(");
1768 close_parens = 1;
1769 break;
1770 case SORT_WILDCARD_BY_ALIGNMENT:
1771 fprintf(f, "SORT_BY_ALIGNMENT(");
1772 close_parens = 1;
1773 break;
1774 case SORT_WILDCARD_BY_NAME_BY_ALIGNMENT:
1775 fprintf(f, "SORT_BY_NAME(SORT_BY_ALIGNMENT(");
1776 close_parens = 2;
1777 break;
1778 case SORT_WILDCARD_BY_ALIGNMENT_BY_NAME:
1779 fprintf(f, "SORT_BY_ALIGNMENT(SORT_BY_NAME(");
1780 close_parens = 2;
1781 break;
1782 default:
1783 gold_unreachable();
1784 }
1785
1786 fprintf(f, "%s", p->pattern.c_str());
1787
1788 for (int i = 0; i < close_parens; ++i)
1789 fprintf(f, ")");
1790
1791 need_space = true;
1792 }
1793
1794 fprintf(f, ")");
1795 }
1796
1797 if (this->keep_)
1798 fprintf(f, ")");
1799
1800 fprintf(f, "\n");
1801}
1802
1803// An output section.
1804
1805class Output_section_definition : public Sections_element
1806{
1807 public:
a445fddf
ILT
1808 typedef Output_section_element::Input_section_list Input_section_list;
1809
494e05f4
ILT
1810 Output_section_definition(const char* name, size_t namelen,
1811 const Parser_output_section_header* header);
1812
1813 // Finish the output section with the information in the trailer.
1814 void
1815 finish(const Parser_output_section_trailer* trailer);
1816
1817 // Add a symbol to be defined.
1818 void
1819 add_symbol_assignment(const char* name, size_t length, Expression* value,
1820 bool provide, bool hidden);
a445fddf
ILT
1821
1822 // Add an assignment to the special dot symbol.
1823 void
1824 add_dot_assignment(Expression* value);
1825
494e05f4
ILT
1826 // Add an assertion.
1827 void
1828 add_assertion(Expression* check, const char* message, size_t messagelen);
1829
1830 // Add a data item to the current output section.
1831 void
1832 add_data(int size, bool is_signed, Expression* val);
1833
1834 // Add a setting for the fill value.
1835 void
1836 add_fill(Expression* val);
1837
1838 // Add an input section specification.
1839 void
1840 add_input_section(const Input_section_spec* spec, bool keep);
1841
0d371ad3
ILT
1842 // Return whether the output section is relro.
1843 bool
1844 is_relro() const
1845 { return this->is_relro_; }
1846
2d924fd9
ILT
1847 // Record that the output section is relro.
1848 void
1849 set_is_relro()
1850 { this->is_relro_ = true; }
1851
919ed24c
ILT
1852 // Create any required output sections.
1853 void
1854 create_sections(Layout*);
1855
a445fddf
ILT
1856 // Add any symbols being defined to the symbol table.
1857 void
1858 add_symbols_to_table(Symbol_table* symtab);
1859
1860 // Finalize symbols and check assertions.
1861 void
77e65537 1862 finalize_symbols(Symbol_table*, const Layout*, uint64_t*);
a445fddf
ILT
1863
1864 // Return the output section name to use for an input file name and
1865 // section name.
1866 const char*
1867 output_section_name(const char* file_name, const char* section_name,
b9b2ae8b
NC
1868 Output_section***, Script_sections::Section_type*,
1869 bool*);
a445fddf 1870
0d371ad3
ILT
1871 // Initialize OSP with an output section.
1872 void
1873 orphan_section_init(Orphan_section_placement* osp,
1874 Script_sections::Elements_iterator p)
1875 { osp->output_section_init(this->name_, this->output_section_, p); }
a445fddf
ILT
1876
1877 // Set the section address.
1878 void
1879 set_section_addresses(Symbol_table* symtab, Layout* layout,
f6973bdc
ILT
1880 uint64_t* dot_value, uint64_t*,
1881 uint64_t* load_address);
a445fddf 1882
3802b2dd
ILT
1883 // Check a constraint (ONLY_IF_RO, etc.) on an output section. If
1884 // this section is constrained, and the input sections do not match,
1885 // return the constraint, and set *POSD.
1886 Section_constraint
1887 check_constraint(Output_section_definition** posd);
1888
1889 // See if this is the alternate output section for a constrained
1890 // output section. If it is, transfer the Output_section and return
1891 // true. Otherwise return false.
1892 bool
1893 alternate_constraint(Output_section_definition*, Section_constraint);
1894
1c4f3631 1895 // Get the list of segments to use for an allocated section when
2cefc357 1896 // using a PHDRS clause.
1c4f3631 1897 Output_section*
2cefc357 1898 allocate_to_segment(String_list** phdrs_list, bool* orphan);
1c4f3631 1899
8f2eb564
ILT
1900 // Look for an output section by name and return the address, the
1901 // load address, the alignment, and the size. This is used when an
1902 // expression refers to an output section which was not actually
1903 // created. This returns true if the section was found, false
1904 // otherwise.
1905 bool
1906 get_output_section_info(const char*, uint64_t*, uint64_t*, uint64_t*,
1907 uint64_t*) const;
1908
2d924fd9
ILT
1909 // Return the associated Output_section if there is one.
1910 Output_section*
1911 get_output_section() const
1912 { return this->output_section_; }
1913
494e05f4
ILT
1914 // Print the contents to the FILE. This is for debugging.
1915 void
1916 print(FILE*) const;
1917
1e5d2fb1
DK
1918 // Return the output section type if specified or Script_sections::ST_NONE.
1919 Script_sections::Section_type
1920 section_type() const;
1921
7f8cd844
NC
1922 // Store the memory region to use.
1923 void
1924 set_memory_region(Memory_region*, bool set_vma);
1925
1926 void
1927 set_section_vma(Expression* address)
1928 { this->address_ = address; }
1929
1930 void
1931 set_section_lma(Expression* address)
1932 { this->load_address_ = address; }
1933
ea5cae92
NC
1934 const std::string&
1935 get_section_name() const
7f8cd844
NC
1936 { return this->name_; }
1937
494e05f4 1938 private:
1e5d2fb1
DK
1939 static const char*
1940 script_section_type_name(Script_section_type);
1941
494e05f4
ILT
1942 typedef std::vector<Output_section_element*> Output_section_elements;
1943
1944 // The output section name.
1945 std::string name_;
1946 // The address. This may be NULL.
1947 Expression* address_;
1948 // The load address. This may be NULL.
1949 Expression* load_address_;
1950 // The alignment. This may be NULL.
1951 Expression* align_;
1952 // The input section alignment. This may be NULL.
1953 Expression* subalign_;
3802b2dd
ILT
1954 // The constraint, if any.
1955 Section_constraint constraint_;
494e05f4
ILT
1956 // The fill value. This may be NULL.
1957 Expression* fill_;
1c4f3631
ILT
1958 // The list of segments this section should go into. This may be
1959 // NULL.
1960 String_list* phdrs_;
494e05f4
ILT
1961 // The list of elements defining the section.
1962 Output_section_elements elements_;
a445fddf
ILT
1963 // The Output_section created for this definition. This will be
1964 // NULL if none was created.
1965 Output_section* output_section_;
8f2eb564
ILT
1966 // The address after it has been evaluated.
1967 uint64_t evaluated_address_;
1968 // The load address after it has been evaluated.
1969 uint64_t evaluated_load_address_;
1970 // The alignment after it has been evaluated.
1971 uint64_t evaluated_addralign_;
2d924fd9
ILT
1972 // The output section is relro.
1973 bool is_relro_;
1e5d2fb1
DK
1974 // The output section type if specified.
1975 enum Script_section_type script_section_type_;
494e05f4
ILT
1976};
1977
1978// Constructor.
1979
1980Output_section_definition::Output_section_definition(
1981 const char* name,
1982 size_t namelen,
1983 const Parser_output_section_header* header)
1984 : name_(name, namelen),
1985 address_(header->address),
1986 load_address_(header->load_address),
1987 align_(header->align),
1988 subalign_(header->subalign),
3802b2dd 1989 constraint_(header->constraint),
494e05f4 1990 fill_(NULL),
1c4f3631 1991 phdrs_(NULL),
a445fddf 1992 elements_(),
2d924fd9
ILT
1993 output_section_(NULL),
1994 evaluated_address_(0),
1995 evaluated_load_address_(0),
1996 evaluated_addralign_(0),
1e5d2fb1
DK
1997 is_relro_(false),
1998 script_section_type_(header->section_type)
494e05f4
ILT
1999{
2000}
2001
2002// Finish an output section.
2003
2004void
2005Output_section_definition::finish(const Parser_output_section_trailer* trailer)
2006{
2007 this->fill_ = trailer->fill;
1c4f3631 2008 this->phdrs_ = trailer->phdrs;
494e05f4
ILT
2009}
2010
2011// Add a symbol to be defined.
2012
2013void
2014Output_section_definition::add_symbol_assignment(const char* name,
2015 size_t length,
2016 Expression* value,
2017 bool provide,
2018 bool hidden)
2019{
2020 Output_section_element* p = new Output_section_element_assignment(name,
2021 length,
2022 value,
2023 provide,
2024 hidden);
2025 this->elements_.push_back(p);
2026}
2027
a445fddf 2028// Add an assignment to the special dot symbol.
494e05f4
ILT
2029
2030void
a445fddf
ILT
2031Output_section_definition::add_dot_assignment(Expression* value)
2032{
2033 Output_section_element* p = new Output_section_element_dot_assignment(value);
2034 this->elements_.push_back(p);
2035}
2036
2037// Add an assertion.
2038
2039void
2040Output_section_definition::add_assertion(Expression* check,
2041 const char* message,
494e05f4
ILT
2042 size_t messagelen)
2043{
2044 Output_section_element* p = new Output_section_element_assertion(check,
2045 message,
2046 messagelen);
2047 this->elements_.push_back(p);
2048}
2049
2050// Add a data item to the current output section.
2051
2052void
2053Output_section_definition::add_data(int size, bool is_signed, Expression* val)
2054{
2055 Output_section_element* p = new Output_section_element_data(size, is_signed,
2056 val);
2057 this->elements_.push_back(p);
2058}
2059
2060// Add a setting for the fill value.
2061
2062void
2063Output_section_definition::add_fill(Expression* val)
2064{
2065 Output_section_element* p = new Output_section_element_fill(val);
2066 this->elements_.push_back(p);
2067}
2068
2069// Add an input section specification.
2070
2071void
2072Output_section_definition::add_input_section(const Input_section_spec* spec,
2073 bool keep)
2074{
2075 Output_section_element* p = new Output_section_element_input(spec, keep);
2076 this->elements_.push_back(p);
2077}
2078
919ed24c
ILT
2079// Create any required output sections. We need an output section if
2080// there is a data statement here.
2081
2082void
2083Output_section_definition::create_sections(Layout* layout)
2084{
2085 if (this->output_section_ != NULL)
2086 return;
2087 for (Output_section_elements::const_iterator p = this->elements_.begin();
2088 p != this->elements_.end();
2089 ++p)
2090 {
2091 if ((*p)->needs_output_section())
2092 {
2093 const char* name = this->name_.c_str();
1e5d2fb1
DK
2094 this->output_section_ =
2095 layout->make_output_section_for_script(name, this->section_type());
919ed24c
ILT
2096 return;
2097 }
2098 }
2099}
2100
a445fddf
ILT
2101// Add any symbols being defined to the symbol table.
2102
2103void
2104Output_section_definition::add_symbols_to_table(Symbol_table* symtab)
2105{
2106 for (Output_section_elements::iterator p = this->elements_.begin();
2107 p != this->elements_.end();
2108 ++p)
2109 (*p)->add_symbols_to_table(symtab);
2110}
2111
2112// Finalize symbols and check assertions.
2113
2114void
2115Output_section_definition::finalize_symbols(Symbol_table* symtab,
2116 const Layout* layout,
a445fddf
ILT
2117 uint64_t* dot_value)
2118{
2119 if (this->output_section_ != NULL)
2120 *dot_value = this->output_section_->address();
2121 else
2122 {
2123 uint64_t address = *dot_value;
2124 if (this->address_ != NULL)
2125 {
919ed24c 2126 address = this->address_->eval_with_dot(symtab, layout, true,
77e65537 2127 *dot_value, NULL,
286adcf4 2128 NULL, NULL, false);
a445fddf
ILT
2129 }
2130 if (this->align_ != NULL)
2131 {
919ed24c 2132 uint64_t align = this->align_->eval_with_dot(symtab, layout, true,
bacff3ab 2133 *dot_value, NULL,
286adcf4 2134 NULL, NULL, false);
a445fddf
ILT
2135 address = align_address(address, align);
2136 }
2137 *dot_value = address;
2138 }
a445fddf 2139
77e65537 2140 Output_section* dot_section = this->output_section_;
a445fddf
ILT
2141 for (Output_section_elements::iterator p = this->elements_.begin();
2142 p != this->elements_.end();
2143 ++p)
77e65537 2144 (*p)->finalize_symbols(symtab, layout, dot_value, &dot_section);
a445fddf
ILT
2145}
2146
2147// Return the output section name to use for an input section name.
2148
2149const char*
1e5d2fb1
DK
2150Output_section_definition::output_section_name(
2151 const char* file_name,
2152 const char* section_name,
2153 Output_section*** slot,
b9b2ae8b
NC
2154 Script_sections::Section_type* psection_type,
2155 bool* keep)
a445fddf
ILT
2156{
2157 // Ask each element whether it matches NAME.
2158 for (Output_section_elements::const_iterator p = this->elements_.begin();
2159 p != this->elements_.end();
2160 ++p)
2161 {
b9b2ae8b 2162 if ((*p)->match_name(file_name, section_name, keep))
a445fddf
ILT
2163 {
2164 // We found a match for NAME, which means that it should go
2165 // into this output section.
2166 *slot = &this->output_section_;
1e5d2fb1 2167 *psection_type = this->section_type();
a445fddf
ILT
2168 return this->name_.c_str();
2169 }
2170 }
2171
2172 // We don't know about this section name.
2173 return NULL;
2174}
2175
ea5cae92
NC
2176// Return true if memory from START to START + LENGTH is contained
2177// within a memory region.
2178
2179bool
2180Script_sections::block_in_region(Symbol_table* symtab, Layout* layout,
2181 uint64_t start, uint64_t length) const
2182{
2183 if (this->memory_regions_ == NULL)
2184 return false;
2185
2186 for (Memory_regions::const_iterator mr = this->memory_regions_->begin();
2187 mr != this->memory_regions_->end();
2188 ++mr)
2189 {
2190 uint64_t s = (*mr)->start_address()->eval(symtab, layout, false);
2191 uint64_t l = (*mr)->length()->eval(symtab, layout, false);
2192
2193 if (s <= start
2194 && (s + l) >= (start + length))
2195 return true;
2196 }
2197
2198 return false;
2199}
2200
2201// Find a memory region that should be used by a given output SECTION.
2202// If provided set PREVIOUS_SECTION_RETURN to point to the last section
2203// that used the return memory region.
2204
2205Memory_region*
2206Script_sections::find_memory_region(
2207 Output_section_definition* section,
2208 bool find_vma_region,
2209 Output_section_definition** previous_section_return)
2210{
2211 if (previous_section_return != NULL)
2212 * previous_section_return = NULL;
2213
2214 // Walk the memory regions specified in this script, if any.
2215 if (this->memory_regions_ == NULL)
2216 return NULL;
2217
2218 // The /DISCARD/ section never gets assigned to any region.
2219 if (section->get_section_name() == "/DISCARD/")
2220 return NULL;
2221
2222 Memory_region* first_match = NULL;
2223
2224 // First check to see if a region has been assigned to this section.
2225 for (Memory_regions::const_iterator mr = this->memory_regions_->begin();
2226 mr != this->memory_regions_->end();
2227 ++mr)
2228 {
2229 if (find_vma_region)
2230 {
2231 for (Memory_region::Section_list::const_iterator s =
2232 (*mr)->get_vma_section_list_start();
2233 s != (*mr)->get_vma_section_list_end();
2234 ++s)
2235 if ((*s) == section)
2236 {
2237 (*mr)->set_last_section(section);
2238 return *mr;
2239 }
2240 }
2241 else
2242 {
2243 for (Memory_region::Section_list::const_iterator s =
2244 (*mr)->get_lma_section_list_start();
2245 s != (*mr)->get_lma_section_list_end();
2246 ++s)
2247 if ((*s) == section)
2248 {
2249 (*mr)->set_last_section(section);
2250 return *mr;
2251 }
2252 }
2253
2254 // Make a note of the first memory region whose attributes
2255 // are compatible with the section. If we do not find an
2256 // explicit region assignment, then we will return this region.
2257 Output_section* out_sec = section->get_output_section();
2258 if (first_match == NULL
3f9a3278 2259 && out_sec != NULL
ea5cae92
NC
2260 && (*mr)->attributes_compatible(out_sec->flags(),
2261 out_sec->type()))
2262 first_match = *mr;
2263 }
2264
2265 // With LMA computations, if an explicit region has not been specified then
2266 // we will want to set the difference between the VMA and the LMA of the
2267 // section were searching for to be the same as the difference between the
2268 // VMA and LMA of the last section to be added to first matched region.
2269 // Hence, if it was asked for, we return a pointer to the last section
2270 // known to be used by the first matched region.
2271 if (first_match != NULL
2272 && previous_section_return != NULL)
2273 *previous_section_return = first_match->get_last_section();
2274
2275 return first_match;
2276}
2277
a445fddf
ILT
2278// Set the section address. Note that the OUTPUT_SECTION_ field will
2279// be NULL if no input sections were mapped to this output section.
2280// We still have to adjust dot and process symbol assignments.
2281
2282void
2283Output_section_definition::set_section_addresses(Symbol_table* symtab,
2284 Layout* layout,
fd247bfe 2285 uint64_t* dot_value,
f6973bdc 2286 uint64_t* dot_alignment,
fd247bfe 2287 uint64_t* load_address)
a445fddf 2288{
ea5cae92
NC
2289 Memory_region* vma_region = NULL;
2290 Memory_region* lma_region = NULL;
2291 Script_sections* script_sections =
2292 layout->script_options()->script_sections();
a445fddf 2293 uint64_t address;
1e5d2fb1
DK
2294 uint64_t old_dot_value = *dot_value;
2295 uint64_t old_load_address = *load_address;
2296
ea5cae92
NC
2297 // Decide the start address for the section. The algorithm is:
2298 // 1) If an address has been specified in a linker script, use that.
2299 // 2) Otherwise if a memory region has been specified for the section,
2300 // use the next free address in the region.
2301 // 3) Otherwise if memory regions have been specified find the first
2302 // region whose attributes are compatible with this section and
2303 // install it into that region.
2304 // 4) Otherwise use the current location counter.
2305
2306 if (this->output_section_ != NULL
2307 // Check for --section-start.
2308 && parameters->options().section_start(this->output_section_->name(),
2309 &address))
2310 ;
2311 else if (this->address_ == NULL)
a445fddf 2312 {
ea5cae92
NC
2313 vma_region = script_sections->find_memory_region(this, true, NULL);
2314
2315 if (vma_region != NULL)
2316 address = vma_region->get_current_address()->eval(symtab, layout,
2317 false);
f4187277 2318 else
ea5cae92 2319 address = *dot_value;
a445fddf 2320 }
ea5cae92
NC
2321 else
2322 address = this->address_->eval_with_dot(symtab, layout, true,
2323 *dot_value, NULL, NULL,
286adcf4 2324 dot_alignment, false);
a445fddf
ILT
2325 uint64_t align;
2326 if (this->align_ == NULL)
2327 {
2328 if (this->output_section_ == NULL)
2329 align = 0;
2330 else
2331 align = this->output_section_->addralign();
2332 }
2333 else
2334 {
77e65537 2335 Output_section* align_section;
919ed24c 2336 align = this->align_->eval_with_dot(symtab, layout, true, *dot_value,
286adcf4 2337 NULL, &align_section, NULL, false);
77e65537
ILT
2338 if (align_section != NULL)
2339 gold_warning(_("alignment of section %s is not absolute"),
2340 this->name_.c_str());
a445fddf
ILT
2341 if (this->output_section_ != NULL)
2342 this->output_section_->set_addralign(align);
2343 }
2344
2345 address = align_address(address, align);
2346
fd247bfe
ILT
2347 uint64_t start_address = address;
2348
a445fddf 2349 *dot_value = address;
a445fddf 2350
1e5d2fb1
DK
2351 // Except for NOLOAD sections, the address of non-SHF_ALLOC sections is
2352 // forced to zero, regardless of what the linker script wants.
a445fddf 2353 if (this->output_section_ != NULL
1e5d2fb1
DK
2354 && ((this->output_section_->flags() & elfcpp::SHF_ALLOC) != 0
2355 || this->output_section_->is_noload()))
a445fddf
ILT
2356 this->output_section_->set_address(address);
2357
8f2eb564
ILT
2358 this->evaluated_address_ = address;
2359 this->evaluated_addralign_ = align;
2360
ea5cae92
NC
2361 uint64_t laddr;
2362
8f2eb564 2363 if (this->load_address_ == NULL)
ea5cae92
NC
2364 {
2365 Output_section_definition* previous_section;
2366
2367 // Determine if an LMA region has been set for this section.
2368 lma_region = script_sections->find_memory_region(this, false,
2369 &previous_section);
2370
2371 if (lma_region != NULL)
2372 {
2373 if (previous_section == NULL)
2374 // The LMA address was explicitly set to the given region.
2375 laddr = lma_region->get_current_address()->eval(symtab, layout,
2376 false);
2377 else
2378 {
2379 // We are not going to use the discovered lma_region, so
2380 // make sure that we do not update it in the code below.
2381 lma_region = NULL;
2382
2383 if (this->address_ != NULL || previous_section == this)
2384 {
2385 // Either an explicit VMA address has been set, or an
2386 // explicit VMA region has been set, so set the LMA equal to
2387 // the VMA.
2388 laddr = address;
2389 }
2390 else
2391 {
2392 // The LMA address was not explicitly or implicitly set.
2393 //
2394 // We have been given the first memory region that is
2395 // compatible with the current section and a pointer to the
2396 // last section to use this region. Set the LMA of this
2397 // section so that the difference between its' VMA and LMA
2398 // is the same as the difference between the VMA and LMA of
2399 // the last section in the given region.
2400 laddr = address + (previous_section->evaluated_load_address_
2401 - previous_section->evaluated_address_);
2402 }
2403 }
2404
2405 if (this->output_section_ != NULL)
2406 this->output_section_->set_load_address(laddr);
2407 }
2408 else
2409 {
2410 // Do not set the load address of the output section, if one exists.
2411 // This allows future sections to determine what the load address
2412 // should be. If none is ever set, it will default to being the
2413 // same as the vma address.
2414 laddr = address;
2415 }
2416 }
8f2eb564 2417 else
a445fddf 2418 {
ea5cae92
NC
2419 laddr = this->load_address_->eval_with_dot(symtab, layout, true,
2420 *dot_value,
2421 this->output_section_,
286adcf4 2422 NULL, NULL, false);
8f2eb564 2423 if (this->output_section_ != NULL)
55458500 2424 this->output_section_->set_load_address(laddr);
a445fddf
ILT
2425 }
2426
ea5cae92
NC
2427 this->evaluated_load_address_ = laddr;
2428
a445fddf
ILT
2429 uint64_t subalign;
2430 if (this->subalign_ == NULL)
2431 subalign = 0;
2432 else
2433 {
77e65537 2434 Output_section* subalign_section;
919ed24c
ILT
2435 subalign = this->subalign_->eval_with_dot(symtab, layout, true,
2436 *dot_value, NULL,
286adcf4
CC
2437 &subalign_section, NULL,
2438 false);
77e65537
ILT
2439 if (subalign_section != NULL)
2440 gold_warning(_("subalign of section %s is not absolute"),
2441 this->name_.c_str());
a445fddf
ILT
2442 }
2443
2444 std::string fill;
2445 if (this->fill_ != NULL)
2446 {
2447 // FIXME: The GNU linker supports fill values of arbitrary
2448 // length.
77e65537 2449 Output_section* fill_section;
919ed24c 2450 uint64_t fill_val = this->fill_->eval_with_dot(symtab, layout, true,
a445fddf 2451 *dot_value,
f6973bdc 2452 NULL, &fill_section,
286adcf4 2453 NULL, false);
77e65537
ILT
2454 if (fill_section != NULL)
2455 gold_warning(_("fill of section %s is not absolute"),
2456 this->name_.c_str());
a445fddf
ILT
2457 unsigned char fill_buff[4];
2458 elfcpp::Swap_unaligned<32, true>::writeval(fill_buff, fill_val);
2459 fill.assign(reinterpret_cast<char*>(fill_buff), 4);
2460 }
2461
2462 Input_section_list input_sections;
2463 if (this->output_section_ != NULL)
2464 {
2465 // Get the list of input sections attached to this output
2466 // section. This will leave the output section with only
2467 // Output_section_data entries.
2468 address += this->output_section_->get_input_sections(address,
2469 fill,
2470 &input_sections);
2471 *dot_value = address;
2472 }
2473
77e65537 2474 Output_section* dot_section = this->output_section_;
a445fddf
ILT
2475 for (Output_section_elements::iterator p = this->elements_.begin();
2476 p != this->elements_.end();
2477 ++p)
2478 (*p)->set_section_addresses(symtab, layout, this->output_section_,
f6973bdc
ILT
2479 subalign, dot_value, dot_alignment,
2480 &dot_section, &fill, &input_sections);
a445fddf
ILT
2481
2482 gold_assert(input_sections.empty());
fd247bfe 2483
ea5cae92
NC
2484 if (vma_region != NULL)
2485 {
2486 // Update the VMA region being used by the section now that we know how
2487 // big it is. Use the current address in the region, rather than
2488 // start_address because that might have been aligned upwards and we
2489 // need to allow for the padding.
2490 Expression* addr = vma_region->get_current_address();
2491 uint64_t size = *dot_value - addr->eval(symtab, layout, false);
2492
2493 vma_region->increment_offset(this->get_section_name(), size,
2494 symtab, layout);
2495 }
2496
2497 // If the LMA region is different from the VMA region, then increment the
2498 // offset there as well. Note that we use the same "dot_value -
2499 // start_address" formula that is used in the load_address assignment below.
2500 if (lma_region != NULL && lma_region != vma_region)
2501 lma_region->increment_offset(this->get_section_name(),
2502 *dot_value - start_address,
2503 symtab, layout);
2504
2505 // Compute the load address for the following section.
2506 if (this->output_section_ == NULL)
fd247bfe 2507 *load_address = *dot_value;
ea5cae92
NC
2508 else if (this->load_address_ == NULL)
2509 {
2510 if (lma_region == NULL)
2511 *load_address = *dot_value;
2512 else
2513 *load_address =
2514 lma_region->get_current_address()->eval(symtab, layout, false);
2515 }
fd247bfe
ILT
2516 else
2517 *load_address = (this->output_section_->load_address()
2518 + (*dot_value - start_address));
2d924fd9
ILT
2519
2520 if (this->output_section_ != NULL)
2521 {
2522 if (this->is_relro_)
2523 this->output_section_->set_is_relro();
2524 else
2525 this->output_section_->clear_is_relro();
1e5d2fb1
DK
2526
2527 // If this is a NOLOAD section, keep dot and load address unchanged.
2528 if (this->output_section_->is_noload())
2529 {
2530 *dot_value = old_dot_value;
2531 *load_address = old_load_address;
2532 }
2d924fd9 2533 }
a445fddf
ILT
2534}
2535
3802b2dd
ILT
2536// Check a constraint (ONLY_IF_RO, etc.) on an output section. If
2537// this section is constrained, and the input sections do not match,
2538// return the constraint, and set *POSD.
2539
2540Section_constraint
2541Output_section_definition::check_constraint(Output_section_definition** posd)
2542{
2543 switch (this->constraint_)
2544 {
2545 case CONSTRAINT_NONE:
2546 return CONSTRAINT_NONE;
2547
2548 case CONSTRAINT_ONLY_IF_RO:
2549 if (this->output_section_ != NULL
2550 && (this->output_section_->flags() & elfcpp::SHF_WRITE) != 0)
2551 {
2552 *posd = this;
2553 return CONSTRAINT_ONLY_IF_RO;
2554 }
2555 return CONSTRAINT_NONE;
2556
2557 case CONSTRAINT_ONLY_IF_RW:
2558 if (this->output_section_ != NULL
2559 && (this->output_section_->flags() & elfcpp::SHF_WRITE) == 0)
2560 {
2561 *posd = this;
2562 return CONSTRAINT_ONLY_IF_RW;
2563 }
2564 return CONSTRAINT_NONE;
2565
2566 case CONSTRAINT_SPECIAL:
2567 if (this->output_section_ != NULL)
2568 gold_error(_("SPECIAL constraints are not implemented"));
2569 return CONSTRAINT_NONE;
2570
2571 default:
2572 gold_unreachable();
2573 }
2574}
2575
2576// See if this is the alternate output section for a constrained
2577// output section. If it is, transfer the Output_section and return
2578// true. Otherwise return false.
2579
2580bool
2581Output_section_definition::alternate_constraint(
2582 Output_section_definition* posd,
2583 Section_constraint constraint)
2584{
2585 if (this->name_ != posd->name_)
2586 return false;
2587
2588 switch (constraint)
2589 {
2590 case CONSTRAINT_ONLY_IF_RO:
2591 if (this->constraint_ != CONSTRAINT_ONLY_IF_RW)
2592 return false;
2593 break;
2594
2595 case CONSTRAINT_ONLY_IF_RW:
2596 if (this->constraint_ != CONSTRAINT_ONLY_IF_RO)
2597 return false;
2598 break;
2599
2600 default:
2601 gold_unreachable();
2602 }
2603
2604 // We have found the alternate constraint. We just need to move
2605 // over the Output_section. When constraints are used properly,
2606 // THIS should not have an output_section pointer, as all the input
2607 // sections should have matched the other definition.
2608
2609 if (this->output_section_ != NULL)
2610 gold_error(_("mismatched definition for constrained sections"));
2611
2612 this->output_section_ = posd->output_section_;
2613 posd->output_section_ = NULL;
2614
2d924fd9
ILT
2615 if (this->is_relro_)
2616 this->output_section_->set_is_relro();
2617 else
2618 this->output_section_->clear_is_relro();
2619
3802b2dd
ILT
2620 return true;
2621}
2622
1c4f3631 2623// Get the list of segments to use for an allocated section when using
2cefc357 2624// a PHDRS clause.
1c4f3631
ILT
2625
2626Output_section*
2cefc357
ILT
2627Output_section_definition::allocate_to_segment(String_list** phdrs_list,
2628 bool* orphan)
1c4f3631 2629{
d103a984
RÁE
2630 // Update phdrs_list even if we don't have an output section. It
2631 // might be used by the following sections.
2632 if (this->phdrs_ != NULL)
2633 *phdrs_list = this->phdrs_;
2634
1c4f3631
ILT
2635 if (this->output_section_ == NULL)
2636 return NULL;
2637 if ((this->output_section_->flags() & elfcpp::SHF_ALLOC) == 0)
2638 return NULL;
2cefc357 2639 *orphan = false;
1c4f3631
ILT
2640 return this->output_section_;
2641}
2642
8f2eb564
ILT
2643// Look for an output section by name and return the address, the load
2644// address, the alignment, and the size. This is used when an
2645// expression refers to an output section which was not actually
2646// created. This returns true if the section was found, false
2647// otherwise.
2648
2649bool
2650Output_section_definition::get_output_section_info(const char* name,
2651 uint64_t* address,
2652 uint64_t* load_address,
2ea97941 2653 uint64_t* addralign,
8f2eb564
ILT
2654 uint64_t* size) const
2655{
2656 if (this->name_ != name)
2657 return false;
2658
2659 if (this->output_section_ != NULL)
2660 {
2661 *address = this->output_section_->address();
2662 if (this->output_section_->has_load_address())
2663 *load_address = this->output_section_->load_address();
2664 else
2665 *load_address = *address;
2ea97941 2666 *addralign = this->output_section_->addralign();
8f2eb564
ILT
2667 *size = this->output_section_->current_data_size();
2668 }
2669 else
2670 {
2671 *address = this->evaluated_address_;
2672 *load_address = this->evaluated_load_address_;
2ea97941 2673 *addralign = this->evaluated_addralign_;
8f2eb564
ILT
2674 *size = 0;
2675 }
2676
2677 return true;
2678}
2679
494e05f4
ILT
2680// Print for debugging.
2681
2682void
2683Output_section_definition::print(FILE* f) const
2684{
2685 fprintf(f, " %s ", this->name_.c_str());
2686
2687 if (this->address_ != NULL)
2688 {
2689 this->address_->print(f);
2690 fprintf(f, " ");
2691 }
2692
1e5d2fb1
DK
2693 if (this->script_section_type_ != SCRIPT_SECTION_TYPE_NONE)
2694 fprintf(f, "(%s) ",
2695 this->script_section_type_name(this->script_section_type_));
2696
494e05f4
ILT
2697 fprintf(f, ": ");
2698
2699 if (this->load_address_ != NULL)
2700 {
2701 fprintf(f, "AT(");
2702 this->load_address_->print(f);
2703 fprintf(f, ") ");
2704 }
2705
2706 if (this->align_ != NULL)
2707 {
2708 fprintf(f, "ALIGN(");
2709 this->align_->print(f);
2710 fprintf(f, ") ");
2711 }
2712
2713 if (this->subalign_ != NULL)
2714 {
2715 fprintf(f, "SUBALIGN(");
2716 this->subalign_->print(f);
2717 fprintf(f, ") ");
2718 }
2719
2720 fprintf(f, "{\n");
2721
2722 for (Output_section_elements::const_iterator p = this->elements_.begin();
2723 p != this->elements_.end();
2724 ++p)
2725 (*p)->print(f);
2726
2727 fprintf(f, " }");
2728
2729 if (this->fill_ != NULL)
2730 {
2731 fprintf(f, " = ");
2732 this->fill_->print(f);
2733 }
2734
7d26c6cc
ILT
2735 if (this->phdrs_ != NULL)
2736 {
2737 for (String_list::const_iterator p = this->phdrs_->begin();
2738 p != this->phdrs_->end();
2739 ++p)
2740 fprintf(f, " :%s", p->c_str());
2741 }
2742
494e05f4
ILT
2743 fprintf(f, "\n");
2744}
2745
1e5d2fb1
DK
2746Script_sections::Section_type
2747Output_section_definition::section_type() const
2748{
2749 switch (this->script_section_type_)
2750 {
2751 case SCRIPT_SECTION_TYPE_NONE:
2752 return Script_sections::ST_NONE;
2753 case SCRIPT_SECTION_TYPE_NOLOAD:
2754 return Script_sections::ST_NOLOAD;
2755 case SCRIPT_SECTION_TYPE_COPY:
2756 case SCRIPT_SECTION_TYPE_DSECT:
2757 case SCRIPT_SECTION_TYPE_INFO:
2758 case SCRIPT_SECTION_TYPE_OVERLAY:
2759 // There are not really support so we treat them as ST_NONE. The
2760 // parse should have issued errors for them already.
2761 return Script_sections::ST_NONE;
2762 default:
2763 gold_unreachable();
2764 }
2765}
2766
2767// Return the name of a script section type.
2768
2769const char*
ca09d69a 2770Output_section_definition::script_section_type_name(
1e5d2fb1
DK
2771 Script_section_type script_section_type)
2772{
2773 switch (script_section_type)
2774 {
2775 case SCRIPT_SECTION_TYPE_NONE:
2776 return "NONE";
2777 case SCRIPT_SECTION_TYPE_NOLOAD:
2778 return "NOLOAD";
2779 case SCRIPT_SECTION_TYPE_DSECT:
2780 return "DSECT";
2781 case SCRIPT_SECTION_TYPE_COPY:
2782 return "COPY";
2783 case SCRIPT_SECTION_TYPE_INFO:
2784 return "INFO";
2785 case SCRIPT_SECTION_TYPE_OVERLAY:
2786 return "OVERLAY";
2787 default:
2788 gold_unreachable();
2789 }
2790}
2791
7f8cd844
NC
2792void
2793Output_section_definition::set_memory_region(Memory_region* mr, bool set_vma)
2794{
2795 gold_assert(mr != NULL);
2796 // Add the current section to the specified region's list.
2797 mr->add_section(this, set_vma);
2798}
2799
a445fddf
ILT
2800// An output section created to hold orphaned input sections. These
2801// do not actually appear in linker scripts. However, for convenience
2802// when setting the output section addresses, we put a marker to these
2803// sections in the appropriate place in the list of SECTIONS elements.
2804
2805class Orphan_output_section : public Sections_element
2806{
2807 public:
2808 Orphan_output_section(Output_section* os)
2809 : os_(os)
2810 { }
2811
0d371ad3
ILT
2812 // Return whether the orphan output section is relro. We can just
2813 // check the output section because we always set the flag, if
2814 // needed, just after we create the Orphan_output_section.
a445fddf 2815 bool
0d371ad3
ILT
2816 is_relro() const
2817 { return this->os_->is_relro(); }
2818
2819 // Initialize OSP with an output section. This should have been
2820 // done already.
2821 void
2822 orphan_section_init(Orphan_section_placement*,
2823 Script_sections::Elements_iterator)
2824 { gold_unreachable(); }
a445fddf
ILT
2825
2826 // Set section addresses.
2827 void
f6973bdc
ILT
2828 set_section_addresses(Symbol_table*, Layout*, uint64_t*, uint64_t*,
2829 uint64_t*);
a445fddf 2830
1c4f3631 2831 // Get the list of segments to use for an allocated section when
2cefc357 2832 // using a PHDRS clause.
1c4f3631 2833 Output_section*
2cefc357 2834 allocate_to_segment(String_list**, bool*);
1c4f3631 2835
2d924fd9
ILT
2836 // Return the associated Output_section.
2837 Output_section*
2838 get_output_section() const
2839 { return this->os_; }
2840
a445fddf
ILT
2841 // Print for debugging.
2842 void
2843 print(FILE* f) const
2844 {
2845 fprintf(f, " marker for orphaned output section %s\n",
2846 this->os_->name());
2847 }
2848
2849 private:
2850 Output_section* os_;
2851};
2852
a445fddf
ILT
2853// Set section addresses.
2854
2855void
2856Orphan_output_section::set_section_addresses(Symbol_table*, Layout*,
fd247bfe 2857 uint64_t* dot_value,
f6973bdc 2858 uint64_t*,
fd247bfe 2859 uint64_t* load_address)
a445fddf 2860{
6625d24e 2861 typedef std::list<Output_section::Input_section> Input_section_list;
a445fddf 2862
fd247bfe
ILT
2863 bool have_load_address = *load_address != *dot_value;
2864
a445fddf
ILT
2865 uint64_t address = *dot_value;
2866 address = align_address(address, this->os_->addralign());
2867
a94907d9
ILT
2868 // For a relocatable link, all orphan sections are put at
2869 // address 0. In general we expect all sections to be at
2870 // address 0 for a relocatable link, but we permit the linker
2871 // script to override that for specific output sections.
2872 if (parameters->options().relocatable())
2873 {
2874 address = 0;
2875 *load_address = 0;
2876 have_load_address = false;
2877 }
2878
a445fddf 2879 if ((this->os_->flags() & elfcpp::SHF_ALLOC) != 0)
fd247bfe
ILT
2880 {
2881 this->os_->set_address(address);
2882 if (have_load_address)
2883 this->os_->set_load_address(align_address(*load_address,
2884 this->os_->addralign()));
2885 }
a445fddf
ILT
2886
2887 Input_section_list input_sections;
2888 address += this->os_->get_input_sections(address, "", &input_sections);
2889
2890 for (Input_section_list::iterator p = input_sections.begin();
2891 p != input_sections.end();
2892 ++p)
2893 {
6625d24e
DK
2894 uint64_t addralign = p->addralign();
2895 if (!p->is_input_section())
2896 p->output_section_data()->finalize_data_size();
2897 uint64_t size = p->data_size();
2ea97941 2898 address = align_address(address, addralign);
6625d24e 2899 this->os_->add_script_input_section(*p);
a445fddf
ILT
2900 address += size;
2901 }
2902
661be1e2
ILT
2903 // An SHF_TLS/SHT_NOBITS section does not take up any address space.
2904 if (this->os_ == NULL
2905 || (this->os_->flags() & elfcpp::SHF_TLS) == 0
2906 || this->os_->type() != elfcpp::SHT_NOBITS)
2907 {
2908 if (!have_load_address)
2909 *load_address = address;
2910 else
2911 *load_address += address - *dot_value;
fd247bfe 2912
661be1e2
ILT
2913 *dot_value = address;
2914 }
a445fddf
ILT
2915}
2916
1c4f3631
ILT
2917// Get the list of segments to use for an allocated section when using
2918// a PHDRS clause. If this is an allocated section, return the
2919// Output_section. We don't change the list of segments.
2920
2921Output_section*
2cefc357 2922Orphan_output_section::allocate_to_segment(String_list**, bool* orphan)
1c4f3631
ILT
2923{
2924 if ((this->os_->flags() & elfcpp::SHF_ALLOC) == 0)
2925 return NULL;
2cefc357 2926 *orphan = true;
1c4f3631
ILT
2927 return this->os_;
2928}
2929
2930// Class Phdrs_element. A program header from a PHDRS clause.
2931
2932class Phdrs_element
2933{
2934 public:
2ea97941
ILT
2935 Phdrs_element(const char* name, size_t namelen, unsigned int type,
2936 bool includes_filehdr, bool includes_phdrs,
1c4f3631 2937 bool is_flags_valid, unsigned int flags,
2ea97941
ILT
2938 Expression* load_address)
2939 : name_(name, namelen), type_(type), includes_filehdr_(includes_filehdr),
2940 includes_phdrs_(includes_phdrs), is_flags_valid_(is_flags_valid),
2941 flags_(flags), load_address_(load_address), load_address_value_(0),
1c4f3631
ILT
2942 segment_(NULL)
2943 { }
2944
2945 // Return the name of this segment.
2946 const std::string&
2947 name() const
2948 { return this->name_; }
2949
2950 // Return the type of the segment.
2951 unsigned int
2952 type() const
2953 { return this->type_; }
2954
2955 // Whether to include the file header.
2956 bool
2957 includes_filehdr() const
2958 { return this->includes_filehdr_; }
2959
2960 // Whether to include the program headers.
2961 bool
2962 includes_phdrs() const
2963 { return this->includes_phdrs_; }
2964
2965 // Return whether there is a load address.
2966 bool
2967 has_load_address() const
2968 { return this->load_address_ != NULL; }
2969
2970 // Evaluate the load address expression if there is one.
2971 void
2ea97941 2972 eval_load_address(Symbol_table* symtab, Layout* layout)
1c4f3631
ILT
2973 {
2974 if (this->load_address_ != NULL)
2ea97941 2975 this->load_address_value_ = this->load_address_->eval(symtab, layout,
919ed24c 2976 true);
1c4f3631
ILT
2977 }
2978
2979 // Return the load address.
2980 uint64_t
2981 load_address() const
2982 {
2983 gold_assert(this->load_address_ != NULL);
2984 return this->load_address_value_;
2985 }
2986
2987 // Create the segment.
2988 Output_segment*
2989 create_segment(Layout* layout)
2990 {
2991 this->segment_ = layout->make_output_segment(this->type_, this->flags_);
2992 return this->segment_;
2993 }
2994
2995 // Return the segment.
2996 Output_segment*
2997 segment()
2998 { return this->segment_; }
2999
20e6d0d6
DK
3000 // Release the segment.
3001 void
3002 release_segment()
3003 { this->segment_ = NULL; }
3004
1c4f3631
ILT
3005 // Set the segment flags if appropriate.
3006 void
3007 set_flags_if_valid()
3008 {
3009 if (this->is_flags_valid_)
3010 this->segment_->set_flags(this->flags_);
3011 }
3012
7d26c6cc
ILT
3013 // Print for debugging.
3014 void
3015 print(FILE*) const;
3016
1c4f3631
ILT
3017 private:
3018 // The name used in the script.
3019 std::string name_;
3020 // The type of the segment (PT_LOAD, etc.).
3021 unsigned int type_;
3022 // Whether this segment includes the file header.
3023 bool includes_filehdr_;
3024 // Whether this segment includes the section headers.
3025 bool includes_phdrs_;
3026 // Whether the flags were explicitly specified.
3027 bool is_flags_valid_;
3028 // The flags for this segment (PF_R, etc.) if specified.
3029 unsigned int flags_;
3030 // The expression for the load address for this segment. This may
3031 // be NULL.
3032 Expression* load_address_;
3033 // The actual load address from evaluating the expression.
3034 uint64_t load_address_value_;
3035 // The segment itself.
3036 Output_segment* segment_;
3037};
3038
7d26c6cc
ILT
3039// Print for debugging.
3040
3041void
3042Phdrs_element::print(FILE* f) const
3043{
3044 fprintf(f, " %s 0x%x", this->name_.c_str(), this->type_);
3045 if (this->includes_filehdr_)
3046 fprintf(f, " FILEHDR");
3047 if (this->includes_phdrs_)
3048 fprintf(f, " PHDRS");
3049 if (this->is_flags_valid_)
3050 fprintf(f, " FLAGS(%u)", this->flags_);
3051 if (this->load_address_ != NULL)
3052 {
3053 fprintf(f, " AT(");
3054 this->load_address_->print(f);
3055 fprintf(f, ")");
3056 }
3057 fprintf(f, ";\n");
3058}
3059
7f8cd844
NC
3060// Add a memory region.
3061
3062void
3063Script_sections::add_memory_region(const char* name, size_t namelen,
3064 unsigned int attributes,
3065 Expression* start, Expression* length)
3066{
3067 if (this->memory_regions_ == NULL)
3068 this->memory_regions_ = new Memory_regions();
3069 else if (this->find_memory_region(name, namelen))
3070 {
ea5cae92 3071 gold_error(_("region '%.*s' already defined"), static_cast<int>(namelen),
33dbc701 3072 name);
7f8cd844
NC
3073 // FIXME: Add a GOLD extension to allow multiple regions with the same
3074 // name. This would amount to a single region covering disjoint blocks
3075 // of memory, which is useful for embedded devices.
3076 }
3077
3078 // FIXME: Check the length and start values. Currently we allow
3079 // non-constant expressions for these values, whereas LD does not.
3080
3081 // FIXME: Add a GOLD extension to allow NEGATIVE LENGTHS. This would
3082 // describe a region that packs from the end address going down, rather
3083 // than the start address going up. This would be useful for embedded
3084 // devices.
3085
3086 this->memory_regions_->push_back(new Memory_region(name, namelen, attributes,
3087 start, length));
3088}
3089
3090// Find a memory region.
3091
3092Memory_region*
3093Script_sections::find_memory_region(const char* name, size_t namelen)
3094{
3095 if (this->memory_regions_ == NULL)
3096 return NULL;
3097
3098 for (Memory_regions::const_iterator m = this->memory_regions_->begin();
3099 m != this->memory_regions_->end();
3100 ++m)
3101 if ((*m)->name_match(name, namelen))
3102 return *m;
3103
3104 return NULL;
3105}
3106
3107// Find a memory region's origin.
3108
3109Expression*
3110Script_sections::find_memory_region_origin(const char* name, size_t namelen)
3111{
3112 Memory_region* mr = find_memory_region(name, namelen);
3113 if (mr == NULL)
3114 return NULL;
3115
3116 return mr->start_address();
3117}
3118
3119// Find a memory region's length.
3120
3121Expression*
3122Script_sections::find_memory_region_length(const char* name, size_t namelen)
3123{
3124 Memory_region* mr = find_memory_region(name, namelen);
3125 if (mr == NULL)
3126 return NULL;
3127
3128 return mr->length();
3129}
3130
3131// Set the memory region to use for the current section.
3132
3133void
3134Script_sections::set_memory_region(Memory_region* mr, bool set_vma)
3135{
3136 gold_assert(!this->sections_elements_->empty());
3137 this->sections_elements_->back()->set_memory_region(mr, set_vma);
3138}
3139
494e05f4
ILT
3140// Class Script_sections.
3141
3142Script_sections::Script_sections()
3143 : saw_sections_clause_(false),
3144 in_sections_clause_(false),
3145 sections_elements_(NULL),
1c4f3631 3146 output_section_(NULL),
7f8cd844 3147 memory_regions_(NULL),
2d924fd9 3148 phdrs_elements_(NULL),
0d371ad3
ILT
3149 orphan_section_placement_(NULL),
3150 data_segment_align_start_(),
3151 saw_data_segment_align_(false),
3c12dcdb
DK
3152 saw_relro_end_(false),
3153 saw_segment_start_expression_(false)
494e05f4
ILT
3154{
3155}
3156
3157// Start a SECTIONS clause.
3158
3159void
3160Script_sections::start_sections()
3161{
3162 gold_assert(!this->in_sections_clause_ && this->output_section_ == NULL);
3163 this->saw_sections_clause_ = true;
3164 this->in_sections_clause_ = true;
3165 if (this->sections_elements_ == NULL)
3166 this->sections_elements_ = new Sections_elements;
3167}
3168
3169// Finish a SECTIONS clause.
3170
3171void
3172Script_sections::finish_sections()
3173{
3174 gold_assert(this->in_sections_clause_ && this->output_section_ == NULL);
3175 this->in_sections_clause_ = false;
3176}
3177
3178// Add a symbol to be defined.
3179
3180void
3181Script_sections::add_symbol_assignment(const char* name, size_t length,
3182 Expression* val, bool provide,
3183 bool hidden)
3184{
3185 if (this->output_section_ != NULL)
3186 this->output_section_->add_symbol_assignment(name, length, val,
3187 provide, hidden);
3188 else
3189 {
3190 Sections_element* p = new Sections_element_assignment(name, length,
3191 val, provide,
3192 hidden);
3193 this->sections_elements_->push_back(p);
3194 }
3195}
3196
a445fddf
ILT
3197// Add an assignment to the special dot symbol.
3198
3199void
3200Script_sections::add_dot_assignment(Expression* val)
3201{
3202 if (this->output_section_ != NULL)
3203 this->output_section_->add_dot_assignment(val);
3204 else
3205 {
12edd763
ILT
3206 // The GNU linker permits assignments to . to appears outside of
3207 // a SECTIONS clause, and treats it as appearing inside, so
3208 // sections_elements_ may be NULL here.
3209 if (this->sections_elements_ == NULL)
3210 {
3211 this->sections_elements_ = new Sections_elements;
3212 this->saw_sections_clause_ = true;
3213 }
3214
a445fddf
ILT
3215 Sections_element* p = new Sections_element_dot_assignment(val);
3216 this->sections_elements_->push_back(p);
3217 }
3218}
3219
494e05f4
ILT
3220// Add an assertion.
3221
3222void
3223Script_sections::add_assertion(Expression* check, const char* message,
3224 size_t messagelen)
3225{
3226 if (this->output_section_ != NULL)
3227 this->output_section_->add_assertion(check, message, messagelen);
3228 else
3229 {
3230 Sections_element* p = new Sections_element_assertion(check, message,
3231 messagelen);
3232 this->sections_elements_->push_back(p);
3233 }
3234}
3235
3236// Start processing entries for an output section.
3237
3238void
3239Script_sections::start_output_section(
3240 const char* name,
3241 size_t namelen,
ca09d69a 3242 const Parser_output_section_header* header)
494e05f4
ILT
3243{
3244 Output_section_definition* posd = new Output_section_definition(name,
3245 namelen,
3246 header);
3247 this->sections_elements_->push_back(posd);
3248 gold_assert(this->output_section_ == NULL);
3249 this->output_section_ = posd;
3250}
3251
3252// Stop processing entries for an output section.
3253
3254void
3255Script_sections::finish_output_section(
3256 const Parser_output_section_trailer* trailer)
3257{
3258 gold_assert(this->output_section_ != NULL);
3259 this->output_section_->finish(trailer);
3260 this->output_section_ = NULL;
3261}
3262
3263// Add a data item to the current output section.
3264
3265void
3266Script_sections::add_data(int size, bool is_signed, Expression* val)
3267{
3268 gold_assert(this->output_section_ != NULL);
3269 this->output_section_->add_data(size, is_signed, val);
3270}
3271
3272// Add a fill value setting to the current output section.
3273
3274void
3275Script_sections::add_fill(Expression* val)
3276{
3277 gold_assert(this->output_section_ != NULL);
3278 this->output_section_->add_fill(val);
3279}
3280
3281// Add an input section specification to the current output section.
3282
3283void
3284Script_sections::add_input_section(const Input_section_spec* spec, bool keep)
3285{
3286 gold_assert(this->output_section_ != NULL);
3287 this->output_section_->add_input_section(spec, keep);
3288}
3289
2d924fd9
ILT
3290// This is called when we see DATA_SEGMENT_ALIGN. It means that any
3291// subsequent output sections may be relro.
3292
3293void
3294Script_sections::data_segment_align()
3295{
0d371ad3 3296 if (this->saw_data_segment_align_)
2d924fd9 3297 gold_error(_("DATA_SEGMENT_ALIGN may only appear once in a linker script"));
0d371ad3
ILT
3298 gold_assert(!this->sections_elements_->empty());
3299 Sections_elements::iterator p = this->sections_elements_->end();
3300 --p;
3301 this->data_segment_align_start_ = p;
3302 this->saw_data_segment_align_ = true;
2d924fd9
ILT
3303}
3304
3305// This is called when we see DATA_SEGMENT_RELRO_END. It means that
3306// any output sections seen since DATA_SEGMENT_ALIGN are relro.
3307
3308void
3309Script_sections::data_segment_relro_end()
3310{
3311 if (this->saw_relro_end_)
3312 gold_error(_("DATA_SEGMENT_RELRO_END may only appear once "
3313 "in a linker script"));
3314 this->saw_relro_end_ = true;
3315
0d371ad3 3316 if (!this->saw_data_segment_align_)
2d924fd9
ILT
3317 gold_error(_("DATA_SEGMENT_RELRO_END must follow DATA_SEGMENT_ALIGN"));
3318 else
3319 {
0d371ad3
ILT
3320 Sections_elements::iterator p = this->data_segment_align_start_;
3321 for (++p; p != this->sections_elements_->end(); ++p)
3322 (*p)->set_is_relro();
2d924fd9
ILT
3323 }
3324}
3325
919ed24c
ILT
3326// Create any required sections.
3327
3328void
3329Script_sections::create_sections(Layout* layout)
3330{
3331 if (!this->saw_sections_clause_)
3332 return;
3333 for (Sections_elements::iterator p = this->sections_elements_->begin();
3334 p != this->sections_elements_->end();
3335 ++p)
3336 (*p)->create_sections(layout);
3337}
3338
a445fddf
ILT
3339// Add any symbols we are defining to the symbol table.
3340
3341void
3342Script_sections::add_symbols_to_table(Symbol_table* symtab)
3343{
3344 if (!this->saw_sections_clause_)
3345 return;
3346 for (Sections_elements::iterator p = this->sections_elements_->begin();
3347 p != this->sections_elements_->end();
3348 ++p)
3349 (*p)->add_symbols_to_table(symtab);
3350}
3351
3352// Finalize symbols and check assertions.
3353
3354void
3355Script_sections::finalize_symbols(Symbol_table* symtab, const Layout* layout)
3356{
3357 if (!this->saw_sections_clause_)
3358 return;
a445fddf
ILT
3359 uint64_t dot_value = 0;
3360 for (Sections_elements::iterator p = this->sections_elements_->begin();
3361 p != this->sections_elements_->end();
3362 ++p)
77e65537 3363 (*p)->finalize_symbols(symtab, layout, &dot_value);
a445fddf
ILT
3364}
3365
3366// Return the name of the output section to use for an input file name
3367// and section name.
3368
3369const char*
1e5d2fb1
DK
3370Script_sections::output_section_name(
3371 const char* file_name,
3372 const char* section_name,
3373 Output_section*** output_section_slot,
b9b2ae8b
NC
3374 Script_sections::Section_type* psection_type,
3375 bool* keep)
a445fddf
ILT
3376{
3377 for (Sections_elements::const_iterator p = this->sections_elements_->begin();
3378 p != this->sections_elements_->end();
3379 ++p)
3380 {
3381 const char* ret = (*p)->output_section_name(file_name, section_name,
1e5d2fb1 3382 output_section_slot,
b9b2ae8b 3383 psection_type, keep);
a445fddf
ILT
3384
3385 if (ret != NULL)
3386 {
3387 // The special name /DISCARD/ means that the input section
3388 // should be discarded.
3389 if (strcmp(ret, "/DISCARD/") == 0)
3390 {
3391 *output_section_slot = NULL;
1e5d2fb1 3392 *psection_type = Script_sections::ST_NONE;
a445fddf
ILT
3393 return NULL;
3394 }
3395 return ret;
3396 }
3397 }
3398
3399 // If we couldn't find a mapping for the name, the output section
3400 // gets the name of the input section.
3401
3402 *output_section_slot = NULL;
1e5d2fb1 3403 *psection_type = Script_sections::ST_NONE;
a445fddf
ILT
3404
3405 return section_name;
3406}
3407
3408// Place a marker for an orphan output section into the SECTIONS
3409// clause.
3410
3411void
3412Script_sections::place_orphan(Output_section* os)
3413{
0d371ad3
ILT
3414 Orphan_section_placement* osp = this->orphan_section_placement_;
3415 if (osp == NULL)
a445fddf 3416 {
0d371ad3
ILT
3417 // Initialize the Orphan_section_placement structure.
3418 osp = new Orphan_section_placement();
3419 for (Sections_elements::iterator p = this->sections_elements_->begin();
3420 p != this->sections_elements_->end();
3421 ++p)
3422 (*p)->orphan_section_init(osp, p);
3423 gold_assert(!this->sections_elements_->empty());
3424 Sections_elements::iterator last = this->sections_elements_->end();
3425 --last;
3426 osp->last_init(last);
3427 this->orphan_section_placement_ = osp;
a445fddf
ILT
3428 }
3429
0d371ad3 3430 Orphan_output_section* orphan = new Orphan_output_section(os);
2d924fd9 3431
0d371ad3
ILT
3432 // Look for where to put ORPHAN.
3433 Sections_elements::iterator* where;
3434 if (osp->find_place(os, &where))
3435 {
3436 if ((**where)->is_relro())
3437 os->set_is_relro();
3438 else
3439 os->clear_is_relro();
3440
3441 // We want to insert ORPHAN after *WHERE, and then update *WHERE
3442 // so that the next one goes after this one.
3443 Sections_elements::iterator p = *where;
3444 gold_assert(p != this->sections_elements_->end());
3445 ++p;
3446 *where = this->sections_elements_->insert(p, orphan);
3447 }
2d924fd9 3448 else
0d371ad3
ILT
3449 {
3450 os->clear_is_relro();
3451 // We don't have a place to put this orphan section. Put it,
3452 // and all other sections like it, at the end, but before the
3453 // sections which always come at the end.
3454 Sections_elements::iterator last = osp->last_place();
3455 *where = this->sections_elements_->insert(last, orphan);
3456 }
a445fddf
ILT
3457}
3458
3459// Set the addresses of all the output sections. Walk through all the
3460// elements, tracking the dot symbol. Apply assignments which set
3461// absolute symbol values, in case they are used when setting dot.
3462// Fill in data statement values. As we find output sections, set the
3463// address, set the address of all associated input sections, and
3464// update dot. Return the segment which should hold the file header
3465// and segment headers, if any.
3466
3467Output_segment*
3468Script_sections::set_section_addresses(Symbol_table* symtab, Layout* layout)
3469{
3470 gold_assert(this->saw_sections_clause_);
7f8cd844 3471
3802b2dd
ILT
3472 // Implement ONLY_IF_RO/ONLY_IF_RW constraints. These are a pain
3473 // for our representation.
3474 for (Sections_elements::iterator p = this->sections_elements_->begin();
3475 p != this->sections_elements_->end();
3476 ++p)
3477 {
3478 Output_section_definition* posd;
3479 Section_constraint failed_constraint = (*p)->check_constraint(&posd);
3480 if (failed_constraint != CONSTRAINT_NONE)
3481 {
3482 Sections_elements::iterator q;
3483 for (q = this->sections_elements_->begin();
3484 q != this->sections_elements_->end();
3485 ++q)
3486 {
3487 if (q != p)
3488 {
3489 if ((*q)->alternate_constraint(posd, failed_constraint))
3490 break;
3491 }
3492 }
3493
3494 if (q == this->sections_elements_->end())
3495 gold_error(_("no matching section constraint"));
3496 }
3497 }
3498
2d924fd9
ILT
3499 // Force the alignment of the first TLS section to be the maximum
3500 // alignment of all TLS sections.
3501 Output_section* first_tls = NULL;
3502 uint64_t tls_align = 0;
3503 for (Sections_elements::const_iterator p = this->sections_elements_->begin();
3504 p != this->sections_elements_->end();
3505 ++p)
3506 {
ca09d69a 3507 Output_section* os = (*p)->get_output_section();
2d924fd9
ILT
3508 if (os != NULL && (os->flags() & elfcpp::SHF_TLS) != 0)
3509 {
3510 if (first_tls == NULL)
3511 first_tls = os;
3512 if (os->addralign() > tls_align)
3513 tls_align = os->addralign();
3514 }
3515 }
3516 if (first_tls != NULL)
3517 first_tls->set_addralign(tls_align);
3518
77e65537 3519 // For a relocatable link, we implicitly set dot to zero.
a445fddf 3520 uint64_t dot_value = 0;
f6973bdc 3521 uint64_t dot_alignment = 0;
fd247bfe 3522 uint64_t load_address = 0;
3c12dcdb
DK
3523
3524 // Check to see if we want to use any of -Ttext, -Tdata and -Tbss options
3525 // to set section addresses. If the script has any SEGMENT_START
3526 // expression, we do not set the section addresses.
3527 bool use_tsection_options =
3528 (!this->saw_segment_start_expression_
3529 && (parameters->options().user_set_Ttext()
3530 || parameters->options().user_set_Tdata()
3531 || parameters->options().user_set_Tbss()));
3532
a445fddf
ILT
3533 for (Sections_elements::iterator p = this->sections_elements_->begin();
3534 p != this->sections_elements_->end();
3535 ++p)
3c12dcdb
DK
3536 {
3537 Output_section* os = (*p)->get_output_section();
3538
3539 // Handle -Ttext, -Tdata and -Tbss options. We do this by looking for
3540 // the special sections by names and doing dot assignments.
3541 if (use_tsection_options
3542 && os != NULL
3543 && (os->flags() & elfcpp::SHF_ALLOC) != 0)
3544 {
3545 uint64_t new_dot_value = dot_value;
3546
3547 if (parameters->options().user_set_Ttext()
3548 && strcmp(os->name(), ".text") == 0)
3549 new_dot_value = parameters->options().Ttext();
3550 else if (parameters->options().user_set_Tdata()
3551 && strcmp(os->name(), ".data") == 0)
3552 new_dot_value = parameters->options().Tdata();
3553 else if (parameters->options().user_set_Tbss()
3554 && strcmp(os->name(), ".bss") == 0)
3555 new_dot_value = parameters->options().Tbss();
3556
3557 // Update dot and load address if necessary.
3558 if (new_dot_value < dot_value)
3559 gold_error(_("dot may not move backward"));
3560 else if (new_dot_value != dot_value)
3561 {
3562 dot_value = new_dot_value;
3563 load_address = new_dot_value;
3564 }
3565 }
3566
f6973bdc
ILT
3567 (*p)->set_section_addresses(symtab, layout, &dot_value, &dot_alignment,
3568 &load_address);
3c12dcdb 3569 }
a445fddf 3570
1c4f3631
ILT
3571 if (this->phdrs_elements_ != NULL)
3572 {
3573 for (Phdrs_elements::iterator p = this->phdrs_elements_->begin();
3574 p != this->phdrs_elements_->end();
3575 ++p)
3576 (*p)->eval_load_address(symtab, layout);
3577 }
3578
f6973bdc 3579 return this->create_segments(layout, dot_alignment);
a445fddf
ILT
3580}
3581
3582// Sort the sections in order to put them into segments.
3583
3584class Sort_output_sections
3585{
3586 public:
eb373049
ILT
3587 Sort_output_sections(const Script_sections::Sections_elements* elements)
3588 : elements_(elements)
3589 { }
3590
a445fddf
ILT
3591 bool
3592 operator()(const Output_section* os1, const Output_section* os2) const;
eb373049
ILT
3593
3594 private:
fd7a005d
ILT
3595 int
3596 script_compare(const Output_section* os1, const Output_section* os2) const;
eb373049
ILT
3597
3598 private:
3599 const Script_sections::Sections_elements* elements_;
a445fddf
ILT
3600};
3601
3602bool
3603Sort_output_sections::operator()(const Output_section* os1,
3604 const Output_section* os2) const
3605{
3606 // Sort first by the load address.
3607 uint64_t lma1 = (os1->has_load_address()
3608 ? os1->load_address()
3609 : os1->address());
3610 uint64_t lma2 = (os2->has_load_address()
3611 ? os2->load_address()
3612 : os2->address());
3613 if (lma1 != lma2)
3614 return lma1 < lma2;
3615
3616 // Then sort by the virtual address.
3617 if (os1->address() != os2->address())
3618 return os1->address() < os2->address();
3619
fd7a005d
ILT
3620 // If the linker script says which of these sections is first, go
3621 // with what it says.
3622 int i = this->script_compare(os1, os2);
3623 if (i != 0)
3624 return i < 0;
3625
0aa45fac
CC
3626 // Sort PROGBITS before NOBITS.
3627 bool nobits1 = os1->type() == elfcpp::SHT_NOBITS;
3628 bool nobits2 = os2->type() == elfcpp::SHT_NOBITS;
3629 if (nobits1 != nobits2)
3630 return nobits2;
3631
3632 // Sort PROGBITS TLS sections to the end, NOBITS TLS sections to the
3633 // beginning.
a445fddf
ILT
3634 bool tls1 = (os1->flags() & elfcpp::SHF_TLS) != 0;
3635 bool tls2 = (os2->flags() & elfcpp::SHF_TLS) != 0;
3636 if (tls1 != tls2)
0aa45fac 3637 return nobits1 ? tls1 : tls2;
a445fddf 3638
1e5d2fb1
DK
3639 // Sort non-NOLOAD before NOLOAD.
3640 if (os1->is_noload() && !os2->is_noload())
3641 return true;
3642 if (!os1->is_noload() && os2->is_noload())
3643 return true;
fd7a005d
ILT
3644
3645 // The sections seem practically identical. Sort by name to get a
3646 // stable sort.
3647 return os1->name() < os2->name();
eb373049
ILT
3648}
3649
fd7a005d
ILT
3650// Return -1 if OS1 comes before OS2 in ELEMENTS_, 1 if comes after, 0
3651// if either OS1 or OS2 is not mentioned. This ensures that we keep
3652// empty sections in the order in which they appear in a linker
3653// script.
eb373049 3654
fd7a005d
ILT
3655int
3656Sort_output_sections::script_compare(const Output_section* os1,
3657 const Output_section* os2) const
eb373049
ILT
3658{
3659 if (this->elements_ == NULL)
fd7a005d 3660 return 0;
eb373049 3661
fd7a005d
ILT
3662 bool found_os1 = false;
3663 bool found_os2 = false;
eb373049
ILT
3664 for (Script_sections::Sections_elements::const_iterator
3665 p = this->elements_->begin();
3666 p != this->elements_->end();
3667 ++p)
3668 {
fd7a005d 3669 if (os2 == (*p)->get_output_section())
eb373049 3670 {
fd7a005d
ILT
3671 if (found_os1)
3672 return -1;
3673 found_os2 = true;
3674 }
3675 else if (os1 == (*p)->get_output_section())
3676 {
3677 if (found_os2)
3678 return 1;
3679 found_os1 = true;
eb373049
ILT
3680 }
3681 }
3682
fd7a005d 3683 return 0;
a445fddf
ILT
3684}
3685
3686// Return whether OS is a BSS section. This is a SHT_NOBITS section.
3687// We treat a section with the SHF_TLS flag set as taking up space
3688// even if it is SHT_NOBITS (this is true of .tbss), as we allocate
3689// space for them in the file.
3690
3691bool
3692Script_sections::is_bss_section(const Output_section* os)
3693{
3694 return (os->type() == elfcpp::SHT_NOBITS
3695 && (os->flags() & elfcpp::SHF_TLS) == 0);
3696}
3697
1c4f3631
ILT
3698// Return the size taken by the file header and the program headers.
3699
3700size_t
3701Script_sections::total_header_size(Layout* layout) const
3702{
3703 size_t segment_count = layout->segment_count();
3704 size_t file_header_size;
3705 size_t segment_headers_size;
8851ecca 3706 if (parameters->target().get_size() == 32)
1c4f3631
ILT
3707 {
3708 file_header_size = elfcpp::Elf_sizes<32>::ehdr_size;
3709 segment_headers_size = segment_count * elfcpp::Elf_sizes<32>::phdr_size;
3710 }
8851ecca 3711 else if (parameters->target().get_size() == 64)
1c4f3631
ILT
3712 {
3713 file_header_size = elfcpp::Elf_sizes<64>::ehdr_size;
3714 segment_headers_size = segment_count * elfcpp::Elf_sizes<64>::phdr_size;
3715 }
3716 else
3717 gold_unreachable();
3718
3719 return file_header_size + segment_headers_size;
3720}
3721
9b547ce6 3722// Return the amount we have to subtract from the LMA to accommodate
1c4f3631
ILT
3723// headers of the given size. The complication is that the file
3724// header have to be at the start of a page, as otherwise it will not
3725// be at the start of the file.
3726
3727uint64_t
3728Script_sections::header_size_adjustment(uint64_t lma,
3729 size_t sizeof_headers) const
3730{
8851ecca 3731 const uint64_t abi_pagesize = parameters->target().abi_pagesize();
1c4f3631
ILT
3732 uint64_t hdr_lma = lma - sizeof_headers;
3733 hdr_lma &= ~(abi_pagesize - 1);
3734 return lma - hdr_lma;
3735}
3736
a445fddf
ILT
3737// Create the PT_LOAD segments when using a SECTIONS clause. Returns
3738// the segment which should hold the file header and segment headers,
3739// if any.
3740
3741Output_segment*
f6973bdc 3742Script_sections::create_segments(Layout* layout, uint64_t dot_alignment)
a445fddf
ILT
3743{
3744 gold_assert(this->saw_sections_clause_);
3745
8851ecca 3746 if (parameters->options().relocatable())
a445fddf
ILT
3747 return NULL;
3748
1c4f3631 3749 if (this->saw_phdrs_clause())
f6973bdc 3750 return create_segments_from_phdrs_clause(layout, dot_alignment);
1c4f3631 3751
a445fddf
ILT
3752 Layout::Section_list sections;
3753 layout->get_allocated_sections(&sections);
3754
3755 // Sort the sections by address.
eb373049
ILT
3756 std::stable_sort(sections.begin(), sections.end(),
3757 Sort_output_sections(this->sections_elements_));
a445fddf
ILT
3758
3759 this->create_note_and_tls_segments(layout, &sections);
3760
3761 // Walk through the sections adding them to PT_LOAD segments.
8851ecca 3762 const uint64_t abi_pagesize = parameters->target().abi_pagesize();
a445fddf
ILT
3763 Output_segment* first_seg = NULL;
3764 Output_segment* current_seg = NULL;
3765 bool is_current_seg_readonly = true;
3766 Layout::Section_list::iterator plast = sections.end();
3767 uint64_t last_vma = 0;
3768 uint64_t last_lma = 0;
3769 uint64_t last_size = 0;
3770 for (Layout::Section_list::iterator p = sections.begin();
3771 p != sections.end();
3772 ++p)
3773 {
3774 const uint64_t vma = (*p)->address();
3775 const uint64_t lma = ((*p)->has_load_address()
3776 ? (*p)->load_address()
3777 : vma);
3778 const uint64_t size = (*p)->current_data_size();
3779
3780 bool need_new_segment;
3781 if (current_seg == NULL)
3782 need_new_segment = true;
3783 else if (lma - vma != last_lma - last_vma)
3784 {
3785 // This section has a different LMA relationship than the
3786 // last one; we need a new segment.
3787 need_new_segment = true;
3788 }
3789 else if (align_address(last_lma + last_size, abi_pagesize)
3790 < align_address(lma, abi_pagesize))
3791 {
3792 // Putting this section in the segment would require
3793 // skipping a page.
3794 need_new_segment = true;
3795 }
3796 else if (is_bss_section(*plast) && !is_bss_section(*p))
3797 {
3798 // A non-BSS section can not follow a BSS section in the
3799 // same segment.
3800 need_new_segment = true;
3801 }
3802 else if (is_current_seg_readonly
af6156ef
ILT
3803 && ((*p)->flags() & elfcpp::SHF_WRITE) != 0
3804 && !parameters->options().omagic())
a445fddf
ILT
3805 {
3806 // Don't put a writable section in the same segment as a
3807 // non-writable section.
3808 need_new_segment = true;
3809 }
3810 else
3811 {
3812 // Otherwise, reuse the existing segment.
3813 need_new_segment = false;
3814 }
3815
3816 elfcpp::Elf_Word seg_flags =
3817 Layout::section_flags_to_segment((*p)->flags());
3818
3819 if (need_new_segment)
3820 {
3821 current_seg = layout->make_output_segment(elfcpp::PT_LOAD,
3822 seg_flags);
3823 current_seg->set_addresses(vma, lma);
f6973bdc 3824 current_seg->set_minimum_p_align(dot_alignment);
a445fddf
ILT
3825 if (first_seg == NULL)
3826 first_seg = current_seg;
3827 is_current_seg_readonly = true;
3828 }
3829
22f0da72 3830 current_seg->add_output_section_to_load(layout, *p, seg_flags);
a445fddf
ILT
3831
3832 if (((*p)->flags() & elfcpp::SHF_WRITE) != 0)
3833 is_current_seg_readonly = false;
3834
3835 plast = p;
3836 last_vma = vma;
3837 last_lma = lma;
3838 last_size = size;
3839 }
3840
3841 // An ELF program should work even if the program headers are not in
3842 // a PT_LOAD segment. However, it appears that the Linux kernel
3843 // does not set the AT_PHDR auxiliary entry in that case. It sets
3844 // the load address to p_vaddr - p_offset of the first PT_LOAD
3845 // segment. It then sets AT_PHDR to the load address plus the
3846 // offset to the program headers, e_phoff in the file header. This
3847 // fails when the program headers appear in the file before the
3848 // first PT_LOAD segment. Therefore, we always create a PT_LOAD
3849 // segment to hold the file header and the program headers. This is
3850 // effectively what the GNU linker does, and it is slightly more
3851 // efficient in any case. We try to use the first PT_LOAD segment
3852 // if we can, otherwise we make a new one.
3853
919ed24c
ILT
3854 if (first_seg == NULL)
3855 return NULL;
3856
3ee173de
ILT
3857 // -n or -N mean that the program is not demand paged and there is
3858 // no need to put the program headers in a PT_LOAD segment.
3859 if (parameters->options().nmagic() || parameters->options().omagic())
3860 return NULL;
3861
1c4f3631 3862 size_t sizeof_headers = this->total_header_size(layout);
3802b2dd 3863
919ed24c
ILT
3864 uint64_t vma = first_seg->vaddr();
3865 uint64_t lma = first_seg->paddr();
3866
3867 uint64_t subtract = this->header_size_adjustment(lma, sizeof_headers);
3868
e6188289
ILT
3869 if ((lma & (abi_pagesize - 1)) >= sizeof_headers)
3870 {
3871 first_seg->set_addresses(vma - subtract, lma - subtract);
3872 return first_seg;
3873 }
3874
919ed24c
ILT
3875 // If there is no room to squeeze in the headers, then punt. The
3876 // resulting executable probably won't run on GNU/Linux, but we
3877 // trust that the user knows what they are doing.
3878 if (lma < subtract || vma < subtract)
3879 return NULL;
3880
ea5cae92
NC
3881 // If memory regions have been specified and the address range
3882 // we are about to use is not contained within any region then
3883 // issue a warning message about the segment we are going to
3884 // create. It will be outside of any region and so possibly
3885 // using non-existent or protected memory. We test LMA rather
3886 // than VMA since we assume that the headers will never be
3887 // relocated.
3888 if (this->memory_regions_ != NULL
3889 && !this->block_in_region (NULL, layout, lma - subtract, subtract))
3890 gold_warning(_("creating a segment to contain the file and program"
3891 " headers outside of any MEMORY region"));
3892
a445fddf
ILT
3893 Output_segment* load_seg = layout->make_output_segment(elfcpp::PT_LOAD,
3894 elfcpp::PF_R);
919ed24c 3895 load_seg->set_addresses(vma - subtract, lma - subtract);
a445fddf
ILT
3896
3897 return load_seg;
3898}
3899
3900// Create a PT_NOTE segment for each SHT_NOTE section and a PT_TLS
3901// segment if there are any SHT_TLS sections.
3902
3903void
3904Script_sections::create_note_and_tls_segments(
3905 Layout* layout,
3906 const Layout::Section_list* sections)
3907{
1c4f3631
ILT
3908 gold_assert(!this->saw_phdrs_clause());
3909
a445fddf
ILT
3910 bool saw_tls = false;
3911 for (Layout::Section_list::const_iterator p = sections->begin();
3912 p != sections->end();
3913 ++p)
3914 {
3915 if ((*p)->type() == elfcpp::SHT_NOTE)
3916 {
3917 elfcpp::Elf_Word seg_flags =
3918 Layout::section_flags_to_segment((*p)->flags());
3919 Output_segment* oseg = layout->make_output_segment(elfcpp::PT_NOTE,
3920 seg_flags);
22f0da72 3921 oseg->add_output_section_to_nonload(*p, seg_flags);
a445fddf
ILT
3922
3923 // Incorporate any subsequent SHT_NOTE sections, in the
3924 // hopes that the script is sensible.
3925 Layout::Section_list::const_iterator pnext = p + 1;
3926 while (pnext != sections->end()
3927 && (*pnext)->type() == elfcpp::SHT_NOTE)
3928 {
3929 seg_flags = Layout::section_flags_to_segment((*pnext)->flags());
22f0da72 3930 oseg->add_output_section_to_nonload(*pnext, seg_flags);
a445fddf
ILT
3931 p = pnext;
3932 ++pnext;
3933 }
3934 }
3935
3936 if (((*p)->flags() & elfcpp::SHF_TLS) != 0)
3937 {
3938 if (saw_tls)
3939 gold_error(_("TLS sections are not adjacent"));
3940
3941 elfcpp::Elf_Word seg_flags =
3942 Layout::section_flags_to_segment((*p)->flags());
3943 Output_segment* oseg = layout->make_output_segment(elfcpp::PT_TLS,
3944 seg_flags);
22f0da72 3945 oseg->add_output_section_to_nonload(*p, seg_flags);
a445fddf
ILT
3946
3947 Layout::Section_list::const_iterator pnext = p + 1;
3948 while (pnext != sections->end()
3949 && ((*pnext)->flags() & elfcpp::SHF_TLS) != 0)
3950 {
3951 seg_flags = Layout::section_flags_to_segment((*pnext)->flags());
22f0da72 3952 oseg->add_output_section_to_nonload(*pnext, seg_flags);
a445fddf
ILT
3953 p = pnext;
3954 ++pnext;
3955 }
3956
3957 saw_tls = true;
3958 }
10b4f102
ILT
3959
3960 // If we are making a shared library, and we see a section named
e1f74f98
ILT
3961 // .interp then put the .interp section in a PT_INTERP segment.
3962 // This is for GNU ld compatibility.
3963 if (strcmp((*p)->name(), ".interp") == 0)
10b4f102
ILT
3964 {
3965 elfcpp::Elf_Word seg_flags =
3966 Layout::section_flags_to_segment((*p)->flags());
3967 Output_segment* oseg = layout->make_output_segment(elfcpp::PT_INTERP,
3968 seg_flags);
3969 oseg->add_output_section_to_nonload(*p, seg_flags);
3970 }
a445fddf
ILT
3971 }
3972}
3973
1c4f3631
ILT
3974// Add a program header. The PHDRS clause is syntactically distinct
3975// from the SECTIONS clause, but we implement it with the SECTIONS
55458500 3976// support because PHDRS is useless if there is no SECTIONS clause.
1c4f3631
ILT
3977
3978void
3979Script_sections::add_phdr(const char* name, size_t namelen, unsigned int type,
3980 bool includes_filehdr, bool includes_phdrs,
3981 bool is_flags_valid, unsigned int flags,
3982 Expression* load_address)
3983{
3984 if (this->phdrs_elements_ == NULL)
3985 this->phdrs_elements_ = new Phdrs_elements();
3986 this->phdrs_elements_->push_back(new Phdrs_element(name, namelen, type,
3987 includes_filehdr,
3988 includes_phdrs,
3989 is_flags_valid, flags,
3990 load_address));
3991}
3992
3802b2dd
ILT
3993// Return the number of segments we expect to create based on the
3994// SECTIONS clause. This is used to implement SIZEOF_HEADERS.
3995
3996size_t
3997Script_sections::expected_segment_count(const Layout* layout) const
3998{
1c4f3631
ILT
3999 if (this->saw_phdrs_clause())
4000 return this->phdrs_elements_->size();
4001
3802b2dd
ILT
4002 Layout::Section_list sections;
4003 layout->get_allocated_sections(&sections);
4004
4005 // We assume that we will need two PT_LOAD segments.
4006 size_t ret = 2;
4007
4008 bool saw_note = false;
4009 bool saw_tls = false;
4010 for (Layout::Section_list::const_iterator p = sections.begin();
4011 p != sections.end();
4012 ++p)
4013 {
4014 if ((*p)->type() == elfcpp::SHT_NOTE)
4015 {
4016 // Assume that all note sections will fit into a single
4017 // PT_NOTE segment.
4018 if (!saw_note)
4019 {
4020 ++ret;
4021 saw_note = true;
4022 }
4023 }
4024 else if (((*p)->flags() & elfcpp::SHF_TLS) != 0)
4025 {
4026 // There can only be one PT_TLS segment.
4027 if (!saw_tls)
4028 {
4029 ++ret;
4030 saw_tls = true;
4031 }
4032 }
4033 }
4034
4035 return ret;
4036}
4037
1c4f3631
ILT
4038// Create the segments from a PHDRS clause. Return the segment which
4039// should hold the file header and program headers, if any.
4040
4041Output_segment*
f6973bdc
ILT
4042Script_sections::create_segments_from_phdrs_clause(Layout* layout,
4043 uint64_t dot_alignment)
1c4f3631
ILT
4044{
4045 this->attach_sections_using_phdrs_clause(layout);
f6973bdc 4046 return this->set_phdrs_clause_addresses(layout, dot_alignment);
1c4f3631
ILT
4047}
4048
4049// Create the segments from the PHDRS clause, and put the output
4050// sections in them.
4051
4052void
4053Script_sections::attach_sections_using_phdrs_clause(Layout* layout)
4054{
4055 typedef std::map<std::string, Output_segment*> Name_to_segment;
4056 Name_to_segment name_to_segment;
4057 for (Phdrs_elements::const_iterator p = this->phdrs_elements_->begin();
4058 p != this->phdrs_elements_->end();
4059 ++p)
4060 name_to_segment[(*p)->name()] = (*p)->create_segment(layout);
4061
4062 // Walk through the output sections and attach them to segments.
4063 // Output sections in the script which do not list segments are
4064 // attached to the same set of segments as the immediately preceding
4065 // output section.
20e6d0d6 4066
1c4f3631 4067 String_list* phdr_names = NULL;
20e6d0d6 4068 bool load_segments_only = false;
1c4f3631
ILT
4069 for (Sections_elements::const_iterator p = this->sections_elements_->begin();
4070 p != this->sections_elements_->end();
4071 ++p)
4072 {
aecf301f 4073 bool is_orphan;
20e6d0d6 4074 String_list* old_phdr_names = phdr_names;
aecf301f 4075 Output_section* os = (*p)->allocate_to_segment(&phdr_names, &is_orphan);
1c4f3631
ILT
4076 if (os == NULL)
4077 continue;
4078
aecf301f
ILT
4079 elfcpp::Elf_Word seg_flags =
4080 Layout::section_flags_to_segment(os->flags());
4081
1c4f3631
ILT
4082 if (phdr_names == NULL)
4083 {
aecf301f
ILT
4084 // Don't worry about empty orphan sections.
4085 if (is_orphan && os->current_data_size() > 0)
4086 gold_error(_("allocated section %s not in any segment"),
4087 os->name());
4088
4089 // To avoid later crashes drop this section into the first
4090 // PT_LOAD segment.
4091 for (Phdrs_elements::const_iterator ppe =
4092 this->phdrs_elements_->begin();
4093 ppe != this->phdrs_elements_->end();
4094 ++ppe)
4095 {
4096 Output_segment* oseg = (*ppe)->segment();
4097 if (oseg->type() == elfcpp::PT_LOAD)
4098 {
4099 oseg->add_output_section_to_load(layout, os, seg_flags);
4100 break;
4101 }
4102 }
4103
1c4f3631
ILT
4104 continue;
4105 }
4106
20e6d0d6
DK
4107 // We see a list of segments names. Disable PT_LOAD segment only
4108 // filtering.
4109 if (old_phdr_names != phdr_names)
4110 load_segments_only = false;
4111
2cefc357
ILT
4112 // If this is an orphan section--one that was not explicitly
4113 // mentioned in the linker script--then it should not inherit
4114 // any segment type other than PT_LOAD. Otherwise, e.g., the
4115 // PT_INTERP segment will pick up following orphan sections,
4116 // which does not make sense. If this is not an orphan section,
4117 // we trust the linker script.
aecf301f 4118 if (is_orphan)
2cefc357 4119 {
20e6d0d6
DK
4120 // Enable PT_LOAD segments only filtering until we see another
4121 // list of segment names.
4122 load_segments_only = true;
2cefc357
ILT
4123 }
4124
1c4f3631
ILT
4125 bool in_load_segment = false;
4126 for (String_list::const_iterator q = phdr_names->begin();
4127 q != phdr_names->end();
4128 ++q)
4129 {
4130 Name_to_segment::const_iterator r = name_to_segment.find(*q);
4131 if (r == name_to_segment.end())
4132 gold_error(_("no segment %s"), q->c_str());
4133 else
4134 {
20e6d0d6
DK
4135 if (load_segments_only
4136 && r->second->type() != elfcpp::PT_LOAD)
4137 continue;
4138
22f0da72
ILT
4139 if (r->second->type() != elfcpp::PT_LOAD)
4140 r->second->add_output_section_to_nonload(os, seg_flags);
4141 else
1c4f3631 4142 {
22f0da72 4143 r->second->add_output_section_to_load(layout, os, seg_flags);
1c4f3631
ILT
4144 if (in_load_segment)
4145 gold_error(_("section in two PT_LOAD segments"));
4146 in_load_segment = true;
4147 }
4148 }
4149 }
4150
4151 if (!in_load_segment)
4152 gold_error(_("allocated section not in any PT_LOAD segment"));
4153 }
4154}
4155
4156// Set the addresses for segments created from a PHDRS clause. Return
4157// the segment which should hold the file header and program headers,
4158// if any.
4159
4160Output_segment*
f6973bdc
ILT
4161Script_sections::set_phdrs_clause_addresses(Layout* layout,
4162 uint64_t dot_alignment)
1c4f3631
ILT
4163{
4164 Output_segment* load_seg = NULL;
4165 for (Phdrs_elements::const_iterator p = this->phdrs_elements_->begin();
4166 p != this->phdrs_elements_->end();
4167 ++p)
4168 {
4169 // Note that we have to set the flags after adding the output
4170 // sections to the segment, as adding an output segment can
4171 // change the flags.
4172 (*p)->set_flags_if_valid();
4173
4174 Output_segment* oseg = (*p)->segment();
4175
4176 if (oseg->type() != elfcpp::PT_LOAD)
4177 {
4178 // The addresses of non-PT_LOAD segments are set from the
4179 // PT_LOAD segments.
4180 if ((*p)->has_load_address())
4181 gold_error(_("may only specify load address for PT_LOAD segment"));
4182 continue;
4183 }
4184
f6973bdc
ILT
4185 oseg->set_minimum_p_align(dot_alignment);
4186
1c4f3631
ILT
4187 // The output sections should have addresses from the SECTIONS
4188 // clause. The addresses don't have to be in order, so find the
4189 // one with the lowest load address. Use that to set the
4190 // address of the segment.
4191
4192 Output_section* osec = oseg->section_with_lowest_load_address();
4193 if (osec == NULL)
4194 {
4195 oseg->set_addresses(0, 0);
4196 continue;
4197 }
4198
4199 uint64_t vma = osec->address();
4200 uint64_t lma = osec->has_load_address() ? osec->load_address() : vma;
4201
4202 // Override the load address of the section with the load
4203 // address specified for the segment.
4204 if ((*p)->has_load_address())
4205 {
4206 if (osec->has_load_address())
4207 gold_warning(_("PHDRS load address overrides "
4208 "section %s load address"),
4209 osec->name());
4210
4211 lma = (*p)->load_address();
4212 }
4213
4214 bool headers = (*p)->includes_filehdr() && (*p)->includes_phdrs();
4215 if (!headers && ((*p)->includes_filehdr() || (*p)->includes_phdrs()))
4216 {
4217 // We could support this if we wanted to.
4218 gold_error(_("using only one of FILEHDR and PHDRS is "
4219 "not currently supported"));
4220 }
4221 if (headers)
4222 {
4223 size_t sizeof_headers = this->total_header_size(layout);
4224 uint64_t subtract = this->header_size_adjustment(lma,
4225 sizeof_headers);
4226 if (lma >= subtract && vma >= subtract)
4227 {
4228 lma -= subtract;
4229 vma -= subtract;
4230 }
4231 else
4232 {
4233 gold_error(_("sections loaded on first page without room "
4234 "for file and program headers "
4235 "are not supported"));
4236 }
4237
4238 if (load_seg != NULL)
4239 gold_error(_("using FILEHDR and PHDRS on more than one "
4240 "PT_LOAD segment is not currently supported"));
4241 load_seg = oseg;
4242 }
4243
4244 oseg->set_addresses(vma, lma);
4245 }
4246
4247 return load_seg;
4248}
4249
4250// Add the file header and segment headers to non-load segments
4251// specified in the PHDRS clause.
4252
4253void
4254Script_sections::put_headers_in_phdrs(Output_data* file_header,
4255 Output_data* segment_headers)
4256{
4257 gold_assert(this->saw_phdrs_clause());
4258 for (Phdrs_elements::iterator p = this->phdrs_elements_->begin();
4259 p != this->phdrs_elements_->end();
4260 ++p)
4261 {
4262 if ((*p)->type() != elfcpp::PT_LOAD)
4263 {
4264 if ((*p)->includes_phdrs())
4265 (*p)->segment()->add_initial_output_data(segment_headers);
4266 if ((*p)->includes_filehdr())
4267 (*p)->segment()->add_initial_output_data(file_header);
4268 }
4269 }
4270}
4271
8f2eb564
ILT
4272// Look for an output section by name and return the address, the load
4273// address, the alignment, and the size. This is used when an
4274// expression refers to an output section which was not actually
4275// created. This returns true if the section was found, false
4276// otherwise.
4277
4278bool
4279Script_sections::get_output_section_info(const char* name, uint64_t* address,
4280 uint64_t* load_address,
2ea97941 4281 uint64_t* addralign,
8f2eb564
ILT
4282 uint64_t* size) const
4283{
4284 if (!this->saw_sections_clause_)
4285 return false;
4286 for (Sections_elements::const_iterator p = this->sections_elements_->begin();
4287 p != this->sections_elements_->end();
4288 ++p)
2ea97941 4289 if ((*p)->get_output_section_info(name, address, load_address, addralign,
8f2eb564
ILT
4290 size))
4291 return true;
4292 return false;
4293}
4294
20e6d0d6
DK
4295// Release all Output_segments. This remove all pointers to all
4296// Output_segments.
4297
4298void
4299Script_sections::release_segments()
4300{
4301 if (this->saw_phdrs_clause())
4302 {
4303 for (Phdrs_elements::const_iterator p = this->phdrs_elements_->begin();
4304 p != this->phdrs_elements_->end();
4305 ++p)
4306 (*p)->release_segment();
4307 }
4308}
4309
494e05f4
ILT
4310// Print the SECTIONS clause to F for debugging.
4311
4312void
4313Script_sections::print(FILE* f) const
4314{
7f8cd844
NC
4315 if (this->phdrs_elements_ != NULL)
4316 {
4317 fprintf(f, "PHDRS {\n");
4318 for (Phdrs_elements::const_iterator p = this->phdrs_elements_->begin();
4319 p != this->phdrs_elements_->end();
4320 ++p)
4321 (*p)->print(f);
4322 fprintf(f, "}\n");
4323 }
4324
4325 if (this->memory_regions_ != NULL)
4326 {
4327 fprintf(f, "MEMORY {\n");
4328 for (Memory_regions::const_iterator m = this->memory_regions_->begin();
4329 m != this->memory_regions_->end();
4330 ++m)
4331 (*m)->print(f);
4332 fprintf(f, "}\n");
4333 }
4334
494e05f4
ILT
4335 if (!this->saw_sections_clause_)
4336 return;
4337
4338 fprintf(f, "SECTIONS {\n");
4339
4340 for (Sections_elements::const_iterator p = this->sections_elements_->begin();
4341 p != this->sections_elements_->end();
4342 ++p)
4343 (*p)->print(f);
4344
4345 fprintf(f, "}\n");
4346}
4347
4348} // End namespace gold.
This page took 0.428655 seconds and 4 git commands to generate.