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