Commit | Line | Data |
---|---|---|
a2fb1b05 ILT |
1 | // output.h -- manage the output file for gold -*- C++ -*- |
2 | ||
3 | #ifndef GOLD_OUTPUT_H | |
4 | #define GOLD_OUTPUT_H | |
5 | ||
6 | #include <list> | |
7 | ||
8 | #include "elfcpp.h" | |
9 | ||
10 | namespace gold | |
11 | { | |
12 | ||
13 | class Object; | |
14 | class Output_file; | |
15 | ||
16 | // An abtract class for data which has to go into the output file | |
17 | // which is not associated with any input section. | |
18 | ||
19 | class Output_data | |
20 | { | |
21 | public: | |
22 | Output_data(off_t size = 0) | |
23 | : size_(size) | |
24 | { } | |
25 | ||
26 | virtual | |
27 | ~Output_data(); | |
28 | ||
29 | // Return the size of the data. | |
30 | off_t | |
31 | size() | |
32 | { return this->size_; } | |
33 | ||
34 | // Write the data to the output file at the specified offset. This | |
35 | // must be implemented by the real class. | |
36 | virtual void | |
37 | write(Output_file*, off_t off) = 0; | |
38 | ||
39 | protected: | |
40 | // Set the size of the data. | |
41 | void | |
42 | set_size(off_t size) | |
43 | { this->size_ = size; } | |
44 | ||
45 | private: | |
46 | Output_data(const Output_data&); | |
47 | Output_data& operator=(const Output_data&); | |
48 | ||
49 | // Size of data in file. | |
50 | off_t size_; | |
51 | }; | |
52 | ||
53 | // A simple cass of Output_data in which we have constant data to | |
54 | // output. | |
55 | ||
56 | class Output_data_const : public Output_data | |
57 | { | |
58 | public: | |
59 | Output_data_const(const std::string& data) | |
60 | : Output_data(data.size()), data_(data) | |
61 | { } | |
62 | ||
63 | Output_data_const(const char* p, off_t len) | |
64 | : Output_data(len), data_(p, len) | |
65 | { } | |
66 | ||
67 | void | |
68 | write(Output_file* output, off_t off); | |
69 | ||
70 | private: | |
71 | std::string data_; | |
72 | }; | |
73 | ||
74 | // An output section. We don't expect to have too many output | |
75 | // sections, so we don't bother to do a template on the size. | |
76 | ||
77 | class Output_section | |
78 | { | |
79 | public: | |
80 | // Create an output section, giving the name, type, and flags. | |
81 | Output_section(const char* name, elfcpp::Elf_Word, elfcpp::Elf_Xword); | |
82 | ~Output_section(); | |
83 | ||
84 | // Add a new input section named NAME with header SHDR from object | |
85 | // OBJECT. Return the offset within the output section. | |
86 | template<int size, bool big_endian> | |
87 | off_t | |
88 | add_input_section(Object* object, const char *name, | |
89 | const elfcpp::Shdr<size, big_endian>& shdr); | |
90 | ||
91 | // Return the section name. | |
92 | const char* | |
93 | name() const | |
94 | { return this->name_; } | |
95 | ||
96 | // Return the section type. | |
97 | elfcpp::Elf_Word | |
98 | type() const | |
99 | { return this->type_; } | |
100 | ||
101 | // Return the section flags. | |
102 | elfcpp::Elf_Xword | |
103 | flags() const | |
104 | { return this->flags_; } | |
105 | ||
106 | private: | |
107 | // Most of these fields are only valid after layout. | |
108 | ||
109 | // The name of the section. This will point into a Stringpool. | |
110 | const char* name_; | |
111 | // The section address. | |
112 | uint64_t addr_; | |
113 | // The section alignment. | |
114 | uint64_t addralign_; | |
115 | // The section entry size. | |
116 | uint64_t entsize_; | |
117 | // The file offset. | |
118 | off_t offset_; | |
119 | // The section size. | |
120 | off_t size_; | |
121 | // The section link field. | |
122 | unsigned int link_; | |
123 | // The section info field. | |
124 | unsigned int info_; | |
125 | // The section type. | |
126 | elfcpp::Elf_Word type_; | |
127 | // The section flags. | |
128 | elfcpp::Elf_Xword flags_; | |
129 | }; | |
130 | ||
131 | // An output segment. PT_LOAD segments are built from collections of | |
132 | // output sections. Other segments typically point within PT_LOAD | |
133 | // segments, and are built directly as needed. | |
134 | ||
135 | class Output_segment | |
136 | { | |
137 | public: | |
138 | // Create an output segment, specifying the type and flags. | |
139 | Output_segment(elfcpp::Elf_Word, elfcpp::Elf_Word); | |
140 | ||
141 | // Return the virtual address. | |
142 | uint64_t | |
143 | vaddr() const | |
144 | { return this->vaddr_; } | |
145 | ||
146 | // Return the physical address. | |
147 | uint64_t | |
148 | paddr() const | |
149 | { return this->paddr_; } | |
150 | ||
151 | // Return the segment type. | |
152 | elfcpp::Elf_Word | |
153 | type() const | |
154 | { return this->type_; } | |
155 | ||
156 | // Return the segment flags. | |
157 | elfcpp::Elf_Word | |
158 | flags() const | |
159 | { return this->flags_; } | |
160 | ||
161 | // Add an Output_section to this segment. | |
162 | void | |
163 | add_output_section(Output_section*); | |
164 | ||
165 | // Update the segment flags to be compatible with FLAGS. | |
166 | void | |
167 | update_flags(elfcpp::Elf_Word flags) | |
168 | { this->flags_ |= flags & (elfcpp::PF_R | elfcpp::PF_W | elfcpp::PF_X); } | |
169 | ||
170 | private: | |
171 | Output_segment(const Output_segment&); | |
172 | Output_segment& operator=(const Output_segment&); | |
173 | ||
174 | typedef std::list<Output_section*> Section_list; | |
175 | ||
176 | // The list of output sections attached to this segment. This is | |
177 | // cleared after layout. | |
178 | Section_list output_sections_; | |
179 | // The segment virtual address. | |
180 | uint64_t vaddr_; | |
181 | // The segment physical address. | |
182 | uint64_t paddr_; | |
183 | // The size of the segment in memory. | |
184 | uint64_t memsz_; | |
185 | // The segment alignment. | |
186 | uint64_t align_; | |
187 | // The offset of the segment data within the file. | |
188 | off_t offset_; | |
189 | // The size of the segment data in the file. | |
190 | off_t filesz_; | |
191 | // The segment type; | |
192 | elfcpp::Elf_Word type_; | |
193 | // The segment flags. | |
194 | elfcpp::Elf_Word flags_; | |
195 | }; | |
196 | ||
197 | // This class represents the output file. The output file is a | |
198 | // collection of output segments and a collection of output sections | |
199 | // which are not associated with segments. | |
200 | ||
201 | class Output_file | |
202 | { | |
203 | public: | |
204 | Output_file(); | |
205 | ~Output_file(); | |
206 | ||
207 | // Write data to the output file. | |
208 | void | |
209 | write(off_t off, const void* data, off_t len); | |
210 | }; | |
211 | ||
212 | } // End namespace gold. | |
213 | ||
214 | #endif // !defined(GOLD_OUTPUT_H) |