OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [gold/] [script-sections.h] - Blame information for rev 862

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 205 julius
// script-sections.h -- linker script SECTIONS for gold   -*- C++ -*-
2
 
3
// Copyright 2008, 2009 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
// This is for the support of the SECTIONS clause in linker scripts.
24
 
25
#ifndef GOLD_SCRIPT_SECTIONS_H
26
#define GOLD_SCRIPT_SECTIONS_H
27
 
28
#include <cstdio>
29
#include <list>
30
#include <vector>
31
 
32
namespace gold
33
{
34
 
35
struct Parser_output_section_header;
36
struct Parser_output_section_trailer;
37
struct Input_section_spec;
38
class Expression;
39
class Sections_element;
40
class Phdrs_element;
41
class Output_data;
42
class Output_section_definition;
43
class Output_section;
44
class Output_segment;
45
class Orphan_section_placement;
46
 
47
class Script_sections
48
{
49
 private:
50
  // This is a list, not a vector, because we insert orphan sections
51
  // in the middle.
52
  typedef std::list<Sections_element*> Sections_elements;
53
 
54
 public:
55
  Script_sections();
56
 
57
  // Start a SECTIONS clause.
58
  void
59
  start_sections();
60
 
61
  // Finish a SECTIONS clause.
62
  void
63
  finish_sections();
64
 
65
  // Return whether we ever saw a SECTIONS clause.  If we did, then
66
  // all section layout needs to go through this class.
67
  bool
68
  saw_sections_clause() const
69
  { return this->saw_sections_clause_; }
70
 
71
  // Return whether we are currently processing a SECTIONS clause.
72
  bool
73
  in_sections_clause() const
74
  { return this->in_sections_clause_; }
75
 
76
  // Return whether we ever saw a PHDRS clause.  We ignore the PHDRS
77
  // clause unless we also saw a SECTIONS clause.
78
  bool
79
  saw_phdrs_clause() const
80
  { return this->saw_sections_clause_ && this->phdrs_elements_ != NULL; }
81
 
82
  // Start processing entries for an output section.
83
  void
84
  start_output_section(const char* name, size_t namelen,
85
                       const Parser_output_section_header*);
86
 
87
  // Finish processing entries for an output section.
88
  void
89
  finish_output_section(const Parser_output_section_trailer*);
90
 
91
  // Add a data item to the current output section.
92
  void
93
  add_data(int size, bool is_signed, Expression* val);
94
 
95
  // Add a symbol to be defined.
96
  void
97
  add_symbol_assignment(const char* name, size_t length, Expression* value,
98
                        bool provide, bool hidden);
99
 
100
  // Add an assignment to the special dot symbol.
101
  void
102
  add_dot_assignment(Expression* value);
103
 
104
  // Add an assertion.
105
  void
106
  add_assertion(Expression* check, const char* message, size_t messagelen);
107
 
108
  // Add a setting for the fill value.
109
  void
110
  add_fill(Expression* val);
111
 
112
  // Add an input section specification.
113
  void
114
  add_input_section(const Input_section_spec* spec, bool keep);
115
 
116
  // Saw DATA_SEGMENT_ALIGN.
117
  void
118
  data_segment_align();
119
 
120
  // Saw DATA_SEGMENT_RELRO_END.
121
  void
122
  data_segment_relro_end();
123
 
124
  // Create any required sections.
125
  void
126
  create_sections(Layout*);
127
 
128
  // Add any symbols we are defining to the symbol table.
129
  void
130
  add_symbols_to_table(Symbol_table*);
131
 
132
  // Finalize symbol values and check assertions.
133
  void
134
  finalize_symbols(Symbol_table* symtab, const Layout* layout);
135
 
136
  // Find the name of the output section to use for an input file name
137
  // and section name.  This returns a name, and sets
138
  // *OUTPUT_SECTION_SLOT to point to the address where the actual
139
  // output section may be stored.
140
  // 1) If the input section should be discarded, this returns NULL
141
  //    and sets *OUTPUT_SECTION_SLOT to NULL.
142
  // 2) If the input section is mapped by the SECTIONS clause, this
143
  //    returns the name to use for the output section (in permanent
144
  //    storage), and sets *OUTPUT_SECTION_SLOT to point to where the
145
  //    output section should be stored.  **OUTPUT_SECTION_SLOT will be
146
  //    non-NULL if we have seen this output section already.
147
  // 3) If the input section is not mapped by the SECTIONS clause,
148
  //    this returns SECTION_NAME, and sets *OUTPUT_SECTION_SLOT to
149
  //    NULL.
150
  const char*
151
  output_section_name(const char* file_name, const char* section_name,
152
                      Output_section*** output_section_slot);
153
 
154
  // Place a marker for an orphan output section into the SECTIONS
155
  // clause.
156
  void
157
  place_orphan(Output_section* os);
158
 
159
  // Set the addresses of all the output sections.  Return the segment
160
  // which holds the file header and segment headers, if any.
161
  Output_segment*
162
  set_section_addresses(Symbol_table*, Layout*);
163
 
164
  // Add a program header definition.
165
  void
166
  add_phdr(const char* name, size_t namelen, unsigned int type,
167
           bool filehdr, bool phdrs, bool is_flags_valid, unsigned int flags,
168
           Expression* load_address);
169
 
170
  // Return the number of segments we expect to create based on the
171
  // SECTIONS clause.
172
  size_t
173
  expected_segment_count(const Layout*) const;
174
 
175
  // Add the file header and segment header to non-load segments as
176
  // specified by the PHDRS clause.
177
  void
178
  put_headers_in_phdrs(Output_data* file_header, Output_data* segment_headers);
179
 
180
  // Look for an output section by name and return the address, the
181
  // load address, the alignment, and the size.  This is used when an
182
  // expression refers to an output section which was not actually
183
  // created.  This returns true if the section was found, false
184
  // otherwise.
185
  bool
186
  get_output_section_info(const char* name, uint64_t* address,
187
                          uint64_t* load_address, uint64_t* addralign,
188
                          uint64_t* size) const;
189
 
190
  // Release all Output_segments.  This is used in relaxation.
191
  void
192
  release_segments();
193
 
194
  // Print the contents to the FILE.  This is for debugging.
195
  void
196
  print(FILE*) const;
197
 
198
  // Used for orphan sections.
199
  typedef Sections_elements::iterator Elements_iterator;
200
 
201
 private:
202
  typedef std::vector<Phdrs_element*> Phdrs_elements;
203
 
204
  // Create segments.
205
  Output_segment*
206
  create_segments(Layout*);
207
 
208
  // Create PT_NOTE and PT_TLS segments.
209
  void
210
  create_note_and_tls_segments(Layout*, const std::vector<Output_section*>*);
211
 
212
  // Return whether the section is a BSS section.
213
  static bool
214
  is_bss_section(const Output_section*);
215
 
216
  // Return the total size of the headers.
217
  size_t
218
  total_header_size(Layout* layout) const;
219
 
220
  // Return the amount we have to subtract from the LMA to accomodate
221
  // headers of the given size.
222
  uint64_t
223
  header_size_adjustment(uint64_t lma, size_t sizeof_headers) const;
224
 
225
  // Create the segments from a PHDRS clause.
226
  Output_segment*
227
  create_segments_from_phdrs_clause(Layout* layout);
228
 
229
  // Attach sections to segments from a PHDRS clause.
230
  void
231
  attach_sections_using_phdrs_clause(Layout*);
232
 
233
  // Set addresses of segments from a PHDRS clause.
234
  Output_segment*
235
  set_phdrs_clause_addresses(Layout*);
236
 
237
  // True if we ever saw a SECTIONS clause.
238
  bool saw_sections_clause_;
239
  // True if we are currently processing a SECTIONS clause.
240
  bool in_sections_clause_;
241
  // The list of elements in the SECTIONS clause.
242
  Sections_elements* sections_elements_;
243
  // The current output section, if there is one.
244
  Output_section_definition* output_section_;
245
  // The list of program headers in the PHDRS clause.
246
  Phdrs_elements* phdrs_elements_;
247
  // Where to put orphan sections.
248
  Orphan_section_placement* orphan_section_placement_;
249
  // A pointer to the last Sections_element when we see
250
  // DATA_SEGMENT_ALIGN.
251
  Sections_elements::iterator data_segment_align_start_;
252
  // Whether we have seen DATA_SEGMENT_ALIGN.
253
  bool saw_data_segment_align_;
254
  // Whether we have seen DATA_SEGMENT_RELRO_END.
255
  bool saw_relro_end_;
256
};
257
 
258
} // End namespace gold.
259
 
260
#endif // !defined(GOLD_SCRIPT_SECTIONS_H

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.