1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
3 Written by DJ Delorie <dj@cygnus.com>
5 This file is part of GLD, the Gnu Linker.
7 GLD is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GLD is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GLD; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "libiberty.h"
39 #include "coff/internal.h"
40 #include "../bfd/libcoff.h"
44 /************************************************************************
46 This file turns a regular Windows PE image into a DLL. Because of
47 the complexity of this operation, it has been broken down into a
48 number of separate modules which are all called by the main function
49 at the end of this file. This function is not re-entrant and is
50 normally only called once, so static variables are used to reduce
51 the number of parameters and return values required.
53 See also: ld/emultempl/pe.em
55 ************************************************************************/
57 /* for emultempl/pe.em */
59 def_file
*pe_def_file
= 0;
60 int pe_dll_export_everything
= 0;
61 int pe_dll_do_default_excludes
= 1;
62 int pe_dll_kill_ats
= 0;
63 int pe_dll_stdcall_aliases
= 0;
64 int pe_dll_warn_dup_exports
= 0;
65 int pe_dll_compat_implib
= 0;
67 /************************************************************************
69 static variables and types
71 ************************************************************************/
73 static bfd_vma image_base
;
75 static bfd
*filler_bfd
;
76 static struct sec
*edata_s
, *reloc_s
;
77 static unsigned char *edata_d
, *reloc_d
;
78 static size_t edata_sz
, reloc_sz
;
83 unsigned int imagebase_reloc
;
89 #define PE_ARCH_i386 1
91 #define PE_ARCH_mips 3
94 static pe_details_type pe_detail_list
[] = {
106 16 /* R_SH_IMAGEBASE */,
127 { NULL
, NULL
, 0, 0, 0, 0 }
130 static pe_details_type
*pe_details
;
132 #define U(str) (pe_details->underscored ? "_" str : str)
135 pe_dll_id_target (target
)
139 for (i
=0; pe_detail_list
[i
].target_name
; i
++)
140 if (strcmp (pe_detail_list
[i
].target_name
, target
) == 0
141 || strcmp (pe_detail_list
[i
].object_target
, target
) == 0)
143 pe_details
= pe_detail_list
+i
;
146 einfo (_("%XUnsupported PEI architecture: %s\n"), target
);
150 /************************************************************************
152 Helper functions for qsort. Relocs must be sorted so that we can write
155 ************************************************************************/
167 bfd_vma a
= ((reloc_data_type
*) va
)->vma
;
168 bfd_vma b
= ((reloc_data_type
*) vb
)->vma
;
169 return (a
> b
) ? 1 : ((a
< b
) ? -1 : 0);
173 pe_export_sort (va
, vb
)
176 def_file_export
*a
= (def_file_export
*) va
;
177 def_file_export
*b
= (def_file_export
*) vb
;
178 return strcmp (a
->name
, b
->name
);
181 /************************************************************************
183 Read and process the .DEF file
185 ************************************************************************/
187 /* These correspond to the entries in pe_def_file->exports[]. I use
188 exported_symbol_sections[i] to tag whether or not the symbol was
189 defined, since we can't export symbols we don't have. */
191 static bfd_vma
*exported_symbol_offsets
;
192 static struct sec
**exported_symbol_sections
;
194 static int export_table_size
;
195 static int count_exported
;
196 static int count_exported_byname
;
197 static int count_with_ordinals
;
198 static const char *dll_name
;
199 static int min_ordinal
, max_ordinal
;
200 static int *exported_symbols
;
202 typedef struct exclude_list_struct
205 struct exclude_list_struct
*next
;
208 static struct exclude_list_struct
*excludes
= 0;
211 pe_dll_add_excludes (new_excludes
)
212 const char *new_excludes
;
215 char *exclude_string
;
217 local_copy
= xstrdup (new_excludes
);
219 exclude_string
= strtok (local_copy
, ",:");
220 for (; exclude_string
; exclude_string
= strtok (NULL
, ",:"))
222 struct exclude_list_struct
*new_exclude
;
224 new_exclude
= ((struct exclude_list_struct
*)
225 xmalloc (sizeof (struct exclude_list_struct
)));
226 new_exclude
->string
= (char *) xmalloc (strlen (exclude_string
) + 1);
227 strcpy (new_exclude
->string
, exclude_string
);
228 new_exclude
->next
= excludes
;
229 excludes
= new_exclude
;
241 struct exclude_list_struct
*ex
;
242 for (i
= 0; i
< d
->num_exports
; i
++)
243 if (strcmp (d
->exports
[i
].name
, n
) == 0)
245 if (pe_dll_do_default_excludes
)
247 if (strcmp (n
, "DllMain@12") == 0)
249 if (strcmp (n
, "DllEntryPoint@0") == 0)
251 if (strcmp (n
, "impure_ptr") == 0)
254 for (ex
= excludes
; ex
; ex
= ex
->next
)
255 if (strcmp (n
, ex
->string
) == 0)
261 process_def_file (abfd
, info
)
262 bfd
*abfd ATTRIBUTE_UNUSED
;
263 struct bfd_link_info
*info
;
266 struct bfd_link_hash_entry
*blhe
;
269 def_file_export
*e
=0;
272 pe_def_file
= def_file_empty ();
274 /* First, run around to all the objects looking for the .drectve
275 sections, and push those into the def file too */
277 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
279 s
= bfd_get_section_by_name (b
, ".drectve");
282 int size
= bfd_get_section_size_before_reloc (s
);
283 char *buf
= xmalloc (size
);
284 bfd_get_section_contents (b
, s
, buf
, 0, size
);
285 def_file_add_directive (pe_def_file
, buf
, size
);
290 /* Now, maybe export everything else the default way */
292 if (pe_dll_export_everything
|| pe_def_file
->num_exports
== 0)
294 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
299 symsize
= bfd_get_symtab_upper_bound (b
);
300 symbols
= (asymbol
**) xmalloc (symsize
);
301 nsyms
= bfd_canonicalize_symtab (b
, symbols
);
303 for (j
= 0; j
< nsyms
; j
++)
305 if (symbols
[j
]->flags
& BSF_GLOBAL
)
307 const char *sn
= symbols
[j
]->name
;
310 if (auto_export (pe_def_file
, sn
))
311 def_file_add_export (pe_def_file
, sn
, 0, -1);
318 #define NE pe_def_file->num_exports
320 /* Canonicalize the export list */
324 for (i
= 0; i
< NE
; i
++)
326 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
328 /* This will preserve internal_name, which may have been pointing
329 to the same memory as name, or might not have */
330 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
);
331 *(strchr (tmp
, '@')) = 0;
332 pe_def_file
->exports
[i
].name
= tmp
;
337 if (pe_dll_stdcall_aliases
)
339 for (i
= 0; i
< NE
; i
++)
341 if (strchr (pe_def_file
->exports
[i
].name
, '@'))
343 char *tmp
= xstrdup (pe_def_file
->exports
[i
].name
);
344 *(strchr (tmp
, '@')) = 0;
345 if (auto_export (pe_def_file
, tmp
))
346 def_file_add_export (pe_def_file
, tmp
,
347 pe_def_file
->exports
[i
].internal_name
, -1);
354 e
= pe_def_file
->exports
; /* convenience, but watch out for it changing */
356 exported_symbol_offsets
= (bfd_vma
*) xmalloc (NE
* sizeof (bfd_vma
));
357 exported_symbol_sections
= (struct sec
**) xmalloc (NE
* sizeof (struct sec
*));
359 memset (exported_symbol_sections
, 0, NE
* sizeof (struct sec
*));
363 count_exported_byname
= 0;
364 count_with_ordinals
= 0;
366 qsort (pe_def_file
->exports
, NE
, sizeof (pe_def_file
->exports
[0]), pe_export_sort
);
367 for (i
= 0, j
= 0; i
< NE
; i
++)
369 if (i
> 0 && strcmp (e
[i
].name
, e
[i
- 1].name
) == 0)
371 /* This is a duplicate. */
372 if (e
[j
- 1].ordinal
!= -1
373 && e
[i
].ordinal
!= -1
374 && e
[j
- 1].ordinal
!= e
[i
].ordinal
)
376 if (pe_dll_warn_dup_exports
)
377 /* xgettext:c-format */
378 einfo (_("%XError, duplicate EXPORT with oridinals: %s (%d vs %d)\n"),
379 e
[j
- 1].name
, e
[j
- 1].ordinal
, e
[i
].ordinal
);
383 if (pe_dll_warn_dup_exports
)
384 /* xgettext:c-format */
385 einfo (_("Warning, duplicate EXPORT: %s\n"),
389 e
[j
- 1].ordinal
= e
[i
].ordinal
;
390 e
[j
- 1].flag_private
|= e
[i
].flag_private
;
391 e
[j
- 1].flag_constant
|= e
[i
].flag_constant
;
392 e
[j
- 1].flag_noname
|= e
[i
].flag_noname
;
393 e
[j
- 1].flag_data
|= e
[i
].flag_data
;
402 pe_def_file
->num_exports
= j
; /* == NE */
404 for (i
= 0; i
< NE
; i
++)
406 char *name
= (char *) xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
407 if (pe_details
->underscored
)
410 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
413 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
415 blhe
= bfd_link_hash_lookup (info
->hash
,
420 && (blhe
->type
== bfd_link_hash_defined
421 || (blhe
->type
== bfd_link_hash_common
)))
424 if (!pe_def_file
->exports
[i
].flag_noname
)
425 count_exported_byname
++;
427 /* Only fill in the sections. The actual offsets are computed
428 in fill_exported_offsets() after common symbols are laid
430 if (blhe
->type
== bfd_link_hash_defined
)
431 exported_symbol_sections
[i
] = blhe
->u
.def
.section
;
433 exported_symbol_sections
[i
] = blhe
->u
.c
.p
->section
;
435 if (pe_def_file
->exports
[i
].ordinal
!= -1)
437 if (max_ordinal
< pe_def_file
->exports
[i
].ordinal
)
438 max_ordinal
= pe_def_file
->exports
[i
].ordinal
;
439 if (min_ordinal
> pe_def_file
->exports
[i
].ordinal
)
440 min_ordinal
= pe_def_file
->exports
[i
].ordinal
;
441 count_with_ordinals
++;
444 else if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
446 /* xgettext:c-format */
447 einfo (_("%XCannot export %s: symbol not defined\n"),
448 pe_def_file
->exports
[i
].internal_name
);
452 /* xgettext:c-format */
453 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
454 pe_def_file
->exports
[i
].internal_name
,
455 blhe
->type
, bfd_link_hash_defined
);
459 /* xgettext:c-format */
460 einfo (_("%XCannot export %s: symbol not found\n"),
461 pe_def_file
->exports
[i
].internal_name
);
467 /************************************************************************
469 Build the bfd that will contain .edata and .reloc sections
471 ************************************************************************/
474 build_filler_bfd (include_edata
)
477 lang_input_statement_type
*filler_file
;
478 filler_file
= lang_add_input_file ("dll stuff",
479 lang_input_file_is_fake_enum
,
481 filler_file
->the_bfd
= filler_bfd
= bfd_create ("dll stuff", output_bfd
);
482 if (filler_bfd
== NULL
483 || !bfd_set_arch_mach (filler_bfd
,
484 bfd_get_arch (output_bfd
),
485 bfd_get_mach (output_bfd
)))
487 einfo ("%X%P: can not create BFD %E\n");
493 edata_s
= bfd_make_section_old_way (filler_bfd
, ".edata");
495 || !bfd_set_section_flags (filler_bfd
, edata_s
,
502 einfo ("%X%P: can not create .edata section: %E\n");
505 bfd_set_section_size (filler_bfd
, edata_s
, edata_sz
);
508 reloc_s
= bfd_make_section_old_way (filler_bfd
, ".reloc");
510 || !bfd_set_section_flags (filler_bfd
, reloc_s
,
517 einfo ("%X%P: can not create .reloc section: %E\n");
520 bfd_set_section_size (filler_bfd
, reloc_s
, 0);
522 ldlang_add_file (filler_file
);
525 /************************************************************************
527 Gather all the exported symbols and build the .edata section
529 ************************************************************************/
532 generate_edata (abfd
, info
)
534 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
537 int name_table_size
= 0;
540 /* First, we need to know how many exported symbols there are,
541 and what the range of ordinals is. */
543 if (pe_def_file
->name
)
545 dll_name
= pe_def_file
->name
;
549 dll_name
= abfd
->filename
;
550 for (dlnp
= dll_name
; *dlnp
; dlnp
++)
552 if (*dlnp
== '\\' || *dlnp
== '/' || *dlnp
== ':')
557 if (count_with_ordinals
&& max_ordinal
> count_exported
)
559 if (min_ordinal
> max_ordinal
- count_exported
+ 1)
560 min_ordinal
= max_ordinal
- count_exported
+ 1;
565 max_ordinal
= count_exported
;
567 export_table_size
= max_ordinal
- min_ordinal
+ 1;
569 exported_symbols
= (int *) xmalloc (export_table_size
* sizeof (int));
570 for (i
= 0; i
< export_table_size
; i
++)
571 exported_symbols
[i
] = -1;
573 /* Now we need to assign ordinals to those that don't have them */
574 for (i
= 0; i
< NE
; i
++)
576 if (exported_symbol_sections
[i
])
578 if (pe_def_file
->exports
[i
].ordinal
!= -1)
580 int ei
= pe_def_file
->exports
[i
].ordinal
- min_ordinal
;
581 int pi
= exported_symbols
[ei
];
584 /* xgettext:c-format */
585 einfo (_("%XError, oridinal used twice: %d (%s vs %s)\n"),
586 pe_def_file
->exports
[i
].ordinal
,
587 pe_def_file
->exports
[i
].name
,
588 pe_def_file
->exports
[pi
].name
);
590 exported_symbols
[ei
] = i
;
592 name_table_size
+= strlen (pe_def_file
->exports
[i
].name
) + 1;
596 next_ordinal
= min_ordinal
;
597 for (i
= 0; i
< NE
; i
++)
598 if (exported_symbol_sections
[i
])
599 if (pe_def_file
->exports
[i
].ordinal
== -1)
601 while (exported_symbols
[next_ordinal
- min_ordinal
] != -1)
603 exported_symbols
[next_ordinal
- min_ordinal
] = i
;
604 pe_def_file
->exports
[i
].ordinal
= next_ordinal
;
607 /* OK, now we can allocate some memory */
609 edata_sz
= (40 /* directory */
610 + 4 * export_table_size
/* addresses */
611 + 4 * count_exported_byname
/* name ptrs */
612 + 2 * count_exported_byname
/* ordinals */
613 + name_table_size
+ strlen (dll_name
) + 1);
616 /* Fill the exported symbol offsets. The preliminary work has already
617 been done in process_def_file(). */
620 fill_exported_offsets (abfd
, info
)
621 bfd
*abfd ATTRIBUTE_UNUSED
;
622 struct bfd_link_info
*info
;
625 struct bfd_link_hash_entry
*blhe
;
627 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
629 char *name
= (char *) xmalloc (strlen (pe_def_file
->exports
[i
].internal_name
) + 2);
630 if (pe_details
->underscored
)
633 strcpy (name
+ 1, pe_def_file
->exports
[i
].internal_name
);
636 strcpy (name
, pe_def_file
->exports
[i
].internal_name
);
638 blhe
= bfd_link_hash_lookup (info
->hash
,
642 if (blhe
&& (blhe
->type
== bfd_link_hash_defined
))
644 exported_symbol_offsets
[i
] = blhe
->u
.def
.value
;
651 fill_edata (abfd
, info
)
653 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
656 unsigned char *edirectory
;
657 unsigned long *eaddresses
;
658 unsigned long *enameptrs
;
659 unsigned short *eordinals
;
660 unsigned char *enamestr
;
665 edata_d
= (unsigned char *) xmalloc (edata_sz
);
667 /* Note use of array pointer math here */
668 edirectory
= edata_d
;
669 eaddresses
= (unsigned long *) (edata_d
+ 40);
670 enameptrs
= eaddresses
+ export_table_size
;
671 eordinals
= (unsigned short *) (enameptrs
+ count_exported_byname
);
672 enamestr
= (char *) (eordinals
+ count_exported_byname
);
674 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) + edata_s->output_section->vma - image_base)
676 memset (edata_d
, 0, 40);
677 bfd_put_32 (abfd
, now
, edata_d
+ 4);
678 if (pe_def_file
->version_major
!= -1)
680 bfd_put_16 (abfd
, pe_def_file
->version_major
, edata_d
+ 8);
681 bfd_put_16 (abfd
, pe_def_file
->version_minor
, edata_d
+ 10);
683 bfd_put_32 (abfd
, ERVA (enamestr
), edata_d
+ 12);
684 strcpy (enamestr
, dll_name
);
685 enamestr
+= strlen (enamestr
) + 1;
686 bfd_put_32 (abfd
, min_ordinal
, edata_d
+ 16);
687 bfd_put_32 (abfd
, export_table_size
, edata_d
+ 20);
688 bfd_put_32 (abfd
, count_exported_byname
, edata_d
+ 24);
689 bfd_put_32 (abfd
, ERVA (eaddresses
), edata_d
+ 28);
690 bfd_put_32 (abfd
, ERVA (enameptrs
), edata_d
+ 32);
691 bfd_put_32 (abfd
, ERVA (eordinals
), edata_d
+ 36);
693 fill_exported_offsets (abfd
, info
);
695 /* Ok, now for the filling in part */
697 for (i
= 0; i
< export_table_size
; i
++)
699 int s
= exported_symbols
[i
];
702 struct sec
*ssec
= exported_symbol_sections
[s
];
703 unsigned long srva
= (exported_symbol_offsets
[s
]
704 + ssec
->output_section
->vma
705 + ssec
->output_offset
);
707 bfd_put_32 (abfd
, srva
- image_base
, (void *) (eaddresses
+ i
));
708 if (!pe_def_file
->exports
[s
].flag_noname
)
710 char *ename
= pe_def_file
->exports
[s
].name
;
711 bfd_put_32 (abfd
, ERVA (enamestr
), (void *) enameptrs
);
712 strcpy (enamestr
, ename
);
713 enamestr
+= strlen (enamestr
) + 1;
714 bfd_put_16 (abfd
, i
, (void *) eordinals
);
716 pe_def_file
->exports
[s
].hint
= hint
++;
723 /************************************************************************
725 Gather all the relocations and build the .reloc section
727 ************************************************************************/
730 generate_reloc (abfd
, info
)
732 struct bfd_link_info
*info
;
735 /* for .reloc stuff */
736 reloc_data_type
*reloc_data
;
737 int total_relocs
= 0;
739 unsigned long sec_page
= (unsigned long) (-1);
740 unsigned long page_ptr
, page_count
;
746 for (b
= info
->input_bfds
; b
; b
= b
->link_next
)
747 for (s
= b
->sections
; s
; s
= s
->next
)
748 total_relocs
+= s
->reloc_count
;
750 reloc_data
= (reloc_data_type
*) xmalloc (total_relocs
* sizeof (reloc_data_type
));
754 for (bi
= 0, b
= info
->input_bfds
; b
; bi
++, b
= b
->link_next
)
757 int relsize
, nrelocs
, i
;
759 for (s
= b
->sections
; s
; s
= s
->next
)
761 unsigned long sec_vma
= s
->output_section
->vma
+ s
->output_offset
;
765 /* if it's not loaded, we don't need to relocate it this way */
766 if (!(s
->output_section
->flags
& SEC_LOAD
))
769 /* I don't know why there would be a reloc for these, but I've
770 seen it happen - DJ */
771 if (s
->output_section
== &bfd_abs_section
)
774 if (s
->output_section
->vma
== 0)
776 /* Huh? Shouldn't happen, but punt if it does */
777 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
778 s
->output_section
->name
, s
->output_section
->index
,
779 s
->output_section
->flags
);
783 symsize
= bfd_get_symtab_upper_bound (b
);
784 symbols
= (asymbol
**) xmalloc (symsize
);
785 nsyms
= bfd_canonicalize_symtab (b
, symbols
);
787 relsize
= bfd_get_reloc_upper_bound (b
, s
);
788 relocs
= (arelent
**) xmalloc ((size_t) relsize
);
789 nrelocs
= bfd_canonicalize_reloc (b
, s
, relocs
, symbols
);
791 for (i
= 0; i
< nrelocs
; i
++)
793 if (!relocs
[i
]->howto
->pc_relative
794 && relocs
[i
]->howto
->type
!= pe_details
->imagebase_reloc
)
797 struct symbol_cache_entry
*sym
= *relocs
[i
]->sym_ptr_ptr
;
798 sym_vma
= (relocs
[i
]->addend
801 + sym
->section
->output_offset
802 + sym
->section
->output_section
->vma
);
803 reloc_data
[total_relocs
].vma
= sec_vma
+ relocs
[i
]->address
;
805 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
807 switch BITS_AND_SHIFT (relocs
[i
]->howto
->bitsize
,
808 relocs
[i
]->howto
->rightshift
)
810 case BITS_AND_SHIFT (32, 0):
811 reloc_data
[total_relocs
].type
= 3;
814 case BITS_AND_SHIFT (16, 0):
815 reloc_data
[total_relocs
].type
= 2;
818 case BITS_AND_SHIFT (16, 16):
819 reloc_data
[total_relocs
].type
= 4;
820 /* FIXME: we can't know the symbol's right value yet,
821 but we probably can safely assume that CE will relocate
822 us in 64k blocks, so leaving it zero is safe. */
823 reloc_data
[total_relocs
].extra
= 0;
826 case BITS_AND_SHIFT (26, 2):
827 reloc_data
[total_relocs
].type
= 5;
831 /* xgettext:c-format */
832 einfo (_("%XError: %d-bit reloc in dll\n"),
833 relocs
[i
]->howto
->bitsize
);
839 /* Warning: the allocated symbols are remembered in BFD and reused
840 later, so don't free them! */
841 /* free (symbols); */
845 /* At this point, we have total_relocs relocation addresses in
846 reloc_addresses, which are all suitable for the .reloc section.
847 We must now create the new sections. */
849 qsort (reloc_data
, total_relocs
, sizeof (*reloc_data
), reloc_sort
);
851 for (i
= 0; i
< total_relocs
; i
++)
853 unsigned long this_page
= (reloc_data
[i
].vma
>> 12);
855 if (this_page
!= sec_page
)
857 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align */
859 sec_page
= this_page
;
864 if (reloc_data
[i
].type
== 4)
867 reloc_sz
= (reloc_sz
+ 3) & ~3; /* 4-byte align */
869 reloc_d
= (unsigned char *) xmalloc (reloc_sz
);
871 sec_page
= (unsigned long) (-1);
873 page_ptr
= (unsigned long) (-1);
875 for (i
= 0; i
< total_relocs
; i
++)
877 unsigned long rva
= reloc_data
[i
].vma
- image_base
;
878 unsigned long this_page
= (rva
& ~0xfff);
879 if (this_page
!= sec_page
)
882 reloc_d
[reloc_sz
++] = 0;
883 if (page_ptr
!= (unsigned long) (-1))
884 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
885 bfd_put_32 (abfd
, this_page
, reloc_d
+ reloc_sz
);
888 sec_page
= this_page
;
891 bfd_put_16 (abfd
, (rva
& 0xfff) + (reloc_data
[i
].type
<<12),
894 if (reloc_data
[i
].type
== 4)
896 bfd_put_16 (abfd
, reloc_data
[i
].extra
, reloc_d
+ reloc_sz
);
902 reloc_d
[reloc_sz
++] = 0;
903 if (page_ptr
!= (unsigned long) (-1))
904 bfd_put_32 (abfd
, reloc_sz
- page_ptr
, reloc_d
+ page_ptr
+ 4);
905 while (reloc_sz
< reloc_s
->_raw_size
)
906 reloc_d
[reloc_sz
++] = 0;
909 /************************************************************************
911 Given the exiting def_file structure, print out a .DEF file that
914 ************************************************************************/
917 quoteput (s
, f
, needs_quotes
)
923 for (cp
= s
; *cp
; cp
++)
927 || isspace ((unsigned char) *cp
)
936 if (*s
== '"' || *s
== '\\')
948 pe_dll_generate_def_file (pe_out_def_filename
)
949 const char *pe_out_def_filename
;
952 FILE *out
= fopen (pe_out_def_filename
, "w");
955 /* xgettext:c-format */
956 einfo (_("%s: Can't open output def file %s\n"),
957 program_name
, pe_out_def_filename
);
962 if (pe_def_file
->name
)
964 if (pe_def_file
->is_dll
)
965 fprintf (out
, "LIBRARY ");
967 fprintf (out
, "NAME ");
968 quoteput (pe_def_file
->name
, out
, 1);
969 if (pe_data (output_bfd
)->pe_opthdr
.ImageBase
)
970 fprintf (out
, " BASE=0x%lx",
971 (unsigned long) pe_data (output_bfd
)->pe_opthdr
.ImageBase
);
975 if (pe_def_file
->description
)
977 fprintf (out
, "DESCRIPTION ");
978 quoteput (pe_def_file
->description
, out
, 1);
982 if (pe_def_file
->version_minor
!= -1)
983 fprintf (out
, "VERSION %d.%d\n", pe_def_file
->version_major
,
984 pe_def_file
->version_minor
);
985 else if (pe_def_file
->version_major
!= -1)
986 fprintf (out
, "VERSION %d\n", pe_def_file
->version_major
);
988 if (pe_def_file
->stack_reserve
!= -1 || pe_def_file
->heap_reserve
!= -1)
991 if (pe_def_file
->stack_commit
!= -1)
992 fprintf (out
, "STACKSIZE 0x%x,0x%x\n",
993 pe_def_file
->stack_reserve
, pe_def_file
->stack_commit
);
994 else if (pe_def_file
->stack_reserve
!= -1)
995 fprintf (out
, "STACKSIZE 0x%x\n", pe_def_file
->stack_reserve
);
996 if (pe_def_file
->heap_commit
!= -1)
997 fprintf (out
, "HEAPSIZE 0x%x,0x%x\n",
998 pe_def_file
->heap_reserve
, pe_def_file
->heap_commit
);
999 else if (pe_def_file
->heap_reserve
!= -1)
1000 fprintf (out
, "HEAPSIZE 0x%x\n", pe_def_file
->heap_reserve
);
1002 if (pe_def_file
->num_section_defs
> 0)
1004 fprintf (out
, "\nSECTIONS\n\n");
1005 for (i
= 0; i
< pe_def_file
->num_section_defs
; i
++)
1008 quoteput (pe_def_file
->section_defs
[i
].name
, out
, 0);
1009 if (pe_def_file
->section_defs
[i
].class)
1011 fprintf (out
, " CLASS ");
1012 quoteput (pe_def_file
->section_defs
[i
].class, out
, 0);
1014 if (pe_def_file
->section_defs
[i
].flag_read
)
1015 fprintf (out
, " READ");
1016 if (pe_def_file
->section_defs
[i
].flag_write
)
1017 fprintf (out
, " WRITE");
1018 if (pe_def_file
->section_defs
[i
].flag_execute
)
1019 fprintf (out
, " EXECUTE");
1020 if (pe_def_file
->section_defs
[i
].flag_shared
)
1021 fprintf (out
, " SHARED");
1022 fprintf (out
, "\n");
1026 if (pe_def_file
->num_exports
> 0)
1028 fprintf (out
, "\nEXPORTS\n\n");
1029 for (i
= 0; i
< pe_def_file
->num_exports
; i
++)
1031 def_file_export
*e
= pe_def_file
->exports
+ i
;
1033 quoteput (e
->name
, out
, 0);
1034 if (e
->internal_name
&& strcmp (e
->internal_name
, e
->name
))
1036 fprintf (out
, " = ");
1037 quoteput (e
->internal_name
, out
, 0);
1039 if (e
->ordinal
!= -1)
1040 fprintf (out
, " @%d", e
->ordinal
);
1041 if (e
->flag_private
)
1042 fprintf (out
, " PRIVATE");
1043 if (e
->flag_constant
)
1044 fprintf (out
, " CONSTANT");
1046 fprintf (out
, " NONAME");
1048 fprintf (out
, " DATA");
1050 fprintf (out
, "\n");
1054 if (pe_def_file
->num_imports
> 0)
1056 fprintf (out
, "\nIMPORTS\n\n");
1057 for (i
= 0; i
< pe_def_file
->num_imports
; i
++)
1059 def_file_import
*im
= pe_def_file
->imports
+ i
;
1061 if (im
->internal_name
1062 && (!im
->name
|| strcmp (im
->internal_name
, im
->name
)))
1064 quoteput (im
->internal_name
, out
, 0);
1065 fprintf (out
, " = ");
1067 quoteput (im
->module
->name
, out
, 0);
1070 quoteput (im
->name
, out
, 0);
1072 fprintf (out
, "%d", im
->ordinal
);
1073 fprintf (out
, "\n");
1078 fprintf (out
, _("; no contents available\n"));
1080 if (fclose (out
) == EOF
)
1082 /* xgettext:c-format */
1083 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename
);
1087 /************************************************************************
1089 Generate the import library
1091 ************************************************************************/
1093 static asymbol
**symtab
;
1096 static const char *dll_filename
;
1097 static char *dll_symname
;
1099 #define UNDSEC (asection *) &bfd_und_section
1102 quick_section(abfd
, name
, flags
, align
)
1111 sec
= bfd_make_section_old_way (abfd
, name
);
1112 bfd_set_section_flags (abfd
, sec
, flags
1117 bfd_set_section_alignment (abfd
, sec
, align
);
1118 /* remember to undo this before trying to link internally! */
1119 sec
->output_section
= sec
;
1121 sym
= bfd_make_empty_symbol (abfd
);
1122 symtab
[symptr
++] = sym
;
1123 sym
->name
= sec
->name
;
1125 sym
->flags
= BSF_LOCAL
;
1132 quick_symbol (abfd
, n1
, n2
, n3
, sec
, flags
, addr
)
1142 char *name
= (char *) xmalloc (strlen (n1
) + strlen (n2
) + strlen (n3
) + 1);
1146 sym
= bfd_make_empty_symbol (abfd
);
1151 symtab
[symptr
++] = sym
;
1154 static arelent
*reltab
= 0;
1155 static int relcount
= 0, relsize
= 0;
1158 quick_reloc (abfd
, address
, which_howto
, symidx
)
1164 if (relcount
>= (relsize
-1))
1168 reltab
= (arelent
*) xrealloc (reltab
, relsize
* sizeof (arelent
));
1170 reltab
= (arelent
*) xmalloc (relsize
* sizeof (arelent
));
1172 reltab
[relcount
].address
= address
;
1173 reltab
[relcount
].addend
= 0;
1174 reltab
[relcount
].howto
= bfd_reloc_type_lookup (abfd
, which_howto
);
1175 reltab
[relcount
].sym_ptr_ptr
= symtab
+ symidx
;
1180 save_relocs (asection
*sec
)
1183 sec
->relocation
= reltab
;
1184 sec
->reloc_count
= relcount
;
1185 sec
->orelocation
= (arelent
**) xmalloc ((relcount
+1) * sizeof (arelent
*));
1186 for (i
=0; i
<relcount
; i
++)
1187 sec
->orelocation
[i
] = sec
->relocation
+ i
;
1188 sec
->orelocation
[relcount
] = 0;
1189 sec
->flags
|= SEC_RELOC
;
1191 relcount
= relsize
= 0;
1196 * .global __head_my_dll
1201 * .rva __my_dll_iname
1217 asection
*id2
, *id5
, *id4
;
1218 unsigned char *d2
, *d5
, *d4
;
1222 oname
= (char *) xmalloc (20);
1223 sprintf (oname
, "d%06d.o", tmp_seq
);
1226 abfd
= bfd_create (oname
, parent
);
1227 bfd_find_target (pe_details
->object_target
, abfd
);
1228 bfd_make_writable (abfd
);
1230 bfd_set_format (abfd
, bfd_object
);
1231 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1234 symtab
= (asymbol
**) xmalloc (6 * sizeof (asymbol
*));
1235 id2
= quick_section (abfd
, ".idata$2", SEC_HAS_CONTENTS
, 2);
1236 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1237 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1238 quick_symbol (abfd
, U("_head_"), dll_symname
, "", id2
, BSF_GLOBAL
, 0);
1239 quick_symbol (abfd
, U(""), dll_symname
, "_iname", UNDSEC
, BSF_GLOBAL
, 0);
1241 /* OK, pay attention here. I got confused myself looking back at
1242 it. We create a four-byte section to mark the beginning of the
1243 list, and we include an offset of 4 in the section, so that the
1244 pointer to the list points to the *end* of this section, which is
1245 the start of the list of sections from other objects. */
1247 bfd_set_section_size (abfd
, id2
, 20);
1248 d2
= (unsigned char *) xmalloc (20);
1251 d2
[0] = d2
[16] = 4; /* reloc addend */
1252 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 2);
1253 quick_reloc (abfd
, 12, BFD_RELOC_RVA
, 4);
1254 quick_reloc (abfd
, 16, BFD_RELOC_RVA
, 1);
1257 bfd_set_section_size (abfd
, id5
, 4);
1258 d5
= (unsigned char *) xmalloc (4);
1262 bfd_set_section_size (abfd
, id4
, 4);
1263 d4
= (unsigned char *) xmalloc (4);
1267 bfd_set_symtab (abfd
, symtab
, symptr
);
1269 bfd_set_section_contents (abfd
, id2
, d2
, 0, 20);
1270 bfd_set_section_contents (abfd
, id5
, d5
, 0, 4);
1271 bfd_set_section_contents (abfd
, id4
, d4
, 0, 4);
1273 bfd_make_readable (abfd
);
1283 * .global __my_dll_iname
1292 asection
*id4
, *id5
, *id7
;
1293 unsigned char *d4
, *d5
, *d7
;
1298 oname
= (char *) xmalloc (20);
1299 sprintf (oname
, "d%06d.o", tmp_seq
);
1302 abfd
= bfd_create (oname
, parent
);
1303 bfd_find_target (pe_details
->object_target
, abfd
);
1304 bfd_make_writable (abfd
);
1306 bfd_set_format (abfd
, bfd_object
);
1307 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1310 symtab
= (asymbol
**) xmalloc (5 * sizeof (asymbol
*));
1311 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1312 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1313 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
1314 quick_symbol (abfd
, U(""), dll_symname
, "_iname", id7
, BSF_GLOBAL
, 0);
1316 bfd_set_section_size (abfd
, id4
, 4);
1317 d4
= (unsigned char *) xmalloc (4);
1321 bfd_set_section_size (abfd
, id5
, 4);
1322 d5
= (unsigned char *) xmalloc (4);
1326 len
= strlen (dll_filename
)+1;
1329 bfd_set_section_size (abfd
, id7
, len
);
1330 d7
= (unsigned char *) xmalloc (len
);
1332 strcpy (d7
, dll_filename
);
1334 bfd_set_symtab (abfd
, symtab
, symptr
);
1336 bfd_set_section_contents (abfd
, id4
, d4
, 0, 4);
1337 bfd_set_section_contents (abfd
, id5
, d5
, 0, 4);
1338 bfd_set_section_contents (abfd
, id7
, d7
, 0, len
);
1340 bfd_make_readable (abfd
);
1347 * .global ___imp_function
1348 * .global __imp__function
1350 * jmp *__imp__function:
1353 * .long __head_my_dll
1364 * .asciz "function" xlate? (add underscore, kill at)
1367 static unsigned char jmp_ix86_bytes
[] = {
1368 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
1377 * .dw __imp_function
1380 static unsigned char jmp_sh_bytes
[] = {
1381 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
1386 * lui $t0,<high:__imp_function>
1387 * lw $t0,<low:__imp_function>
1392 static unsigned char jmp_mips_bytes
[] = {
1393 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
1394 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
1398 make_one (exp
, parent
)
1399 def_file_export
*exp
;
1402 asection
*tx
, *id7
, *id5
, *id4
, *id6
;
1403 unsigned char *td
, *d7
, *d5
, *d4
, *d6
= NULL
;
1407 unsigned char *jmp_bytes
= NULL
;
1408 int jmp_byte_count
= 0;
1410 switch (pe_details
->pe_arch
)
1413 jmp_bytes
= jmp_ix86_bytes
;
1414 jmp_byte_count
= sizeof (jmp_ix86_bytes
);
1417 jmp_bytes
= jmp_sh_bytes
;
1418 jmp_byte_count
= sizeof (jmp_sh_bytes
);
1421 jmp_bytes
= jmp_mips_bytes
;
1422 jmp_byte_count
= sizeof (jmp_mips_bytes
);
1426 oname
= (char *) xmalloc (20);
1427 sprintf (oname
, "d%06d.o", tmp_seq
);
1430 abfd
= bfd_create (oname
, parent
);
1431 bfd_find_target (pe_details
->object_target
, abfd
);
1432 bfd_make_writable (abfd
);
1434 bfd_set_format (abfd
, bfd_object
);
1435 bfd_set_arch_mach (abfd
, pe_details
->bfd_arch
, 0);
1438 symtab
= (asymbol
**) xmalloc (10 * sizeof (asymbol
*));
1439 tx
= quick_section (abfd
, ".text", SEC_CODE
|SEC_HAS_CONTENTS
, 2);
1440 id7
= quick_section (abfd
, ".idata$7", SEC_HAS_CONTENTS
, 2);
1441 id5
= quick_section (abfd
, ".idata$5", SEC_HAS_CONTENTS
, 2);
1442 id4
= quick_section (abfd
, ".idata$4", SEC_HAS_CONTENTS
, 2);
1443 id6
= quick_section (abfd
, ".idata$6", SEC_HAS_CONTENTS
, 2);
1444 if (! exp
->flag_data
)
1445 quick_symbol (abfd
, U(""), exp
->internal_name
, "", tx
, BSF_GLOBAL
, 0);
1446 quick_symbol (abfd
, U("_head_"), dll_symname
, "", UNDSEC
, BSF_GLOBAL
, 0);
1447 quick_symbol (abfd
, U("_imp__"), exp
->internal_name
, "", id5
, BSF_GLOBAL
, 0);
1448 if (pe_dll_compat_implib
)
1449 quick_symbol (abfd
, U("__imp_"), exp
->internal_name
, "",
1450 id5
, BSF_GLOBAL
, 0);
1452 bfd_set_section_size (abfd
, tx
, jmp_byte_count
);
1453 td
= (unsigned char *) xmalloc (jmp_byte_count
);
1455 memcpy (td
, jmp_bytes
, jmp_byte_count
);
1456 switch (pe_details
->pe_arch
)
1459 quick_reloc (abfd
, 2, BFD_RELOC_32
, 2);
1462 quick_reloc (abfd
, 8, BFD_RELOC_32
, 2);
1465 quick_reloc (abfd
, 0, BFD_RELOC_HI16_S
, 2);
1466 quick_reloc (abfd
, 0, BFD_RELOC_LO16
, 0); /* MIPS_R_PAIR */
1467 quick_reloc (abfd
, 4, BFD_RELOC_LO16
, 2);
1472 bfd_set_section_size (abfd
, id7
, 4);
1473 d7
= (unsigned char *) xmalloc (4);
1476 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 6);
1479 bfd_set_section_size (abfd
, id5
, 4);
1480 d5
= (unsigned char *) xmalloc (4);
1483 if (exp
->flag_noname
)
1485 d5
[0] = exp
->ordinal
;
1486 d5
[1] = exp
->ordinal
>> 8;
1491 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
1495 bfd_set_section_size (abfd
, id4
, 4);
1496 d4
= (unsigned char *) xmalloc (4);
1499 if (exp
->flag_noname
)
1501 d5
[0] = exp
->ordinal
;
1502 d5
[1] = exp
->ordinal
>> 8;
1507 quick_reloc (abfd
, 0, BFD_RELOC_RVA
, 4);
1511 if (exp
->flag_noname
)
1514 bfd_set_section_size (abfd
, id6
, 0);
1518 len
= strlen (exp
->name
) + 3;
1521 bfd_set_section_size (abfd
, id6
, len
);
1522 d6
= (unsigned char *) xmalloc (len
);
1524 memset (d6
, 0, len
);
1525 d6
[0] = exp
->hint
& 0xff;
1526 d6
[1] = exp
->hint
>> 8;
1527 strcpy (d6
+2, exp
->name
);
1530 bfd_set_symtab (abfd
, symtab
, symptr
);
1532 bfd_set_section_contents (abfd
, tx
, td
, 0, jmp_byte_count
);
1533 bfd_set_section_contents (abfd
, id7
, d7
, 0, 4);
1534 bfd_set_section_contents (abfd
, id5
, d5
, 0, 4);
1535 bfd_set_section_contents (abfd
, id4
, d4
, 0, 4);
1536 if (!exp
->flag_noname
)
1537 bfd_set_section_contents (abfd
, id6
, d6
, 0, len
);
1539 bfd_make_readable (abfd
);
1544 pe_dll_generate_implib (def
, impfilename
)
1546 const char *impfilename
;
1554 dll_filename
= (def
->name
) ? def
->name
: dll_name
;
1555 dll_symname
= xstrdup (dll_filename
);
1556 for (i
=0; dll_symname
[i
]; i
++)
1557 if (!isalnum ((unsigned char) dll_symname
[i
]))
1558 dll_symname
[i
] = '_';
1560 unlink (impfilename
);
1562 outarch
= bfd_openw (impfilename
, 0);
1566 /* xgettext:c-format */
1567 einfo (_("%XCan't open .lib file: %s\n"), impfilename
);
1571 /* xgettext:c-format */
1572 einfo (_("Creating library file: %s\n"), impfilename
);
1574 bfd_set_format (outarch
, bfd_archive
);
1575 outarch
->has_armap
= 1;
1577 /* Work out a reasonable size of things to put onto one line. */
1579 ar_head
= make_head (outarch
);
1581 for (i
= 0; i
<def
->num_exports
; i
++)
1583 /* The import library doesn't know about the internal name */
1584 char *internal
= def
->exports
[i
].internal_name
;
1586 def
->exports
[i
].internal_name
= def
->exports
[i
].name
;
1587 n
= make_one (def
->exports
+i
, outarch
);
1590 def
->exports
[i
].internal_name
= internal
;
1593 ar_tail
= make_tail (outarch
);
1595 if (ar_head
== NULL
|| ar_tail
== NULL
)
1598 /* Now stick them all into the archive */
1600 ar_head
->next
= head
;
1601 ar_tail
->next
= ar_head
;
1604 if (! bfd_set_archive_head (outarch
, head
))
1605 einfo ("%Xbfd_set_archive_head: %s\n", bfd_errmsg (bfd_get_error ()));
1607 if (! bfd_close (outarch
))
1608 einfo ("%Xbfd_close %s: %s\n", impfilename
, bfd_errmsg (bfd_get_error ()));
1610 while (head
!= NULL
)
1612 bfd
*n
= head
->next
;
1619 add_bfd_to_link (abfd
, name
, link_info
)
1622 struct bfd_link_info
*link_info
;
1624 lang_input_statement_type
*fake_file
;
1625 fake_file
= lang_add_input_file (name
,
1626 lang_input_file_is_fake_enum
,
1628 fake_file
->the_bfd
= abfd
;
1629 ldlang_add_file (fake_file
);
1630 if (!bfd_link_add_symbols (abfd
, link_info
))
1631 einfo ("%Xaddsym %s: %s\n", name
, bfd_errmsg (bfd_get_error ()));
1635 pe_process_import_defs (output_bfd
, link_info
)
1637 struct bfd_link_info
*link_info
;
1639 def_file_module
*module
;
1640 pe_dll_id_target(bfd_get_target (output_bfd
));
1645 for (module
= pe_def_file
->modules
; module
; module
= module
->next
)
1649 dll_filename
= module
->name
;
1650 dll_symname
= xstrdup (module
->name
);
1651 for (i
=0; dll_symname
[i
]; i
++)
1652 if (!isalnum (dll_symname
[i
]))
1653 dll_symname
[i
] = '_';
1657 for (i
=0; i
<pe_def_file
->num_imports
; i
++)
1658 if (pe_def_file
->imports
[i
].module
== module
)
1660 def_file_export exp
;
1661 struct bfd_link_hash_entry
*blhe
;
1663 /* see if we need this import */
1664 char *name
= (char *) xmalloc (strlen (pe_def_file
->imports
[i
].internal_name
) + 2 + 6);
1665 sprintf (name
, "%s%s", U(""), pe_def_file
->imports
[i
].internal_name
);
1666 blhe
= bfd_link_hash_lookup (link_info
->hash
, name
,
1667 false, false, false);
1668 if (!blhe
|| (blhe
&& blhe
->type
!= bfd_link_hash_undefined
))
1670 sprintf (name
, "%s%s", U("_imp__"),
1671 pe_def_file
->imports
[i
].internal_name
);
1672 blhe
= bfd_link_hash_lookup (link_info
->hash
, name
,
1673 false, false, false);
1676 if (blhe
&& blhe
->type
== bfd_link_hash_undefined
)
1682 bfd
*ar_head
= make_head (output_bfd
);
1683 add_bfd_to_link (ar_head
, ar_head
->filename
, link_info
);
1686 exp
.internal_name
= pe_def_file
->imports
[i
].internal_name
;
1687 exp
.name
= pe_def_file
->imports
[i
].name
;
1688 exp
.ordinal
= pe_def_file
->imports
[i
].ordinal
;
1689 exp
.hint
= exp
.ordinal
>= 0 ? exp
.ordinal
: 0;
1690 exp
.flag_private
= 0;
1691 exp
.flag_constant
= 0;
1693 exp
.flag_noname
= exp
.name
? 0 : 1;
1694 one
= make_one (&exp
, output_bfd
);
1695 add_bfd_to_link (one
, one
->filename
, link_info
);
1700 bfd
*ar_tail
= make_tail (output_bfd
);
1701 add_bfd_to_link (ar_tail
, ar_tail
->filename
, link_info
);
1708 /************************************************************************
1710 We were handed a *.DLL file. Parse it and turn it into a set of
1711 IMPORTS directives in the def file. Return true if the file was
1712 handled, false if not.
1714 ************************************************************************/
1717 pe_get16 (abfd
, where
)
1722 bfd_seek (abfd
, where
, SEEK_SET
);
1723 bfd_read (b
, 1, 2, abfd
);
1724 return b
[0] + (b
[1]<<8);
1728 pe_get32 (abfd
, where
)
1733 bfd_seek (abfd
, where
, SEEK_SET
);
1734 bfd_read (b
, 1, 4, abfd
);
1735 return b
[0] + (b
[1]<<8) + (b
[2]<<16) + (b
[3]<<24);
1738 #if 0 /* This is not currently used. */
1744 unsigned char *b
= ptr
;
1745 return b
[0] + (b
[1]<<8);
1754 unsigned char *b
= ptr
;
1755 return b
[0] + (b
[1]<<8) + (b
[2]<<16) + (b
[3]<<24);
1759 pe_implied_import_dll (filename
)
1760 const char *filename
;
1763 unsigned long pe_header_offset
, opthdr_ofs
, num_entries
, i
;
1764 unsigned long export_rva
, export_size
, nsections
, secptr
, expptr
;
1765 unsigned char *expdata
, *erva
;
1766 unsigned long name_rvas
, ordinals
, nexp
, ordbase
;
1767 const char *dll_name
;
1769 /* No, I can't use bfd here. kernel32.dll puts its export table in
1770 the middle of the .rdata section. */
1772 dll
= bfd_openr (filename
, pe_details
->target_name
);
1775 einfo ("%Xopen %s: %s\n", filename
, bfd_errmsg (bfd_get_error ()));
1778 /* PEI dlls seem to be bfd_objects */
1779 if (!bfd_check_format (dll
, bfd_object
))
1781 einfo ("%X%s: this doesn't appear to be a DLL\n", filename
);
1785 dll_name
= filename
;
1786 for (i
=0; filename
[i
]; i
++)
1787 if (filename
[i
] == '/' || filename
[i
] == '\\' || filename
[i
] == ':')
1788 dll_name
= filename
+ i
+ 1;
1790 pe_header_offset
= pe_get32 (dll
, 0x3c);
1791 opthdr_ofs
= pe_header_offset
+ 4 + 20;
1792 num_entries
= pe_get32 (dll
, opthdr_ofs
+ 92);
1793 if (num_entries
< 1) /* no exports */
1795 export_rva
= pe_get32 (dll
, opthdr_ofs
+ 96);
1796 export_size
= pe_get32 (dll
, opthdr_ofs
+ 100);
1797 nsections
= pe_get16 (dll
, pe_header_offset
+ 4 + 2);
1798 secptr
= (pe_header_offset
+ 4 + 20 +
1799 pe_get16 (dll
, pe_header_offset
+ 4 + 16));
1801 for (i
=0; i
<nsections
; i
++)
1804 unsigned long secptr1
= secptr
+ 40 * i
;
1805 unsigned long vaddr
= pe_get32 (dll
, secptr1
+ 12);
1806 unsigned long vsize
= pe_get32 (dll
, secptr1
+ 16);
1807 unsigned long fptr
= pe_get32 (dll
, secptr1
+ 20);
1808 bfd_seek(dll
, secptr1
, SEEK_SET
);
1809 bfd_read(sname
, 1, 8, dll
);
1810 if (vaddr
<= export_rva
&& vaddr
+vsize
> export_rva
)
1812 expptr
= fptr
+ (export_rva
- vaddr
);
1813 if (export_rva
+ export_size
> vaddr
+ vsize
)
1814 export_size
= vsize
- (export_rva
- vaddr
);
1819 expdata
= (unsigned char *) xmalloc (export_size
);
1820 bfd_seek (dll
, expptr
, SEEK_SET
);
1821 bfd_read (expdata
, 1, export_size
, dll
);
1822 erva
= expdata
- export_rva
;
1824 if (pe_def_file
== 0)
1825 pe_def_file
= def_file_empty();
1827 nexp
= pe_as32 (expdata
+24);
1828 name_rvas
= pe_as32 (expdata
+32);
1829 ordinals
= pe_as32 (expdata
+36);
1830 ordbase
= pe_as32 (expdata
+16);
1831 for (i
=0; i
<nexp
; i
++)
1833 unsigned long name_rva
= pe_as32 (erva
+name_rvas
+i
*4);
1834 def_file_import
*imp
;
1835 imp
= def_file_add_import (pe_def_file
, erva
+name_rva
, dll_name
,
1842 /************************************************************************
1844 These are the main functions, called from the emulation. The first
1845 is called after the bfds are read, so we can guess at how much space
1846 we need. The second is called after everything is placed, so we
1847 can put the right values in place.
1849 ************************************************************************/
1852 pe_dll_build_sections (abfd
, info
)
1854 struct bfd_link_info
*info
;
1856 pe_dll_id_target (bfd_get_target (abfd
));
1857 process_def_file (abfd
, info
);
1859 generate_edata (abfd
, info
);
1860 build_filler_bfd (1);
1864 pe_exe_build_sections (abfd
, info
)
1866 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1868 pe_dll_id_target (bfd_get_target (abfd
));
1869 build_filler_bfd (0);
1873 pe_dll_fill_sections (abfd
, info
)
1875 struct bfd_link_info
*info
;
1877 pe_dll_id_target (bfd_get_target (abfd
));
1878 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
1880 generate_reloc (abfd
, info
);
1883 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
1885 /* Resize the sections. */
1886 lang_size_sections (stat_ptr
->head
, abs_output_section
,
1887 &stat_ptr
->head
, 0, (bfd_vma
) 0, false);
1889 /* Redo special stuff. */
1890 ldemul_after_allocation ();
1892 /* Do the assignments again. */
1893 lang_do_assignments (stat_ptr
->head
,
1895 (fill_type
) 0, (bfd_vma
) 0);
1898 fill_edata (abfd
, info
);
1900 pe_data (abfd
)->dll
= 1;
1902 edata_s
->contents
= edata_d
;
1903 reloc_s
->contents
= reloc_d
;
1907 pe_exe_fill_sections (abfd
, info
)
1909 struct bfd_link_info
*info
;
1911 pe_dll_id_target (bfd_get_target (abfd
));
1912 image_base
= pe_data (abfd
)->pe_opthdr
.ImageBase
;
1914 generate_reloc (abfd
, info
);
1917 bfd_set_section_size (filler_bfd
, reloc_s
, reloc_sz
);
1919 /* Resize the sections. */
1920 lang_size_sections (stat_ptr
->head
, abs_output_section
,
1921 &stat_ptr
->head
, 0, (bfd_vma
) 0, false);
1923 /* Redo special stuff. */
1924 ldemul_after_allocation ();
1926 /* Do the assignments again. */
1927 lang_do_assignments (stat_ptr
->head
,
1929 (fill_type
) 0, (bfd_vma
) 0);
1931 reloc_s
->contents
= reloc_d
;