projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Apply patch to fix compuation of frag offsets for symbols
[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
10821322
NC		 595 if (section == NULL)
596 section = (asection_ptr) & bfd_und_section;
597
17505c5c
NC		 598 /* Initialise the external symbol. */
599 bfd_h_put_32 (vars->abfd, vars->string_ptr - vars->string_table, (bfd_byte *) esym->e.e.e_offset);
10821322 600 bfd_h_put_16 (vars->abfd, section->target_index, (bfd_byte *) esym->e_scnum);
17505c5c
NC		 601 esym->e_sclass[0] = sclass;
602
603 /* The following initialisations are unnecessary - the memory is
604 zero initialised. They are just kept here as reminders. */
605#if 0
606 esym->e.e.e_zeroes = 0;
607 esym->e_value = 0;
608 esym->e_type = T_NULL;
609 esym->e_numaux = 0;
610#endif
611
612 /* Initialise the internal symbol structure. */
613 ent->u.syment.n_sclass = sclass;
10821322 614 ent->u.syment.n_scnum = section->target_index;
17505c5c
NC		 615 ent->u.syment._n._n_n._n_offset = (long) sym;
616
617#if 0 /* See comment above. */
618 ent->u.syment.n_value = 0;
619 ent->u.syment.n_flags = 0;
620 ent->u.syment.n_type = T_NULL;
621 ent->u.syment.n_numaux = 0;
622 ent->fix_value = 0;
623#endif
624
625 sym->symbol.the_bfd = vars->abfd;
626 sym->symbol.name = vars->string_ptr;
627 sym->symbol.flags = BSF_EXPORT | BSF_GLOBAL | extra_flags;
628 sym->symbol.section = section;
629 sym->native = ent;
630
631#if 0 /* See comment above. */
632 sym->symbol.value = 0;
633 sym->symbol.udata.i = 0;
634 sym->done_lineno = false;
635 sym->lineno = NULL;
636#endif
637
638 * vars->table_ptr = vars->sym_index;
11c8a8d1
NC		 639 * vars->sym_ptr_ptr = sym;
640
17505c5c
NC		 641 /* Adjust pointers for the next symbol. */
642 vars->sym_index ++;
643 vars->sym_ptr ++;
11c8a8d1 644 vars->sym_ptr_ptr ++;
17505c5c
NC		 645 vars->table_ptr ++;
646 vars->native_ptr ++;
647 vars->esym_ptr ++;
11c8a8d1 648 vars->string_ptr += strlen (symbol_name) + strlen (prefix) + 1;
17505c5c
NC		 649
650 BFD_ASSERT (vars->string_ptr < vars->end_string_ptr);
651}
652
653/* Create a section. */
654static asection_ptr
655pe_ILF_make_a_section (pe_ILF_vars * vars,
656 const char * name,
657 unsigned int size,
658 flagword extra_flags)
659{
660 asection_ptr sec;
661 flagword flags;
662
663 sec = bfd_make_section_old_way (vars->abfd, name);
664 if (sec == NULL)
665 return NULL;
666
667 flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_KEEP | SEC_IN_MEMORY;
668
669 bfd_set_section_flags (vars->abfd, sec, flags | extra_flags);
670
671 bfd_set_section_alignment (vars->abfd, sec, 2);
672
673 /* Check that we will not run out of space. */
674 BFD_ASSERT (vars->data + size < vars->bim->buffer + vars->bim->size);
675
676 /* Set the section size and contents. The actual
677 contents are filled in by our parent. */
678 bfd_set_section_size (vars->abfd, sec, size);
679 sec->contents = vars->data;
680 sec->target_index = vars->sec_index ++;
681
682 /* Advance data pointer in the vars structure. */
683 vars->data += size;
684
685 /* Skip the padding byte if it was not needed.
686 The logic here is that if the string length is odd,
687 then the entire string length, including the null byte,
688 is even and so the extra, padding byte, is not needed. */
689 if (size & 1)
690 vars->data --;
691
692 /* Create a coff_section_tdata structure for our use. */
693 sec->used_by_bfd = (struct coff_section_tdata *) vars->data;
694 vars->data += sizeof (struct coff_section_tdata);
695
696 BFD_ASSERT (vars->data <= vars->bim->buffer + vars->bim->size);
697
698 /* Create a symbol to refer to this section. */
699 pe_ILF_make_a_symbol (vars, "", name, sec, BSF_LOCAL);
700
11c8a8d1 701 /* Cache the index to the symbol in the coff_section_data structure. */
17505c5c
NC		 702 coff_section_data (vars->abfd, sec)->i = vars->sym_index - 1;
703
704 return sec;
705}
706
707/* This structure contains the code that goes into the .text section
708 in order to perform a jump into the DLL lookup table. The entries
709 in the table are index by the magic number used to represent the
710 machine type in the PE file. The contents of the data[] arrays in
711 these entries are stolen from the jtab[] arrays in ld/pe-dll.c.
712 The SIZE field says how many bytes in the DATA array are actually
713 used. The OFFSET field says where in the data array the address
714 of the .idata$5 section should be placed. */
715#define MAX_TEXT_SECTION_SIZE 32
716
717typedef struct
718{
719 unsigned short magic;
720 unsigned char data[MAX_TEXT_SECTION_SIZE];
721 unsigned int size;
722 unsigned int offset;
723}
724jump_table;
725
86033394 726static jump_table jtab[] =
17505c5c
NC		 727{
728#ifdef I386MAGIC
729 { I386MAGIC,
730 { 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90 },
731 8, 2
732 },
733#endif
734
735#ifdef MC68MAGIC
736 { MC68MAGIC, { /* XXX fill me in */ }, 0, 0 },
737#endif
738#ifdef MIPS_ARCH_MAGIC_WINCE
739 { MIPS_ARCH_MAGIC_WINCE,
740 { 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
741 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 },
742 16, 0
743 },
744#endif
745
746#ifdef SH_ARCH_MAGIC_WINCE
747 { SH_ARCH_MAGIC_WINCE,
748 { 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40,
749 0x09, 0x00, 0x00, 0x00, 0x00, 0x00 },
750 12, 8
751 },
752#endif
753
754#ifdef ARMPEMAGIC
755 { ARMPEMAGIC,
756 { 0x00, 0xc0, 0x9f, 0xe5, 0x00, 0xf0,
757 0x9c, 0xe5, 0x00, 0x00, 0x00, 0x00},
758 12, 8
759 },
760#endif
761
762#ifdef THUMBPEMAGIC
763 { THUMBPEMAGIC,
764 { 0x40, 0xb4, 0x02, 0x4e, 0x36, 0x68, 0xb4, 0x46,
765 0x40, 0xbc, 0x60, 0x47, 0x00, 0x00, 0x00, 0x00 },
766 16, 12
767 },
768#endif
769 { 0, { 0 }, 0, 0 }
770};
771
772#ifndef NUM_ENTRIES
773#define NUM_ENTRIES(a) (sizeof (a) / sizeof (a)[0])
774#endif
775
776/* Build a full BFD from the information supplied in a ILF object. */
777static boolean
778pe_ILF_build_a_bfd (bfd * abfd,
779 unsigned short magic,
780 bfd_byte * symbol_name,
781 bfd_byte * source_dll,
782 unsigned int ordinal,
783 unsigned int types)
784{
785 bfd_byte * ptr;
786 pe_ILF_vars vars;
787 struct internal_filehdr internal_f;
788 unsigned int import_type;
789 unsigned int import_name_type;
11c8a8d1
NC		 790 asection_ptr id4, id5, id6 = NULL, text = NULL;
791 coff_symbol_type ** imp_sym;
792 unsigned int imp_index;
17505c5c 793
17505c5c
NC		 794 /* Decode and verify the types field of the ILF structure. */
795 import_type = types & 0x3;
796 import_name_type = (types & 0x1c) >> 2;
797
798 switch (import_type)
799 {
800 case IMPORT_CODE:
801 case IMPORT_DATA:
802 break;
803
804 case IMPORT_CONST:
805 /* XXX code yet to be written. */
806 _bfd_error_handler (_("%s: Unhandled import type; %x"),
807 bfd_get_filename (abfd), import_type);
808 return false;
809
810 default:
811 _bfd_error_handler (_("%s: Unrecognised import type; %x"),
812 bfd_get_filename (abfd), import_type);
813 return false;
814 }
815
816 switch (import_name_type)
817 {
818 case IMPORT_ORDINAL:
819 case IMPORT_NAME:
820 case IMPORT_NAME_NOPREFIX:
821 case IMPORT_NAME_UNDECORATE:
822 break;
823
824 default:
825 _bfd_error_handler (_("%s: Unrecognised import name type; %x"),
826 bfd_get_filename (abfd), import_name_type);
827 return false;
828 }
829
830 /* Initialise local variables.
831
832 Note these are kept in a structure rather than being
833 declared as statics since bfd frowns on global variables.
834
835 We are going to construct the contents of the BFD in memory,
836 so allocate all the space that we will need right now. */
837 ptr = bfd_zalloc (abfd, ILF_DATA_SIZE);
838 if (ptr == NULL)
839 return false;
840
841 /* Create a bfd_in_memory structure. */
842 vars.bim = (struct bfd_in_memory *) ptr;
843 vars.bim->buffer = ptr;
844 vars.bim->size = ILF_DATA_SIZE;
845 ptr += sizeof (* vars.bim);
846
847 /* Initialise the pointers to regions of the memory and the
848 other contents of the pe_ILF_vars structure as well. */
849 vars.sym_cache = (coff_symbol_type *) ptr;
850 vars.sym_ptr = (coff_symbol_type *) ptr;
851 vars.sym_index = 0;
852 ptr += SIZEOF_ILF_SYMS;
853
854 vars.sym_table = (unsigned int *) ptr;
855 vars.table_ptr = (unsigned int *) ptr;
856 ptr += SIZEOF_ILF_SYM_TABLE;
857
858 vars.native_syms = (combined_entry_type *) ptr;
859 vars.native_ptr = (combined_entry_type *) ptr;
860 ptr += SIZEOF_ILF_NATIVE_SYMS;
11c8a8d1
NC		 861
862 vars.sym_ptr_table = (coff_symbol_type **) ptr;
863 vars.sym_ptr_ptr = (coff_symbol_type **) ptr;
864 ptr += SIZEOF_ILF_SYM_PTR_TABLE;
17505c5c
NC		 865
866 vars.esym_table = (SYMENT *) ptr;
867 vars.esym_ptr = (SYMENT *) ptr;
868 ptr += SIZEOF_ILF_EXT_SYMS;
869
870 vars.reltab = (arelent *) ptr;
871 vars.relcount = 0;
872 ptr += SIZEOF_ILF_RELOCS;
873
874 vars.int_reltab = (struct internal_reloc *) ptr;
875 ptr += SIZEOF_ILF_INT_RELOCS;
876
877 vars.string_table = ptr;
878 vars.string_ptr = ptr + STRING_SIZE_SIZE;
879 ptr += SIZEOF_ILF_STRINGS;
880 vars.end_string_ptr = ptr;
881
882 /* The remaining space in bim->buffer is used
883 by the pe_ILF_make_a_section() function. */
884 vars.data = ptr;
885 vars.abfd = abfd;
886 vars.sec_index = 0;
887 vars.magic = magic;
888
889 /* Create the initial .idata$<n> sections:
11c8a8d1 890 [.idata$2: Import Directory Table -- not needed]
17505c5c
NC		 891 .idata$4: Import Lookup Table
892 .idata$5: Import Address Table
893
894 Note we do not create a .idata$3 section as this is
895 created for us by the linker script. */
17505c5c
NC		 896 id4 = pe_ILF_make_a_section (& vars, ".idata$4", SIZEOF_IDATA4, 0);
897 id5 = pe_ILF_make_a_section (& vars, ".idata$5", SIZEOF_IDATA5, 0);
11c8a8d1 898 if (id4 == NULL || id5 == NULL)
17505c5c
NC		 899 return false;
900
901 /* Fill in the contents of these sections. */
902 if (import_name_type == IMPORT_ORDINAL)
903 {
904 if (ordinal == 0)
905 /* XXX - treat as IMPORT_NAME ??? */
906 abort ();
907
11c8a8d1
NC		 908 * (unsigned int *) id4->contents = ordinal | 0x80000000UL;
909 * (unsigned int *) id5->contents = ordinal | 0x80000000UL;
17505c5c
NC		 910 }
911 else
912 {
913 char * symbol;
914
915 /* Create .idata$6 - the Hint Name Table. */
916 id6 = pe_ILF_make_a_section (& vars, ".idata$6", SIZEOF_IDATA6, 0);
917 if (id6 == NULL)
918 return false;
919
920 /* If necessary, trim the import symbol name. */
921 symbol = symbol_name;
922
923 if (import_name_type != IMPORT_NAME)
924 /* Skip any prefix in symbol_name. */
925 while (*symbol == '@' || * symbol == '?' || * symbol == '_')
926 ++ symbol;
927
928 if (import_name_type == IMPORT_NAME_UNDECORATE)
929 {
930 /* Truncate at the first '@' */
931 while (* symbol != 0 && * symbol != '@')
932 symbol ++;
933
934 * symbol = 0;
935 }
936
11c8a8d1
NC		 937 id6->contents[0] = ordinal & 0xff;
938 id6->contents[1] = ordinal >> 8;
939
940 strcpy (id6->contents + 2, symbol);
17505c5c
NC		 941 }
942
17505c5c
NC		 943 if (import_name_type != IMPORT_ORDINAL)
944 {
945 pe_ILF_make_a_reloc (& vars, 0, BFD_RELOC_RVA, id6);
946 pe_ILF_save_relocs (& vars, id4);
947
948 pe_ILF_make_a_reloc (& vars, 0, BFD_RELOC_RVA, id6);
949 pe_ILF_save_relocs (& vars, id5);
950 }
951
952 /* Create extra sections depending upon the type of import we are dealing with. */
953 switch (import_type)
954 {
955 int i;
956
957 case IMPORT_CODE:
958 /* Create a .text section.
959 First we need to look up its contents in the jump table. */
960 for (i = NUM_ENTRIES (jtab); i--;)
961 {
962 if (jtab[i].size == 0)
963 continue;
964 if (jtab[i].magic == magic)
965 break;
966 }
967 /* If we did not find a matching entry something is wrong. */
968 if (i < 0)
969 abort ();
970
971 /* Create the .text section. */
972 text = pe_ILF_make_a_section (& vars, ".text", jtab[i].size, SEC_CODE);
973 if (text == NULL)
974 return false;
975
976 /* Copy in the jump code. */
977 memcpy (text->contents, jtab[i].data, jtab[i].size);
978
11c8a8d1
NC		 979 /* Create an import symbol. */
980 pe_ILF_make_a_symbol (& vars, "__imp_", symbol_name, id5, 0);
981 imp_sym = vars.sym_ptr_ptr - 1;
982 imp_index = vars.sym_index - 1;
983
17505c5c
NC		 984 /* Create a reloc for the data in the text section. */
985#ifdef MIPS_ARCH_MAGIC_WINCE
986 if (magic == MIPS_ARCH_MAGIC_WINCE)
987 {
11c8a8d1
NC		 988 pe_ILF_make_a_symbol_reloc (& vars, 0, BFD_RELOC_HI16_S,
989 (asection **) imp_sym, imp_index);
17505c5c 990 pe_ILF_make_a_reloc (& vars, 0, BFD_RELOC_LO16, text);
11c8a8d1
NC		 991 pe_ILF_make_a_symbol_reloc (& vars, 4, BFD_RELOC_LO16,
992 (asection **) imp_sym, imp_index);
17505c5c
NC		 993 }
994 else
995#endif
11c8a8d1
NC		 996 pe_ILF_make_a_symbol_reloc (& vars, jtab[i].offset, BFD_RELOC_32,
997 (asymbol **) imp_sym, imp_index);
17505c5c
NC		 998
999 pe_ILF_save_relocs (& vars, text);
1000 break;
1001
1002 case IMPORT_DATA:
1003 break;
1004
1005 default:
1006 /* XXX code not yet written. */
1007 abort ();
1008 }
1009
1010 /* Initialise the bfd. */
1011 memset (& internal_f, 0, sizeof (internal_f));
1012
1013 internal_f.f_magic = magic;
1014 internal_f.f_symptr = 0;
1015 internal_f.f_nsyms = 0;
1016 internal_f.f_flags = F_AR32WR | F_LNNO; /* XXX is this correct ? */
1017
1018 if ( ! bfd_set_start_address (abfd, 0)
1019 || ! bfd_coff_set_arch_mach_hook (abfd, & internal_f))
1020 return false;
1021
1022 if (bfd_coff_mkobject_hook (abfd, (PTR) & internal_f, NULL) == NULL)
1023 return false;
1024
1025 coff_data (abfd)->pe = 1;
1026#ifdef THUMBPEMAGIC
1027 if (vars.magic == THUMBPEMAGIC)
1028 /* Stop some linker warnings about thumb code not supporting interworking. */
1029 coff_data (abfd)->flags |= F_INTERWORK | F_INTERWORK_SET;
1030#endif
1031
1032 /* Switch from file contents to memory contents. */
1033 bfd_cache_close (abfd);
1034
1035 abfd->iostream = (PTR) vars.bim;
1036 abfd->flags |= BFD_IN_MEMORY /* | HAS_LOCALS */;
1037 abfd->where = 0;
1038 obj_sym_filepos (abfd) = 0;
1039
1040 /* Now create a symbol describing the imported value. */
1041 switch (import_type)
1042 {
11c8a8d1
NC		 1043 bfd_byte * ptr;
1044
17505c5c
NC		 1045 case IMPORT_CODE:
1046 pe_ILF_make_a_symbol (& vars, "", symbol_name, text,
1047 BSF_NOT_AT_END | BSF_FUNCTION);
11c8a8d1
NC		 1048
1049 /* Create an import symbol for the DLL, without the
1050 .dll suffix. */
1051 ptr = strrchr (source_dll, '.');
1052 if (ptr)
1053 * ptr = 0;
1054 pe_ILF_make_a_symbol (& vars, "__IMPORT_DESCRIPTOR_", source_dll, NULL, 0);
1055 if (ptr)
1056 * ptr = '.';
17505c5c
NC		 1057 break;
1058
1059 case IMPORT_DATA:
11c8a8d1 1060 /* Nothing to do here. */
17505c5c
NC		 1061 break;
1062
1063 default:
1064 /* XXX code not yet written. */
1065 abort ();
1066 }
1067
17505c5c
NC		 1068 /* Point the bfd at the symbol table. */
1069 obj_symbols (abfd) = vars.sym_cache;
1070 bfd_get_symcount (abfd) = vars.sym_index;
1071
1072 obj_raw_syments (abfd) = vars.native_syms;
1073 obj_raw_syment_count (abfd) = vars.sym_index;
1074
1075 obj_coff_external_syms (abfd) = (PTR) vars.esym_table;
1076 obj_coff_keep_syms (abfd) = true;
1077
1078 obj_convert (abfd) = vars.sym_table;
1079 obj_conv_table_size (abfd) = vars.sym_index;
1080
1081 obj_coff_strings (abfd) = vars.string_table;
1082 obj_coff_keep_strings (abfd) = true;
1083
1084 abfd->flags |= HAS_SYMS;
1085
1086 return true;
1087}
1088
1089/* We have detected a Image Library Format archive element.
1090 Decode the element and return the appropriate target. */
cb665cd3 1091static const bfd_target *
17505c5c
NC		 1092pe_ILF_object_p (bfd * abfd)
1093{
1094 bfd_byte buffer[16];
1095 bfd_byte * ptr;
1096 bfd_byte * symbol_name;
1097 bfd_byte * source_dll;
1098 unsigned int machine;
1099 unsigned long size;
1100 unsigned int ordinal;
1101 unsigned int types;
1102 unsigned short magic;
1103
1104 /* Upon entry the first four buyes of the ILF header have
1105 already been read. Now read the rest of the header. */
1106 if (bfd_read (buffer, 1, 16, abfd) != 16)
1107 return NULL;
1108
1109 ptr = buffer;
1110
1111 /* We do not bother to check the version number.
1112 version = bfd_h_get_16 (abfd, ptr); */
1113 ptr += 2;
1114
1115 machine = bfd_h_get_16 (abfd, ptr);
1116 ptr += 2;
1117
1118 /* Check that the machine type is recognised. */
1119 magic = 0;
1120
1121 switch (machine)
1122 {
1123 case IMAGE_FILE_MACHINE_UNKNOWN:
1124 case IMAGE_FILE_MACHINE_ALPHA:
1125 case IMAGE_FILE_MACHINE_ALPHA64:
1126 case IMAGE_FILE_MACHINE_IA64:
1127 break;
1128
1129 case IMAGE_FILE_MACHINE_I386:
1130#ifdef I386MAGIC
1131 magic = I386MAGIC;
1132#endif
1133 break;
1134
1135 case IMAGE_FILE_MACHINE_M68K:
1136#ifdef MC68AGIC
1137 magic = MC68MAGIC;
1138#endif
1139 break;
1140
1141 case IMAGE_FILE_MACHINE_R3000:
1142 case IMAGE_FILE_MACHINE_R4000:
1143 case IMAGE_FILE_MACHINE_R10000:
1144
1145 case IMAGE_FILE_MACHINE_MIPS16:
1146 case IMAGE_FILE_MACHINE_MIPSFPU:
1147 case IMAGE_FILE_MACHINE_MIPSFPU16:
1148#ifdef MIPS_ARCH_MAGIC_WINCE
1149 magic = MIPS_ARCH_MAGIC_WINCE;
1150#endif
1151 break;
1152
1153 case IMAGE_FILE_MACHINE_SH3:
1154 case IMAGE_FILE_MACHINE_SH4:
1155#ifdef SH_ARCH_MAGIC_WINCE
1156 magic = SH_ARCH_MAGIC_WINCE;
1157#endif
1158 break;
1159
1160 case IMAGE_FILE_MACHINE_ARM:
1161#ifdef ARMPEMAGIC
1162 magic = ARMPEMAGIC;
1163#endif
1164 break;
1165
1166 case IMAGE_FILE_MACHINE_THUMB:
1167#ifdef THUMBPEMAGIC
1168 {
1169 extern bfd_target armpei_little_vec;
1170
1171 if (abfd->xvec == & armpei_little_vec)
1172 magic = THUMBPEMAGIC;
1173 }
1174#endif
1175 break;
1176
1177 case IMAGE_FILE_MACHINE_POWERPC:
1178 /* We no longer support PowerPC. */
1179 default:
1180 _bfd_error_handler
1181 (
1182_("%s: Unrecognised machine type (0x%x) in Import Library Format archive"),
1183 bfd_get_filename (abfd), machine);
1184 bfd_set_error (bfd_error_malformed_archive);
1185
1186 return NULL;
1187 break;
1188 }
1189
1190 if (magic == 0)
1191 {
1192 _bfd_error_handler
1193 (
1194_("%s: Recognised but unhandled machine type (0x%x) in Import Library Format archive"),
1195 bfd_get_filename (abfd), machine);
1196 bfd_set_error (bfd_error_wrong_format);
1197
1198 return NULL;
1199 }
1200
1201 /* We do not bother to check the date.
1202 date = bfd_h_get_32 (abfd, ptr); */
1203 ptr += 4;
1204
1205 size = bfd_h_get_32 (abfd, ptr);
1206 ptr += 4;
1207
1208 if (size == 0)
1209 {
1210 _bfd_error_handler
1211 (_("%s: size field is zero in Import Library Format header"),
1212 bfd_get_filename (abfd));
1213 bfd_set_error (bfd_error_malformed_archive);
1214
1215 return NULL;
1216 }
1217
1218 ordinal = bfd_h_get_16 (abfd, ptr);
1219 ptr += 2;
1220
1221 types = bfd_h_get_16 (abfd, ptr);
1222 /* ptr += 2; */
1223
1224 /* Now read in the two strings that follow. */
1225 ptr = bfd_alloc (abfd, size);
1226 if (ptr == NULL)
1227 return NULL;
1228
1229 if (bfd_read (ptr, 1, size, abfd) != size)
1230 return NULL;
1231
1232 symbol_name = ptr;
1233 source_dll = ptr + strlen (ptr) + 1;
1234
1235 /* Verify that the strings are null terminated. */
11c8a8d1 1236 if (ptr[size - 1] != 0 || ((unsigned long) (source_dll - ptr) >= size))
17505c5c
NC		 1237 {
1238 _bfd_error_handler
1239 (_("%s: string not null terminated in ILF object file."),
1240 bfd_get_filename (abfd));
1241 bfd_set_error (bfd_error_malformed_archive);
1242
1243 return NULL;
1244 }
1245
1246 /* Now construct the bfd. */
1247 if (! pe_ILF_build_a_bfd (abfd, magic, symbol_name,
1248 source_dll, ordinal, types))
1249 return NULL;
1250
1251 return abfd->xvec;
1252}
1253
1254static const bfd_target *
1255pe_bfd_object_p (bfd * abfd)
cb665cd3
NC		 1256{
1257 /* We need to handle a PE image correctly. In PE images created by
1258 the GNU linker, the offset to the COFF header is always the size.
1259 However, this is not the case in images generated by other PE
1260 linkers. The PE format stores a four byte offset to the PE
1261 signature just before the COFF header at location 0x3c of the file.
1262 We pick up that offset, verify that the PE signature is there, and
1263 then set ourselves up to read in the COFF header. */
1264 bfd_byte buffer[4];
1265 file_ptr offset;
1266 unsigned long signature;
1267
1268 /* Detect if this a Microsoft Import Library Format element. */
1269 if (bfd_seek (abfd, 0x00, SEEK_SET) != 0
1270 || bfd_read (buffer, 1, 4, abfd) != 4)
1271 {
1272 if (bfd_get_error () != bfd_error_system_call)
1273 bfd_set_error (bfd_error_wrong_format);
1274 return NULL;
1275 }
1276
1277 signature = bfd_h_get_32 (abfd, buffer);
1278
1279 if (signature == 0xffff0000)
17505c5c 1280 return pe_ILF_object_p (abfd);
cb665cd3
NC		 1281
1282 if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0
1283 || bfd_read (buffer, 1, 4, abfd) != 4)
1284 {
1285 if (bfd_get_error () != bfd_error_system_call)
1286 bfd_set_error (bfd_error_wrong_format);
1287 return NULL;
1288 }
1289
1290 offset = bfd_h_get_32 (abfd, buffer);
1291
1292 if (bfd_seek (abfd, offset, SEEK_SET) != 0
1293 || bfd_read (buffer, 1, 4, abfd) != 4)
1294 {
1295 if (bfd_get_error () != bfd_error_system_call)
1296 bfd_set_error (bfd_error_wrong_format);
1297 return NULL;
1298 }
1299
1300 signature = bfd_h_get_32 (abfd, buffer);
1301
1302 if (signature != 0x4550)
1303 {
1304 bfd_set_error (bfd_error_wrong_format);
1305 return NULL;
1306 }
1307
1308 /* Here is the hack. coff_object_p wants to read filhsz bytes to
1309 pick up the COFF header. We adjust so that that will work. 20
1310 is the size of the i386 COFF filehdr. */
1311 if (bfd_seek (abfd,
1312 (bfd_tell (abfd)
1313 - bfd_coff_filhsz (abfd)
1314 + 20),
1315 SEEK_SET)
1316 != 0)
1317 {
1318 if (bfd_get_error () != bfd_error_system_call)
1319 bfd_set_error (bfd_error_wrong_format);
1320 return NULL;
1321 }
1322
1323 return coff_object_p (abfd);
1324}
1325
1326#define coff_object_p pe_bfd_object_p
17505c5c 1327#endif /* COFF_IMAGE_WITH_PE */
GDB Binutils - Deliverables
This page took 0.097463 seconds and 4 git commands to generate.