Another snapshot of the current state of the sources. Gets to the
[binutils-gdb.git] / gold / object.cc
1 // object.cc -- support for an object file for linking in gold
2
3 #include "gold.h"
4
5 #include <cerrno>
6 #include <cstring>
7 #include <cassert>
8
9 #include "object.h"
10 #include "target-select.h"
11
12 namespace gold
13 {
14
15 // Class Object.
16
17 const unsigned char*
18 Object::get_view(off_t start, off_t size)
19 {
20 return this->input_file_->file().get_view(start + this->offset_, size);
21 }
22
23 void
24 Object::read(off_t start, off_t size, void* p)
25 {
26 this->input_file_->file().read(start + this->offset_, size, p);
27 }
28
29 File_view*
30 Object::get_lasting_view(off_t start, off_t size)
31 {
32 return this->input_file_->file().get_lasting_view(start + this->offset_,
33 size);
34 }
35
36 // Class Sized_object.
37
38 template<int size, bool big_endian>
39 Sized_object<size, big_endian>::Sized_object(
40 const std::string& name,
41 Input_file* input_file,
42 off_t offset,
43 const elfcpp::Ehdr<size, big_endian>& ehdr)
44 : Object(name, input_file, false, offset),
45 osabi_(ehdr.get_e_ident()[elfcpp::EI_OSABI]),
46 abiversion_(ehdr.get_e_ident()[elfcpp::EI_ABIVERSION]),
47 machine_(ehdr.get_e_machine()),
48 flags_(ehdr.get_e_flags()),
49 shoff_(ehdr.get_e_shoff()),
50 shnum_(0),
51 shstrndx_(0),
52 symtab_shnum_(0),
53 symbols_(NULL)
54 {
55 if (ehdr.get_e_ehsize() != elfcpp::Elf_sizes<size>::ehdr_size)
56 {
57 fprintf(stderr, _("%s: %s: bad e_ehsize field (%d != %d)\n"),
58 program_name, this->name().c_str(), ehdr.get_e_ehsize(),
59 elfcpp::Elf_sizes<size>::ehdr_size);
60 gold_exit(false);
61 }
62 if (ehdr.get_e_shentsize() != elfcpp::Elf_sizes<size>::shdr_size)
63 {
64 fprintf(stderr, _("%s: %s: bad e_shentsize field (%d != %d)\n"),
65 program_name, this->name().c_str(), ehdr.get_e_shentsize(),
66 elfcpp::Elf_sizes<size>::shdr_size);
67 gold_exit(false);
68 }
69 }
70
71 template<int size, bool big_endian>
72 Sized_object<size, big_endian>::~Sized_object()
73 {
74 }
75
76 // Set up an object file bsaed on the file header. This sets up the
77 // target and reads the section information.
78
79 template<int size, bool big_endian>
80 void
81 Sized_object<size, big_endian>::setup(
82 const elfcpp::Ehdr<size, big_endian>& ehdr)
83 {
84 Target* target = select_target(this->machine_, size, big_endian,
85 this->osabi_, this->abiversion_);
86 if (target == NULL)
87 {
88 fprintf(stderr, _("%s: %s: unsupported ELF machine number %d\n"),
89 program_name, this->name().c_str(), this->machine_);
90 gold_exit(false);
91 }
92 this->set_target(target);
93 unsigned int shnum = ehdr.get_e_shnum();
94 unsigned int shstrndx = ehdr.get_e_shstrndx();
95 if ((shnum == 0 || shstrndx == elfcpp::SHN_XINDEX)
96 && this->shoff_ != 0)
97 {
98 const unsigned char* p = this->get_view
99 (this->shoff_, elfcpp::Elf_sizes<size>::shdr_size);
100 elfcpp::Shdr<size, big_endian> shdr(p);
101 if (shnum == 0)
102 shnum = shdr.get_sh_size();
103 if (shstrndx == elfcpp::SHN_XINDEX)
104 shstrndx = shdr.get_sh_link();
105 }
106 this->shnum_ = shnum;
107 this->shstrndx_ = shstrndx;
108
109 if (shnum == 0)
110 return;
111
112 // Find the SHT_SYMTAB section.
113 const unsigned char* p = this->get_view
114 (this->shoff_, shnum * elfcpp::Elf_sizes<size>::shdr_size);
115 // Skip the first section, which is always empty.
116 p += elfcpp::Elf_sizes<size>::shdr_size;
117 for (unsigned int i = 1; i < shnum; ++i)
118 {
119 elfcpp::Shdr<size, big_endian> shdr(p);
120 if (shdr.get_sh_type() == elfcpp::SHT_SYMTAB)
121 {
122 this->symtab_shnum_ = i;
123 break;
124 }
125 p += elfcpp::Elf_sizes<size>::shdr_size;
126 }
127 }
128
129 // Read the symbols and relocations from an object file.
130
131 template<int size, bool big_endian>
132 Read_symbols_data
133 Sized_object<size, big_endian>::do_read_symbols()
134 {
135 if (this->symtab_shnum_ == 0)
136 {
137 // No symbol table. Weird but legal.
138 Read_symbols_data ret;
139 ret.symbols = NULL;
140 ret.symbols_size = 0;
141 ret.symbol_names = NULL;
142 ret.symbol_names_size = 0;
143 return ret;
144 }
145
146 int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
147
148 // Read the symbol table section header.
149 off_t symtabshdroff = this->shoff_ + (this->symtab_shnum_ * shdr_size);
150 const unsigned char* psymtabshdr = this->get_view(symtabshdroff, shdr_size);
151 elfcpp::Shdr<size, big_endian> symtabshdr(psymtabshdr);
152 assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
153
154 // We only need the external symbols.
155 int sym_size = elfcpp::Elf_sizes<size>::sym_size;
156 off_t locsize = symtabshdr.get_sh_info() * sym_size;
157 off_t extoff = symtabshdr.get_sh_offset() + locsize;
158 off_t extsize = symtabshdr.get_sh_size() - locsize;
159
160 // Read the symbol table.
161 File_view* fvsymtab = this->get_lasting_view(extoff, extsize);
162
163 // Read the section header for the symbol names.
164 unsigned int strtab_shnum = symtabshdr.get_sh_link();
165 if (strtab_shnum == 0 || strtab_shnum >= this->shnum_)
166 {
167 fprintf(stderr, _("%s: %s: invalid symbol table name index: %u\n"),
168 program_name, this->name().c_str(), strtab_shnum);
169 gold_exit(false);
170 }
171 off_t strtabshdroff = this->shoff_ + (strtab_shnum * shdr_size);
172 const unsigned char *pstrtabshdr = this->get_view(strtabshdroff, shdr_size);
173 elfcpp::Shdr<size, big_endian> strtabshdr(pstrtabshdr);
174 if (strtabshdr.get_sh_type() != elfcpp::SHT_STRTAB)
175 {
176 fprintf(stderr,
177 _("%s: %s: symbol table name section has wrong type: %u\n"),
178 program_name, this->name().c_str(),
179 static_cast<unsigned int>(strtabshdr.get_sh_type()));
180 gold_exit(false);
181 }
182
183 // Read the symbol names.
184 File_view* fvstrtab = this->get_lasting_view(strtabshdr.get_sh_offset(),
185 strtabshdr.get_sh_size());
186
187 Read_symbols_data ret;
188 ret.symbols = fvsymtab;
189 ret.symbols_size = extsize;
190 ret.symbol_names = fvstrtab;
191 ret.symbol_names_size = strtabshdr.get_sh_size();
192
193 return ret;
194 }
195
196 // Add the symbols to the symbol table.
197
198 template<int size, bool big_endian>
199 void
200 Sized_object<size, big_endian>::do_add_symbols(Symbol_table* symtab,
201 Read_symbols_data sd)
202 {
203 if (sd.symbols == NULL)
204 {
205 assert(sd.symbol_names == NULL);
206 return;
207 }
208
209 unsigned int sym_size = elfcpp::Elf_sizes<size>::sym_size;
210 size_t symcount = sd.symbols_size / sym_size;
211 if (symcount * sym_size != sd.symbols_size)
212 {
213 fprintf(stderr,
214 _("%s: %s: size of symbols is not multiple of symbol size\n"),
215 program_name, this->name().c_str());
216 gold_exit(false);
217 }
218
219 this->symbols_ = new Symbol*[symcount];
220
221 const elfcpp::Sym<size, big_endian>* syms =
222 reinterpret_cast<const elfcpp::Sym<size, big_endian>*>(sd.symbols->data());
223 const char* sym_names =
224 reinterpret_cast<const char*>(sd.symbol_names->data());
225 symtab->add_from_object(this, syms, symcount, sym_names,
226 sd.symbol_names_size, this->symbols_);
227 }
228
229 } // End namespace gold.
230
231 namespace
232 {
233
234 using namespace gold;
235
236 // Read an ELF file with the header and return the appropriate
237 // instance of Object.
238
239 template<int size, bool big_endian>
240 Object*
241 make_elf_sized_object(const std::string& name, Input_file* input_file,
242 off_t offset, const elfcpp::Ehdr<size, big_endian>& ehdr)
243 {
244 int et = ehdr.get_e_type();
245 if (et != elfcpp::ET_REL && et != elfcpp::ET_DYN)
246 {
247 fprintf(stderr, "%s: %s: unsupported ELF type %d\n",
248 program_name, name.c_str(), static_cast<int>(et));
249 gold_exit(false);
250 }
251
252 if (et == elfcpp::ET_REL)
253 {
254 Sized_object<size, big_endian>* obj =
255 new Sized_object<size, big_endian>(name, input_file, offset, ehdr);
256 obj->setup(ehdr);
257 return obj;
258 }
259 else
260 {
261 // elfcpp::ET_DYN
262 fprintf(stderr, _("%s: %s: dynamic objects are not yet supported\n"),
263 program_name, name.c_str());
264 gold_exit(false);
265 // Sized_dynobj<size, big_endian>* obj =
266 // new Sized_dynobj<size, big_endian>(this->input_.name(), input_file,
267 // offset, ehdr);
268 // obj->setup(ehdr);
269 // return obj;
270 }
271 }
272
273 } // End anonymous namespace.
274
275 namespace gold
276 {
277
278 // Read an ELF file and return the appropriate instance of Object.
279
280 Object*
281 make_elf_object(const std::string& name, Input_file* input_file, off_t offset,
282 const unsigned char* p, off_t bytes)
283 {
284 if (bytes < elfcpp::EI_NIDENT)
285 {
286 fprintf(stderr, _("%s: %s: ELF file too short\n"),
287 program_name, name.c_str());
288 gold_exit(false);
289 }
290
291 int v = p[elfcpp::EI_VERSION];
292 if (v != elfcpp::EV_CURRENT)
293 {
294 if (v == elfcpp::EV_NONE)
295 fprintf(stderr, _("%s: %s: invalid ELF version 0\n"),
296 program_name, name.c_str());
297 else
298 fprintf(stderr, _("%s: %s: unsupported ELF version %d\n"),
299 program_name, name.c_str(), v);
300 gold_exit(false);
301 }
302
303 int c = p[elfcpp::EI_CLASS];
304 if (c == elfcpp::ELFCLASSNONE)
305 {
306 fprintf(stderr, _("%s: %s: invalid ELF class 0\n"),
307 program_name, name.c_str());
308 gold_exit(false);
309 }
310 else if (c != elfcpp::ELFCLASS32
311 && c != elfcpp::ELFCLASS64)
312 {
313 fprintf(stderr, _("%s: %s: unsupported ELF class %d\n"),
314 program_name, name.c_str(), c);
315 gold_exit(false);
316 }
317
318 int d = p[elfcpp::EI_DATA];
319 if (d == elfcpp::ELFDATANONE)
320 {
321 fprintf(stderr, _("%s: %s: invalid ELF data encoding\n"),
322 program_name, name.c_str());
323 gold_exit(false);
324 }
325 else if (d != elfcpp::ELFDATA2LSB
326 && d != elfcpp::ELFDATA2MSB)
327 {
328 fprintf(stderr, _("%s: %s: unsupported ELF data encoding %d\n"),
329 program_name, name.c_str(), d);
330 gold_exit(false);
331 }
332
333 bool big_endian = d == elfcpp::ELFDATA2MSB;
334
335 if (c == elfcpp::ELFCLASS32)
336 {
337 if (bytes < elfcpp::Elf_sizes<32>::ehdr_size)
338 {
339 fprintf(stderr, _("%s: %s: ELF file too short\n"),
340 program_name, name.c_str());
341 gold_exit(false);
342 }
343 if (big_endian)
344 {
345 elfcpp::Ehdr<32, true> ehdr(p);
346 return make_elf_sized_object<32, true>(name, input_file,
347 offset, ehdr);
348 }
349 else
350 {
351 elfcpp::Ehdr<32, false> ehdr(p);
352 return make_elf_sized_object<32, false>(name, input_file,
353 offset, ehdr);
354 }
355 }
356 else
357 {
358 if (bytes < elfcpp::Elf_sizes<32>::ehdr_size)
359 {
360 fprintf(stderr, _("%s: %s: ELF file too short\n"),
361 program_name, name.c_str());
362 gold_exit(false);
363 }
364 if (big_endian)
365 {
366 elfcpp::Ehdr<64, true> ehdr(p);
367 return make_elf_sized_object<64, true>(name, input_file,
368 offset, ehdr);
369 }
370 else
371 {
372 elfcpp::Ehdr<64, false> ehdr(p);
373 return make_elf_sized_object<64, false>(name, input_file,
374 offset, ehdr);
375 }
376 }
377 }
378
379 // Instantiate the templates we need. We could use the configure
380 // script to restrict this to only the ones for implemented targets.
381
382 template
383 class Sized_object<32, false>;
384
385 template
386 class Sized_object<32, true>;
387
388 template
389 class Sized_object<64, false>;
390
391 template
392 class Sized_object<64, true>;
393
394 } // End namespace gold.