1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
|
// layout.h -- lay out output file sections for gold -*- C++ -*-
#ifndef GOLD_LAYOUT_H
#define GOLD_LAYOUT_H
#include <list>
#include <string>
#include <utility>
#include <vector>
#include "options.h"
#include "workqueue.h"
#include "object.h"
#include "stringpool.h"
namespace gold
{
class Input_objects;
class Output_section;
class Output_section_symtab;
class Output_segment;
class Output_data;
// This Task handles mapping the input sections to output sections and
// laying them out in memory.
class Layout_task : public Task
{
public:
// OPTIONS is the command line options, INPUT_OBJECTS is the list of
// input objects, THIS_BLOCKER is a token which blocks this task
// from executing until all the input symbols have been read.
Layout_task(const General_options& options,
const Input_objects* input_objects,
Task_token* this_blocker)
: options_(options), input_objects_(input_objects),
this_blocker_(this_blocker)
{ }
~Layout_task();
// The standard Task methods.
Is_runnable_type
is_runnable(Workqueue*);
Task_locker*
locks(Workqueue*);
void
run(Workqueue*);
private:
Layout_task(const Layout_task&);
Layout_task& operator=(const Layout_task&);
const General_options& options_;
const Input_objects* input_objects_;
Task_token* this_blocker_;
};
// This class handles the details of laying out input sections.
class Layout
{
public:
Layout(const General_options& options);
// Initialize the object.
void
init();
// Given an input section named NAME with data in SHDR from the
// object file OBJECT, return the output section where this input
// section should go. Set *OFFSET to the offset within the output
// section.
template<int size, bool big_endian>
Output_section*
layout(Object *object, const char* name,
const elfcpp::Shdr<size, big_endian>& shdr, off_t* offset);
// Return whether a section is a .gnu.linkonce section, given the
// section name.
static inline bool
is_linkonce(const char* name)
{ return strncmp(name, ".gnu.linkonce", sizeof(".gnu.linkonce") - 1) == 0; }
// Record the signature of a comdat section, and return whether to
// include it in the link. The GROUP parameter is true for a
// section group signature, false for a signature derived from a
// .gnu.linkonce section.
bool
add_comdat(const char*, bool group);
// Finalize the layout after all the input sections have been added.
void
finalize(const Input_objects*);
// The list of segments.
typedef std::vector<Output_segment*> Segment_list;
// The list of sections not attached to a segment.
typedef std::list<Output_section*> Section_list;
// The list of information to write out which is not attached to
// either a section or a segment.
typedef std::list<Output_data*> Data_list;
private:
Layout(const Layout&);
Layout& operator=(const Layout&);
// Mapping from .gnu.linkonce section names to output section names.
struct Linkonce_mapping
{
const char* from;
int fromlen;
const char* to;
};
static const Linkonce_mapping linkonce_mapping[];
static const int linkonce_mapping_count;
// Lay out the local symbols from a SHT_SYMTAB section.
template<int size, bool big_endian>
void
add_symtab_locals(Object* object, const elfcpp::Shdr<size, big_endian>&);
// Create the output sections for the symbol table.
void
create_symtab_sections();
// Finalize the symbol table.
void
finalize_symtab();
// Return whether to include this section in the link.
template<int size, bool big_endian>
bool
include_section(Object* object, const char* name,
const elfcpp::Shdr<size, big_endian>&);
// Return the output section name to use for a linkonce section
// name.
static const char*
linkonce_output_name(const char* name);
// Create a new Output_section.
Output_section*
make_output_section(const char* name, elfcpp::Elf_Word type,
elfcpp::Elf_Xword flags);
// Return whether SEG1 comes before SEG2 in the output file.
static bool
Layout::segment_precedes(const Output_segment* seg1,
const Output_segment* seg2);
// Map from section flags to segment flags.
static elfcpp::Elf_Word
section_flags_to_segment(elfcpp::Elf_Xword flags);
// A mapping used for group signatures.
typedef Unordered_map<std::string, bool> Signatures;
// Mapping from input section name/type/flags to output section. We
// use canonicalized strings here.
typedef std::pair<const char*,
std::pair<elfcpp::Elf_Word, elfcpp::Elf_Xword> > Key;
struct Hash_key
{
size_t
operator()(const Key& k) const;
};
typedef Unordered_map<Key, Output_section*, Hash_key> Section_name_map;
// A comparison class for segments.
struct Compare_segments
{
bool
operator()(const Output_segment* seg1, const Output_segment* seg2)
{ return Layout::segment_precedes(seg1, seg2); }
};
// A reference to the options on the command line.
const General_options& options_;
// The output section names.
Stringpool namepool_;
// The list of group sections and linkonce sections which we have seen.
Signatures signatures_;
// The mapping from input section name/type/flags to output sections.
Section_name_map section_name_map_;
// The list of output segments.
Segment_list segment_list_;
// The list of output sections which are not attached to any output
// segment.
Section_list section_list_;
// The list of output data objects which are not attached to any
// output section or output segment.
Data_list data_list_;
};
} // End namespace gold.
#endif // !defined(GOLD_LAYOUT_H)
|
