Don't pass around the target in order to define symbols; get it from
[external/binutils.git] / gold / script-sections.cc
1 // script-sections.cc -- linker script SECTIONS for gold
2
3 // Copyright 2008 Free Software Foundation, Inc.
4 // Written by Ian Lance Taylor <iant@google.com>.
5
6 // This file is part of gold.
7
8 // This program is free software; you can redistribute it and/or modify
9 // it under the terms of the GNU General Public License as published by
10 // the Free Software Foundation; either version 3 of the License, or
11 // (at your option) any later version.
12
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 // GNU General Public License for more details.
17
18 // You should have received a copy of the GNU General Public License
19 // along with this program; if not, write to the Free Software
20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 // MA 02110-1301, USA.
22
23 #include "gold.h"
24
25 #include <string>
26 #include <vector>
27
28 #include "script-c.h"
29 #include "script.h"
30 #include "script-sections.h"
31
32 // Support for the SECTIONS clause in linker scripts.
33
34 namespace gold
35 {
36
37 // An element in a SECTIONS clause.
38
39 class Sections_element
40 {
41  public:
42   Sections_element()
43   { }
44
45   virtual ~Sections_element()
46   { }
47
48   virtual void
49   print(FILE* f) const = 0;
50 };
51
52 // An assignment in a SECTIONS clause outside of an output section.
53
54 class Sections_element_assignment : public Sections_element
55 {
56  public:
57   Sections_element_assignment(const char* name, size_t namelen,
58                               Expression* val, bool provide, bool hidden)
59     : assignment_(name, namelen, val, provide, hidden)
60   { }
61
62   void
63   print(FILE* f) const
64   {
65     fprintf(f, "  ");
66     this->assignment_.print(f);
67   }
68
69  private:
70   Symbol_assignment assignment_;
71 };
72
73 // An assertion in a SECTIONS clause outside of an output section.
74
75 class Sections_element_assertion : public Sections_element
76 {
77  public:
78   Sections_element_assertion(Expression* check, const char* message,
79                              size_t messagelen)
80     : assertion_(check, message, messagelen)
81   { }
82
83   void
84   print(FILE* f) const
85   {
86     fprintf(f, "  ");
87     this->assertion_.print(f);
88   }
89
90  private:
91   Script_assertion assertion_;
92 };
93
94 // An element in an output section in a SECTIONS clause.
95
96 class Output_section_element
97 {
98  public:
99   Output_section_element()
100   { }
101
102   virtual ~Output_section_element()
103   { }
104
105   virtual void
106   print(FILE* f) const = 0;
107 };
108
109 // A symbol assignment in an output section.
110
111 class Output_section_element_assignment : public Output_section_element
112 {
113  public:
114   Output_section_element_assignment(const char* name, size_t namelen,
115                                     Expression* val, bool provide,
116                                     bool hidden)
117     : assignment_(name, namelen, val, provide, hidden)
118   { }
119
120   void
121   print(FILE* f) const
122   {
123     fprintf(f, "    ");
124     this->assignment_.print(f);
125   }
126
127  private:
128   Symbol_assignment assignment_;
129 };
130
131 // An assertion in an output section.
132
133 class Output_section_element_assertion : public Output_section_element
134 {
135  public:
136   Output_section_element_assertion(Expression* check, const char* message,
137                                    size_t messagelen)
138     : assertion_(check, message, messagelen)
139   { }
140
141   void
142   print(FILE* f) const
143   {
144     fprintf(f, "    ");
145     this->assertion_.print(f);
146   }
147
148  private:
149   Script_assertion assertion_;
150 };
151
152 // A data item in an output section.
153
154 class Output_section_element_data : public Output_section_element
155 {
156  public:
157   Output_section_element_data(int size, bool is_signed, Expression* val)
158     : size_(size), is_signed_(is_signed), val_(val)
159   { }
160
161   void
162   print(FILE*) const;
163
164  private:
165   // The size in bytes.
166   int size_;
167   // Whether the value is signed.
168   bool is_signed_;
169   // The value.
170   Expression* val_;
171 };
172
173 // Print for debugging.
174
175 void
176 Output_section_element_data::print(FILE* f) const
177 {
178   const char* s;
179   switch (this->size_)
180     {
181     case 1:
182       s = "BYTE";
183       break;
184     case 2:
185       s = "SHORT";
186       break;
187     case 4:
188       s = "LONG";
189       break;
190     case 8:
191       if (this->is_signed_)
192         s = "SQUAD";
193       else
194         s = "QUAD";
195       break;
196     default:
197       gold_unreachable();
198     }
199   fprintf(f, "    %s(", s);
200   this->val_->print(f);
201   fprintf(f, ")\n");
202 }
203
204 // A fill value setting in an output section.
205
206 class Output_section_element_fill : public Output_section_element
207 {
208  public:
209   Output_section_element_fill(Expression* val)
210     : val_(val)
211   { }
212
213   void
214   print(FILE* f) const
215   {
216     fprintf(f, "    FILL(");
217     this->val_->print(f);
218     fprintf(f, ")\n");
219   }
220
221  private:
222   // The new fill value.
223   Expression* val_;
224 };
225
226 // An input section specification in an output section
227
228 class Output_section_element_input : public Output_section_element
229 {
230  public:
231   // Note that an Input_section_spec holds some pointers to vectors.
232   // This constructor takes ownership of them.  The parser is
233   // implemented such that this works.
234   Output_section_element_input(const Input_section_spec* spec, bool keep);
235
236   void
237   print(FILE* f) const;
238
239  private:
240   // An input section pattern.
241   struct Input_section_pattern
242   {
243     std::string pattern;
244     Sort_wildcard sort;
245
246     Input_section_pattern(const char* patterna, size_t patternlena,
247                           Sort_wildcard sorta)
248       : pattern(patterna, patternlena), sort(sorta)
249     { }
250   };
251
252   typedef std::vector<Input_section_pattern> Input_section_patterns;
253
254   typedef std::vector<std::string> Filename_exclusions;
255
256   // The file name pattern.
257   std::string filename_pattern_;
258   // How the file names should be sorted.  This may only be
259   // SORT_WILDCARD_NONE or SORT_WILDCARD_BY_NAME.
260   Sort_wildcard filename_sort_;
261   // The list of file names to exclude.
262   Filename_exclusions filename_exclusions_;
263   // The list of input section patterns.
264   Input_section_patterns input_section_patterns_;
265   // Whether to keep this section when garbage collecting.
266   bool keep_;
267 };
268
269 // Construct Output_section_element_input.  The parser records strings
270 // as pointers into a copy of the script file, which will go away when
271 // parsing is complete.  We make sure they are in std::string objects.
272
273 Output_section_element_input::Output_section_element_input(
274     const Input_section_spec* spec,
275     bool keep)
276   : filename_pattern_(spec->file.name.value, spec->file.name.length),
277     filename_sort_(spec->file.sort),
278     filename_exclusions_(),
279     input_section_patterns_(),
280     keep_(keep)
281 {
282   if (spec->input_sections.exclude != NULL)
283     {
284       for (String_list::const_iterator p =
285              spec->input_sections.exclude->begin();
286            p != spec->input_sections.exclude->end();
287            ++p)
288         this->filename_exclusions_.push_back(*p);
289     }
290
291   if (spec->input_sections.sections != NULL)
292     {
293       Input_section_patterns& isp(this->input_section_patterns_);
294       for (String_sort_list::const_iterator p =
295              spec->input_sections.sections->begin();
296            p != spec->input_sections.sections->end();
297            ++p)
298         isp.push_back(Input_section_pattern(p->name.value, p->name.length,
299                                             p->sort));
300     }
301 }
302
303 // Print for debugging.
304
305 void
306 Output_section_element_input::print(FILE* f) const
307 {
308   fprintf(f, "    ");
309
310   if (this->keep_)
311     fprintf(f, "KEEP(");
312
313   if (!this->filename_pattern_.empty())
314     {
315       bool need_close_paren = false;
316       switch (this->filename_sort_)
317         {
318         case SORT_WILDCARD_NONE:
319           break;
320         case SORT_WILDCARD_BY_NAME:
321           fprintf(f, "SORT_BY_NAME(");
322           need_close_paren = true;
323           break;
324         default:
325           gold_unreachable();
326         }
327
328       fprintf(f, "%s", this->filename_pattern_.c_str());
329
330       if (need_close_paren)
331         fprintf(f, ")");
332     }
333
334   if (!this->input_section_patterns_.empty()
335       || !this->filename_exclusions_.empty())
336     {
337       fprintf(f, "(");
338
339       bool need_space = false;
340       if (!this->filename_exclusions_.empty())
341         {
342           fprintf(f, "EXCLUDE_FILE(");
343           bool need_comma = false;
344           for (Filename_exclusions::const_iterator p =
345                  this->filename_exclusions_.begin();
346                p != this->filename_exclusions_.end();
347                ++p)
348             {
349               if (need_comma)
350                 fprintf(f, ", ");
351               fprintf(f, "%s", p->c_str());
352               need_comma = true;
353             }
354           fprintf(f, ")");
355           need_space = true;
356         }
357
358       for (Input_section_patterns::const_iterator p =
359              this->input_section_patterns_.begin();
360            p != this->input_section_patterns_.end();
361            ++p)
362         {
363           if (need_space)
364             fprintf(f, " ");
365
366           int close_parens = 0;
367           switch (p->sort)
368             {
369             case SORT_WILDCARD_NONE:
370               break;
371             case SORT_WILDCARD_BY_NAME:
372               fprintf(f, "SORT_BY_NAME(");
373               close_parens = 1;
374               break;
375             case SORT_WILDCARD_BY_ALIGNMENT:
376               fprintf(f, "SORT_BY_ALIGNMENT(");
377               close_parens = 1;
378               break;
379             case SORT_WILDCARD_BY_NAME_BY_ALIGNMENT:
380               fprintf(f, "SORT_BY_NAME(SORT_BY_ALIGNMENT(");
381               close_parens = 2;
382               break;
383             case SORT_WILDCARD_BY_ALIGNMENT_BY_NAME:
384               fprintf(f, "SORT_BY_ALIGNMENT(SORT_BY_NAME(");
385               close_parens = 2;
386               break;
387             default:
388               gold_unreachable();
389             }
390
391           fprintf(f, "%s", p->pattern.c_str());
392
393           for (int i = 0; i < close_parens; ++i)
394             fprintf(f, ")");
395
396           need_space = true;
397         }
398
399       fprintf(f, ")");
400     }
401
402   if (this->keep_)
403     fprintf(f, ")");
404
405   fprintf(f, "\n");
406 }
407
408 // An output section.
409
410 class Output_section_definition : public Sections_element
411 {
412  public:
413   Output_section_definition(const char* name, size_t namelen,
414                             const Parser_output_section_header* header);
415
416   // Finish the output section with the information in the trailer.
417   void
418   finish(const Parser_output_section_trailer* trailer);
419
420   // Add a symbol to be defined.
421   void
422   add_symbol_assignment(const char* name, size_t length, Expression* value,
423                         bool provide, bool hidden);
424   // Add an assertion.
425   void
426   add_assertion(Expression* check, const char* message, size_t messagelen);
427
428   // Add a data item to the current output section.
429   void
430   add_data(int size, bool is_signed, Expression* val);
431
432   // Add a setting for the fill value.
433   void
434   add_fill(Expression* val);
435
436   // Add an input section specification.
437   void
438   add_input_section(const Input_section_spec* spec, bool keep);
439
440   // Print the contents to the FILE.  This is for debugging.
441   void
442   print(FILE*) const;
443
444  private:
445   typedef std::vector<Output_section_element*> Output_section_elements;
446
447   // The output section name.
448   std::string name_;
449   // The address.  This may be NULL.
450   Expression* address_;
451   // The load address.  This may be NULL.
452   Expression* load_address_;
453   // The alignment.  This may be NULL.
454   Expression* align_;
455   // The input section alignment.  This may be NULL.
456   Expression* subalign_;
457   // The fill value.  This may be NULL.
458   Expression* fill_;
459   // The list of elements defining the section.
460   Output_section_elements elements_;
461 };
462
463 // Constructor.
464
465 Output_section_definition::Output_section_definition(
466     const char* name,
467     size_t namelen,
468     const Parser_output_section_header* header)
469   : name_(name, namelen),
470     address_(header->address),
471     load_address_(header->load_address),
472     align_(header->align),
473     subalign_(header->subalign),
474     fill_(NULL),
475     elements_()
476 {
477 }
478
479 // Finish an output section.
480
481 void
482 Output_section_definition::finish(const Parser_output_section_trailer* trailer)
483 {
484   this->fill_ = trailer->fill;
485 }
486
487 // Add a symbol to be defined.
488
489 void
490 Output_section_definition::add_symbol_assignment(const char* name,
491                                                  size_t length,
492                                                  Expression* value,
493                                                  bool provide,
494                                                  bool hidden)
495 {
496   Output_section_element* p = new Output_section_element_assignment(name,
497                                                                     length,
498                                                                     value,
499                                                                     provide,
500                                                                     hidden);
501   this->elements_.push_back(p);
502 }
503
504 // Add an assertion.
505
506 void
507 Output_section_definition::add_assertion(Expression* check,
508                                          const char* message,
509                                          size_t messagelen)
510 {
511   Output_section_element* p = new Output_section_element_assertion(check,
512                                                                    message,
513                                                                    messagelen);
514   this->elements_.push_back(p);
515 }
516
517 // Add a data item to the current output section.
518
519 void
520 Output_section_definition::add_data(int size, bool is_signed, Expression* val)
521 {
522   Output_section_element* p = new Output_section_element_data(size, is_signed,
523                                                               val);
524   this->elements_.push_back(p);
525 }
526
527 // Add a setting for the fill value.
528
529 void
530 Output_section_definition::add_fill(Expression* val)
531 {
532   Output_section_element* p = new Output_section_element_fill(val);
533   this->elements_.push_back(p);
534 }
535
536 // Add an input section specification.
537
538 void
539 Output_section_definition::add_input_section(const Input_section_spec* spec,
540                                              bool keep)
541 {
542   Output_section_element* p = new Output_section_element_input(spec, keep);
543   this->elements_.push_back(p);
544 }
545
546 // Print for debugging.
547
548 void
549 Output_section_definition::print(FILE* f) const
550 {
551   fprintf(f, "  %s ", this->name_.c_str());
552
553   if (this->address_ != NULL)
554     {
555       this->address_->print(f);
556       fprintf(f, " ");
557     }
558
559   fprintf(f, ": ");
560
561   if (this->load_address_ != NULL)
562     {
563       fprintf(f, "AT(");
564       this->load_address_->print(f);
565       fprintf(f, ") ");
566     }
567
568   if (this->align_ != NULL)
569     {
570       fprintf(f, "ALIGN(");
571       this->align_->print(f);
572       fprintf(f, ") ");
573     }
574
575   if (this->subalign_ != NULL)
576     {
577       fprintf(f, "SUBALIGN(");
578       this->subalign_->print(f);
579       fprintf(f, ") ");
580     }
581
582   fprintf(f, "{\n");
583
584   for (Output_section_elements::const_iterator p = this->elements_.begin();
585        p != this->elements_.end();
586        ++p)
587     (*p)->print(f);
588
589   fprintf(f, "  }");
590
591   if (this->fill_ != NULL)
592     {
593       fprintf(f, " = ");
594       this->fill_->print(f);
595     }
596
597   fprintf(f, "\n");
598 }
599
600 // Class Script_sections.
601
602 Script_sections::Script_sections()
603   : saw_sections_clause_(false),
604     in_sections_clause_(false),
605     sections_elements_(NULL),
606     output_section_(NULL)
607 {
608 }
609
610 // Start a SECTIONS clause.
611
612 void
613 Script_sections::start_sections()
614 {
615   gold_assert(!this->in_sections_clause_ && this->output_section_ == NULL);
616   this->saw_sections_clause_ = true;
617   this->in_sections_clause_ = true;
618   if (this->sections_elements_ == NULL)
619     this->sections_elements_ = new Sections_elements;
620 }
621
622 // Finish a SECTIONS clause.
623
624 void
625 Script_sections::finish_sections()
626 {
627   gold_assert(this->in_sections_clause_ && this->output_section_ == NULL);
628   this->in_sections_clause_ = false;
629 }
630
631 // Add a symbol to be defined.
632
633 void
634 Script_sections::add_symbol_assignment(const char* name, size_t length,
635                                        Expression* val, bool provide,
636                                        bool hidden)
637 {
638   if (this->output_section_ != NULL)
639     this->output_section_->add_symbol_assignment(name, length, val,
640                                                  provide, hidden);
641   else
642     {
643       Sections_element* p = new Sections_element_assignment(name, length,
644                                                             val, provide,
645                                                             hidden);
646       this->sections_elements_->push_back(p);
647     }
648 }
649
650 // Add an assertion.
651
652 void
653 Script_sections::add_assertion(Expression* check, const char* message,
654                                size_t messagelen)
655 {
656   if (this->output_section_ != NULL)
657     this->output_section_->add_assertion(check, message, messagelen);
658   else
659     {
660       Sections_element* p = new Sections_element_assertion(check, message,
661                                                            messagelen);
662       this->sections_elements_->push_back(p);
663     }
664 }
665
666 // Start processing entries for an output section.
667
668 void
669 Script_sections::start_output_section(
670     const char* name,
671     size_t namelen,
672     const Parser_output_section_header *header)
673 {
674   Output_section_definition* posd = new Output_section_definition(name,
675                                                                   namelen,
676                                                                   header);
677   this->sections_elements_->push_back(posd);
678   gold_assert(this->output_section_ == NULL);
679   this->output_section_ = posd;
680 }
681
682 // Stop processing entries for an output section.
683
684 void
685 Script_sections::finish_output_section(
686     const Parser_output_section_trailer* trailer)
687 {
688   gold_assert(this->output_section_ != NULL);
689   this->output_section_->finish(trailer);
690   this->output_section_ = NULL;
691 }
692
693 // Add a data item to the current output section.
694
695 void
696 Script_sections::add_data(int size, bool is_signed, Expression* val)
697 {
698   gold_assert(this->output_section_ != NULL);
699   this->output_section_->add_data(size, is_signed, val);
700 }
701
702 // Add a fill value setting to the current output section.
703
704 void
705 Script_sections::add_fill(Expression* val)
706 {
707   gold_assert(this->output_section_ != NULL);
708   this->output_section_->add_fill(val);
709 }
710
711 // Add an input section specification to the current output section.
712
713 void
714 Script_sections::add_input_section(const Input_section_spec* spec, bool keep)
715 {
716   gold_assert(this->output_section_ != NULL);
717   this->output_section_->add_input_section(spec, keep);
718 }
719
720 // Print the SECTIONS clause to F for debugging.
721
722 void
723 Script_sections::print(FILE* f) const
724 {
725   if (!this->saw_sections_clause_)
726     return;
727
728   fprintf(f, "SECTIONS {\n");
729
730   for (Sections_elements::const_iterator p = this->sections_elements_->begin();
731        p != this->sections_elements_->end();
732        ++p)
733     (*p)->print(f);
734
735   fprintf(f, "}\n");
736 }
737
738 } // End namespace gold.