projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2000-02-27 Mark Elbrecht <snowball3@bigfoot.com>
[deliverable/binutils-gdb.git] / ld / pe-dll.c
CommitLineData
252b5132 1/* Routines to help build PEI-format DLLs (Win32 etc)
a6483292 2 Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
252b5132
RH		 3 Written by DJ Delorie <dj@cygnus.com>
4
5 This file is part of GLD, the Gnu Linker.
6
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)
10 any later version.
11
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.
16
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
20 02111-1307, USA. */
21
22#include "bfd.h"
23#include "sysdep.h"
24#include "bfdlink.h"
25#include "libiberty.h"
26
27#include <time.h>
28#include <ctype.h>
29
30#include "ld.h"
31#include "ldexp.h"
32#include "ldlang.h"
33#include "ldwrite.h"
34#include "ldmisc.h"
35#include "ldgram.h"
36#include "ldmain.h"
37#include "ldemul.h"
38#include "coff/internal.h"
39#include "../bfd/libcoff.h"
40#include "deffile.h"
1069dd8d 41#include "pe-dll.h"
252b5132
RH		 42
43/************************************************************************
44
45 This file turns a regular Windows PE image into a DLL. Because of
46 the complexity of this operation, it has been broken down into a
47 number of separate modules which are all called by the main function
48 at the end of this file. This function is not re-entrant and is
49 normally only called once, so static variables are used to reduce
50 the number of parameters and return values required.
51
52 See also: ld/emultempl/pe.em
53
54 ************************************************************************/
55
56/* for emultempl/pe.em */
57
58def_file *pe_def_file = 0;
59int pe_dll_export_everything = 0;
60int pe_dll_do_default_excludes = 1;
61int pe_dll_kill_ats = 0;
62int pe_dll_stdcall_aliases = 0;
870df5dc
NC		 63int pe_dll_warn_dup_exports = 0;
64int pe_dll_compat_implib = 0;
252b5132
RH		 65
66/************************************************************************
67
68 static variables and types
69
70 ************************************************************************/
71
72static bfd_vma image_base;
73
74static bfd *filler_bfd;
75static struct sec *edata_s, *reloc_s;
76static unsigned char *edata_d, *reloc_d;
1069dd8d 77static size_t edata_sz, reloc_sz;
252b5132 78
c6c37250
DD		 79typedef struct {
80 char *target_name;
81 char *object_target;
1069dd8d 82 unsigned int imagebase_reloc;
c6c37250
DD		 83 int pe_arch;
84 int bfd_arch;
85 int underscored;
86} pe_details_type;
87
88#define PE_ARCH_i386 1
344a211f
NC		 89#define PE_ARCH_sh 2
90#define PE_ARCH_mips 3
91#define PE_ARCH_arm 4
c6c37250
DD		 92
93static pe_details_type pe_detail_list[] = {
94 {
95 "pei-i386",
96 "pe-i386",
97 7 /* R_IMAGEBASE */,
98 PE_ARCH_i386,
99 bfd_arch_i386,
100 1
101 },
344a211f
NC		 102 {
103 "pei-shl",
104 "pe-shl",
105 16 /* R_SH_IMAGEBASE */,
106 PE_ARCH_sh,
107 bfd_arch_sh,
108 1
109 },
110 {
111 "pei-mips",
112 "pe-mips",
113 34 /* MIPS_R_RVA */,
114 PE_ARCH_mips,
115 bfd_arch_mips,
116 0
117 },
118 {
119 "pei-arm-little",
120 "pe-arm-little",
121 11 /* ARM_RVA32 */,
122 PE_ARCH_arm,
123 bfd_arch_arm,
124 0
125 },
1069dd8d 126 { NULL, NULL, 0, 0, 0, 0 }
c6c37250
DD		 127};
128
129static pe_details_type *pe_details;
130
131#define U(str) (pe_details->underscored ? "_" str : str)
132
133void
134pe_dll_id_target (target)
1069dd8d 135 const char *target;
c6c37250
DD		 136{
137 int i;
138 for (i=0; pe_detail_list[i].target_name; i++)
139 if (strcmp (pe_detail_list[i].target_name, target) == 0)
140 {
141 pe_details = pe_detail_list+i;
142 return;
143 }
144 einfo (_("%XUnsupported PEI architecture: %s\n"), target);
145 exit (1);
146}
147
252b5132
RH		 148/************************************************************************
149
150 Helper functions for qsort. Relocs must be sorted so that we can write
151 them out by pages.
152
153 ************************************************************************/
154
c6c37250
DD		 155typedef struct {
156 bfd_vma vma;
157 char type;
158 short extra;
159} reloc_data_type;
160
252b5132
RH		 161static int
162reloc_sort (va, vb)
163 const void *va, *vb;
164{
c6c37250
DD		 165 bfd_vma a = ((reloc_data_type *) va)->vma;
166 bfd_vma b = ((reloc_data_type *) vb)->vma;
167 return (a > b) ? 1 : ((a < b) ? -1 : 0);
252b5132
RH		 168}
169
170static int
171pe_export_sort (va, vb)
172 const void *va, *vb;
173{
174 def_file_export *a = (def_file_export *) va;
175 def_file_export *b = (def_file_export *) vb;
176 return strcmp (a->name, b->name);
177}
178
179/************************************************************************
180
181 Read and process the .DEF file
182
183 ************************************************************************/
184
185/* These correspond to the entries in pe_def_file->exports[]. I use
186 exported_symbol_sections[i] to tag whether or not the symbol was
187 defined, since we can't export symbols we don't have. */
188
189static bfd_vma *exported_symbol_offsets;
190static struct sec **exported_symbol_sections;
191
192static int export_table_size;
193static int count_exported;
194static int count_exported_byname;
195static int count_with_ordinals;
196static const char *dll_name;
197static int min_ordinal, max_ordinal;
198static int *exported_symbols;
199
200typedef struct exclude_list_struct
201 {
202 char *string;
203 struct exclude_list_struct *next;
204 }
205exclude_list_struct;
206static struct exclude_list_struct *excludes = 0;
207
208void
209pe_dll_add_excludes (new_excludes)
210 const char *new_excludes;
211{
212 char *local_copy;
213 char *exclude_string;
214
215 local_copy = xstrdup (new_excludes);
216
217 exclude_string = strtok (local_copy, ",:");
218 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
219 {
220 struct exclude_list_struct *new_exclude;
221
222 new_exclude = ((struct exclude_list_struct *)
223 xmalloc (sizeof (struct exclude_list_struct)));
224 new_exclude->string = (char *) xmalloc (strlen (exclude_string) + 1);
225 strcpy (new_exclude->string, exclude_string);
226 new_exclude->next = excludes;
227 excludes = new_exclude;
228 }
229
230 free (local_copy);
231}
232
233static int
234auto_export (d, n)
235 def_file *d;
236 const char *n;
237{
238 int i;
239 struct exclude_list_struct *ex;
240 for (i = 0; i < d->num_exports; i++)
241 if (strcmp (d->exports[i].name, n) == 0)
242 return 0;
243 if (pe_dll_do_default_excludes)
244 {
245 if (strcmp (n, "DllMain@12") == 0)
246 return 0;
247 if (strcmp (n, "DllEntryPoint@0") == 0)
248 return 0;
249 if (strcmp (n, "impure_ptr") == 0)
250 return 0;
251 }
252 for (ex = excludes; ex; ex = ex->next)
253 if (strcmp (n, ex->string) == 0)
254 return 0;
255 return 1;
256}
257
258static void
259process_def_file (abfd, info)
1069dd8d 260 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 261 struct bfd_link_info *info;
262{
263 int i, j;
264 struct bfd_link_hash_entry *blhe;
265 bfd *b;
266 struct sec *s;
267 def_file_export *e=0;
268
269 if (!pe_def_file)
270 pe_def_file = def_file_empty ();
271
272 /* First, run around to all the objects looking for the .drectve
273 sections, and push those into the def file too */
274
275 for (b = info->input_bfds; b; b = b->link_next)
276 {
277 s = bfd_get_section_by_name (b, ".drectve");
278 if (s)
279 {
280 int size = bfd_get_section_size_before_reloc (s);
281 char *buf = xmalloc (size);
282 bfd_get_section_contents (b, s, buf, 0, size);
283 def_file_add_directive (pe_def_file, buf, size);
284 free (buf);
285 }
286 }
287
288 /* Now, maybe export everything else the default way */
289
290 if (pe_dll_export_everything || pe_def_file->num_exports == 0)
291 {
292 for (b = info->input_bfds; b; b = b->link_next)
293 {
294 asymbol **symbols;
295 int nsyms, symsize;
296
297 symsize = bfd_get_symtab_upper_bound (b);
298 symbols = (asymbol **) xmalloc (symsize);
299 nsyms = bfd_canonicalize_symtab (b, symbols);
300
301 for (j = 0; j < nsyms; j++)
302 {
303 if ((symbols[j]->flags & (BSF_FUNCTION | BSF_GLOBAL))
304 == (BSF_FUNCTION | BSF_GLOBAL))
305 {
306 const char *sn = symbols[j]->name;
307 if (*sn == '_')
308 sn++;
309 if (auto_export (pe_def_file, sn))
310 def_file_add_export (pe_def_file, sn, 0, -1);
311 }
312 }
313 }
314 }
315
316#undef NE
317#define NE pe_def_file->num_exports
318
319 /* Canonicalize the export list */
320
321 if (pe_dll_kill_ats)
322 {
323 for (i = 0; i < NE; i++)
324 {
325 if (strchr (pe_def_file->exports[i].name, '@'))
326 {
327 /* This will preserve internal_name, which may have been pointing
328 to the same memory as name, or might not have */
329 char *tmp = xstrdup (pe_def_file->exports[i].name);
330 *(strchr (tmp, '@')) = 0;
331 pe_def_file->exports[i].name = tmp;
332 }
333 }
334 }
335
336 if (pe_dll_stdcall_aliases)
337 {
338 for (i = 0; i < NE; i++)
339 {
340 if (strchr (pe_def_file->exports[i].name, '@'))
341 {
342 char *tmp = xstrdup (pe_def_file->exports[i].name);
343 *(strchr (tmp, '@')) = 0;
344 if (auto_export (pe_def_file, tmp))
345 def_file_add_export (pe_def_file, tmp,
346 pe_def_file->exports[i].internal_name, -1);
347 else
348 free (tmp);
349 }
350 }
351 }
352
353 e = pe_def_file->exports; /* convenience, but watch out for it changing */
354
355 exported_symbol_offsets = (bfd_vma *) xmalloc (NE * sizeof (bfd_vma));
356 exported_symbol_sections = (struct sec **) xmalloc (NE * sizeof (struct sec *));
357
358 memset (exported_symbol_sections, 0, NE * sizeof (struct sec *));
359 max_ordinal = 0;
360 min_ordinal = 65536;
361 count_exported = 0;
362 count_exported_byname = 0;
363 count_with_ordinals = 0;
364
365 qsort (pe_def_file->exports, NE, sizeof (pe_def_file->exports[0]), pe_export_sort);
366 for (i = 0, j = 0; i < NE; i++)
367 {
368 if (i > 0 && strcmp (e[i].name, e[i - 1].name) == 0)
369 {
870df5dc 370 /* This is a duplicate. */
252b5132
RH		 371 if (e[j - 1].ordinal != -1
372 && e[i].ordinal != -1
373 && e[j - 1].ordinal != e[i].ordinal)
374 {
870df5dc
NC		 375 if (pe_dll_warn_dup_exports)
376 /* xgettext:c-format */
377 einfo (_("%XError, duplicate EXPORT with oridinals: %s (%d vs %d)\n"),
378 e[j - 1].name, e[j - 1].ordinal, e[i].ordinal);
252b5132
RH		 379 }
380 else
381 {
870df5dc
NC		 382 if (pe_dll_warn_dup_exports)
383 /* xgettext:c-format */
384 einfo (_("Warning, duplicate EXPORT: %s\n"),
385 e[j - 1].name);
252b5132
RH		 386 }
387 if (e[i].ordinal)
388 e[j - 1].ordinal = e[i].ordinal;
389 e[j - 1].flag_private |= e[i].flag_private;
390 e[j - 1].flag_constant |= e[i].flag_constant;
391 e[j - 1].flag_noname |= e[i].flag_noname;
392 e[j - 1].flag_data |= e[i].flag_data;
393 }
394 else
395 {
396 if (i != j)
397 e[j] = e[i];
398 j++;
399 }
400 }
401 pe_def_file->num_exports = j; /* == NE */
402
403 for (i = 0; i < NE; i++)
404 {
405 char *name = (char *) xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
c6c37250
DD		 406 if (pe_details->underscored)
407 {
408 *name = '_';
409 strcpy (name + 1, pe_def_file->exports[i].internal_name);
410 }
411 else
412 strcpy (name, pe_def_file->exports[i].internal_name);
252b5132
RH		 413
414 blhe = bfd_link_hash_lookup (info->hash,
415 name,
416 false, false, true);
417
8a5b676c
DD		 418 if (blhe
419 && (blhe->type == bfd_link_hash_defined
420 || (blhe->type == bfd_link_hash_common)))
252b5132
RH		 421 {
422 count_exported++;
423 if (!pe_def_file->exports[i].flag_noname)
424 count_exported_byname++;
8a5b676c
DD		 425
426 /* Only fill in the sections. The actual offsets are computed
427 in fill_exported_offsets() after common symbols are laid
428 out. */
429 if (blhe->type == bfd_link_hash_defined)
430 exported_symbol_sections[i] = blhe->u.def.section;
431 else
432 exported_symbol_sections[i] = blhe->u.c.p->section;
344a211f 433
252b5132
RH		 434 if (pe_def_file->exports[i].ordinal != -1)
435 {
436 if (max_ordinal < pe_def_file->exports[i].ordinal)
437 max_ordinal = pe_def_file->exports[i].ordinal;
438 if (min_ordinal > pe_def_file->exports[i].ordinal)
439 min_ordinal = pe_def_file->exports[i].ordinal;
440 count_with_ordinals++;
441 }
442 }
443 else if (blhe && blhe->type == bfd_link_hash_undefined)
444 {
445 /* xgettext:c-format */
446 einfo (_("%XCannot export %s: symbol not defined\n"),
447 pe_def_file->exports[i].internal_name);
448 }
449 else if (blhe)
450 {
451 /* xgettext:c-format */
452 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
453 pe_def_file->exports[i].internal_name,
454 blhe->type, bfd_link_hash_defined);
455 }
456 else
457 {
458 /* xgettext:c-format */
459 einfo (_("%XCannot export %s: symbol not found\n"),
460 pe_def_file->exports[i].internal_name);
461 }
462 free (name);
463 }
464}
465
466/************************************************************************
467
468 Build the bfd that will contain .edata and .reloc sections
469
470 ************************************************************************/
471
472static void
c6c37250
DD		 473build_filler_bfd (include_edata)
474 int include_edata;
252b5132
RH		 475{
476 lang_input_statement_type *filler_file;
477 filler_file = lang_add_input_file ("dll stuff",
478 lang_input_file_is_fake_enum,
479 NULL);
480 filler_file->the_bfd = filler_bfd = bfd_create ("dll stuff", output_bfd);
481 if (filler_bfd == NULL
482 || !bfd_set_arch_mach (filler_bfd,
483 bfd_get_arch (output_bfd),
484 bfd_get_mach (output_bfd)))
485 {
486 einfo ("%X%P: can not create BFD %E\n");
487 return;
488 }
489
c6c37250 490 if (include_edata)
252b5132 491 {
c6c37250
DD		 492 edata_s = bfd_make_section_old_way (filler_bfd, ".edata");
493 if (edata_s == NULL
494 || !bfd_set_section_flags (filler_bfd, edata_s,
495 (SEC_HAS_CONTENTS
496 | SEC_ALLOC
497 | SEC_LOAD
498 | SEC_KEEP
499 | SEC_IN_MEMORY)))
500 {
501 einfo ("%X%P: can not create .edata section: %E\n");
502 return;
503 }
504 bfd_set_section_size (filler_bfd, edata_s, edata_sz);
252b5132 505 }
252b5132
RH		 506
507 reloc_s = bfd_make_section_old_way (filler_bfd, ".reloc");
508 if (reloc_s == NULL
509 || !bfd_set_section_flags (filler_bfd, reloc_s,
510 (SEC_HAS_CONTENTS
511 | SEC_ALLOC
512 | SEC_LOAD
513 | SEC_KEEP
514 | SEC_IN_MEMORY)))
515 {
516 einfo ("%X%P: can not create .reloc section: %E\n");
517 return;
518 }
519 bfd_set_section_size (filler_bfd, reloc_s, 0);
520
521 ldlang_add_file (filler_file);
522}
523
524/************************************************************************
525
526 Gather all the exported symbols and build the .edata section
527
528 ************************************************************************/
529
530static void
531generate_edata (abfd, info)
532 bfd *abfd;
1069dd8d 533 struct bfd_link_info *info ATTRIBUTE_UNUSED;
252b5132
RH		 534{
535 int i, next_ordinal;
536 int name_table_size = 0;
537 const char *dlnp;
538
539 /* First, we need to know how many exported symbols there are,
540 and what the range of ordinals is. */
541
542 if (pe_def_file->name)
543 {
544 dll_name = pe_def_file->name;
545 }
546 else
547 {
548 dll_name = abfd->filename;
549 for (dlnp = dll_name; *dlnp; dlnp++)
550 {
551 if (*dlnp == '\\' || *dlnp == '/' || *dlnp == ':')
552 dll_name = dlnp + 1;
553 }
554 }
555
556 if (count_with_ordinals && max_ordinal > count_exported)
557 {
558 if (min_ordinal > max_ordinal - count_exported + 1)
559 min_ordinal = max_ordinal - count_exported + 1;
560 }
561 else
562 {
563 min_ordinal = 1;
564 max_ordinal = count_exported;
565 }
566 export_table_size = max_ordinal - min_ordinal + 1;
567
568 exported_symbols = (int *) xmalloc (export_table_size * sizeof (int));
569 for (i = 0; i < export_table_size; i++)
570 exported_symbols[i] = -1;
571
572 /* Now we need to assign ordinals to those that don't have them */
573 for (i = 0; i < NE; i++)
574 {
575 if (exported_symbol_sections[i])
576 {
577 if (pe_def_file->exports[i].ordinal != -1)
578 {
579 int ei = pe_def_file->exports[i].ordinal - min_ordinal;
580 int pi = exported_symbols[ei];
581 if (pi != -1)
582 {
583 /* xgettext:c-format */
584 einfo (_("%XError, oridinal used twice: %d (%s vs %s)\n"),
585 pe_def_file->exports[i].ordinal,
586 pe_def_file->exports[i].name,
587 pe_def_file->exports[pi].name);
588 }
589 exported_symbols[ei] = i;
590 }
591 name_table_size += strlen (pe_def_file->exports[i].name) + 1;
592 }
593 }
594
595 next_ordinal = min_ordinal;
596 for (i = 0; i < NE; i++)
597 if (exported_symbol_sections[i])
598 if (pe_def_file->exports[i].ordinal == -1)
599 {
600 while (exported_symbols[next_ordinal - min_ordinal] != -1)
601 next_ordinal++;
602 exported_symbols[next_ordinal - min_ordinal] = i;
603 pe_def_file->exports[i].ordinal = next_ordinal;
604 }
605
606 /* OK, now we can allocate some memory */
607
608 edata_sz = (40 /* directory */
609 + 4 * export_table_size /* addresses */
610 + 4 * count_exported_byname /* name ptrs */
611 + 2 * count_exported_byname /* ordinals */
612 + name_table_size + strlen (dll_name) + 1);
613}
614
8a5b676c
DD		 615/* Fill the exported symbol offsets. The preliminary work has already
616 been done in process_def_file(). */
617
618static void
619fill_exported_offsets (abfd, info)
620 bfd *abfd;
621 struct bfd_link_info *info;
622{
623 int i, j;
624 struct bfd_link_hash_entry *blhe;
625 bfd *b;
626 struct sec *s;
627 def_file_export *e=0;
628
629 for (i = 0; i < pe_def_file->num_exports; i++)
630 {
631 char *name = (char *) xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
632 if (pe_details->underscored)
633 {
634 *name = '_';
635 strcpy (name + 1, pe_def_file->exports[i].internal_name);
636 }
637 else
638 strcpy (name, pe_def_file->exports[i].internal_name);
639
640 blhe = bfd_link_hash_lookup (info->hash,
641 name,
642 false, false, true);
643
644 if (blhe && (blhe->type == bfd_link_hash_defined))
645 {
646 exported_symbol_offsets[i] = blhe->u.def.value;
647 }
648 free (name);
649 }
650}
651
252b5132
RH		 652static void
653fill_edata (abfd, info)
654 bfd *abfd;
1069dd8d 655 struct bfd_link_info *info ATTRIBUTE_UNUSED;
252b5132
RH		 656{
657 int i, hint;
658 unsigned char *edirectory;
659 unsigned long *eaddresses;
660 unsigned long *enameptrs;
661 unsigned short *eordinals;
662 unsigned char *enamestr;
663 time_t now;
664
665 time (&now);
666
667 edata_d = (unsigned char *) xmalloc (edata_sz);
668
669 /* Note use of array pointer math here */
670 edirectory = edata_d;
671 eaddresses = (unsigned long *) (edata_d + 40);
672 enameptrs = eaddresses + export_table_size;
673 eordinals = (unsigned short *) (enameptrs + count_exported_byname);
674 enamestr = (char *) (eordinals + count_exported_byname);
675
676#define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) + edata_s->output_section->vma - image_base)
677
678 memset (edata_d, 0, 40);
679 bfd_put_32 (abfd, now, edata_d + 4);
680 if (pe_def_file->version_major != -1)
681 {
682 bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8);
683 bfd_put_16 (abfd, pe_def_file->version_minor, edata_d + 10);
684 }
685 bfd_put_32 (abfd, ERVA (enamestr), edata_d + 12);
686 strcpy (enamestr, dll_name);
687 enamestr += strlen (enamestr) + 1;
688 bfd_put_32 (abfd, min_ordinal, edata_d + 16);
689 bfd_put_32 (abfd, export_table_size, edata_d + 20);
690 bfd_put_32 (abfd, count_exported_byname, edata_d + 24);
691 bfd_put_32 (abfd, ERVA (eaddresses), edata_d + 28);
692 bfd_put_32 (abfd, ERVA (enameptrs), edata_d + 32);
693 bfd_put_32 (abfd, ERVA (eordinals), edata_d + 36);
694
8a5b676c
DD		 695 fill_exported_offsets (abfd, info);
696
252b5132
RH		 697 /* Ok, now for the filling in part */
698 hint = 0;
699 for (i = 0; i < export_table_size; i++)
700 {
701 int s = exported_symbols[i];
702 if (s != -1)
703 {
704 struct sec *ssec = exported_symbol_sections[s];
705 unsigned long srva = (exported_symbol_offsets[s]
706 + ssec->output_section->vma
707 + ssec->output_offset);
708
709 bfd_put_32 (abfd, srva - image_base, (void *) (eaddresses + i));
710 if (!pe_def_file->exports[s].flag_noname)
711 {
712 char *ename = pe_def_file->exports[s].name;
713 bfd_put_32 (abfd, ERVA (enamestr), (void *) enameptrs);
714 strcpy (enamestr, ename);
715 enamestr += strlen (enamestr) + 1;
716 bfd_put_16 (abfd, i, (void *) eordinals);
717 enameptrs++;
718 pe_def_file->exports[s].hint = hint++;
719 }
720 eordinals++;
721 }
722 }
723}
724
725/************************************************************************
726
727 Gather all the relocations and build the .reloc section
728
729 ************************************************************************/
730
731static void
732generate_reloc (abfd, info)
733 bfd *abfd;
734 struct bfd_link_info *info;
735{
736
737 /* for .reloc stuff */
c6c37250 738 reloc_data_type *reloc_data;
252b5132
RH		 739 int total_relocs = 0;
740 int i;
741 unsigned long sec_page = (unsigned long) (-1);
742 unsigned long page_ptr, page_count;
743 int bi;
744 bfd *b;
745 struct sec *s;
746
747 total_relocs = 0;
748 for (b = info->input_bfds; b; b = b->link_next)
749 for (s = b->sections; s; s = s->next)
750 total_relocs += s->reloc_count;
751
c6c37250 752 reloc_data = (reloc_data_type *) xmalloc (total_relocs * sizeof (reloc_data_type));
252b5132
RH		 753
754 total_relocs = 0;
755 bi = 0;
756 for (bi = 0, b = info->input_bfds; b; bi++, b = b->link_next)
757 {
758 arelent **relocs;
759 int relsize, nrelocs, i;
760
761 for (s = b->sections; s; s = s->next)
762 {
763 unsigned long sec_vma = s->output_section->vma + s->output_offset;
764 asymbol **symbols;
765 int nsyms, symsize;
766
767 /* if it's not loaded, we don't need to relocate it this way */
768 if (!(s->output_section->flags & SEC_LOAD))
769 continue;
770
771 /* I don't know why there would be a reloc for these, but I've
772 seen it happen - DJ */
773 if (s->output_section == &bfd_abs_section)
774 continue;
775
776 if (s->output_section->vma == 0)
777 {
778 /* Huh? Shouldn't happen, but punt if it does */
779 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
780 s->output_section->name, s->output_section->index,
781 s->output_section->flags);
782 continue;
783 }
784
785 symsize = bfd_get_symtab_upper_bound (b);
786 symbols = (asymbol **) xmalloc (symsize);
787 nsyms = bfd_canonicalize_symtab (b, symbols);
788
789 relsize = bfd_get_reloc_upper_bound (b, s);
790 relocs = (arelent **) xmalloc ((size_t) relsize);
791 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
792
793 for (i = 0; i < nrelocs; i++)
794 {
795 if (!relocs[i]->howto->pc_relative
c6c37250 796 && relocs[i]->howto->type != pe_details->imagebase_reloc)
252b5132 797 {
c6c37250
DD		 798 bfd_vma sym_vma;
799 struct symbol_cache_entry *sym = *relocs[i]->sym_ptr_ptr;
800 sym_vma = (relocs[i]->addend
801 + sym->value
802 + sym->section->vma
803 + sym->section->output_offset
804 + sym->section->output_section->vma);
805 reloc_data[total_relocs].vma = sec_vma + relocs[i]->address;
344a211f
NC		 806
807#define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
808
809 switch BITS_AND_SHIFT (relocs[i]->howto->bitsize,
810 relocs[i]->howto->rightshift)
252b5132 811 {
344a211f 812 case BITS_AND_SHIFT (32, 0):
c6c37250
DD		 813 reloc_data[total_relocs].type = 3;
814 total_relocs++;
252b5132 815 break;
344a211f
NC		 816 case BITS_AND_SHIFT (16, 0):
817 reloc_data[total_relocs].type = 2;
818 total_relocs++;
819 break;
820 case BITS_AND_SHIFT (16, 16):
821 reloc_data[total_relocs].type = 4;
822 /* FIXME: we can't know the symbol's right value yet,
823 but we probably can safely assume that CE will relocate
824 us in 64k blocks, so leaving it zero is safe. */
825 reloc_data[total_relocs].extra = 0;
826 total_relocs++;
827 break;
828 case BITS_AND_SHIFT (26, 2):
829 reloc_data[total_relocs].type = 5;
830 total_relocs++;
831 break;
252b5132
RH		 832 default:
833 /* xgettext:c-format */
834 einfo (_("%XError: %d-bit reloc in dll\n"),
835 relocs[i]->howto->bitsize);
836 break;
837 }
838 }
839 }
840 free (relocs);
841 /* Warning: the allocated symbols are remembered in BFD and reused
842 later, so don't free them! */
843 /* free (symbols); */
844 }
845 }
846
847 /* At this point, we have total_relocs relocation addresses in
848 reloc_addresses, which are all suitable for the .reloc section.
849 We must now create the new sections. */
850
c6c37250 851 qsort (reloc_data, total_relocs, sizeof (*reloc_data), reloc_sort);
252b5132
RH		 852
853 for (i = 0; i < total_relocs; i++)
854 {
c6c37250 855 unsigned long this_page = (reloc_data[i].vma >> 12);
344a211f 856
252b5132
RH		 857 if (this_page != sec_page)
858 {
859 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align */
860 reloc_sz += 8;
861 sec_page = this_page;
862 }
344a211f 863
252b5132 864 reloc_sz += 2;
344a211f
NC		 865
866 if (reloc_data[i].type == 4)
867 reloc_sz += 2;
252b5132
RH		 868 }
869 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align */
870
871 reloc_d = (unsigned char *) xmalloc (reloc_sz);
872
873 sec_page = (unsigned long) (-1);
874 reloc_sz = 0;
875 page_ptr = (unsigned long) (-1);
876 page_count = 0;
877 for (i = 0; i < total_relocs; i++)
878 {
c6c37250 879 unsigned long rva = reloc_data[i].vma - image_base;
252b5132
RH		 880 unsigned long this_page = (rva & ~0xfff);
881 if (this_page != sec_page)
882 {
883 while (reloc_sz & 3)
884 reloc_d[reloc_sz++] = 0;
885 if (page_ptr != (unsigned long) (-1))
886 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
887 bfd_put_32 (abfd, this_page, reloc_d + reloc_sz);
888 page_ptr = reloc_sz;
889 reloc_sz += 8;
890 sec_page = this_page;
891 page_count = 0;
892 }
c6c37250
DD		 893 bfd_put_16 (abfd, (rva & 0xfff) + (reloc_data[i].type<<12),
894 reloc_d + reloc_sz);
252b5132 895 reloc_sz += 2;
c6c37250
DD		 896 if (reloc_data[i].type == 4)
897 {
898 bfd_put_16 (abfd, reloc_data[i].extra, reloc_d + reloc_sz);
899 reloc_sz += 2;
900 }
252b5132
RH		 901 page_count++;
902 }
903 while (reloc_sz & 3)
904 reloc_d[reloc_sz++] = 0;
905 if (page_ptr != (unsigned long) (-1))
906 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
907 while (reloc_sz < reloc_s->_raw_size)
908 reloc_d[reloc_sz++] = 0;
909}
910
911/************************************************************************
912
913 Given the exiting def_file structure, print out a .DEF file that
914 corresponds to it.
915
916 ************************************************************************/
917
918static void
919quoteput (s, f, needs_quotes)
920 char *s;
921 FILE * f;
922 int needs_quotes;
923{
924 char *cp;
925 for (cp = s; *cp; cp++)
926 if (*cp == '\''
927 || *cp == '"'
928 || *cp == '\\'
929 || isspace ((unsigned char) *cp)
930 || *cp == ','
931 || *cp == ';')
932 needs_quotes = 1;
933 if (needs_quotes)
934 {
935 putc ('"', f);
936 while (*s)
937 {
938 if (*s == '"' || *s == '\\')
939 putc ('\\', f);
940 putc (*s, f);
941 s++;
942 }
943 putc ('"', f);
944 }
945 else
946 fputs (s, f);
947}
948
949void
950pe_dll_generate_def_file (pe_out_def_filename)
1069dd8d 951 const char *pe_out_def_filename;
252b5132
RH		 952{
953 int i;
954 FILE *out = fopen (pe_out_def_filename, "w");
955 if (out == NULL)
956 {
957 /* xgettext:c-format */
958 einfo (_("%s: Can't open output def file %s\n"),
959 program_name, pe_out_def_filename);
960 }
961
962 if (pe_def_file)
963 {
964 if (pe_def_file->name)
965 {
966 if (pe_def_file->is_dll)
967 fprintf (out, "LIBRARY ");
968 else
969 fprintf (out, "NAME ");
970 quoteput (pe_def_file->name, out, 1);
971 if (pe_data (output_bfd)->pe_opthdr.ImageBase)
972 fprintf (out, " BASE=0x%lx",
973 (unsigned long) pe_data (output_bfd)->pe_opthdr.ImageBase);
974 fprintf (out, "\n");
975 }
976
977 if (pe_def_file->description)
978 {
979 fprintf (out, "DESCRIPTION ");
980 quoteput (pe_def_file->description, out, 1);
981 fprintf (out, "\n");
982 }
983
984 if (pe_def_file->version_minor != -1)
985 fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major,
986 pe_def_file->version_minor);
987 else if (pe_def_file->version_major != -1)
988 fprintf (out, "VERSION %d\n", pe_def_file->version_major);
989
990 if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1)
991 fprintf (out, "\n");
992
993 if (pe_def_file->stack_commit != -1)
994 fprintf (out, "STACKSIZE 0x%x,0x%x\n",
995 pe_def_file->stack_reserve, pe_def_file->stack_commit);
996 else if (pe_def_file->stack_reserve != -1)
997 fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve);
998 if (pe_def_file->heap_commit != -1)
999 fprintf (out, "HEAPSIZE 0x%x,0x%x\n",
1000 pe_def_file->heap_reserve, pe_def_file->heap_commit);
1001 else if (pe_def_file->heap_reserve != -1)
1002 fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve);
1003
1004 if (pe_def_file->num_section_defs > 0)
1005 {
1006 fprintf (out, "\nSECTIONS\n\n");
1007 for (i = 0; i < pe_def_file->num_section_defs; i++)
1008 {
1009 fprintf (out, " ");
1010 quoteput (pe_def_file->section_defs[i].name, out, 0);
1011 if (pe_def_file->section_defs[i].class)
1012 {
1013 fprintf (out, " CLASS ");
1014 quoteput (pe_def_file->section_defs[i].class, out, 0);
1015 }
1016 if (pe_def_file->section_defs[i].flag_read)
1017 fprintf (out, " READ");
1018 if (pe_def_file->section_defs[i].flag_write)
1019 fprintf (out, " WRITE");
1020 if (pe_def_file->section_defs[i].flag_execute)
1021 fprintf (out, " EXECUTE");
1022 if (pe_def_file->section_defs[i].flag_shared)
1023 fprintf (out, " SHARED");
1024 fprintf (out, "\n");
1025 }
1026 }
1027
1028 if (pe_def_file->num_exports > 0)
1029 {
1030 fprintf (out, "\nEXPORTS\n\n");
1031 for (i = 0; i < pe_def_file->num_exports; i++)
1032 {
1033 def_file_export *e = pe_def_file->exports + i;
1034 fprintf (out, " ");
1035 quoteput (e->name, out, 0);
1036 if (e->internal_name && strcmp (e->internal_name, e->name))
1037 {
1038 fprintf (out, " = ");
1039 quoteput (e->internal_name, out, 0);
1040 }
1041 if (e->ordinal != -1)
1042 fprintf (out, " @%d", e->ordinal);
1043 if (e->flag_private)
1044 fprintf (out, " PRIVATE");
1045 if (e->flag_constant)
1046 fprintf (out, " CONSTANT");
1047 if (e->flag_noname)
1048 fprintf (out, " NONAME");
1049 if (e->flag_data)
1050 fprintf (out, " DATA");
1051
1052 fprintf (out, "\n");
1053 }
1054 }
1055
1056 if (pe_def_file->num_imports > 0)
1057 {
1058 fprintf (out, "\nIMPORTS\n\n");
1059 for (i = 0; i < pe_def_file->num_imports; i++)
1060 {
1061 def_file_import *im = pe_def_file->imports + i;
1062 fprintf (out, " ");
1063 if (im->internal_name
1064 && (!im->name || strcmp (im->internal_name, im->name)))
1065 {
1066 quoteput (im->internal_name, out, 0);
1067 fprintf (out, " = ");
1068 }
1069 quoteput (im->module->name, out, 0);
1070 fprintf (out, ".");
1071 if (im->name)
1072 quoteput (im->name, out, 0);
1073 else
1074 fprintf (out, "%d", im->ordinal);
1075 fprintf (out, "\n");
1076 }
1077 }
1078 }
1079 else
1080 fprintf (out, _("; no contents available\n"));
1081
1082 if (fclose (out) == EOF)
1083 {
1084 /* xgettext:c-format */
1085 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename);
1086 }
1087}
1088
1089/************************************************************************
1090
1091 Generate the import library
1092
1093 ************************************************************************/
1094
1095static asymbol **symtab;
1096static int symptr;
1097static int tmp_seq;
1098static const char *dll_filename;
1099static char *dll_symname;
1100
1101#define UNDSEC (asection *) &bfd_und_section
1102
1103static asection *
1104quick_section(abfd, name, flags, align)
1105 bfd *abfd;
1106 const char *name;
1107 int flags;
1108 int align;
1109{
1110 asection *sec;
1111 asymbol *sym;
1112
1113 sec = bfd_make_section_old_way (abfd, name);
1114 bfd_set_section_flags (abfd, sec, flags
1115 | SEC_ALLOC
1116 | SEC_LOAD
1117 | SEC_KEEP
1118 );
1119 bfd_set_section_alignment (abfd, sec, align);
1120 /* remember to undo this before trying to link internally! */
1121 sec->output_section = sec;
1122
1123 sym = bfd_make_empty_symbol (abfd);
1124 symtab[symptr++] = sym;
1125 sym->name = sec->name;
1126 sym->section = sec;
1127 sym->flags = BSF_LOCAL;
1128 sym->value = 0;
1129
1130 return sec;
1131}
1132
1133static void
1134quick_symbol (abfd, n1, n2, n3, sec, flags, addr)
1135 bfd *abfd;
1136 char *n1;
1137 char *n2;
1138 char *n3;
1139 asection *sec;
1140 int flags;
1141 int addr;
1142{
1143 asymbol *sym;
1144 char *name = (char *) xmalloc (strlen (n1) + strlen (n2) + strlen (n3) + 1);
1145 strcpy (name, n1);
1146 strcat (name, n2);
1147 strcat (name, n3);
1148 sym = bfd_make_empty_symbol (abfd);
1149 sym->name = name;
1150 sym->section = sec;
1151 sym->flags = flags;
1152 sym->value = addr;
1153 symtab[symptr++] = sym;
1154}
1155
1156static arelent *reltab = 0;
1157static int relcount = 0, relsize = 0;
1158
1159static void
1160quick_reloc (abfd, address, which_howto, symidx)
1161 bfd *abfd;
1162 int address;
1163 int which_howto;
1164 int symidx;
1165{
1166 if (relcount >= (relsize-1))
1167 {
1168 relsize += 10;
1169 if (reltab)
1170 reltab = (arelent *) xrealloc (reltab, relsize * sizeof (arelent));
1171 else
1172 reltab = (arelent *) xmalloc (relsize * sizeof (arelent));
1173 }
1174 reltab[relcount].address = address;
1175 reltab[relcount].addend = 0;
1176 reltab[relcount].howto = bfd_reloc_type_lookup (abfd, which_howto);
1177 reltab[relcount].sym_ptr_ptr = symtab + symidx;
1178 relcount++;
1179}
1180
1181static void
1182save_relocs (asection *sec)
1183{
1184 int i;
1185 sec->relocation = reltab;
1186 sec->reloc_count = relcount;
1187 sec->orelocation = (arelent **) xmalloc ((relcount+1) * sizeof (arelent *));
1188 for (i=0; i<relcount; i++)
1189 sec->orelocation[i] = sec->relocation + i;
1190 sec->orelocation[relcount] = 0;
1191 sec->flags |= SEC_RELOC;
1192 reltab = 0;
1193 relcount = relsize = 0;
1194}
1195
1196/*
1197 * .section .idata$2
1198 * .global __head_my_dll
1199 * __head_my_dll:
1200 * .rva hname
1201 * .long 0
1202 * .long 0
1203 * .rva __my_dll_iname
1204 * .rva fthunk
1205 *
1206 * .section .idata$5
1207 * .long 0
1208 * fthunk:
1209 *
1210 * .section .idata$4
1211 * .long 0
1212 * hname:
1213 */
1214
1215static bfd *
1216make_head (parent)
1217 bfd *parent;
1218{
1219 asection *id2, *id5, *id4;
1220 unsigned char *d2, *d5, *d4;
1221 char *oname;
1222 bfd *abfd;
1223
1224 oname = (char *) xmalloc (20);
1225 sprintf (oname, "d%06d.o", tmp_seq);
1226 tmp_seq++;
1227
1228 abfd = bfd_create (oname, parent);
c6c37250 1229 bfd_find_target (pe_details->object_target, abfd);
252b5132
RH		 1230 bfd_make_writable (abfd);
1231
1232 bfd_set_format (abfd, bfd_object);
c6c37250 1233 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
252b5132
RH		 1234
1235 symptr = 0;
1236 symtab = (asymbol **) xmalloc (6 * sizeof (asymbol *));
1237 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
1238 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1239 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
c6c37250
DD		 1240 quick_symbol (abfd, U("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0);
1241 quick_symbol (abfd, U(""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
1242
1243 /* OK, pay attention here. I got confused myself looking back at
1244 it. We create a four-byte section to mark the beginning of the
1245 list, and we include an offset of 4 in the section, so that the
1246 pointer to the list points to the *end* of this section, which is
1247 the start of the list of sections from other objects. */
252b5132
RH		 1248
1249 bfd_set_section_size (abfd, id2, 20);
1250 d2 = (unsigned char *) xmalloc (20);
1251 id2->contents = d2;
1252 memset (d2, 0, 20);
1253 d2[0] = d2[16] = 4; /* reloc addend */
1254 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
1255 quick_reloc (abfd, 12, BFD_RELOC_RVA, 4);
1256 quick_reloc (abfd, 16, BFD_RELOC_RVA, 1);
1257 save_relocs (id2);
1258
1259 bfd_set_section_size (abfd, id5, 4);
1260 d5 = (unsigned char *) xmalloc (4);
1261 id5->contents = d5;
1262 memset (d5, 0, 4);
1263
1264 bfd_set_section_size (abfd, id4, 4);
1265 d4 = (unsigned char *) xmalloc (4);
1266 id4->contents = d4;
1267 memset (d4, 0, 4);
1268
1269 bfd_set_symtab (abfd, symtab, symptr);
1270
1271 bfd_set_section_contents (abfd, id2, d2, 0, 20);
1272 bfd_set_section_contents (abfd, id5, d5, 0, 4);
1273 bfd_set_section_contents (abfd, id4, d4, 0, 4);
1274
1275 bfd_make_readable (abfd);
1276 return abfd;
1277}
1278
1279/*
1280 * .section .idata$4
1281 * .long 0
1282 * .section .idata$5
1283 * .long 0
1284 * .section idata$7
1285 * .global __my_dll_iname
1286 *__my_dll_iname:
1287 * .asciz "my.dll"
1288 */
1289
1290static bfd *
1291make_tail (parent)
1292 bfd *parent;
1293{
1294 asection *id4, *id5, *id7;
1295 unsigned char *d4, *d5, *d7;
1296 int len;
1297 char *oname;
1298 bfd *abfd;
1299
1300 oname = (char *) xmalloc (20);
1301 sprintf (oname, "d%06d.o", tmp_seq);
1302 tmp_seq++;
1303
1304 abfd = bfd_create (oname, parent);
c6c37250 1305 bfd_find_target (pe_details->object_target, abfd);
252b5132
RH		 1306 bfd_make_writable (abfd);
1307
1308 bfd_set_format (abfd, bfd_object);
c6c37250 1309 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
252b5132
RH		 1310
1311 symptr = 0;
1312 symtab = (asymbol **) xmalloc (5 * sizeof (asymbol *));
1313 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1314 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1315 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
c6c37250 1316 quick_symbol (abfd, U(""), dll_symname, "_iname", id7, BSF_GLOBAL, 0);
252b5132
RH		 1317
1318 bfd_set_section_size (abfd, id4, 4);
1319 d4 = (unsigned char *) xmalloc (4);
1320 id4->contents = d4;
1321 memset (d4, 0, 4);
1322
1323 bfd_set_section_size (abfd, id5, 4);
1324 d5 = (unsigned char *) xmalloc (4);
1325 id5->contents = d5;
1326 memset (d5, 0, 4);
1327
1328 len = strlen (dll_filename)+1;
1329 if (len & 1)
1330 len ++;
1331 bfd_set_section_size (abfd, id7, len);
1332 d7 = (unsigned char *) xmalloc (len);
1333 id7->contents = d7;
1334 strcpy (d7, dll_filename);
1335
1336 bfd_set_symtab (abfd, symtab, symptr);
1337
1338 bfd_set_section_contents (abfd, id4, d4, 0, 4);
1339 bfd_set_section_contents (abfd, id5, d5, 0, 4);
1340 bfd_set_section_contents (abfd, id7, d7, 0, len);
1341
1342 bfd_make_readable (abfd);
1343 return abfd;
1344}
1345
1346/*
1347 * .text
1348 * .global _function
1349 * .global ___imp_function
1350 * .global __imp__function
1351 *_function:
1352 * jmp *__imp__function:
1353 *
1354 * .section idata$7
1355 * .long __head_my_dll
1356 *
1357 * .section .idata$5
1358 *___imp_function:
1359 *__imp__function:
1360 *iat?
1361 * .section .idata$4
1362 *iat?
1363 * .section .idata$6
1364 *ID<ordinal>:
1365 * .short <hint>
1366 * .asciz "function" xlate? (add underscore, kill at)
1367 */
1368
1369static unsigned char jmp_ix86_bytes[] = {
1370 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
1371};
1372
344a211f
NC		 1373/*
1374 *_function:
1375 * mov.l ip+8,r0
1376 * mov.l @r0,r0
1377 * jmp @r0
1378 * nop
1379 * .dw __imp_function
1380 */
1381
1382static unsigned char jmp_sh_bytes[] = {
1383 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
1384};
1385
1386/*
1387 *_function:
1388 * lui $t0,<high:__imp_function>
1389 * lw $t0,<low:__imp_function>
1390 * jr $t0
1391 * nop
1392 */
1393
1394static unsigned char jmp_mips_bytes[] = {
1395 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
1396 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
1397};
252b5132
RH		 1398
1399static bfd *
1400make_one (exp, parent)
1401 def_file_export *exp;
1402 bfd *parent;
1403{
1404 asection *tx, *id7, *id5, *id4, *id6;
1405 unsigned char *td, *d7, *d5, *d4, *d6;
1406 int len;
1407 char *oname;
1408 bfd *abfd;
c6c37250
DD		 1409 unsigned char *jmp_bytes;
1410 int jmp_byte_count;
1411
1412 switch (pe_details->pe_arch)
1413 {
1414 case PE_ARCH_i386:
1415 jmp_bytes = jmp_ix86_bytes;
1416 jmp_byte_count = sizeof (jmp_ix86_bytes);
1417 break;
344a211f
NC		 1418 case PE_ARCH_sh:
1419 jmp_bytes = jmp_sh_bytes;
1420 jmp_byte_count = sizeof (jmp_sh_bytes);
1421 break;
1422 case PE_ARCH_mips:
1423 jmp_bytes = jmp_mips_bytes;
1424 jmp_byte_count = sizeof (jmp_mips_bytes);
1425 break;
c6c37250 1426 }
252b5132
RH		 1427
1428 oname = (char *) xmalloc (20);
1429 sprintf (oname, "d%06d.o", tmp_seq);
1430 tmp_seq++;
1431
1432 abfd = bfd_create (oname, parent);
c6c37250 1433 bfd_find_target (pe_details->object_target, abfd);
252b5132
RH		 1434 bfd_make_writable (abfd);
1435
1436 bfd_set_format (abfd, bfd_object);
c6c37250 1437 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
252b5132
RH		 1438
1439 symptr = 0;
1440 symtab = (asymbol **) xmalloc (10 * sizeof (asymbol *));
1441 tx = quick_section (abfd, ".text", SEC_CODE|SEC_HAS_CONTENTS, 2);
1442 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1443 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1444 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1445 id6 = quick_section (abfd, ".idata$6", SEC_HAS_CONTENTS, 2);
7c9e78f8
DD		 1446 if (! exp->flag_data)
1447 quick_symbol (abfd, U(""), exp->internal_name, "", tx, BSF_GLOBAL, 0);
c6c37250
DD		 1448 quick_symbol (abfd, U("_head_"), dll_symname, "", UNDSEC, BSF_GLOBAL, 0);
1449 quick_symbol (abfd, U("__imp_"), exp->internal_name, "", id5, BSF_GLOBAL, 0);
870df5dc
NC		 1450 if (pe_dll_compat_implib)
1451 quick_symbol (abfd, U("__imp_"), exp->internal_name, "",
1452 id5, BSF_GLOBAL, 0);
252b5132 1453
c6c37250
DD		 1454 bfd_set_section_size (abfd, tx, jmp_byte_count);
1455 td = (unsigned char *) xmalloc (jmp_byte_count);
252b5132 1456 tx->contents = td;
c6c37250
DD		 1457 memcpy (td, jmp_bytes, jmp_byte_count);
1458 switch (pe_details->pe_arch)
1459 {
1460 case PE_ARCH_i386:
1461 quick_reloc (abfd, 2, BFD_RELOC_32, 2);
1462 break;
344a211f
NC		 1463 case PE_ARCH_sh:
1464 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
1465 break;
1466 case PE_ARCH_mips:
1467 quick_reloc (abfd, 0, BFD_RELOC_HI16_S, 2);
1468 quick_reloc (abfd, 0, BFD_RELOC_LO16, 0); /* MIPS_R_PAIR */
1469 quick_reloc (abfd, 4, BFD_RELOC_LO16, 2);
1470 break;
c6c37250 1471 }
252b5132
RH		 1472 save_relocs (tx);
1473
1474 bfd_set_section_size (abfd, id7, 4);
1475 d7 = (unsigned char *) xmalloc (4);
1476 id7->contents = d7;
1477 memset (d7, 0, 4);
1478 quick_reloc (abfd, 0, BFD_RELOC_RVA, 6);
1479 save_relocs (id7);
1480
1481 bfd_set_section_size (abfd, id5, 4);
1482 d5 = (unsigned char *) xmalloc (4);
1483 id5->contents = d5;
1484 memset (d5, 0, 4);
1485 if (exp->flag_noname)
1486 {
1487 d5[0] = exp->ordinal;
1488 d5[1] = exp->ordinal >> 8;
1489 d5[3] = 0x80;
1490 }
1491 else
1492 {
1493 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
1494 save_relocs (id5);
1495 }
1496
1497 bfd_set_section_size (abfd, id4, 4);
1498 d4 = (unsigned char *) xmalloc (4);
1499 id4->contents = d4;
1500 memset (d4, 0, 4);
1501 if (exp->flag_noname)
1502 {
1503 d5[0] = exp->ordinal;
1504 d5[1] = exp->ordinal >> 8;
1505 d5[3] = 0x80;
1506 }
1507 else
1508 {
1509 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
1510 save_relocs (id4);
1511 }
1512
1513 if (exp->flag_noname)
1514 {
1515 len = 0;
1516 bfd_set_section_size (abfd, id6, 0);
1517 }
1518 else
1519 {
1520 len = strlen (exp->name) + 3;
1521 if (len & 1)
1522 len++;
1523 bfd_set_section_size (abfd, id6, len);
1524 d6 = (unsigned char *) xmalloc (len);
1525 id6->contents = d6;
1526 memset (d6, 0, len);
1527 d6[0] = exp->hint & 0xff;
1528 d6[1] = exp->hint >> 8;
1529 strcpy (d6+2, exp->name);
1530 }
1531
1532 bfd_set_symtab (abfd, symtab, symptr);
1533
c6c37250 1534 bfd_set_section_contents (abfd, tx, td, 0, jmp_byte_count);
252b5132
RH		 1535 bfd_set_section_contents (abfd, id7, d7, 0, 4);
1536 bfd_set_section_contents (abfd, id5, d5, 0, 4);
1537 bfd_set_section_contents (abfd, id4, d4, 0, 4);
1538 if (!exp->flag_noname)
1539 bfd_set_section_contents (abfd, id6, d6, 0, len);
1540
1541 bfd_make_readable (abfd);
1542 return abfd;
1543}
1544
1545void
1546pe_dll_generate_implib (def, impfilename)
1547 def_file *def;
1069dd8d 1548 const char *impfilename;
252b5132
RH		 1549{
1550 int i;
1551 bfd *ar_head;
1552 bfd *ar_tail;
1553 bfd *outarch;
1554 bfd *head = 0;
1555
5aaace27 1556 dll_filename = (def->name) ? def->name : dll_name;
252b5132
RH		 1557 dll_symname = xstrdup (dll_filename);
1558 for (i=0; dll_symname[i]; i++)
1559 if (!isalnum ((unsigned char) dll_symname[i]))
1560 dll_symname[i] = '_';
1561
1562 unlink (impfilename);
1563
1564 outarch = bfd_openw (impfilename, 0);
1565
1566 if (!outarch)
1567 {
1568 /* xgettext:c-format */
1569 einfo (_("%XCan't open .lib file: %s\n"), impfilename);
1570 return;
1571 }
1572
1573 /* xgettext:c-format */
1574 einfo (_("Creating library file: %s\n"), impfilename);
1575
1576 bfd_set_format (outarch, bfd_archive);
1577 outarch->has_armap = 1;
1578
1579 /* Work out a reasonable size of things to put onto one line. */
1580
1581 ar_head = make_head (outarch);
252b5132
RH		 1582
1583 for (i = 0; i<def->num_exports; i++)
1584 {
1585 /* The import library doesn't know about the internal name */
1586 char *internal = def->exports[i].internal_name;
1587 bfd *n;
1588 def->exports[i].internal_name = def->exports[i].name;
1589 n = make_one (def->exports+i, outarch);
1590 n->next = head;
1591 head = n;
1592 def->exports[i].internal_name = internal;
1593 }
1594
c6c37250
DD		 1595 ar_tail = make_tail (outarch);
1596
1597 if (ar_head == NULL || ar_tail == NULL)
1598 return;
1599
252b5132
RH		 1600 /* Now stick them all into the archive */
1601
1602 ar_head->next = head;
1603 ar_tail->next = ar_head;
1604 head = ar_tail;
1605
1606 if (! bfd_set_archive_head (outarch, head))
1607 einfo ("%Xbfd_set_archive_head: %s\n", bfd_errmsg (bfd_get_error ()));
1608
1609 if (! bfd_close (outarch))
1610 einfo ("%Xbfd_close %s: %s\n", impfilename, bfd_errmsg (bfd_get_error ()));
1611
1612 while (head != NULL)
1613 {
1614 bfd *n = head->next;
1615 bfd_close (head);
1616 head = n;
1617 }
1618}
1619
1620static void
1621add_bfd_to_link (abfd, name, link_info)
1622 bfd *abfd;
1623 char *name;
1624 struct bfd_link_info *link_info;
1625{
1626 lang_input_statement_type *fake_file;
1627 fake_file = lang_add_input_file (name,
1628 lang_input_file_is_fake_enum,
1629 NULL);
1630 fake_file->the_bfd = abfd;
1631 ldlang_add_file (fake_file);
1632 if (!bfd_link_add_symbols (abfd, link_info))
1633 einfo ("%Xaddsym %s: %s\n", name, bfd_errmsg (bfd_get_error ()));
1634}
1635
1636void
1637pe_process_import_defs (output_bfd, link_info)
1638 bfd *output_bfd;
1639 struct bfd_link_info *link_info;
1640{
1641 def_file_module *module;
c6c37250 1642 pe_dll_id_target(bfd_get_target (output_bfd));
252b5132
RH		 1643
1644 if (!pe_def_file)
1645 return;
1646
1647 for (module = pe_def_file->modules; module; module = module->next)
1648 {
1649 int i, do_this_dll;
1650
1651 dll_filename = module->name;
1652 dll_symname = xstrdup (module->name);
1653 for (i=0; dll_symname[i]; i++)
1654 if (!isalnum (dll_symname[i]))
1655 dll_symname[i] = '_';
1656
1657 do_this_dll = 0;
1658
1659 for (i=0; i<pe_def_file->num_imports; i++)
1660 if (pe_def_file->imports[i].module == module)
1661 {
1662 def_file_export exp;
1663 struct bfd_link_hash_entry *blhe;
1664
1665 /* see if we need this import */
1666 char *name = (char *) xmalloc (strlen (pe_def_file->imports[i].internal_name) + 2);
c6c37250 1667 sprintf (name, "%s%s", U(""), pe_def_file->imports[i].internal_name);
252b5132
RH		 1668 blhe = bfd_link_hash_lookup (link_info->hash, name,
1669 false, false, false);
1670 free (name);
1671 if (blhe && blhe->type == bfd_link_hash_undefined)
1672 {
1673 bfd *one;
1674 /* we do */
1675 if (!do_this_dll)
1676 {
1677 bfd *ar_head = make_head (output_bfd);
1678 add_bfd_to_link (ar_head, ar_head->filename, link_info);
1679 do_this_dll = 1;
1680 }
1681 exp.internal_name = pe_def_file->imports[i].internal_name;
1682 exp.name = pe_def_file->imports[i].name;
1683 exp.ordinal = pe_def_file->imports[i].ordinal;
1684 exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
1685 exp.flag_private = 0;
1686 exp.flag_constant = 0;
1687 exp.flag_data = 0;
1688 exp.flag_noname = exp.name ? 0 : 1;
1689 one = make_one (&exp, output_bfd);
1690 add_bfd_to_link (one, one->filename, link_info);
1691 }
1692 }
1693 if (do_this_dll)
1694 {
1695 bfd *ar_tail = make_tail (output_bfd);
1696 add_bfd_to_link (ar_tail, ar_tail->filename, link_info);
1697 }
1698
1699 free (dll_symname);
1700 }
1701}
1702
1703/************************************************************************
1704
1705 We were handed a *.DLL file. Parse it and turn it into a set of
1706 IMPORTS directives in the def file. Return true if the file was
1707 handled, false if not.
1708
1709 ************************************************************************/
1710
1711static unsigned int
1712pe_get16 (abfd, where)
1713 bfd *abfd;
1714 int where;
1715{
1716 unsigned char b[2];
1717 bfd_seek (abfd, where, SEEK_SET);
1718 bfd_read (b, 1, 2, abfd);
1719 return b[0] + (b[1]<<8);
1720}
1721
1722static unsigned int
1723pe_get32 (abfd, where)
1724 bfd *abfd;
1725 int where;
1726{
1727 unsigned char b[4];
1728 bfd_seek (abfd, where, SEEK_SET);
1729 bfd_read (b, 1, 4, abfd);
1730 return b[0] + (b[1]<<8) + (b[2]<<16) + (b[3]<<24);
1731}
1732
1733#if 0 /* This is not currently used. */
1734
1735static unsigned int
1736pe_as16 (ptr)
1737 void *ptr;
1738{
1739 unsigned char *b = ptr;
1740 return b[0] + (b[1]<<8);
1741}
1742
1743#endif
1744
1745static unsigned int
1746pe_as32 (ptr)
1747 void *ptr;
1748{
1749 unsigned char *b = ptr;
1750 return b[0] + (b[1]<<8) + (b[2]<<16) + (b[3]<<24);
1751}
1752
1753boolean
1754pe_implied_import_dll (filename)
1069dd8d 1755 const char *filename;
252b5132
RH		 1756{
1757 bfd *dll;
1758 unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
1759 unsigned long export_rva, export_size, nsections, secptr, expptr;
1760 unsigned char *expdata, *erva;
1761 unsigned long name_rvas, ordinals, nexp, ordbase;
1069dd8d 1762 const char *dll_name;
252b5132
RH		 1763
1764 /* No, I can't use bfd here. kernel32.dll puts its export table in
1765 the middle of the .rdata section. */
1766
c6c37250 1767 dll = bfd_openr (filename, pe_details->target_name);
252b5132
RH		 1768 if (!dll)
1769 {
1770 einfo ("%Xopen %s: %s\n", filename, bfd_errmsg (bfd_get_error ()));
1771 return false;
1772 }
1773 /* PEI dlls seem to be bfd_objects */
1774 if (!bfd_check_format (dll, bfd_object))
1775 {
1776 einfo ("%X%s: this doesn't appear to be a DLL\n", filename);
1777 return false;
1778 }
1779
1780 dll_name = filename;
1781 for (i=0; filename[i]; i++)
1782 if (filename[i] == '/' || filename[i] == '\\' || filename[i] == ':')
1783 dll_name = filename + i + 1;
1784
1785 pe_header_offset = pe_get32 (dll, 0x3c);
1786 opthdr_ofs = pe_header_offset + 4 + 20;
1787 num_entries = pe_get32 (dll, opthdr_ofs + 92);
1788 if (num_entries < 1) /* no exports */
1789 return false;
1790 export_rva = pe_get32 (dll, opthdr_ofs + 96);
1791 export_size = pe_get32 (dll, opthdr_ofs + 100);
1792 nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
1793 secptr = (pe_header_offset + 4 + 20 +
1794 pe_get16 (dll, pe_header_offset + 4 + 16));
1795 expptr = 0;
1796 for (i=0; i<nsections; i++)
1797 {
1798 char sname[8];
1799 unsigned long secptr1 = secptr + 40 * i;
1800 unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
1801 unsigned long vsize = pe_get32 (dll, secptr1 + 16);
1802 unsigned long fptr = pe_get32 (dll, secptr1 + 20);
1803 bfd_seek(dll, secptr1, SEEK_SET);
1804 bfd_read(sname, 1, 8, dll);
1805 if (vaddr <= export_rva && vaddr+vsize > export_rva)
1806 {
1807 expptr = fptr + (export_rva - vaddr);
1808 if (export_rva + export_size > vaddr + vsize)
1809 export_size = vsize - (export_rva - vaddr);
1810 break;
1811 }
1812 }
1813
1814 expdata = (unsigned char *) xmalloc (export_size);
1815 bfd_seek (dll, expptr, SEEK_SET);
1816 bfd_read (expdata, 1, export_size, dll);
1817 erva = expdata - export_rva;
1818
1819 if (pe_def_file == 0)
1820 pe_def_file = def_file_empty();
1821
1822 nexp = pe_as32 (expdata+24);
1823 name_rvas = pe_as32 (expdata+32);
1824 ordinals = pe_as32 (expdata+36);
1825 ordbase = pe_as32 (expdata+16);
1826 for (i=0; i<nexp; i++)
1827 {
1828 unsigned long name_rva = pe_as32 (erva+name_rvas+i*4);
1829 def_file_import *imp;
1830 imp = def_file_add_import (pe_def_file, erva+name_rva, dll_name,
1831 i, 0);
1832 }
1833
1834 return true;
1835}
1836
1837/************************************************************************
1838
1839 These are the main functions, called from the emulation. The first
1840 is called after the bfds are read, so we can guess at how much space
1841 we need. The second is called after everything is placed, so we
1842 can put the right values in place.
1843
1844 ************************************************************************/
1845
1846void
1847pe_dll_build_sections (abfd, info)
1848 bfd *abfd;
1849 struct bfd_link_info *info;
1850{
c6c37250 1851 pe_dll_id_target (bfd_get_target (abfd));
252b5132
RH		 1852 process_def_file (abfd, info);
1853
1854 generate_edata (abfd, info);
c6c37250
DD		 1855 build_filler_bfd (1);
1856}
1857
1858void
1859pe_exe_build_sections (abfd, info)
1860 bfd *abfd;
1069dd8d 1861 struct bfd_link_info *info ATTRIBUTE_UNUSED;
c6c37250
DD		 1862{
1863 pe_dll_id_target (bfd_get_target (abfd));
1864 build_filler_bfd (0);
252b5132
RH		 1865}
1866
1867void
1868pe_dll_fill_sections (abfd, info)
1869 bfd *abfd;
1870 struct bfd_link_info *info;
1871{
c6c37250 1872 pe_dll_id_target (bfd_get_target (abfd));
252b5132
RH		 1873 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
1874
1875 generate_reloc (abfd, info);
1876 if (reloc_sz > 0)
1877 {
1878 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
1879
1880 /* Resize the sections. */
1881 lang_size_sections (stat_ptr->head, abs_output_section,
1882 &stat_ptr->head, 0, (bfd_vma) 0, false);
1883
1884 /* Redo special stuff. */
1885 ldemul_after_allocation ();
1886
1887 /* Do the assignments again. */
1888 lang_do_assignments (stat_ptr->head,
1889 abs_output_section,
1890 (fill_type) 0, (bfd_vma) 0);
1891 }
1892
1893 fill_edata (abfd, info);
1894
1895 pe_data (abfd)->dll = 1;
1896
1897 edata_s->contents = edata_d;
1898 reloc_s->contents = reloc_d;
1899}
c6c37250
DD		 1900
1901void
1902pe_exe_fill_sections (abfd, info)
1903 bfd *abfd;
1904 struct bfd_link_info *info;
1905{
1906 pe_dll_id_target (bfd_get_target (abfd));
1907 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
1908
1909 generate_reloc (abfd, info);
1910 if (reloc_sz > 0)
1911 {
1912 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
1913
1914 /* Resize the sections. */
1915 lang_size_sections (stat_ptr->head, abs_output_section,
1916 &stat_ptr->head, 0, (bfd_vma) 0, false);
1917
1918 /* Redo special stuff. */
1919 ldemul_after_allocation ();
1920
1921 /* Do the assignments again. */
1922 lang_do_assignments (stat_ptr->head,
1923 abs_output_section,
1924 (fill_type) 0, (bfd_vma) 0);
1925 }
1926 reloc_s->contents = reloc_d;
1927}
GDB Binutils - Deliverables
This page took 0.1124 seconds and 4 git commands to generate.