projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2000-03-06 Elena Zannoni <ezannoni@kwikemart.cygnus.com>
[deliverable/binutils-gdb.git] / bfd / peicode.h
CommitLineData
277d1b5e 1/* Support for the generic parts of PE/PEI, for BFD.
86033394 2 Copyright 1995, 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
277d1b5e 3 Written by Cygnus Solutions.
252b5132
RH		 4
5This file is part of BFD, the Binary File Descriptor library.
6
7This program is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2 of the License, or
10(at your option) any later version.
11
12This program is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with this program; if not, write to the Free Software
19Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21/*
22Most of this hacked by Steve Chamberlain,
23 sac@cygnus.com
277d1b5e
ILT		 24
25PE/PEI rearrangement (and code added): Donn Terry
26 Softway Systems, Inc.
252b5132
RH		 27*/
28
29/* Hey look, some documentation [and in a place you expect to find it]!
30
31 The main reference for the pei format is "Microsoft Portable Executable
32 and Common Object File Format Specification 4.1". Get it if you need to
33 do some serious hacking on this code.
34
35 Another reference:
36 "Peering Inside the PE: A Tour of the Win32 Portable Executable
37 File Format", MSJ 1994, Volume 9.
38
39 The *sole* difference between the pe format and the pei format is that the
40 latter has an MSDOS 2.0 .exe header on the front that prints the message
41 "This app must be run under Windows." (or some such).
42 (FIXME: Whether that statement is *really* true or not is unknown.
43 Are there more subtle differences between pe and pei formats?
44 For now assume there aren't. If you find one, then for God sakes
45 document it here!)
46
47 The Microsoft docs use the word "image" instead of "executable" because
48 the former can also refer to a DLL (shared library). Confusion can arise
49 because the `i' in `pei' also refers to "image". The `pe' format can
50 also create images (i.e. executables), it's just that to run on a win32
51 system you need to use the pei format.
52
53 FIXME: Please add more docs here so the next poor fool that has to hack
54 on this code has a chance of getting something accomplished without
55 wasting too much time.
56*/
57
277d1b5e
ILT		 58#include "libpei.h"
59
252b5132 60static boolean (*pe_saved_coff_bfd_print_private_bfd_data)
277d1b5e
ILT		 61 PARAMS ((bfd *, PTR)) =
62#ifndef coff_bfd_print_private_bfd_data
63 NULL;
252b5132 64#else
277d1b5e
ILT		 65 coff_bfd_print_private_bfd_data;
66#undef coff_bfd_print_private_bfd_data
252b5132
RH		 67#endif
68
277d1b5e
ILT		 69static boolean pe_print_private_bfd_data PARAMS ((bfd *, PTR));
70#define coff_bfd_print_private_bfd_data pe_print_private_bfd_data
252b5132 71
252b5132 72
277d1b5e
ILT		 73static boolean (*pe_saved_coff_bfd_copy_private_bfd_data)
74 PARAMS ((bfd *, bfd *)) =
75#ifndef coff_bfd_copy_private_bfd_data
76 NULL;
77#else
78 coff_bfd_copy_private_bfd_data;
79#undef coff_bfd_copy_private_bfd_data
252b5132
RH		 80#endif
81
277d1b5e
ILT		 82static boolean pe_bfd_copy_private_bfd_data PARAMS ((bfd *, bfd *));
83#define coff_bfd_copy_private_bfd_data pe_bfd_copy_private_bfd_data
252b5132 84
277d1b5e
ILT		 85#define coff_mkobject pe_mkobject
86#define coff_mkobject_hook pe_mkobject_hook
252b5132 87
17505c5c 88#ifndef NO_COFF_RELOCS
252b5132
RH		 89static void coff_swap_reloc_in PARAMS ((bfd *, PTR, PTR));
90static unsigned int coff_swap_reloc_out PARAMS ((bfd *, PTR, PTR));
17505c5c 91#endif
252b5132 92static void coff_swap_filehdr_in PARAMS ((bfd *, PTR, PTR));
252b5132 93static void coff_swap_scnhdr_in PARAMS ((bfd *, PTR, PTR));
252b5132
RH		 94static boolean pe_mkobject PARAMS ((bfd *));
95static PTR pe_mkobject_hook PARAMS ((bfd *, PTR, PTR));
252b5132 96
17505c5c
NC		 97#ifdef COFF_IMAGE_WITH_PE
98/* This structure contains static variables used by the ILF code. */
99typedef asection * asection_ptr;
100
101typedef struct
102{
103 bfd * abfd;
104 bfd_byte * data;
105 struct bfd_in_memory * bim;
106 unsigned short magic;
107
108 arelent * reltab;
109 unsigned int relcount;
110
111 coff_symbol_type * sym_cache;
112 coff_symbol_type * sym_ptr;
113 unsigned int sym_index;
114
115 unsigned int * sym_table;
116 unsigned int * table_ptr;
11c8a8d1 117
17505c5c
NC		 118 combined_entry_type * native_syms;
119 combined_entry_type * native_ptr;
120
11c8a8d1
NC		 121 coff_symbol_type ** sym_ptr_table;
122 coff_symbol_type ** sym_ptr_ptr;
123
17505c5c
NC		 124 unsigned int sec_index;
125
126 char * string_table;
127 char * string_ptr;
128 char * end_string_ptr;
129
130 SYMENT * esym_table;
131 SYMENT * esym_ptr;
132
133 struct internal_reloc * int_reltab;
134}
135pe_ILF_vars;
136
137static asection_ptr pe_ILF_make_a_section PARAMS ((pe_ILF_vars *, const char *, unsigned int, flagword));
138static void pe_ILF_make_a_reloc PARAMS ((pe_ILF_vars *, bfd_vma, bfd_reloc_code_real_type, asection_ptr));
139static void pe_ILF_make_a_symbol PARAMS ((pe_ILF_vars *, const char *, const char *, asection_ptr, flagword));
140static void pe_ILF_save_relocs PARAMS ((pe_ILF_vars *, asection_ptr));
11c8a8d1 141static void pe_ILF_make_a_symbol_reloc PARAMS ((pe_ILF_vars *, bfd_vma, bfd_reloc_code_real_type, struct symbol_cache_entry **, unsigned int));
17505c5c
NC		 142static boolean pe_ILF_build_a_bfd PARAMS ((bfd *, unsigned short, bfd_byte *, bfd_byte *, unsigned int, unsigned int));
143static const bfd_target * pe_ILF_object_p PARAMS ((bfd *));
11c8a8d1 144static const bfd_target * pe_bfd_object_p PARAMS ((bfd *));
17505c5c
NC		 145#endif /* COFF_IMAGE_WITH_PE */
146
252b5132
RH		 147/**********************************************************************/
148
17505c5c 149#ifndef NO_COFF_RELOCS
252b5132
RH		 150static void
151coff_swap_reloc_in (abfd, src, dst)
152 bfd *abfd;
153 PTR src;
154 PTR dst;
155{
156 RELOC *reloc_src = (RELOC *) src;
157 struct internal_reloc *reloc_dst = (struct internal_reloc *) dst;
158
159 reloc_dst->r_vaddr = bfd_h_get_32(abfd, (bfd_byte *)reloc_src->r_vaddr);
160 reloc_dst->r_symndx = bfd_h_get_signed_32(abfd, (bfd_byte *) reloc_src->r_symndx);
161
162 reloc_dst->r_type = bfd_h_get_16(abfd, (bfd_byte *) reloc_src->r_type);
163
164#ifdef SWAP_IN_RELOC_OFFSET
165 reloc_dst->r_offset = SWAP_IN_RELOC_OFFSET(abfd,
166 (bfd_byte *) reloc_src->r_offset);
167#endif
168}
169
170
171static unsigned int
172coff_swap_reloc_out (abfd, src, dst)
173 bfd *abfd;
174 PTR src;
175 PTR dst;
176{
177 struct internal_reloc *reloc_src = (struct internal_reloc *)src;
178 struct external_reloc *reloc_dst = (struct external_reloc *)dst;
179 bfd_h_put_32(abfd, reloc_src->r_vaddr, (bfd_byte *) reloc_dst->r_vaddr);
180 bfd_h_put_32(abfd, reloc_src->r_symndx, (bfd_byte *) reloc_dst->r_symndx);
181
182 bfd_h_put_16(abfd, reloc_src->r_type, (bfd_byte *)
183 reloc_dst->r_type);
184
185#ifdef SWAP_OUT_RELOC_OFFSET
186 SWAP_OUT_RELOC_OFFSET(abfd,
187 reloc_src->r_offset,
188 (bfd_byte *) reloc_dst->r_offset);
189#endif
190#ifdef SWAP_OUT_RELOC_EXTRA
191 SWAP_OUT_RELOC_EXTRA(abfd,reloc_src, reloc_dst);
192#endif
193 return RELSZ;
194}
17505c5c 195#endif /* not NO_COFF_RELOCS */
252b5132
RH		 196
197static void
198coff_swap_filehdr_in (abfd, src, dst)
199 bfd *abfd;
200 PTR src;
201 PTR dst;
202{
203 FILHDR *filehdr_src = (FILHDR *) src;
204 struct internal_filehdr *filehdr_dst = (struct internal_filehdr *) dst;
205 filehdr_dst->f_magic = bfd_h_get_16(abfd, (bfd_byte *) filehdr_src->f_magic);
206 filehdr_dst->f_nscns = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_nscns);
207 filehdr_dst->f_timdat = bfd_h_get_32(abfd, (bfd_byte *)filehdr_src-> f_timdat);
208
209 filehdr_dst->f_nsyms = bfd_h_get_32(abfd, (bfd_byte *)filehdr_src-> f_nsyms);
210 filehdr_dst->f_flags = bfd_h_get_16(abfd, (bfd_byte *)filehdr_src-> f_flags);
211 filehdr_dst->f_symptr = bfd_h_get_32 (abfd, (bfd_byte *) filehdr_src->f_symptr);
212
05bf877a
ILT		 213#ifdef COFF_IMAGE_WITH_PE
214 /* There are really two magic numbers involved; the magic number
215 that says this is a NT executable (PEI) and the magic number that
216 determines the architecture. The former is DOSMAGIC, stored in
217 the e_magic field. The latter is stored in the f_magic field.
218 If the NT magic number isn't valid, the architecture magic number
219 could be mimicked by some other field (specifically, the number
220 of relocs in section 3). Since this routine can only be called
221 correctly for a PEI file, check the e_magic number here, and, if
222 it doesn't match, clobber the f_magic number so that we don't get
223 a false match. */
224 if (bfd_h_get_16 (abfd, (bfd_byte *) filehdr_src->e_magic) != DOSMAGIC)
225 filehdr_dst->f_magic = -1;
226#endif
227
252b5132
RH		 228 /* Other people's tools sometimes generate headers with an nsyms but
229 a zero symptr. */
230 if (filehdr_dst->f_nsyms != 0 && filehdr_dst->f_symptr == 0)
231 {
232 filehdr_dst->f_nsyms = 0;
233 filehdr_dst->f_flags |= F_LSYMS;
234 }
235
236 filehdr_dst->f_opthdr = bfd_h_get_16(abfd,
237 (bfd_byte *)filehdr_src-> f_opthdr);
238}
239
240#ifdef COFF_IMAGE_WITH_PE
277d1b5e 241#define coff_swap_filehdr_out _bfd_pei_only_swap_filehdr_out
252b5132 242#else
277d1b5e 243#define coff_swap_filehdr_out _bfd_pe_only_swap_filehdr_out
252b5132 244#endif
252b5132 245
252b5132
RH		 246
247static void
e166a60f
ILT		 248coff_swap_scnhdr_in (abfd, ext, in)
249 bfd *abfd;
250 PTR ext;
251 PTR in;
252b5132
RH		 252{
253 SCNHDR *scnhdr_ext = (SCNHDR *) ext;
254 struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
255
256 memcpy(scnhdr_int->s_name, scnhdr_ext->s_name, sizeof(scnhdr_int->s_name));
257 scnhdr_int->s_vaddr =
258 GET_SCNHDR_VADDR (abfd, (bfd_byte *) scnhdr_ext->s_vaddr);
259 scnhdr_int->s_paddr =
260 GET_SCNHDR_PADDR (abfd, (bfd_byte *) scnhdr_ext->s_paddr);
261 scnhdr_int->s_size =
262 GET_SCNHDR_SIZE (abfd, (bfd_byte *) scnhdr_ext->s_size);
263 scnhdr_int->s_scnptr =
264 GET_SCNHDR_SCNPTR (abfd, (bfd_byte *) scnhdr_ext->s_scnptr);
265 scnhdr_int->s_relptr =
266 GET_SCNHDR_RELPTR (abfd, (bfd_byte *) scnhdr_ext->s_relptr);
267 scnhdr_int->s_lnnoptr =
268 GET_SCNHDR_LNNOPTR (abfd, (bfd_byte *) scnhdr_ext->s_lnnoptr);
269 scnhdr_int->s_flags = bfd_h_get_32(abfd, (bfd_byte *) scnhdr_ext->s_flags);
270
cb43721d
ILT		 271 /* MS handles overflow of line numbers by carrying into the reloc
272 field (it appears). Since it's supposed to be zero for PE
273 *IMAGE* format, that's safe. This is still a bit iffy. */
274#ifdef COFF_IMAGE_WITH_PE
275 scnhdr_int->s_nlnno =
276 (bfd_h_get_16 (abfd, (bfd_byte *) scnhdr_ext->s_nlnno)
277 + (bfd_h_get_16 (abfd, (bfd_byte *) scnhdr_ext->s_nreloc) << 16));
278 scnhdr_int->s_nreloc = 0;
279#else
280 scnhdr_int->s_nreloc = bfd_h_get_16 (abfd,
281 (bfd_byte *) scnhdr_ext->s_nreloc);
282 scnhdr_int->s_nlnno = bfd_h_get_16 (abfd,
283 (bfd_byte *) scnhdr_ext->s_nlnno);
284#endif
252b5132
RH		 285
286 if (scnhdr_int->s_vaddr != 0)
287 {
288 scnhdr_int->s_vaddr += pe_data (abfd)->pe_opthdr.ImageBase;
289 scnhdr_int->s_vaddr &= 0xffffffff;
290 }
e166a60f 291
17505c5c 292#ifndef COFF_NO_HACK_SCNHDR_SIZE
e166a60f
ILT		 293 /* If this section holds uninitialized data, use the virtual size
294 (stored in s_paddr) instead of the physical size. */
295 if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
252b5132
RH		 296 {
297 scnhdr_int->s_size = scnhdr_int->s_paddr;
e166a60f
ILT		 298 /* This code used to set scnhdr_int->s_paddr to 0. However,
299 coff_set_alignment_hook stores s_paddr in virt_size, which
300 only works if it correctly holds the virtual size of the
301 section. */
252b5132 302 }
17505c5c 303#endif
252b5132
RH		 304}
305
252b5132
RH		 306static boolean
307pe_mkobject (abfd)
308 bfd * abfd;
309{
310 pe_data_type *pe;
311 abfd->tdata.pe_obj_data =
312 (struct pe_tdata *) bfd_zalloc (abfd, sizeof (pe_data_type));
313
314 if (abfd->tdata.pe_obj_data == 0)
315 return false;
316
317 pe = pe_data (abfd);
318
319 pe->coff.pe = 1;
277d1b5e
ILT		 320
321 /* in_reloc_p is architecture dependent. */
252b5132
RH		 322 pe->in_reloc_p = in_reloc_p;
323 return true;
324}
325
326/* Create the COFF backend specific information. */
327static PTR
328pe_mkobject_hook (abfd, filehdr, aouthdr)
329 bfd * abfd;
330 PTR filehdr;
5f771d47 331 PTR aouthdr ATTRIBUTE_UNUSED;
252b5132
RH		 332{
333 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
334 pe_data_type *pe;
335
336 if (pe_mkobject (abfd) == false)
337 return NULL;
338
339 pe = pe_data (abfd);
340 pe->coff.sym_filepos = internal_f->f_symptr;
341 /* These members communicate important constants about the symbol
342 table to GDB's symbol-reading code. These `constants'
343 unfortunately vary among coff implementations... */
344 pe->coff.local_n_btmask = N_BTMASK;
345 pe->coff.local_n_btshft = N_BTSHFT;
346 pe->coff.local_n_tmask = N_TMASK;
347 pe->coff.local_n_tshift = N_TSHIFT;
348 pe->coff.local_symesz = SYMESZ;
349 pe->coff.local_auxesz = AUXESZ;
350 pe->coff.local_linesz = LINESZ;
351
1135238b
ILT		 352 pe->coff.timestamp = internal_f->f_timdat;
353
252b5132
RH		 354 obj_raw_syment_count (abfd) =
355 obj_conv_table_size (abfd) =
356 internal_f->f_nsyms;
357
358 pe->real_flags = internal_f->f_flags;
359
360 if ((internal_f->f_flags & F_DLL) != 0)
361 pe->dll = 1;
362
4cfec37b
ILT		 363 if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0)
364 abfd->flags |= HAS_DEBUG;
365
252b5132
RH		 366#ifdef COFF_IMAGE_WITH_PE
367 if (aouthdr)
368 pe->pe_opthdr = ((struct internal_aouthdr *)aouthdr)->pe;
369#endif
370
371#ifdef ARM
372 if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags))
373 coff_data (abfd) ->flags = 0;
374#endif
375
376 return (PTR) pe;
377}
378
277d1b5e
ILT		 379static boolean
380pe_print_private_bfd_data (abfd, vfile)
381 bfd *abfd;
382 PTR vfile;
383{
384 FILE *file = (FILE *) vfile;
385
386 if (!_bfd_pe_print_private_bfd_data_common (abfd, vfile))
387 return false;
252b5132 388
277d1b5e
ILT		 389 if (pe_saved_coff_bfd_print_private_bfd_data != NULL)
390 {
391 fputc ('\n', file);
392
393 return pe_saved_coff_bfd_print_private_bfd_data (abfd, vfile);
394 }
395
396 return true;
397}
252b5132
RH		 398
399/* Copy any private info we understand from the input bfd
400 to the output bfd. */
401
252b5132
RH		 402static boolean
403pe_bfd_copy_private_bfd_data (ibfd, obfd)
404 bfd *ibfd, *obfd;
405{
277d1b5e
ILT		 406 if (!_bfd_pe_bfd_copy_private_bfd_data_common (ibfd, obfd))
407 return false;
252b5132
RH		 408
409 if (pe_saved_coff_bfd_copy_private_bfd_data)
410 return pe_saved_coff_bfd_copy_private_bfd_data (ibfd, obfd);
252b5132
RH		 411
412 return true;
413}
414
277d1b5e
ILT		 415#define coff_bfd_copy_private_section_data \
416 _bfd_pe_bfd_copy_private_section_data
7d2b58d6
ILT		 417
418#define coff_get_symbol_info _bfd_pe_get_symbol_info
cb665cd3 419
b1f10154 420#ifdef COFF_IMAGE_WITH_PE
17505c5c
NC		 421\f
422/* Code to handle Microsoft's Image Library Format.
423 Also known as LINK6 format.
424 Documentation about this format can be found at:
425
426 http://msdn.microsoft.com/library/specs/pecoff_section8.htm */
427
428/* The following constants specify the sizes of the various data
429 structures that we have to create in order to build a bfd describing
430 an ILF object file. The final "+ 1" in the definitions of SIZEOF_IDATA6
431 and SIZEOF_IDATA7 below is to allow for the possibility that we might
432 need a padding byte in order to ensure 16 bit alignment for the section's
433 contents.
434
435 The value for SIZEOF_ILF_STRINGS is computed as follows:
436
437 There will be NUM_ILF_SECTIONS section symbols. Allow 9 characters
11c8a8d1 438 per symbol for their names (longest section name is .idata$x).
17505c5c
NC		 439
440 There will be two symbols for the imported value, one the symbol name
441 and one with _imp__ prefixed. Allowing for the terminating nul's this
11c8a8d1 442 is strlen (symbol_name) * 2 + 8 + 21 + strlen (source_dll).
17505c5c
NC		 443
444 The strings in the string table must start STRING__SIZE_SIZE bytes into
445 the table in order to for the string lookup code in coffgen/coffcode to
446 work. */
447#define NUM_ILF_RELOCS 8
448#define NUM_ILF_SECTIONS 6
449#define NUM_ILF_SYMS (2 + NUM_ILF_SECTIONS)
450
451#define SIZEOF_ILF_SYMS (NUM_ILF_SYMS * sizeof (* vars.sym_cache))
452#define SIZEOF_ILF_SYM_TABLE (NUM_ILF_SYMS * sizeof (* vars.sym_table))
453#define SIZEOF_ILF_NATIVE_SYMS (NUM_ILF_SYMS * sizeof (* vars.native_syms))
11c8a8d1 454#define SIZEOF_ILF_SYM_PTR_TABLE (NUM_ILF_SYMS * sizeof (* vars.sym_ptr_table))
17505c5c
NC		 455#define SIZEOF_ILF_EXT_SYMS (NUM_ILF_SYMS * sizeof (* vars.esym_table))
456#define SIZEOF_ILF_RELOCS (NUM_ILF_RELOCS * sizeof (* vars.reltab))
457#define SIZEOF_ILF_INT_RELOCS (NUM_ILF_RELOCS * sizeof (* vars.int_reltab))
11c8a8d1
NC		 458#define SIZEOF_ILF_STRINGS (strlen (symbol_name) * 2 + 8 \
459 + 21 + strlen (source_dll) \
460 + NUM_ILF_SECTIONS * 9 \
461 + STRING_SIZE_SIZE)
17505c5c
NC		 462#define SIZEOF_IDATA2 (5 * 4)
463#define SIZEOF_IDATA4 (1 * 4)
464#define SIZEOF_IDATA5 (1 * 4)
465#define SIZEOF_IDATA6 (2 + strlen (symbol_name) + 1 + 1)
466#define SIZEOF_IDATA7 (strlen (source_dll) + 1 + 1)
467#define SIZEOF_ILF_SECTIONS (NUM_ILF_SECTIONS * sizeof (struct coff_section_tdata))
468
469#define ILF_DATA_SIZE \
470 sizeof (* vars.bim) \
471 + SIZEOF_ILF_SYMS \
472 + SIZEOF_ILF_SYM_TABLE \
473 + SIZEOF_ILF_NATIVE_SYMS \
11c8a8d1 474 + SIZEOF_ILF_SYM_PTR_TABLE \
17505c5c
NC		 475 + SIZEOF_ILF_EXT_SYMS \
476 + SIZEOF_ILF_RELOCS \
477 + SIZEOF_ILF_INT_RELOCS \
478 + SIZEOF_ILF_STRINGS \
479 + SIZEOF_IDATA2 \
480 + SIZEOF_IDATA4 \
481 + SIZEOF_IDATA5 \
482 + SIZEOF_IDATA6 \
483 + SIZEOF_IDATA7 \
484 + SIZEOF_ILF_SECTIONS \
485 + MAX_TEXT_SECTION_SIZE
486
487
488/* Create an empty relocation against the given symbol. */
489static void
11c8a8d1
NC		 490pe_ILF_make_a_symbol_reloc (pe_ILF_vars * vars,
491 bfd_vma address,
492 bfd_reloc_code_real_type reloc,
493 struct symbol_cache_entry ** sym,
494 unsigned int sym_index)
17505c5c
NC		 495{
496 arelent * entry;
497 struct internal_reloc * internal;
498
499 entry = vars->reltab + vars->relcount;
500 internal = vars->int_reltab + vars->relcount;
501
502 entry->address = address;
503 entry->addend = 0;
504 entry->howto = bfd_reloc_type_lookup (vars->abfd, reloc);
11c8a8d1 505 entry->sym_ptr_ptr = sym;
17505c5c
NC		 506
507 internal->r_vaddr = address;
11c8a8d1 508 internal->r_symndx = sym_index;
17505c5c
NC		 509 internal->r_type = entry->howto->type;
510#if 0 /* These fields do not need to be initialised. */
511 internal->r_size = 0;
512 internal->r_extern = 0;
513 internal->r_offset = 0;
514#endif
515
516 vars->relcount ++;
517
518 BFD_ASSERT (vars->relcount <= NUM_ILF_RELOCS);
519}
520
11c8a8d1
NC		 521/* Create an empty relocation against the given section. */
522static void
523pe_ILF_make_a_reloc (pe_ILF_vars * vars,
524 bfd_vma address,
525 bfd_reloc_code_real_type reloc,
526 asection_ptr sec)
527{
528 pe_ILF_make_a_symbol_reloc (vars, address, reloc, sec->symbol_ptr_ptr,
529 coff_section_data (vars->abfd, sec)->i);
530}
531
17505c5c
NC		 532/* Move the queued relocs into the given section. */
533static void
534pe_ILF_save_relocs (pe_ILF_vars * vars,
535 asection_ptr sec)
536{
537 /* Make sure that there is somewhere to store the internal relocs. */
538 if (coff_section_data (vars->abfd, sec) == NULL)
539 /* We should probably return an error indication here. */
540 abort ();
541
542 coff_section_data (vars->abfd, sec)->relocs = vars->int_reltab;
543 coff_section_data (vars->abfd, sec)->keep_relocs = true;
544
545 sec->relocation = vars->reltab;
546 sec->reloc_count = vars->relcount;
547 sec->flags |= SEC_RELOC;
548
549 vars->reltab += vars->relcount;
550 vars->int_reltab += vars->relcount;
551 vars->relcount = 0;
552
553 BFD_ASSERT ((bfd_byte *)vars->int_reltab < (bfd_byte *)vars->string_table);
554}
555
556/* Create a global symbol and add it to the relevant tables. */
557static void
558pe_ILF_make_a_symbol (pe_ILF_vars * vars,
559 const char * prefix,
560 const char * symbol_name,
561 asection_ptr section,
562 flagword extra_flags)
563{
564 coff_symbol_type * sym;
565 combined_entry_type * ent;
566 SYMENT * esym;
567 unsigned short sclass;
568
569 if (extra_flags & BSF_LOCAL)
11c8a8d1 570 sclass = C_STAT;
17505c5c
NC		 571 else
572 sclass = C_EXT;
573
574#ifdef THUMBPEMAGIC
575 if (vars->magic == THUMBPEMAGIC)
576 {
577 if (extra_flags & BSF_FUNCTION)
578 sclass = C_THUMBEXTFUNC;
579 else if (extra_flags & BSF_LOCAL)
11c8a8d1 580 sclass = C_THUMBSTAT;
17505c5c
NC		 581 else
582 sclass = C_THUMBEXT;
583 }
584#endif
585
586 BFD_ASSERT (vars->sym_index < NUM_ILF_SYMS);
587
588 sym = vars->sym_ptr;
589 ent = vars->native_ptr;
590 esym = vars->esym_ptr;
591
592 /* Copy the symbol's name into the string table. */
593 sprintf (vars->string_ptr, "%s%s", prefix, symbol_name);
594
595 /* Initialise the external symbol. */
596 bfd_h_put_32 (vars->abfd, vars->string_ptr - vars->string_table, (bfd_byte *) esym->e.e.e_offset);
11c8a8d1
NC		 597 if (section)
598 bfd_h_put_16 (vars->abfd, section->target_index, (bfd_byte *) esym->e_scnum);
599 else
600 bfd_h_put_16 (vars->abfd, 0, (bfd_byte *) esym->e_scnum);
601
17505c5c
NC		 602 esym->e_sclass[0] = sclass;
603
604 /* The following initialisations are unnecessary - the memory is
605 zero initialised. They are just kept here as reminders. */
606#if 0
607 esym->e.e.e_zeroes = 0;
608 esym->e_value = 0;
609 esym->e_type = T_NULL;
610 esym->e_numaux = 0;
611#endif
612
613 /* Initialise the internal symbol structure. */
614 ent->u.syment.n_sclass = sclass;
11c8a8d1
NC		 615 if (section)
616 ent->u.syment.n_scnum = section->target_index;
17505c5c
NC		 617 ent->u.syment._n._n_n._n_offset = (long) sym;
618
619#if 0 /* See comment above. */
620 ent->u.syment.n_value = 0;
621 ent->u.syment.n_flags = 0;
622 ent->u.syment.n_type = T_NULL;
623 ent->u.syment.n_numaux = 0;
624 ent->fix_value = 0;
625#endif
626
627 sym->symbol.the_bfd = vars->abfd;
628 sym->symbol.name = vars->string_ptr;
629 sym->symbol.flags = BSF_EXPORT | BSF_GLOBAL | extra_flags;
630 sym->symbol.section = section;
631 sym->native = ent;
632
633#if 0 /* See comment above. */
634 sym->symbol.value = 0;
635 sym->symbol.udata.i = 0;
636 sym->done_lineno = false;
637 sym->lineno = NULL;
638#endif
639
640 * vars->table_ptr = vars->sym_index;
11c8a8d1
NC		 641 * vars->sym_ptr_ptr = sym;
642
17505c5c
NC		 643 /* Adjust pointers for the next symbol. */
644 vars->sym_index ++;
645 vars->sym_ptr ++;
11c8a8d1 646 vars->sym_ptr_ptr ++;
17505c5c
NC		 647 vars->table_ptr ++;
648 vars->native_ptr ++;
649 vars->esym_ptr ++;
11c8a8d1 650 vars->string_ptr += strlen (symbol_name) + strlen (prefix) + 1;
17505c5c
NC		 651
652 BFD_ASSERT (vars->string_ptr < vars->end_string_ptr);
653}
654
655/* Create a section. */
656static asection_ptr
657pe_ILF_make_a_section (pe_ILF_vars * vars,
658 const char * name,
659 unsigned int size,
660 flagword extra_flags)
661{
662 asection_ptr sec;
663 flagword flags;
664
665 sec = bfd_make_section_old_way (vars->abfd, name);
666 if (sec == NULL)
667 return NULL;
668
669 flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_IN_MEMORY;
670
671 bfd_set_section_flags (vars->abfd, sec, flags | extra_flags);
672
673 bfd_set_section_alignment (vars->abfd, sec, 2);
674
675 /* Check that we will not run out of space. */
676 BFD_ASSERT (vars->data + size < vars->bim->buffer + vars->bim->size);
677
678 /* Set the section size and contents. The actual
679 contents are filled in by our parent. */
680 bfd_set_section_size (vars->abfd, sec, size);
681 sec->contents = vars->data;
682 sec->target_index = vars->sec_index ++;
683
684 /* Advance data pointer in the vars structure. */
685 vars->data += size;
686
687 /* Skip the padding byte if it was not needed.
688 The logic here is that if the string length is odd,
689 then the entire string length, including the null byte,
690 is even and so the extra, padding byte, is not needed. */
691 if (size & 1)
692 vars->data --;
693
694 /* Create a coff_section_tdata structure for our use. */
695 sec->used_by_bfd = (struct coff_section_tdata *) vars->data;
696 vars->data += sizeof (struct coff_section_tdata);
697
698 BFD_ASSERT (vars->data <= vars->bim->buffer + vars->bim->size);
699
700 /* Create a symbol to refer to this section. */
701 pe_ILF_make_a_symbol (vars, "", name, sec, BSF_LOCAL);
702
11c8a8d1 703 /* Cache the index to the symbol in the coff_section_data structure. */
17505c5c
NC		 704 coff_section_data (vars->abfd, sec)->i = vars->sym_index - 1;
705
706 return sec;
707}
708
709/* This structure contains the code that goes into the .text section
710 in order to perform a jump into the DLL lookup table. The entries
711 in the table are index by the magic number used to represent the
712 machine type in the PE file. The contents of the data[] arrays in
713 these entries are stolen from the jtab[] arrays in ld/pe-dll.c.
714 The SIZE field says how many bytes in the DATA array are actually
715 used. The OFFSET field says where in the data array the address
716 of the .idata$5 section should be placed. */
717#define MAX_TEXT_SECTION_SIZE 32
718
719typedef struct
720{
721 unsigned short magic;
722 unsigned char data[MAX_TEXT_SECTION_SIZE];
723 unsigned int size;
724 unsigned int offset;
725}
726jump_table;
727
86033394 728static jump_table jtab[] =
17505c5c
NC		 729{
730#ifdef I386MAGIC
731 { I386MAGIC,
732 { 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90 },
733 8, 2
734 },
735#endif
736
737#ifdef MC68MAGIC
738 { MC68MAGIC, { /* XXX fill me in */ }, 0, 0 },
739#endif
740#ifdef MIPS_ARCH_MAGIC_WINCE
741 { MIPS_ARCH_MAGIC_WINCE,
742 { 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
743 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 },
744 16, 0
745 },
746#endif
747
748#ifdef SH_ARCH_MAGIC_WINCE
749 { SH_ARCH_MAGIC_WINCE,
750 { 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40,
751 0x09, 0x00, 0x00, 0x00, 0x00, 0x00 },
752 12, 8
753 },
754#endif
755
756#ifdef ARMPEMAGIC
757 { ARMPEMAGIC,
758 { 0x00, 0xc0, 0x9f, 0xe5, 0x00, 0xf0,
759 0x9c, 0xe5, 0x00, 0x00, 0x00, 0x00},
760 12, 8
761 },
762#endif
763
764#ifdef THUMBPEMAGIC
765 { THUMBPEMAGIC,
766 { 0x40, 0xb4, 0x02, 0x4e, 0x36, 0x68, 0xb4, 0x46,
767 0x40, 0xbc, 0x60, 0x47, 0x00, 0x00, 0x00, 0x00 },
768 16, 12
769 },
770#endif
771 { 0, { 0 }, 0, 0 }
772};
773
774#ifndef NUM_ENTRIES
775#define NUM_ENTRIES(a) (sizeof (a) / sizeof (a)[0])
776#endif
777
778/* Build a full BFD from the information supplied in a ILF object. */
779static boolean
780pe_ILF_build_a_bfd (bfd * abfd,
781 unsigned short magic,
782 bfd_byte * symbol_name,
783 bfd_byte * source_dll,
784 unsigned int ordinal,
785 unsigned int types)
786{
787 bfd_byte * ptr;
788 pe_ILF_vars vars;
789 struct internal_filehdr internal_f;
790 unsigned int import_type;
791 unsigned int import_name_type;
11c8a8d1
NC		 792 asection_ptr id4, id5, id6 = NULL, text = NULL;
793 coff_symbol_type ** imp_sym;
794 unsigned int imp_index;
17505c5c 795
17505c5c
NC		 796 /* Decode and verify the types field of the ILF structure. */
797 import_type = types & 0x3;
798 import_name_type = (types & 0x1c) >> 2;
799
800 switch (import_type)
801 {
802 case IMPORT_CODE:
803 case IMPORT_DATA:
804 break;
805
806 case IMPORT_CONST:
807 /* XXX code yet to be written. */
808 _bfd_error_handler (_("%s: Unhandled import type; %x"),
809 bfd_get_filename (abfd), import_type);
810 return false;
811
812 default:
813 _bfd_error_handler (_("%s: Unrecognised import type; %x"),
814 bfd_get_filename (abfd), import_type);
815 return false;
816 }
817
818 switch (import_name_type)
819 {
820 case IMPORT_ORDINAL:
821 case IMPORT_NAME:
822 case IMPORT_NAME_NOPREFIX:
823 case IMPORT_NAME_UNDECORATE:
824 break;
825
826 default:
827 _bfd_error_handler (_("%s: Unrecognised import name type; %x"),
828 bfd_get_filename (abfd), import_name_type);
829 return false;
830 }
831
832 /* Initialise local variables.
833
834 Note these are kept in a structure rather than being
835 declared as statics since bfd frowns on global variables.
836
837 We are going to construct the contents of the BFD in memory,
838 so allocate all the space that we will need right now. */
839 ptr = bfd_zalloc (abfd, ILF_DATA_SIZE);
840 if (ptr == NULL)
841 return false;
842
843 /* Create a bfd_in_memory structure. */
844 vars.bim = (struct bfd_in_memory *) ptr;
845 vars.bim->buffer = ptr;
846 vars.bim->size = ILF_DATA_SIZE;
847 ptr += sizeof (* vars.bim);
848
849 /* Initialise the pointers to regions of the memory and the
850 other contents of the pe_ILF_vars structure as well. */
851 vars.sym_cache = (coff_symbol_type *) ptr;
852 vars.sym_ptr = (coff_symbol_type *) ptr;
853 vars.sym_index = 0;
854 ptr += SIZEOF_ILF_SYMS;
855
856 vars.sym_table = (unsigned int *) ptr;
857 vars.table_ptr = (unsigned int *) ptr;
858 ptr += SIZEOF_ILF_SYM_TABLE;
859
860 vars.native_syms = (combined_entry_type *) ptr;
861 vars.native_ptr = (combined_entry_type *) ptr;
862 ptr += SIZEOF_ILF_NATIVE_SYMS;
11c8a8d1
NC		 863
864 vars.sym_ptr_table = (coff_symbol_type **) ptr;
865 vars.sym_ptr_ptr = (coff_symbol_type **) ptr;
866 ptr += SIZEOF_ILF_SYM_PTR_TABLE;
17505c5c
NC		 867
868 vars.esym_table = (SYMENT *) ptr;
869 vars.esym_ptr = (SYMENT *) ptr;
870 ptr += SIZEOF_ILF_EXT_SYMS;
871
872 vars.reltab = (arelent *) ptr;
873 vars.relcount = 0;
874 ptr += SIZEOF_ILF_RELOCS;
875
876 vars.int_reltab = (struct internal_reloc *) ptr;
877 ptr += SIZEOF_ILF_INT_RELOCS;
878
879 vars.string_table = ptr;
880 vars.string_ptr = ptr + STRING_SIZE_SIZE;
881 ptr += SIZEOF_ILF_STRINGS;
882 vars.end_string_ptr = ptr;
883
884 /* The remaining space in bim->buffer is used
885 by the pe_ILF_make_a_section() function. */
886 vars.data = ptr;
887 vars.abfd = abfd;
888 vars.sec_index = 0;
889 vars.magic = magic;
890
891 /* Create the initial .idata$<n> sections:
11c8a8d1 892 [.idata$2: Import Directory Table -- not needed]
17505c5c
NC		 893 .idata$4: Import Lookup Table
894 .idata$5: Import Address Table
895
896 Note we do not create a .idata$3 section as this is
897 created for us by the linker script. */
17505c5c
NC		 898 id4 = pe_ILF_make_a_section (& vars, ".idata$4", SIZEOF_IDATA4, 0);
899 id5 = pe_ILF_make_a_section (& vars, ".idata$5", SIZEOF_IDATA5, 0);
11c8a8d1 900 if (id4 == NULL || id5 == NULL)
17505c5c
NC		 901 return false;
902
903 /* Fill in the contents of these sections. */
904 if (import_name_type == IMPORT_ORDINAL)
905 {
906 if (ordinal == 0)
907 /* XXX - treat as IMPORT_NAME ??? */
908 abort ();
909
11c8a8d1
NC		 910 * (unsigned int *) id4->contents = ordinal | 0x80000000UL;
911 * (unsigned int *) id5->contents = ordinal | 0x80000000UL;
17505c5c
NC		 912 }
913 else
914 {
915 char * symbol;
916
917 /* Create .idata$6 - the Hint Name Table. */
918 id6 = pe_ILF_make_a_section (& vars, ".idata$6", SIZEOF_IDATA6, 0);
919 if (id6 == NULL)
920 return false;
921
922 /* If necessary, trim the import symbol name. */
923 symbol = symbol_name;
924
925 if (import_name_type != IMPORT_NAME)
926 /* Skip any prefix in symbol_name. */
927 while (*symbol == '@' || * symbol == '?' || * symbol == '_')
928 ++ symbol;
929
930 if (import_name_type == IMPORT_NAME_UNDECORATE)
931 {
932 /* Truncate at the first '@' */
933 while (* symbol != 0 && * symbol != '@')
934 symbol ++;
935
936 * symbol = 0;
937 }
938
11c8a8d1
NC		 939 id6->contents[0] = ordinal & 0xff;
940 id6->contents[1] = ordinal >> 8;
941
942 strcpy (id6->contents + 2, symbol);
17505c5c
NC		 943 }
944
17505c5c
NC		 945 if (import_name_type != IMPORT_ORDINAL)
946 {
947 pe_ILF_make_a_reloc (& vars, 0, BFD_RELOC_RVA, id6);
948 pe_ILF_save_relocs (& vars, id4);
949
950 pe_ILF_make_a_reloc (& vars, 0, BFD_RELOC_RVA, id6);
951 pe_ILF_save_relocs (& vars, id5);
952 }
953
954 /* Create extra sections depending upon the type of import we are dealing with. */
955 switch (import_type)
956 {
957 int i;
958
959 case IMPORT_CODE:
960 /* Create a .text section.
961 First we need to look up its contents in the jump table. */
962 for (i = NUM_ENTRIES (jtab); i--;)
963 {
964 if (jtab[i].size == 0)
965 continue;
966 if (jtab[i].magic == magic)
967 break;
968 }
969 /* If we did not find a matching entry something is wrong. */
970 if (i < 0)
971 abort ();
972
973 /* Create the .text section. */
974 text = pe_ILF_make_a_section (& vars, ".text", jtab[i].size, SEC_CODE);
975 if (text == NULL)
976 return false;
977
978 /* Copy in the jump code. */
979 memcpy (text->contents, jtab[i].data, jtab[i].size);
980
11c8a8d1
NC		 981 /* Create an import symbol. */
982 pe_ILF_make_a_symbol (& vars, "__imp_", symbol_name, id5, 0);
983 imp_sym = vars.sym_ptr_ptr - 1;
984 imp_index = vars.sym_index - 1;
985
17505c5c
NC		 986 /* Create a reloc for the data in the text section. */
987#ifdef MIPS_ARCH_MAGIC_WINCE
988 if (magic == MIPS_ARCH_MAGIC_WINCE)
989 {
11c8a8d1
NC		 990 pe_ILF_make_a_symbol_reloc (& vars, 0, BFD_RELOC_HI16_S,
991 (asection **) imp_sym, imp_index);
17505c5c 992 pe_ILF_make_a_reloc (& vars, 0, BFD_RELOC_LO16, text);
11c8a8d1
NC		 993 pe_ILF_make_a_symbol_reloc (& vars, 4, BFD_RELOC_LO16,
994 (asection **) imp_sym, imp_index);
17505c5c
NC		 995 }
996 else
997#endif
11c8a8d1
NC		 998 pe_ILF_make_a_symbol_reloc (& vars, jtab[i].offset, BFD_RELOC_32,
999 (asymbol **) imp_sym, imp_index);
17505c5c
NC		 1000
1001 pe_ILF_save_relocs (& vars, text);
1002 break;
1003
1004 case IMPORT_DATA:
1005 break;
1006
1007 default:
1008 /* XXX code not yet written. */
1009 abort ();
1010 }
1011
1012 /* Initialise the bfd. */
1013 memset (& internal_f, 0, sizeof (internal_f));
1014
1015 internal_f.f_magic = magic;
1016 internal_f.f_symptr = 0;
1017 internal_f.f_nsyms = 0;
1018 internal_f.f_flags = F_AR32WR | F_LNNO; /* XXX is this correct ? */
1019
1020 if ( ! bfd_set_start_address (abfd, 0)
1021 || ! bfd_coff_set_arch_mach_hook (abfd, & internal_f))
1022 return false;
1023
1024 if (bfd_coff_mkobject_hook (abfd, (PTR) & internal_f, NULL) == NULL)
1025 return false;
1026
1027 coff_data (abfd)->pe = 1;
1028#ifdef THUMBPEMAGIC
1029 if (vars.magic == THUMBPEMAGIC)
1030 /* Stop some linker warnings about thumb code not supporting interworking. */
1031 coff_data (abfd)->flags |= F_INTERWORK | F_INTERWORK_SET;
1032#endif
1033
1034 /* Switch from file contents to memory contents. */
1035 bfd_cache_close (abfd);
1036
1037 abfd->iostream = (PTR) vars.bim;
1038 abfd->flags |= BFD_IN_MEMORY /* | HAS_LOCALS */;
1039 abfd->where = 0;
1040 obj_sym_filepos (abfd) = 0;
1041
1042 /* Now create a symbol describing the imported value. */
1043 switch (import_type)
1044 {
11c8a8d1
NC		 1045 bfd_byte * ptr;
1046
17505c5c
NC		 1047 case IMPORT_CODE:
1048 pe_ILF_make_a_symbol (& vars, "", symbol_name, text,
1049 BSF_NOT_AT_END | BSF_FUNCTION);
11c8a8d1
NC		 1050
1051 /* Create an import symbol for the DLL, without the
1052 .dll suffix. */
1053 ptr = strrchr (source_dll, '.');
1054 if (ptr)
1055 * ptr = 0;
1056 pe_ILF_make_a_symbol (& vars, "__IMPORT_DESCRIPTOR_", source_dll, NULL, 0);
1057 if (ptr)
1058 * ptr = '.';
17505c5c
NC		 1059 break;
1060
1061 case IMPORT_DATA:
11c8a8d1 1062 /* Nothing to do here. */
17505c5c
NC		 1063 break;
1064
1065 default:
1066 /* XXX code not yet written. */
1067 abort ();
1068 }
1069
17505c5c
NC		 1070 /* Point the bfd at the symbol table. */
1071 obj_symbols (abfd) = vars.sym_cache;
1072 bfd_get_symcount (abfd) = vars.sym_index;
1073
1074 obj_raw_syments (abfd) = vars.native_syms;
1075 obj_raw_syment_count (abfd) = vars.sym_index;
1076
1077 obj_coff_external_syms (abfd) = (PTR) vars.esym_table;
1078 obj_coff_keep_syms (abfd) = true;
1079
1080 obj_convert (abfd) = vars.sym_table;
1081 obj_conv_table_size (abfd) = vars.sym_index;
1082
1083 obj_coff_strings (abfd) = vars.string_table;
1084 obj_coff_keep_strings (abfd) = true;
1085
1086 abfd->flags |= HAS_SYMS;
1087
1088 return true;
1089}
1090
1091/* We have detected a Image Library Format archive element.
1092 Decode the element and return the appropriate target. */
cb665cd3 1093static const bfd_target *
17505c5c
NC		 1094pe_ILF_object_p (bfd * abfd)
1095{
1096 bfd_byte buffer[16];
1097 bfd_byte * ptr;
1098 bfd_byte * symbol_name;
1099 bfd_byte * source_dll;
1100 unsigned int machine;
1101 unsigned long size;
1102 unsigned int ordinal;
1103 unsigned int types;
1104 unsigned short magic;
1105
1106 /* Upon entry the first four buyes of the ILF header have
1107 already been read. Now read the rest of the header. */
1108 if (bfd_read (buffer, 1, 16, abfd) != 16)
1109 return NULL;
1110
1111 ptr = buffer;
1112
1113 /* We do not bother to check the version number.
1114 version = bfd_h_get_16 (abfd, ptr); */
1115 ptr += 2;
1116
1117 machine = bfd_h_get_16 (abfd, ptr);
1118 ptr += 2;
1119
1120 /* Check that the machine type is recognised. */
1121 magic = 0;
1122
1123 switch (machine)
1124 {
1125 case IMAGE_FILE_MACHINE_UNKNOWN:
1126 case IMAGE_FILE_MACHINE_ALPHA:
1127 case IMAGE_FILE_MACHINE_ALPHA64:
1128 case IMAGE_FILE_MACHINE_IA64:
1129 break;
1130
1131 case IMAGE_FILE_MACHINE_I386:
1132#ifdef I386MAGIC
1133 magic = I386MAGIC;
1134#endif
1135 break;
1136
1137 case IMAGE_FILE_MACHINE_M68K:
1138#ifdef MC68AGIC
1139 magic = MC68MAGIC;
1140#endif
1141 break;
1142
1143 case IMAGE_FILE_MACHINE_R3000:
1144 case IMAGE_FILE_MACHINE_R4000:
1145 case IMAGE_FILE_MACHINE_R10000:
1146
1147 case IMAGE_FILE_MACHINE_MIPS16:
1148 case IMAGE_FILE_MACHINE_MIPSFPU:
1149 case IMAGE_FILE_MACHINE_MIPSFPU16:
1150#ifdef MIPS_ARCH_MAGIC_WINCE
1151 magic = MIPS_ARCH_MAGIC_WINCE;
1152#endif
1153 break;
1154
1155 case IMAGE_FILE_MACHINE_SH3:
1156 case IMAGE_FILE_MACHINE_SH4:
1157#ifdef SH_ARCH_MAGIC_WINCE
1158 magic = SH_ARCH_MAGIC_WINCE;
1159#endif
1160 break;
1161
1162 case IMAGE_FILE_MACHINE_ARM:
1163#ifdef ARMPEMAGIC
1164 magic = ARMPEMAGIC;
1165#endif
1166 break;
1167
1168 case IMAGE_FILE_MACHINE_THUMB:
1169#ifdef THUMBPEMAGIC
1170 {
1171 extern bfd_target armpei_little_vec;
1172
1173 if (abfd->xvec == & armpei_little_vec)
1174 magic = THUMBPEMAGIC;
1175 }
1176#endif
1177 break;
1178
1179 case IMAGE_FILE_MACHINE_POWERPC:
1180 /* We no longer support PowerPC. */
1181 default:
1182 _bfd_error_handler
1183 (
1184_("%s: Unrecognised machine type (0x%x) in Import Library Format archive"),
1185 bfd_get_filename (abfd), machine);
1186 bfd_set_error (bfd_error_malformed_archive);
1187
1188 return NULL;
1189 break;
1190 }
1191
1192 if (magic == 0)
1193 {
1194 _bfd_error_handler
1195 (
1196_("%s: Recognised but unhandled machine type (0x%x) in Import Library Format archive"),
1197 bfd_get_filename (abfd), machine);
1198 bfd_set_error (bfd_error_wrong_format);
1199
1200 return NULL;
1201 }
1202
1203 /* We do not bother to check the date.
1204 date = bfd_h_get_32 (abfd, ptr); */
1205 ptr += 4;
1206
1207 size = bfd_h_get_32 (abfd, ptr);
1208 ptr += 4;
1209
1210 if (size == 0)
1211 {
1212 _bfd_error_handler
1213 (_("%s: size field is zero in Import Library Format header"),
1214 bfd_get_filename (abfd));
1215 bfd_set_error (bfd_error_malformed_archive);
1216
1217 return NULL;
1218 }
1219
1220 ordinal = bfd_h_get_16 (abfd, ptr);
1221 ptr += 2;
1222
1223 types = bfd_h_get_16 (abfd, ptr);
1224 /* ptr += 2; */
1225
1226 /* Now read in the two strings that follow. */
1227 ptr = bfd_alloc (abfd, size);
1228 if (ptr == NULL)
1229 return NULL;
1230
1231 if (bfd_read (ptr, 1, size, abfd) != size)
1232 return NULL;
1233
1234 symbol_name = ptr;
1235 source_dll = ptr + strlen (ptr) + 1;
1236
1237 /* Verify that the strings are null terminated. */
11c8a8d1 1238 if (ptr[size - 1] != 0 || ((unsigned long) (source_dll - ptr) >= size))
17505c5c
NC		 1239 {
1240 _bfd_error_handler
1241 (_("%s: string not null terminated in ILF object file."),
1242 bfd_get_filename (abfd));
1243 bfd_set_error (bfd_error_malformed_archive);
1244
1245 return NULL;
1246 }
1247
1248 /* Now construct the bfd. */
1249 if (! pe_ILF_build_a_bfd (abfd, magic, symbol_name,
1250 source_dll, ordinal, types))
1251 return NULL;
1252
1253 return abfd->xvec;
1254}
1255
1256static const bfd_target *
1257pe_bfd_object_p (bfd * abfd)
cb665cd3
NC		 1258{
1259 /* We need to handle a PE image correctly. In PE images created by
1260 the GNU linker, the offset to the COFF header is always the size.
1261 However, this is not the case in images generated by other PE
1262 linkers. The PE format stores a four byte offset to the PE
1263 signature just before the COFF header at location 0x3c of the file.
1264 We pick up that offset, verify that the PE signature is there, and
1265 then set ourselves up to read in the COFF header. */
1266 bfd_byte buffer[4];
1267 file_ptr offset;
1268 unsigned long signature;
1269
1270 /* Detect if this a Microsoft Import Library Format element. */
1271 if (bfd_seek (abfd, 0x00, SEEK_SET) != 0
1272 || bfd_read (buffer, 1, 4, abfd) != 4)
1273 {
1274 if (bfd_get_error () != bfd_error_system_call)
1275 bfd_set_error (bfd_error_wrong_format);
1276 return NULL;
1277 }
1278
1279 signature = bfd_h_get_32 (abfd, buffer);
1280
1281 if (signature == 0xffff0000)
17505c5c 1282 return pe_ILF_object_p (abfd);
cb665cd3
NC		 1283
1284 if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0
1285 || bfd_read (buffer, 1, 4, abfd) != 4)
1286 {
1287 if (bfd_get_error () != bfd_error_system_call)
1288 bfd_set_error (bfd_error_wrong_format);
1289 return NULL;
1290 }
1291
1292 offset = bfd_h_get_32 (abfd, buffer);
1293
1294 if (bfd_seek (abfd, offset, SEEK_SET) != 0
1295 || bfd_read (buffer, 1, 4, abfd) != 4)
1296 {
1297 if (bfd_get_error () != bfd_error_system_call)
1298 bfd_set_error (bfd_error_wrong_format);
1299 return NULL;
1300 }
1301
1302 signature = bfd_h_get_32 (abfd, buffer);
1303
1304 if (signature != 0x4550)
1305 {
1306 bfd_set_error (bfd_error_wrong_format);
1307 return NULL;
1308 }
1309
1310 /* Here is the hack. coff_object_p wants to read filhsz bytes to
1311 pick up the COFF header. We adjust so that that will work. 20
1312 is the size of the i386 COFF filehdr. */
1313 if (bfd_seek (abfd,
1314 (bfd_tell (abfd)
1315 - bfd_coff_filhsz (abfd)
1316 + 20),
1317 SEEK_SET)
1318 != 0)
1319 {
1320 if (bfd_get_error () != bfd_error_system_call)
1321 bfd_set_error (bfd_error_wrong_format);
1322 return NULL;
1323 }
1324
1325 return coff_object_p (abfd);
1326}
1327
1328#define coff_object_p pe_bfd_object_p
17505c5c 1329#endif /* COFF_IMAGE_WITH_PE */
GDB Binutils - Deliverables
This page took 0.117828 seconds and 4 git commands to generate.