* pe-dll.c (auto_export): Use bsearch to speed up scan of exports
[external/binutils.git] / ld / pe-dll.c
1 /* Routines to help build PEI-format DLLs (Win32 etc)
2    Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3    2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
4    Written by DJ Delorie <dj@cygnus.com>
5
6    This file is part of the GNU Binutils.
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21    MA 02110-1301, USA.  */
22
23 #include "sysdep.h"
24 #include "bfd.h"
25 #include "bfdlink.h"
26 #include "libiberty.h"
27 #include "filenames.h"
28 #include "safe-ctype.h"
29
30 #include <time.h>
31
32 #include "ld.h"
33 #include "ldexp.h"
34 #include "ldlang.h"
35 #include "ldwrite.h"
36 #include "ldmisc.h"
37 #include <ldgram.h>
38 #include "ldmain.h"
39 #include "ldfile.h"
40 #include "ldemul.h"
41 #include "coff/internal.h"
42 #include "../bfd/libcoff.h"
43 #include "deffile.h"
44
45 #ifdef pe_use_x86_64
46
47 #define PE_IDATA4_SIZE  8
48 #define PE_IDATA5_SIZE  8
49 #include "pep-dll.h"
50 #undef  AOUTSZ
51 #define AOUTSZ          PEPAOUTSZ
52 #define PEAOUTHDR       PEPAOUTHDR
53
54 #else
55
56 #include "pe-dll.h"
57
58 #endif
59
60 #ifndef PE_IDATA4_SIZE
61 #define PE_IDATA4_SIZE  4
62 #endif
63
64 #ifndef PE_IDATA5_SIZE
65 #define PE_IDATA5_SIZE  4
66 #endif
67
68 /*  This file turns a regular Windows PE image into a DLL.  Because of
69     the complexity of this operation, it has been broken down into a
70     number of separate modules which are all called by the main function
71     at the end of this file.  This function is not re-entrant and is
72     normally only called once, so static variables are used to reduce
73     the number of parameters and return values required.
74
75     See also: ld/emultempl/pe.em and ld/emultempl/pep.em.  */
76
77 /*  Auto-import feature by Paul Sokolovsky
78
79     Quick facts:
80
81     1. With this feature on, DLL clients can import variables from DLL
82     without any concern from their side (for example, without any source
83     code modifications).
84
85     2. This is done completely in bounds of the PE specification (to be fair,
86     there's a place where it pokes nose out of, but in practice it works).
87     So, resulting module can be used with any other PE compiler/linker.
88
89     3. Auto-import is fully compatible with standard import method and they
90     can be mixed together.
91
92     4. Overheads: space: 8 bytes per imported symbol, plus 20 for each
93     reference to it; load time: negligible; virtual/physical memory: should be
94     less than effect of DLL relocation, and I sincerely hope it doesn't affect
95     DLL sharability (too much).
96
97     Idea
98
99     The obvious and only way to get rid of dllimport insanity is to make client
100     access variable directly in the DLL, bypassing extra dereference. I.e.,
101     whenever client contains something like
102
103     mov dll_var,%eax,
104
105     address of dll_var in the command should be relocated to point into loaded
106     DLL. The aim is to make OS loader do so, and than make ld help with that.
107     Import section of PE made following way: there's a vector of structures
108     each describing imports from particular DLL. Each such structure points
109     to two other parallel vectors: one holding imported names, and one which
110     will hold address of corresponding imported name. So, the solution is
111     de-vectorize these structures, making import locations be sparse and
112     pointing directly into code. Before continuing, it is worth a note that,
113     while authors strives to make PE act ELF-like, there're some other people
114     make ELF act PE-like: elfvector, ;-) .
115
116     Implementation
117
118     For each reference of data symbol to be imported from DLL (to set of which
119     belong symbols with name <sym>, if __imp_<sym> is found in implib), the
120     import fixup entry is generated. That entry is of type
121     IMAGE_IMPORT_DESCRIPTOR and stored in .idata$2 subsection. Each
122     fixup entry contains pointer to symbol's address within .text section
123     (marked with __fuN_<sym> symbol, where N is integer), pointer to DLL name
124     (so, DLL name is referenced by multiple entries), and pointer to symbol
125     name thunk. Symbol name thunk is singleton vector (__nm_th_<symbol>)
126     pointing to IMAGE_IMPORT_BY_NAME structure (__nm_<symbol>) directly
127     containing imported name. Here comes that "on the edge" problem mentioned
128     above: PE specification rambles that name vector (OriginalFirstThunk)
129     should run in parallel with addresses vector (FirstThunk), i.e. that they
130     should have same number of elements and terminated with zero. We violate
131     this, since FirstThunk points directly into machine code. But in practice,
132     OS loader implemented the sane way: it goes thru OriginalFirstThunk and
133     puts addresses to FirstThunk, not something else. It once again should be
134     noted that dll and symbol name structures are reused across fixup entries
135     and should be there anyway to support standard import stuff, so sustained
136     overhead is 20 bytes per reference. Other question is whether having several
137     IMAGE_IMPORT_DESCRIPTORS for the same DLL is possible. Answer is yes, it is
138     done even by native compiler/linker (libth32's functions are in fact reside
139     in windows9x kernel32.dll, so if you use it, you have two
140     IMAGE_IMPORT_DESCRIPTORS for kernel32.dll). Yet other question is whether
141     referencing the same PE structures several times is valid. The answer is why
142     not, prohibiting that (detecting violation) would require more work on
143     behalf of loader than not doing it.
144
145     See also: ld/emultempl/pe.em and ld/emultempl/pep.em.  */
146
147 static void add_bfd_to_link (bfd *, const char *, struct bfd_link_info *);
148
149 /* For emultempl/pe.em.  */
150
151 def_file * pe_def_file = 0;
152 int pe_dll_export_everything = 0;
153 int pe_dll_exclude_all_symbols = 0;
154 int pe_dll_do_default_excludes = 1;
155 int pe_dll_kill_ats = 0;
156 int pe_dll_stdcall_aliases = 0;
157 int pe_dll_warn_dup_exports = 0;
158 int pe_dll_compat_implib = 0;
159 int pe_dll_extra_pe_debug = 0;
160 int pe_use_nul_prefixed_import_tables = 0;
161 int pe_use_coff_long_section_names = -1;
162 int pe_leading_underscore = -1;
163
164 /* Static variables and types.  */
165
166 static bfd_vma image_base;
167 static bfd *filler_bfd;
168 static struct bfd_section *edata_s, *reloc_s;
169 static unsigned char *edata_d, *reloc_d;
170 static size_t edata_sz, reloc_sz;
171 static int runtime_pseudo_relocs_created = 0;
172 static int runtime_pseudp_reloc_v2_init = 0;
173
174 typedef struct
175 {
176   const char *name;
177   int len;
178 }
179 autofilter_entry_type;
180
181 typedef struct
182 {
183   const char *target_name;
184   const char *object_target;
185   unsigned int imagebase_reloc;
186   int pe_arch;
187   int bfd_arch;
188   bfd_boolean underscored;
189   const autofilter_entry_type* autofilter_symbollist;
190 }
191 pe_details_type;
192
193 static const autofilter_entry_type autofilter_symbollist_generic[] =
194 {
195   { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
196   /* Entry point symbols.  */
197   { STRING_COMMA_LEN ("DllMain") },
198   { STRING_COMMA_LEN ("DllMainCRTStartup") },
199   { STRING_COMMA_LEN ("_DllMainCRTStartup") },
200   /* Runtime pseudo-reloc.  */
201   { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
202   { STRING_COMMA_LEN ("do_pseudo_reloc") },
203   { NULL, 0 }
204 };
205
206 static const autofilter_entry_type autofilter_symbollist_i386[] =
207 {
208   { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
209   /* Entry point symbols, and entry hooks.  */
210   { STRING_COMMA_LEN ("cygwin_crt0") },
211 #ifdef pe_use_x86_64
212   { STRING_COMMA_LEN ("DllMain") },
213   { STRING_COMMA_LEN ("DllEntryPoint") },
214   { STRING_COMMA_LEN ("DllMainCRTStartup") },
215   { STRING_COMMA_LEN ("_cygwin_dll_entry") },
216   { STRING_COMMA_LEN ("_cygwin_crt0_common") },
217   { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry") },
218 #else
219   { STRING_COMMA_LEN ("DllMain@12") },
220   { STRING_COMMA_LEN ("DllEntryPoint@0") },
221   { STRING_COMMA_LEN ("DllMainCRTStartup@12") },
222   { STRING_COMMA_LEN ("_cygwin_dll_entry@12") },
223   { STRING_COMMA_LEN ("_cygwin_crt0_common@8") },
224   { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry@12") },
225   { STRING_COMMA_LEN ("cygwin_attach_dll") },
226 #endif
227   { STRING_COMMA_LEN ("cygwin_premain0") },
228   { STRING_COMMA_LEN ("cygwin_premain1") },
229   { STRING_COMMA_LEN ("cygwin_premain2") },
230   { STRING_COMMA_LEN ("cygwin_premain3") },
231   /* Runtime pseudo-reloc.  */
232   { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
233   { STRING_COMMA_LEN ("do_pseudo_reloc") },
234   /* Global vars that should not be exported.  */
235   { STRING_COMMA_LEN ("impure_ptr") },
236   { STRING_COMMA_LEN ("_impure_ptr") },
237   { STRING_COMMA_LEN ("_fmode") },
238   { STRING_COMMA_LEN ("environ") },
239   { NULL, 0 }
240 };
241
242 #define PE_ARCH_i386     1
243 #define PE_ARCH_sh       2
244 #define PE_ARCH_mips     3
245 #define PE_ARCH_arm      4
246 #define PE_ARCH_arm_epoc 5
247 #define PE_ARCH_arm_wince 6
248
249 /* Don't make it constant as underscore mode gets possibly overriden
250    by target or -(no-)leading-underscore option.  */
251 static pe_details_type pe_detail_list[] =
252 {
253   {
254 #ifdef pe_use_x86_64
255     "pei-x86-64",
256     "pe-x86-64",
257     3 /* R_IMAGEBASE */,
258 #else
259     "pei-i386",
260     "pe-i386",
261     7 /* R_IMAGEBASE */,
262 #endif
263     PE_ARCH_i386,
264     bfd_arch_i386,
265 #ifdef pe_use_x86_64
266     FALSE,
267 #else
268     TRUE,
269 #endif
270     autofilter_symbollist_i386
271   },
272   {
273     "pei-shl",
274     "pe-shl",
275     16 /* R_SH_IMAGEBASE */,
276     PE_ARCH_sh,
277     bfd_arch_sh,
278     TRUE,
279     autofilter_symbollist_generic
280   },
281   {
282     "pei-mips",
283     "pe-mips",
284     34 /* MIPS_R_RVA */,
285     PE_ARCH_mips,
286     bfd_arch_mips,
287     FALSE,
288     autofilter_symbollist_generic
289   },
290   {
291     "pei-arm-little",
292     "pe-arm-little",
293     11 /* ARM_RVA32 */,
294     PE_ARCH_arm,
295     bfd_arch_arm,
296     TRUE,
297     autofilter_symbollist_generic
298   },
299   {
300     "epoc-pei-arm-little",
301     "epoc-pe-arm-little",
302     11 /* ARM_RVA32 */,
303     PE_ARCH_arm_epoc,
304     bfd_arch_arm,
305     FALSE,
306     autofilter_symbollist_generic
307   },
308   {
309     "pei-arm-wince-little",
310     "pe-arm-wince-little",
311     2,  /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c.  */
312     PE_ARCH_arm_wince,
313     bfd_arch_arm,
314     FALSE,
315     autofilter_symbollist_generic
316   },
317   { NULL, NULL, 0, 0, 0, FALSE, NULL }
318 };
319
320 static const pe_details_type *pe_details;
321
322 /* Do not specify library suffix explicitly, to allow for dllized versions.  */
323 static const autofilter_entry_type autofilter_liblist[] =
324 {
325   { STRING_COMMA_LEN ("libcegcc") },
326   { STRING_COMMA_LEN ("libcygwin") },
327   { STRING_COMMA_LEN ("libgcc") },
328   { STRING_COMMA_LEN ("libgcc_s") },
329   { STRING_COMMA_LEN ("libstdc++") },
330   { STRING_COMMA_LEN ("libmingw32") },
331   { STRING_COMMA_LEN ("libmingwex") },
332   { STRING_COMMA_LEN ("libg2c") },
333   { STRING_COMMA_LEN ("libsupc++") },
334   { STRING_COMMA_LEN ("libobjc") },
335   { STRING_COMMA_LEN ("libgcj") },
336   { NULL, 0 }
337 };
338
339 /* Regardless of the suffix issue mentioned above, we must ensure that
340   we do not falsely match on a leading substring, such as when libtool
341   builds libstdc++ as a DLL using libsupc++convenience.a as an intermediate.
342   This routine ensures that the leading part of the name matches and that
343   it is followed by only an optional version suffix and a file extension,
344   returning zero if so or -1 if not.  */
345 static int libnamencmp (const char *libname, const autofilter_entry_type *afptr)
346 {
347   if (filename_ncmp (libname, afptr->name, afptr->len))
348     return -1;
349
350   libname += afptr->len;
351
352   /* Be liberal in interpreting what counts as a version suffix; we
353     accept anything that has a dash to separate it from the name and
354     begins with a digit.  */
355   if (libname[0] == '-')
356     {
357       if (!ISDIGIT (*++libname))
358         return -1;
359       /* Ensure the filename has an extension.  */
360       while (*++libname != '.')
361         if (!*libname)
362           return -1;
363     }
364   else if (libname[0] != '.')
365     return -1;
366
367   return 0;
368 }
369
370 static const autofilter_entry_type autofilter_objlist[] =
371 {
372   { STRING_COMMA_LEN ("crt0.o") },
373   { STRING_COMMA_LEN ("crt1.o") },
374   { STRING_COMMA_LEN ("crt2.o") },
375   { STRING_COMMA_LEN ("dllcrt1.o") },
376   { STRING_COMMA_LEN ("dllcrt2.o") },
377   { STRING_COMMA_LEN ("gcrt0.o") },
378   { STRING_COMMA_LEN ("gcrt1.o") },
379   { STRING_COMMA_LEN ("gcrt2.o") },
380   { STRING_COMMA_LEN ("crtbegin.o") },
381   { STRING_COMMA_LEN ("crtend.o") },
382   { NULL, 0 }
383 };
384
385 static const autofilter_entry_type autofilter_symbolprefixlist[] =
386 {
387   /* _imp_ is treated specially, as it is always underscored.  */
388   /* { STRING_COMMA_LEN ("_imp_") },  */
389   /* Don't export some c++ symbols.  */
390   { STRING_COMMA_LEN ("__rtti_") },
391   { STRING_COMMA_LEN ("__builtin_") },
392   /* Don't re-export auto-imported symbols.  */
393   { STRING_COMMA_LEN ("__nm_") },
394   /* Don't export symbols specifying internal DLL layout.  */
395   { STRING_COMMA_LEN ("_head_") },
396   { STRING_COMMA_LEN ("_IMPORT_DESCRIPTOR_") },
397   /* Don't export section labels or artificial symbols
398   (eg ".weak.foo".  */
399   { STRING_COMMA_LEN (".") },
400   { NULL, 0 }
401 };
402
403 static const autofilter_entry_type autofilter_symbolsuffixlist[] =
404 {
405   { STRING_COMMA_LEN ("_iname") },
406   { STRING_COMMA_LEN ("_NULL_THUNK_DATA") },
407   { NULL, 0 }
408 };
409
410 #define U(str) (pe_details->underscored ? "_" str : str)
411
412 void
413 pe_dll_id_target (const char *target)
414 {
415   int i;
416
417   for (i = 0; pe_detail_list[i].target_name; i++)
418     if (strcmp (pe_detail_list[i].target_name, target) == 0
419         || strcmp (pe_detail_list[i].object_target, target) == 0)
420       {
421         int u = pe_leading_underscore; /* Underscoring mode. -1 for use default.  */
422         if (u == -1)
423           bfd_get_target_info (target, NULL, NULL, &u, NULL);
424         if (u == -1)
425           abort ();
426         pe_detail_list[i].underscored = (u != 0 ? TRUE : FALSE);
427         pe_details = pe_detail_list + i;
428         pe_leading_underscore = (u != 0 ? 1 : 0);
429         return;
430       }
431   einfo (_("%XUnsupported PEI architecture: %s\n"), target);
432   exit (1);
433 }
434
435 /* Helper functions for qsort.  Relocs must be sorted so that we can write
436    them out by pages.  */
437
438 typedef struct
439   {
440     bfd_vma vma;
441     char type;
442     short extra;
443   }
444 reloc_data_type;
445
446 static int
447 reloc_sort (const void *va, const void *vb)
448 {
449   bfd_vma a = ((const reloc_data_type *) va)->vma;
450   bfd_vma b = ((const reloc_data_type *) vb)->vma;
451
452   return (a > b) ? 1 : ((a < b) ? -1 : 0);
453 }
454
455 static int
456 pe_export_sort (const void *va, const void *vb)
457 {
458   const def_file_export *a = va;
459   const def_file_export *b = vb;
460   char *an = a->name;
461   char *bn = b->name;
462   if (a->its_name)
463     an = a->its_name;
464   if (b->its_name)
465     bn = b->its_name;
466
467   return strcmp (an, bn);
468 }
469
470 /* Read and process the .DEF file.  */
471
472 /* These correspond to the entries in pe_def_file->exports[].  I use
473    exported_symbol_sections[i] to tag whether or not the symbol was
474    defined, since we can't export symbols we don't have.  */
475
476 static bfd_vma *exported_symbol_offsets;
477 static struct bfd_section **exported_symbol_sections;
478 static int export_table_size;
479 static int count_exported;
480 static int count_exported_byname;
481 static int count_with_ordinals;
482 static const char *dll_name;
483 static int min_ordinal, max_ordinal;
484 static int *exported_symbols;
485
486 typedef struct exclude_list_struct
487   {
488     char *string;
489     struct exclude_list_struct *next;
490     exclude_type type;
491   }
492 exclude_list_struct;
493
494 static struct exclude_list_struct *excludes = 0;
495
496 void
497 pe_dll_add_excludes (const char *new_excludes, const exclude_type type)
498 {
499   char *local_copy;
500   char *exclude_string;
501
502   local_copy = xstrdup (new_excludes);
503
504   exclude_string = strtok (local_copy, ",:");
505   for (; exclude_string; exclude_string = strtok (NULL, ",:"))
506     {
507       struct exclude_list_struct *new_exclude;
508
509       new_exclude = xmalloc (sizeof (struct exclude_list_struct));
510       new_exclude->string = xmalloc (strlen (exclude_string) + 1);
511       strcpy (new_exclude->string, exclude_string);
512       new_exclude->type = type;
513       new_exclude->next = excludes;
514       excludes = new_exclude;
515     }
516
517   free (local_copy);
518 }
519
520 static bfd_boolean
521 is_import (const char* n)
522 {
523   return (CONST_STRNEQ (n, "__imp_"));
524 }
525
526 /* abfd is a bfd containing n (or NULL)
527    It can be used for contextual checks.  */
528
529 static int
530 auto_export (bfd *abfd, def_file *d, const char *n)
531 {
532   def_file_export key;
533   struct exclude_list_struct *ex;
534   const autofilter_entry_type *afptr;
535   const char * libname = NULL;
536
537   if (abfd && abfd->my_archive)
538     libname = lbasename (abfd->my_archive->filename);
539
540   key.name = key.its_name = (char *) n;
541
542   /* Return false if n is in the d->exports table.  */
543   if (bsearch (&key, d->exports, d->num_exports,
544                sizeof (pe_def_file->exports[0]), pe_export_sort))
545     return 0;
546
547   if (pe_dll_do_default_excludes)
548     {
549       const char * p;
550       int    len;
551
552       if (pe_dll_extra_pe_debug)
553         printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
554                 n, abfd, abfd->my_archive);
555
556       /* First of all, make context checks:
557          Don't export anything from standard libs.  */
558       if (libname)
559         {
560           afptr = autofilter_liblist;
561
562           while (afptr->name)
563             {
564               if (libnamencmp (libname, afptr) == 0 )
565                 return 0;
566               afptr++;
567             }
568         }
569
570       /* Next, exclude symbols from certain startup objects.  */
571
572       if (abfd && (p = lbasename (abfd->filename)))
573         {
574           afptr = autofilter_objlist;
575           while (afptr->name)
576             {
577               if (strcmp (p, afptr->name) == 0)
578                 return 0;
579               afptr++;
580             }
581         }
582
583       /* Don't try to blindly exclude all symbols
584          that begin with '__'; this was tried and
585          it is too restrictive.  Instead we have
586          a target specific list to use:  */
587       afptr = pe_details->autofilter_symbollist;
588
589       while (afptr->name)
590         {
591           if (strcmp (n, afptr->name) == 0)
592             return 0;
593
594           afptr++;
595         }
596
597       /* Next, exclude symbols starting with ...  */
598       afptr = autofilter_symbolprefixlist;
599       while (afptr->name)
600         {
601           if (strncmp (n, afptr->name, afptr->len) == 0)
602             return 0;
603
604           afptr++;
605         }
606
607       /* Finally, exclude symbols ending with ...  */
608       len = strlen (n);
609       afptr = autofilter_symbolsuffixlist;
610       while (afptr->name)
611         {
612           if ((len >= afptr->len)
613               /* Add 1 to insure match with trailing '\0'.  */
614               && strncmp (n + len - afptr->len, afptr->name,
615                           afptr->len + 1) == 0)
616             return 0;
617
618           afptr++;
619         }
620     }
621
622   for (ex = excludes; ex; ex = ex->next)
623     {
624       if (ex->type == EXCLUDELIBS)
625         {
626           if (libname
627               && ((filename_cmp (libname, ex->string) == 0)
628                    || (strcasecmp ("ALL", ex->string) == 0)))
629             return 0;
630         }
631       else if (ex->type == EXCLUDEFORIMPLIB)
632         {
633           if (filename_cmp (abfd->filename, ex->string) == 0)
634             return 0;
635         }
636       else if (strcmp (n, ex->string) == 0)
637         return 0;
638     }
639
640   return 1;
641 }
642
643 static void
644 process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
645 {
646   int i, j;
647   struct bfd_link_hash_entry *blhe;
648   bfd *b;
649   struct bfd_section *s;
650   def_file_export *e = 0;
651   bfd_boolean resort_needed;
652
653   if (!pe_def_file)
654     pe_def_file = def_file_empty ();
655
656   /* First, run around to all the objects looking for the .drectve
657      sections, and push those into the def file too.  */
658   for (b = info->input_bfds; b; b = b->link_next)
659     {
660       s = bfd_get_section_by_name (b, ".drectve");
661       if (s)
662         {
663           long size = s->size;
664           char *buf = xmalloc (size);
665
666           bfd_get_section_contents (b, s, buf, 0, size);
667           def_file_add_directive (pe_def_file, buf, size);
668           free (buf);
669         }
670     }
671
672   /* Process aligned common symbol information from the
673      .drectve sections now; common symbol allocation is
674      done before final link, so it will be too late to
675      process them in process_embedded_commands() called
676      from _bfd_coff_link_input_bfd().  */
677   if (pe_def_file->aligncomms)
678     {
679       def_file_aligncomm *ac = pe_def_file->aligncomms;
680       while (ac)
681         {
682           struct coff_link_hash_entry *sym_hash;
683           sym_hash = coff_link_hash_lookup (coff_hash_table (info),
684                 ac->symbol_name, FALSE, FALSE, FALSE);
685           if (sym_hash && sym_hash->root.type == bfd_link_hash_common
686             && sym_hash->root.u.c.p->alignment_power < (unsigned) ac->alignment)
687             {
688               sym_hash->root.u.c.p->alignment_power = (unsigned) ac->alignment;
689             }
690           ac = ac->next;
691         }
692     }
693
694   /* If we are building an executable and there is nothing
695      to export, we do not build an export table at all.  */
696   if (info->executable && pe_def_file->num_exports == 0
697       && (!pe_dll_export_everything || pe_dll_exclude_all_symbols))
698     return;
699
700   /* Now, maybe export everything else the default way.  */
701   if ((pe_dll_export_everything || pe_def_file->num_exports == 0)
702       && !pe_dll_exclude_all_symbols)
703     {
704       for (b = info->input_bfds; b; b = b->link_next)
705         {
706           asymbol **symbols;
707           int nsyms;
708
709           if (!bfd_generic_link_read_symbols (b))
710             {
711               einfo (_("%B%F: could not read symbols: %E\n"), b);
712               return;
713             }
714
715           symbols = bfd_get_outsymbols (b);
716           nsyms = bfd_get_symcount (b);
717
718           for (j = 0; j < nsyms; j++)
719             {
720               /* We should export symbols which are either global or not
721                  anything at all.  (.bss data is the latter)
722                  We should not export undefined symbols.  */
723               bfd_boolean would_export = symbols[j]->section != &bfd_und_section
724                       && ((symbols[j]->flags & BSF_GLOBAL)
725                           || (symbols[j]->flags == 0));
726               if (link_info.version_info && would_export)
727                   would_export
728                     = !bfd_hide_sym_by_version (link_info.version_info,
729                                                 symbols[j]->name);
730               if (would_export)
731                 {
732                   const char *sn = symbols[j]->name;
733
734                   /* We should not re-export imported stuff.  */
735                   {
736                     char *name;
737                     if (is_import (sn))
738                           continue;
739
740                     name = xmalloc (strlen ("__imp_") + strlen (sn) + 1);
741                     sprintf (name, "%s%s", "__imp_", sn);
742
743                     blhe = bfd_link_hash_lookup (info->hash, name,
744                                                  FALSE, FALSE, FALSE);
745                     free (name);
746
747                     if (blhe && blhe->type == bfd_link_hash_defined)
748                       continue;
749                   }
750
751                   if (pe_details->underscored && *sn == '_')
752                     sn++;
753
754                   if (auto_export (b, pe_def_file, sn))
755                     {
756                       int is_dup = 0;
757                       def_file_export *p;
758
759                       p = def_file_add_export (pe_def_file, sn, 0, -1,
760                                                NULL, &is_dup);
761                       /* Fill data flag properly, from dlltool.c.  */
762                       if (!is_dup)
763                         p->flag_data = !(symbols[j]->flags & BSF_FUNCTION);
764                     }
765                 }
766             }
767         }
768     }
769
770 #undef NE
771 #define NE pe_def_file->num_exports
772
773   /* Don't create an empty export table.  */
774   if (NE == 0)
775     return;
776
777   resort_needed = FALSE;
778
779   /* Canonicalize the export list.  */
780   if (pe_dll_kill_ats)
781     {
782       for (i = 0; i < NE; i++)
783         {
784           if (strchr (pe_def_file->exports[i].name, '@'))
785             {
786               /* This will preserve internal_name, which may have been
787                  pointing to the same memory as name, or might not
788                  have.  */
789               int lead_at = (*pe_def_file->exports[i].name == '@');
790               char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
791               char *tmp_at = strchr (tmp, '@');
792
793               if (tmp_at)
794                 *tmp_at = 0;
795               else
796                 einfo (_("%XCannot export %s: invalid export name\n"),
797                        pe_def_file->exports[i].name);
798               pe_def_file->exports[i].name = tmp;
799               resort_needed = TRUE;
800             }
801         }
802     }
803
804   /* Re-sort the exports table as we have possibly changed the order
805      by removing leading @.  */
806   if (resort_needed)
807     qsort (pe_def_file->exports, NE, sizeof (pe_def_file->exports[0]),
808            pe_export_sort);
809
810   if (pe_dll_stdcall_aliases)
811     {
812       for (i = 0; i < NE; i++)
813         {
814           if (is_import (pe_def_file->exports[i].name))
815             continue;
816
817           if (strchr (pe_def_file->exports[i].name, '@'))
818             {
819               int is_dup = 1;
820               int lead_at = (*pe_def_file->exports[i].name == '@');
821               char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
822
823               *(strchr (tmp, '@')) = 0;
824               if (auto_export (NULL, pe_def_file, tmp))
825                 def_file_add_export (pe_def_file, tmp,
826                                      pe_def_file->exports[i].internal_name,
827                                      -1, NULL, &is_dup);
828               if (is_dup)
829                 free (tmp);
830             }
831         }
832     }
833
834   /* Convenience, but watch out for it changing.  */
835   e = pe_def_file->exports;
836
837   exported_symbol_offsets = xmalloc (NE * sizeof (bfd_vma));
838   exported_symbol_sections = xmalloc (NE * sizeof (struct bfd_section *));
839
840   memset (exported_symbol_sections, 0, NE * sizeof (struct bfd_section *));
841   max_ordinal = 0;
842   min_ordinal = 65536;
843   count_exported = 0;
844   count_exported_byname = 0;
845   count_with_ordinals = 0;
846
847   for (i = 0, j = 0; i < NE; i++)
848     {
849       if (i > 0 && strcmp (e[i].name, e[i - 1].name) == 0)
850         {
851           /* This is a duplicate.  */
852           if (e[j - 1].ordinal != -1
853               && e[i].ordinal != -1
854               && e[j - 1].ordinal != e[i].ordinal)
855             {
856               if (pe_dll_warn_dup_exports)
857                 /* xgettext:c-format */
858                 einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
859                        e[j - 1].name, e[j - 1].ordinal, e[i].ordinal);
860             }
861           else
862             {
863               if (pe_dll_warn_dup_exports)
864                 /* xgettext:c-format */
865                 einfo (_("Warning, duplicate EXPORT: %s\n"),
866                        e[j - 1].name);
867             }
868
869           if (e[i].ordinal != -1)
870             e[j - 1].ordinal = e[i].ordinal;
871           e[j - 1].flag_private |= e[i].flag_private;
872           e[j - 1].flag_constant |= e[i].flag_constant;
873           e[j - 1].flag_noname |= e[i].flag_noname;
874           e[j - 1].flag_data |= e[i].flag_data;
875         }
876       else
877         {
878           if (i != j)
879             e[j] = e[i];
880           j++;
881         }
882     }
883   pe_def_file->num_exports = j; /* == NE */
884
885   for (i = 0; i < NE; i++)
886     {
887       char *name;
888       name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
889       if (pe_details->underscored
890           && (*pe_def_file->exports[i].internal_name != '@'))
891         {
892           *name = '_';
893           strcpy (name + 1, pe_def_file->exports[i].internal_name);
894         }
895       else
896         strcpy (name, pe_def_file->exports[i].internal_name);
897
898       blhe = bfd_link_hash_lookup (info->hash,
899                                    name,
900                                    FALSE, FALSE, TRUE);
901
902       if (blhe
903           && (blhe->type == bfd_link_hash_defined
904               || (blhe->type == bfd_link_hash_common)))
905         {
906           count_exported++;
907           if (!pe_def_file->exports[i].flag_noname)
908             count_exported_byname++;
909
910           /* Only fill in the sections. The actual offsets are computed
911              in fill_exported_offsets() after common symbols are laid
912              out.  */
913           if (blhe->type == bfd_link_hash_defined)
914             exported_symbol_sections[i] = blhe->u.def.section;
915           else
916             exported_symbol_sections[i] = blhe->u.c.p->section;
917
918           if (pe_def_file->exports[i].ordinal != -1)
919             {
920               if (max_ordinal < pe_def_file->exports[i].ordinal)
921                 max_ordinal = pe_def_file->exports[i].ordinal;
922               if (min_ordinal > pe_def_file->exports[i].ordinal)
923                 min_ordinal = pe_def_file->exports[i].ordinal;
924               count_with_ordinals++;
925             }
926         }
927       /* Check for forward exports.  These are indicated in DEF files by an
928          export directive of the form NAME1 = MODULE-NAME.EXTERNAL-NAME
929          but we must take care not to be fooled when the user wants to export
930          a symbol that actually really has a dot in it, so we only check
931          for them here, after real defined symbols have already been matched.  */
932       else if (strchr (pe_def_file->exports[i].internal_name, '.'))
933         {
934           count_exported++;
935           if (!pe_def_file->exports[i].flag_noname)
936             count_exported_byname++;
937
938           pe_def_file->exports[i].flag_forward = 1;
939
940           if (pe_def_file->exports[i].ordinal != -1)
941             {
942               if (max_ordinal < pe_def_file->exports[i].ordinal)
943                 max_ordinal = pe_def_file->exports[i].ordinal;
944               if (min_ordinal > pe_def_file->exports[i].ordinal)
945                 min_ordinal = pe_def_file->exports[i].ordinal;
946               count_with_ordinals++;
947             }
948         }
949       else if (blhe && blhe->type == bfd_link_hash_undefined)
950         {
951           /* xgettext:c-format */
952           einfo (_("%XCannot export %s: symbol not defined\n"),
953                  pe_def_file->exports[i].internal_name);
954         }
955       else if (blhe)
956         {
957           /* xgettext:c-format */
958           einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
959                  pe_def_file->exports[i].internal_name,
960                  blhe->type, bfd_link_hash_defined);
961         }
962       else
963         {
964           /* xgettext:c-format */
965           einfo (_("%XCannot export %s: symbol not found\n"),
966                  pe_def_file->exports[i].internal_name);
967         }
968       free (name);
969     }
970 }
971
972 /* Build the bfd that will contain .edata and .reloc sections.  */
973
974 static void
975 build_filler_bfd (int include_edata)
976 {
977   lang_input_statement_type *filler_file;
978   filler_file = lang_add_input_file ("dll stuff",
979                                      lang_input_file_is_fake_enum,
980                                      NULL);
981   filler_file->the_bfd = filler_bfd = bfd_create ("dll stuff",
982                                                   link_info.output_bfd);
983   if (filler_bfd == NULL
984       || !bfd_set_arch_mach (filler_bfd,
985                              bfd_get_arch (link_info.output_bfd),
986                              bfd_get_mach (link_info.output_bfd)))
987     {
988       einfo ("%X%P: can not create BFD: %E\n");
989       return;
990     }
991
992   if (include_edata)
993     {
994       edata_s = bfd_make_section_old_way (filler_bfd, ".edata");
995       if (edata_s == NULL
996           || !bfd_set_section_flags (filler_bfd, edata_s,
997                                      (SEC_HAS_CONTENTS
998                                       | SEC_ALLOC
999                                       | SEC_LOAD
1000                                       | SEC_KEEP
1001                                       | SEC_IN_MEMORY)))
1002         {
1003           einfo ("%X%P: can not create .edata section: %E\n");
1004           return;
1005         }
1006       bfd_set_section_size (filler_bfd, edata_s, edata_sz);
1007     }
1008
1009   reloc_s = bfd_make_section_old_way (filler_bfd, ".reloc");
1010   if (reloc_s == NULL
1011       || !bfd_set_section_flags (filler_bfd, reloc_s,
1012                                  (SEC_HAS_CONTENTS
1013                                   | SEC_ALLOC
1014                                   | SEC_LOAD
1015                                   | SEC_KEEP
1016                                   | SEC_IN_MEMORY)))
1017     {
1018       einfo ("%X%P: can not create .reloc section: %E\n");
1019       return;
1020     }
1021
1022   bfd_set_section_size (filler_bfd, reloc_s, 0);
1023
1024   ldlang_add_file (filler_file);
1025 }
1026
1027 /* Gather all the exported symbols and build the .edata section.  */
1028
1029 static void
1030 generate_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
1031 {
1032   int i, next_ordinal;
1033   int name_table_size = 0;
1034   const char *dlnp;
1035
1036   /* First, we need to know how many exported symbols there are,
1037      and what the range of ordinals is.  */
1038   if (pe_def_file->name)
1039     dll_name = pe_def_file->name;
1040   else
1041     {
1042       dll_name = abfd->filename;
1043
1044       for (dlnp = dll_name; *dlnp; dlnp++)
1045         if (*dlnp == '\\' || *dlnp == '/' || *dlnp == ':')
1046           dll_name = dlnp + 1;
1047     }
1048
1049   if (count_with_ordinals && max_ordinal > count_exported)
1050     {
1051       if (min_ordinal > max_ordinal - count_exported + 1)
1052         min_ordinal = max_ordinal - count_exported + 1;
1053     }
1054   else
1055     {
1056       min_ordinal = 1;
1057       max_ordinal = count_exported;
1058     }
1059
1060   export_table_size = max_ordinal - min_ordinal + 1;
1061   exported_symbols = xmalloc (export_table_size * sizeof (int));
1062   for (i = 0; i < export_table_size; i++)
1063     exported_symbols[i] = -1;
1064
1065   /* Now we need to assign ordinals to those that don't have them.  */
1066   for (i = 0; i < NE; i++)
1067     {
1068       if (exported_symbol_sections[i] ||
1069           pe_def_file->exports[i].flag_forward)
1070         {
1071           if (pe_def_file->exports[i].ordinal != -1)
1072             {
1073               int ei = pe_def_file->exports[i].ordinal - min_ordinal;
1074               int pi = exported_symbols[ei];
1075
1076               if (pi != -1)
1077                 {
1078                   /* xgettext:c-format */
1079                   einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
1080                          pe_def_file->exports[i].ordinal,
1081                          pe_def_file->exports[i].name,
1082                          pe_def_file->exports[pi].name);
1083                 }
1084               exported_symbols[ei] = i;
1085             }
1086           if (pe_def_file->exports[i].its_name)
1087             name_table_size += strlen (pe_def_file->exports[i].its_name) + 1;
1088           else
1089             name_table_size += strlen (pe_def_file->exports[i].name) + 1;
1090         }
1091
1092       /* Reserve space for the forward name. */
1093       if (pe_def_file->exports[i].flag_forward)
1094         {
1095           name_table_size += strlen (pe_def_file->exports[i].internal_name) + 1;
1096         }
1097     }
1098
1099   next_ordinal = min_ordinal;
1100   for (i = 0; i < NE; i++)
1101     if ((exported_symbol_sections[i] ||
1102          pe_def_file->exports[i].flag_forward) &&
1103         pe_def_file->exports[i].ordinal == -1)
1104       {
1105         while (exported_symbols[next_ordinal - min_ordinal] != -1)
1106           next_ordinal++;
1107
1108         exported_symbols[next_ordinal - min_ordinal] = i;
1109         pe_def_file->exports[i].ordinal = next_ordinal;
1110       }
1111
1112   /* OK, now we can allocate some memory.  */
1113   edata_sz = (40                                /* directory */
1114               + 4 * export_table_size           /* addresses */
1115               + 4 * count_exported_byname       /* name ptrs */
1116               + 2 * count_exported_byname       /* ordinals */
1117               + name_table_size + strlen (dll_name) + 1);
1118 }
1119
1120 /* Fill the exported symbol offsets. The preliminary work has already
1121    been done in process_def_file_and_drectve().  */
1122
1123 static void
1124 fill_exported_offsets (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
1125 {
1126   int i;
1127   struct bfd_link_hash_entry *blhe;
1128
1129   for (i = 0; i < pe_def_file->num_exports; i++)
1130     {
1131       char *name;
1132
1133       name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
1134       if (pe_details->underscored
1135           && *pe_def_file->exports[i].internal_name != '@')
1136         {
1137           *name = '_';
1138           strcpy (name + 1, pe_def_file->exports[i].internal_name);
1139         }
1140       else
1141         strcpy (name, pe_def_file->exports[i].internal_name);
1142
1143       blhe = bfd_link_hash_lookup (info->hash,
1144                                    name,
1145                                    FALSE, FALSE, TRUE);
1146
1147       if (blhe && blhe->type == bfd_link_hash_defined)
1148         exported_symbol_offsets[i] = blhe->u.def.value;
1149
1150       free (name);
1151     }
1152 }
1153
1154 static void
1155 fill_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
1156 {
1157   int s, hint;
1158   unsigned char *edirectory;
1159   unsigned char *eaddresses;
1160   unsigned char *enameptrs;
1161   unsigned char *eordinals;
1162   char *enamestr;
1163   time_t now;
1164
1165   time (&now);
1166
1167   edata_d = xmalloc (edata_sz);
1168
1169   /* Note use of array pointer math here.  */
1170   edirectory = edata_d;
1171   eaddresses = edirectory + 40;
1172   enameptrs = eaddresses + 4 * export_table_size;
1173   eordinals = enameptrs + 4 * count_exported_byname;
1174   enamestr = (char *) eordinals + 2 * count_exported_byname;
1175
1176 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1177                    + edata_s->output_section->vma - image_base)
1178
1179   memset (edata_d, 0, edata_sz);
1180   bfd_put_32 (abfd, now, edata_d + 4);
1181   if (pe_def_file->version_major != -1)
1182     {
1183       bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8);
1184       bfd_put_16 (abfd, pe_def_file->version_minor, edata_d + 10);
1185     }
1186
1187   bfd_put_32 (abfd, ERVA (enamestr), edata_d + 12);
1188   strcpy (enamestr, dll_name);
1189   enamestr += strlen (enamestr) + 1;
1190   bfd_put_32 (abfd, min_ordinal, edata_d + 16);
1191   bfd_put_32 (abfd, export_table_size, edata_d + 20);
1192   bfd_put_32 (abfd, count_exported_byname, edata_d + 24);
1193   bfd_put_32 (abfd, ERVA (eaddresses), edata_d + 28);
1194   bfd_put_32 (abfd, ERVA (enameptrs), edata_d + 32);
1195   bfd_put_32 (abfd, ERVA (eordinals), edata_d + 36);
1196
1197   fill_exported_offsets (abfd, info);
1198
1199   /* Ok, now for the filling in part.
1200      Scan alphabetically - ie the ordering in the exports[] table,
1201      rather than by ordinal - the ordering in the exported_symbol[]
1202      table.  See dlltool.c and:
1203         http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1204      for more information.  */
1205   hint = 0;
1206   for (s = 0; s < NE; s++)
1207     {
1208       struct bfd_section *ssec = exported_symbol_sections[s];
1209       if (pe_def_file->exports[s].ordinal != -1 &&
1210           (pe_def_file->exports[s].flag_forward || ssec != NULL))
1211         {
1212           int ord = pe_def_file->exports[s].ordinal;
1213
1214           if (pe_def_file->exports[s].flag_forward)
1215             {
1216               bfd_put_32 (abfd, ERVA (enamestr),
1217                           eaddresses + 4 * (ord - min_ordinal));
1218
1219               strcpy (enamestr, pe_def_file->exports[s].internal_name);
1220               enamestr += strlen (pe_def_file->exports[s].internal_name) + 1;
1221             }
1222           else
1223             {
1224               bfd_vma srva = (exported_symbol_offsets[s]
1225                                     + ssec->output_section->vma
1226                                     + ssec->output_offset);
1227
1228               bfd_put_32 (abfd, srva - image_base,
1229                           eaddresses + 4 * (ord - min_ordinal));
1230             }
1231
1232           if (!pe_def_file->exports[s].flag_noname)
1233             {
1234               char *ename = pe_def_file->exports[s].name;
1235               if (pe_def_file->exports[s].its_name)
1236                 ename = pe_def_file->exports[s].its_name;
1237
1238               bfd_put_32 (abfd, ERVA (enamestr), enameptrs);
1239               enameptrs += 4;
1240               strcpy (enamestr, ename);
1241               enamestr += strlen (enamestr) + 1;
1242               bfd_put_16 (abfd, ord - min_ordinal, eordinals);
1243               eordinals += 2;
1244               pe_def_file->exports[s].hint = hint++;
1245             }
1246         }
1247     }
1248 }
1249
1250
1251 static struct bfd_section *current_sec;
1252
1253 void
1254 pe_walk_relocs_of_symbol (struct bfd_link_info *info,
1255                           const char *name,
1256                           int (*cb) (arelent *, asection *))
1257 {
1258   bfd *b;
1259   asection *s;
1260
1261   for (b = info->input_bfds; b; b = b->link_next)
1262     {
1263       asymbol **symbols;
1264
1265       if (!bfd_generic_link_read_symbols (b))
1266         {
1267           einfo (_("%B%F: could not read symbols: %E\n"), b);
1268           return;
1269         }
1270
1271       symbols = bfd_get_outsymbols (b);
1272
1273       for (s = b->sections; s; s = s->next)
1274         {
1275           arelent **relocs;
1276           int relsize, nrelocs, i;
1277           int flags = bfd_get_section_flags (b, s);
1278
1279           /* Skip discarded linkonce sections.  */
1280           if (flags & SEC_LINK_ONCE
1281               && s->output_section == bfd_abs_section_ptr)
1282             continue;
1283
1284           current_sec = s;
1285
1286           relsize = bfd_get_reloc_upper_bound (b, s);
1287           relocs = xmalloc (relsize);
1288           nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1289
1290           for (i = 0; i < nrelocs; i++)
1291             {
1292               struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1293
1294               if (!strcmp (name, sym->name))
1295                 cb (relocs[i], s);
1296             }
1297
1298           free (relocs);
1299
1300           /* Warning: the allocated symbols are remembered in BFD and reused
1301              later, so don't free them! */
1302           /* free (symbols); */
1303         }
1304     }
1305 }
1306
1307 /* Gather all the relocations and build the .reloc section.  */
1308
1309 static void
1310 generate_reloc (bfd *abfd, struct bfd_link_info *info)
1311 {
1312
1313   /* For .reloc stuff.  */
1314   reloc_data_type *reloc_data;
1315   int total_relocs = 0;
1316   int i;
1317   bfd_vma sec_page = (bfd_vma) -1;
1318   bfd_vma page_ptr, page_count;
1319   int bi;
1320   bfd *b;
1321   struct bfd_section *s;
1322
1323   total_relocs = 0;
1324   for (b = info->input_bfds; b; b = b->link_next)
1325     for (s = b->sections; s; s = s->next)
1326       total_relocs += s->reloc_count;
1327
1328   reloc_data = xmalloc (total_relocs * sizeof (reloc_data_type));
1329
1330   total_relocs = 0;
1331   bi = 0;
1332   for (bi = 0, b = info->input_bfds; b; bi++, b = b->link_next)
1333     {
1334       arelent **relocs;
1335       int relsize, nrelocs;
1336
1337       for (s = b->sections; s; s = s->next)
1338         {
1339           bfd_vma sec_vma = s->output_section->vma + s->output_offset;
1340           asymbol **symbols;
1341
1342           /* If it's not loaded, we don't need to relocate it this way.  */
1343           if (!(s->output_section->flags & SEC_LOAD))
1344             continue;
1345
1346           /* I don't know why there would be a reloc for these, but I've
1347              seen it happen - DJ  */
1348           if (s->output_section == &bfd_abs_section)
1349             continue;
1350
1351           if (s->output_section->vma == 0)
1352             {
1353               /* Huh?  Shouldn't happen, but punt if it does.  */
1354               einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
1355                      s->output_section->name, s->output_section->index,
1356                      s->output_section->flags);
1357               continue;
1358             }
1359
1360           if (!bfd_generic_link_read_symbols (b))
1361             {
1362               einfo (_("%B%F: could not read symbols: %E\n"), b);
1363               return;
1364             }
1365
1366           symbols = bfd_get_outsymbols (b);
1367           relsize = bfd_get_reloc_upper_bound (b, s);
1368           relocs = xmalloc (relsize);
1369           nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1370
1371           for (i = 0; i < nrelocs; i++)
1372             {
1373               if (pe_dll_extra_pe_debug)
1374                 {
1375                   struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1376                   printf ("rel: %s\n", sym->name);
1377                 }
1378               if (!relocs[i]->howto->pc_relative
1379                   && relocs[i]->howto->type != pe_details->imagebase_reloc)
1380                 {
1381                   struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1382
1383                   /* Don't create relocs for undefined weak symbols.  */
1384                   if (sym->flags == BSF_WEAK)
1385                     {
1386                       struct bfd_link_hash_entry *blhe
1387                         = bfd_wrapped_link_hash_lookup (abfd, info, sym->name,
1388                                                 FALSE, FALSE, FALSE);
1389                       if (blhe && blhe->type == bfd_link_hash_undefweak)
1390                         {
1391                           /* Check aux sym and see if it is defined or not. */
1392                           struct coff_link_hash_entry *h, *h2;
1393                           h = (struct coff_link_hash_entry *)blhe;
1394                           if (h->symbol_class != C_NT_WEAK || h->numaux != 1)
1395                             continue;
1396                           h2 = h->auxbfd->tdata.coff_obj_data->sym_hashes
1397                                                 [h->aux->x_sym.x_tagndx.l];
1398                           /* We don't want a base reloc if the aux sym is not
1399                              found, undefined, or if it is the constant ABS
1400                              zero default value.  (We broaden that slightly by
1401                              not testing the value, just the section; there's
1402                              no reason we'd want a reference to any absolute
1403                              address to get relocated during rebasing).  */
1404                           if (!h2 || h2->root.type == bfd_link_hash_undefined
1405                                 || h2->root.u.def.section == &bfd_abs_section)
1406                             continue;
1407                         }
1408                       else if (!blhe || blhe->type != bfd_link_hash_defined)
1409                         continue;
1410                     }
1411                   /* Nor for Dwarf FDE references to discarded sections.  */
1412                   else if (bfd_is_abs_section (sym->section->output_section))
1413                     {
1414                       /* We only ignore relocs from .eh_frame sections, as
1415                          they are discarded by the final link rather than
1416                          resolved against the kept section.  */
1417                       if (!strcmp (s->name, ".eh_frame"))
1418                         continue;
1419                     }
1420
1421                   reloc_data[total_relocs].vma = sec_vma + relocs[i]->address;
1422
1423 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1424
1425                   switch BITS_AND_SHIFT (relocs[i]->howto->bitsize,
1426                                          relocs[i]->howto->rightshift)
1427                     {
1428 #ifdef pe_use_x86_64
1429                     case BITS_AND_SHIFT (64, 0):
1430                       reloc_data[total_relocs].type = 10;
1431                       total_relocs++;
1432                       break;
1433 #endif
1434                     case BITS_AND_SHIFT (32, 0):
1435                       reloc_data[total_relocs].type = 3;
1436                       total_relocs++;
1437                       break;
1438                     case BITS_AND_SHIFT (16, 0):
1439                       reloc_data[total_relocs].type = 2;
1440                       total_relocs++;
1441                       break;
1442                     case BITS_AND_SHIFT (16, 16):
1443                       reloc_data[total_relocs].type = 4;
1444                       /* FIXME: we can't know the symbol's right value
1445                          yet, but we probably can safely assume that
1446                          CE will relocate us in 64k blocks, so leaving
1447                          it zero is safe.  */
1448                       reloc_data[total_relocs].extra = 0;
1449                       total_relocs++;
1450                       break;
1451                     case BITS_AND_SHIFT (26, 2):
1452                       reloc_data[total_relocs].type = 5;
1453                       total_relocs++;
1454                       break;
1455                     case BITS_AND_SHIFT (24, 2):
1456                       /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1457                          Those ARM_xxx definitions should go in proper
1458                          header someday.  */
1459                       if (relocs[i]->howto->type == 0
1460                           /* Older GNU linkers used 5 instead of 0 for this reloc.  */
1461                           || relocs[i]->howto->type == 5)
1462                         /* This is an ARM_26D reloc, which is an ARM_26 reloc
1463                            that has already been fully processed during a
1464                            previous link stage, so ignore it here.  */
1465                         break;
1466                       /* Fall through.  */
1467                     default:
1468                       /* xgettext:c-format */
1469                       einfo (_("%XError: %d-bit reloc in dll\n"),
1470                              relocs[i]->howto->bitsize);
1471                       break;
1472                     }
1473                 }
1474             }
1475           free (relocs);
1476           /* Warning: the allocated symbols are remembered in BFD and
1477              reused later, so don't free them!  */
1478         }
1479     }
1480
1481   /* At this point, we have total_relocs relocation addresses in
1482      reloc_addresses, which are all suitable for the .reloc section.
1483      We must now create the new sections.  */
1484   qsort (reloc_data, total_relocs, sizeof (*reloc_data), reloc_sort);
1485
1486   for (i = 0; i < total_relocs; i++)
1487     {
1488       bfd_vma this_page = (reloc_data[i].vma >> 12);
1489
1490       if (this_page != sec_page)
1491         {
1492           reloc_sz = (reloc_sz + 3) & ~3;       /* 4-byte align.  */
1493           reloc_sz += 8;
1494           sec_page = this_page;
1495         }
1496
1497       reloc_sz += 2;
1498
1499       if (reloc_data[i].type == 4)
1500         reloc_sz += 2;
1501     }
1502
1503   reloc_sz = (reloc_sz + 3) & ~3;       /* 4-byte align.  */
1504   reloc_d = xmalloc (reloc_sz);
1505   sec_page = (bfd_vma) -1;
1506   reloc_sz = 0;
1507   page_ptr = (bfd_vma) -1;
1508   page_count = 0;
1509
1510   for (i = 0; i < total_relocs; i++)
1511     {
1512       bfd_vma rva = reloc_data[i].vma - image_base;
1513       bfd_vma this_page = (rva & ~0xfff);
1514
1515       if (this_page != sec_page)
1516         {
1517           while (reloc_sz & 3)
1518             reloc_d[reloc_sz++] = 0;
1519
1520           if (page_ptr != (bfd_vma) -1)
1521             bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1522
1523           bfd_put_32 (abfd, this_page, reloc_d + reloc_sz);
1524           page_ptr = reloc_sz;
1525           reloc_sz += 8;
1526           sec_page = this_page;
1527           page_count = 0;
1528         }
1529
1530       bfd_put_16 (abfd, (rva & 0xfff) + (reloc_data[i].type << 12),
1531                   reloc_d + reloc_sz);
1532       reloc_sz += 2;
1533
1534       if (reloc_data[i].type == 4)
1535         {
1536           bfd_put_16 (abfd, reloc_data[i].extra, reloc_d + reloc_sz);
1537           reloc_sz += 2;
1538         }
1539
1540       page_count++;
1541     }
1542
1543   while (reloc_sz & 3)
1544     reloc_d[reloc_sz++] = 0;
1545
1546   if (page_ptr != (bfd_vma) -1)
1547     bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1548
1549   while (reloc_sz < reloc_s->size)
1550     reloc_d[reloc_sz++] = 0;
1551 }
1552
1553 /* Given the exiting def_file structure, print out a .DEF file that
1554    corresponds to it.  */
1555
1556 static void
1557 quoteput (char *s, FILE *f, int needs_quotes)
1558 {
1559   char *cp;
1560
1561   for (cp = s; *cp; cp++)
1562     if (*cp == '\''
1563         || *cp == '"'
1564         || *cp == '\\'
1565         || ISSPACE (*cp)
1566         || *cp == ','
1567         || *cp == ';')
1568       needs_quotes = 1;
1569
1570   if (needs_quotes)
1571     {
1572       putc ('"', f);
1573
1574       while (*s)
1575         {
1576           if (*s == '"' || *s == '\\')
1577             putc ('\\', f);
1578
1579           putc (*s, f);
1580           s++;
1581         }
1582
1583       putc ('"', f);
1584     }
1585   else
1586     fputs (s, f);
1587 }
1588
1589 void
1590 pe_dll_generate_def_file (const char *pe_out_def_filename)
1591 {
1592   int i;
1593   FILE *out = fopen (pe_out_def_filename, "w");
1594
1595   if (out == NULL)
1596     /* xgettext:c-format */
1597     einfo (_("%s: Can't open output def file %s\n"),
1598            program_name, pe_out_def_filename);
1599
1600   if (pe_def_file)
1601     {
1602       if (pe_def_file->name)
1603         {
1604           if (pe_def_file->is_dll)
1605             fprintf (out, "LIBRARY ");
1606           else
1607             fprintf (out, "NAME ");
1608
1609           quoteput (pe_def_file->name, out, 1);
1610
1611           if (pe_data (link_info.output_bfd)->pe_opthdr.ImageBase)
1612             {
1613               fprintf (out, " BASE=0x");
1614               fprintf_vma (out, ((bfd_vma) pe_data (link_info.output_bfd)->pe_opthdr.ImageBase));
1615             }
1616           fprintf (out, "\n");
1617         }
1618
1619       if (pe_def_file->description)
1620         {
1621           fprintf (out, "DESCRIPTION ");
1622           quoteput (pe_def_file->description, out, 1);
1623           fprintf (out, "\n");
1624         }
1625
1626       if (pe_def_file->version_minor != -1)
1627         fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major,
1628                  pe_def_file->version_minor);
1629       else if (pe_def_file->version_major != -1)
1630         fprintf (out, "VERSION %d\n", pe_def_file->version_major);
1631
1632       if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1)
1633         fprintf (out, "\n");
1634
1635       if (pe_def_file->stack_commit != -1)
1636         fprintf (out, "STACKSIZE 0x%x,0x%x\n",
1637                  pe_def_file->stack_reserve, pe_def_file->stack_commit);
1638       else if (pe_def_file->stack_reserve != -1)
1639         fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve);
1640
1641       if (pe_def_file->heap_commit != -1)
1642         fprintf (out, "HEAPSIZE 0x%x,0x%x\n",
1643                  pe_def_file->heap_reserve, pe_def_file->heap_commit);
1644       else if (pe_def_file->heap_reserve != -1)
1645         fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve);
1646
1647       if (pe_def_file->num_section_defs > 0)
1648         {
1649           fprintf (out, "\nSECTIONS\n\n");
1650
1651           for (i = 0; i < pe_def_file->num_section_defs; i++)
1652             {
1653               fprintf (out, "    ");
1654               quoteput (pe_def_file->section_defs[i].name, out, 0);
1655
1656               if (pe_def_file->section_defs[i].class)
1657                 {
1658                   fprintf (out, " CLASS ");
1659                   quoteput (pe_def_file->section_defs[i].class, out, 0);
1660                 }
1661
1662               if (pe_def_file->section_defs[i].flag_read)
1663                 fprintf (out, " READ");
1664
1665               if (pe_def_file->section_defs[i].flag_write)
1666                 fprintf (out, " WRITE");
1667
1668               if (pe_def_file->section_defs[i].flag_execute)
1669                 fprintf (out, " EXECUTE");
1670
1671               if (pe_def_file->section_defs[i].flag_shared)
1672                 fprintf (out, " SHARED");
1673
1674               fprintf (out, "\n");
1675             }
1676         }
1677
1678       if (pe_def_file->num_exports > 0)
1679         {
1680           fprintf (out, "EXPORTS\n");
1681
1682           for (i = 0; i < pe_def_file->num_exports; i++)
1683             {
1684               def_file_export *e = pe_def_file->exports + i;
1685               fprintf (out, "    ");
1686               quoteput (e->name, out, 0);
1687
1688               if (e->internal_name && strcmp (e->internal_name, e->name))
1689                 {
1690                   fprintf (out, " = ");
1691                   quoteput (e->internal_name, out, 0);
1692                 }
1693
1694               if (e->ordinal != -1)
1695                 fprintf (out, " @%d", e->ordinal);
1696
1697               if (e->flag_private)
1698                 fprintf (out, " PRIVATE");
1699
1700               if (e->flag_constant)
1701                 fprintf (out, " CONSTANT");
1702
1703               if (e->flag_noname)
1704                 fprintf (out, " NONAME");
1705
1706               if (e->flag_data)
1707                 fprintf (out, " DATA");
1708
1709               fprintf (out, "\n");
1710             }
1711         }
1712
1713       if (pe_def_file->num_imports > 0)
1714         {
1715           fprintf (out, "\nIMPORTS\n\n");
1716
1717           for (i = 0; i < pe_def_file->num_imports; i++)
1718             {
1719               def_file_import *im = pe_def_file->imports + i;
1720               fprintf (out, "    ");
1721
1722               if (im->internal_name
1723                   && (!im->name || strcmp (im->internal_name, im->name)))
1724                 {
1725                   quoteput (im->internal_name, out, 0);
1726                   fprintf (out, " = ");
1727                 }
1728
1729               quoteput (im->module->name, out, 0);
1730               fprintf (out, ".");
1731
1732               if (im->name)
1733                 quoteput (im->name, out, 0);
1734               else
1735                 fprintf (out, "%d", im->ordinal);
1736
1737               if (im->its_name)
1738                 {
1739                   fprintf (out, " == ");
1740                   quoteput (im->its_name, out, 0);
1741                 }
1742
1743               fprintf (out, "\n");
1744             }
1745         }
1746     }
1747   else
1748     fprintf (out, _("; no contents available\n"));
1749
1750   if (fclose (out) == EOF)
1751     /* xgettext:c-format */
1752     einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename);
1753 }
1754
1755 /* Generate the import library.  */
1756
1757 static asymbol **symtab;
1758 static int symptr;
1759 static int tmp_seq;
1760 static int tmp_seq2;
1761 static const char *dll_filename;
1762 static char *dll_symname;
1763
1764 #define UNDSEC (asection *) &bfd_und_section
1765
1766 static asection *
1767 quick_section (bfd *abfd, const char *name, int flags, int align)
1768 {
1769   asection *sec;
1770   asymbol *sym;
1771
1772   sec = bfd_make_section_old_way (abfd, name);
1773   bfd_set_section_flags (abfd, sec, flags | SEC_ALLOC | SEC_LOAD | SEC_KEEP);
1774   bfd_set_section_alignment (abfd, sec, align);
1775   /* Remember to undo this before trying to link internally!  */
1776   sec->output_section = sec;
1777
1778   sym = bfd_make_empty_symbol (abfd);
1779   symtab[symptr++] = sym;
1780   sym->name = sec->name;
1781   sym->section = sec;
1782   sym->flags = BSF_LOCAL;
1783   sym->value = 0;
1784
1785   return sec;
1786 }
1787
1788 static void
1789 quick_symbol (bfd *abfd,
1790               const char *n1,
1791               const char *n2,
1792               const char *n3,
1793               asection *sec,
1794               int flags,
1795               int addr)
1796 {
1797   asymbol *sym;
1798   char *name = xmalloc (strlen (n1) + strlen (n2) + strlen (n3) + 1);
1799
1800   strcpy (name, n1);
1801   strcat (name, n2);
1802   strcat (name, n3);
1803   sym = bfd_make_empty_symbol (abfd);
1804   sym->name = name;
1805   sym->section = sec;
1806   sym->flags = flags;
1807   sym->value = addr;
1808   symtab[symptr++] = sym;
1809 }
1810
1811 static arelent *reltab = 0;
1812 static int relcount = 0, relsize = 0;
1813
1814 static void
1815 quick_reloc (bfd *abfd, bfd_size_type address, int which_howto, int symidx)
1816 {
1817   if (relcount >= relsize - 1)
1818     {
1819       relsize += 10;
1820       if (reltab)
1821         reltab = xrealloc (reltab, relsize * sizeof (arelent));
1822       else
1823         reltab = xmalloc (relsize * sizeof (arelent));
1824     }
1825   reltab[relcount].address = address;
1826   reltab[relcount].addend = 0;
1827   reltab[relcount].howto = bfd_reloc_type_lookup (abfd, which_howto);
1828   reltab[relcount].sym_ptr_ptr = symtab + symidx;
1829   relcount++;
1830 }
1831
1832 static void
1833 save_relocs (asection *sec)
1834 {
1835   int i;
1836
1837   sec->relocation = reltab;
1838   sec->reloc_count = relcount;
1839   sec->orelocation = xmalloc ((relcount + 1) * sizeof (arelent *));
1840   for (i = 0; i < relcount; i++)
1841     sec->orelocation[i] = sec->relocation + i;
1842   sec->orelocation[relcount] = 0;
1843   sec->flags |= SEC_RELOC;
1844   reltab = 0;
1845   relcount = relsize = 0;
1846 }
1847
1848 /*      .section        .idata$2
1849         .global         __head_my_dll
1850    __head_my_dll:
1851         .rva            hname
1852         .long           0
1853         .long           0
1854         .rva            __my_dll_iname
1855         .rva            fthunk
1856
1857         .section        .idata$5
1858         .long           0
1859    fthunk:
1860
1861         .section        .idata$4
1862         .long           0
1863    hname:                              */
1864
1865 static bfd *
1866 make_head (bfd *parent)
1867 {
1868   asection *id2, *id5, *id4;
1869   unsigned char *d2, *d5, *d4;
1870   char *oname;
1871   bfd *abfd;
1872
1873   oname = xmalloc (20);
1874   sprintf (oname, "d%06d.o", tmp_seq);
1875   tmp_seq++;
1876
1877   abfd = bfd_create (oname, parent);
1878   bfd_find_target (pe_details->object_target, abfd);
1879   bfd_make_writable (abfd);
1880
1881   bfd_set_format (abfd, bfd_object);
1882   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1883
1884   symptr = 0;
1885   symtab = xmalloc (6 * sizeof (asymbol *));
1886   id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
1887   id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1888   id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1889   quick_symbol (abfd, U ("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0);
1890   quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
1891
1892   /* OK, pay attention here.  I got confused myself looking back at
1893      it.  We create a four-byte section to mark the beginning of the
1894      list, and we include an offset of 4 in the section, so that the
1895      pointer to the list points to the *end* of this section, which is
1896      the start of the list of sections from other objects.  */
1897
1898   bfd_set_section_size (abfd, id2, 20);
1899   d2 = xmalloc (20);
1900   id2->contents = d2;
1901   memset (d2, 0, 20);
1902   if (pe_use_nul_prefixed_import_tables)
1903     d2[0] = d2[16] = PE_IDATA5_SIZE; /* Reloc addend.  */
1904   quick_reloc (abfd,  0, BFD_RELOC_RVA, 2);
1905   quick_reloc (abfd, 12, BFD_RELOC_RVA, 4);
1906   quick_reloc (abfd, 16, BFD_RELOC_RVA, 1);
1907   save_relocs (id2);
1908
1909   if (pe_use_nul_prefixed_import_tables)
1910     bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
1911   else
1912     bfd_set_section_size (abfd, id5, 0);
1913   d5 = xmalloc (PE_IDATA5_SIZE);
1914   id5->contents = d5;
1915   memset (d5, 0, PE_IDATA5_SIZE);
1916   if (pe_use_nul_prefixed_import_tables)
1917     bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
1918   else
1919     bfd_set_section_size (abfd, id4, 0);
1920   d4 = xmalloc (PE_IDATA4_SIZE);
1921   id4->contents = d4;
1922   memset (d4, 0, PE_IDATA4_SIZE);
1923
1924   bfd_set_symtab (abfd, symtab, symptr);
1925
1926   bfd_set_section_contents (abfd, id2, d2, 0, 20);
1927   if (pe_use_nul_prefixed_import_tables)
1928     {
1929       bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
1930       bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
1931     }
1932   else
1933     {
1934       bfd_set_section_contents (abfd, id5, d5, 0, 0);
1935       bfd_set_section_contents (abfd, id4, d4, 0, 0);
1936     }
1937
1938   bfd_make_readable (abfd);
1939   return abfd;
1940 }
1941
1942 /*      .section        .idata$4
1943         .long           0
1944         [.long          0] for PE+
1945         .section        .idata$5
1946         .long           0
1947         [.long          0] for PE+
1948         .section        idata$7
1949         .global         __my_dll_iname
1950   __my_dll_iname:
1951         .asciz          "my.dll"       */
1952
1953 static bfd *
1954 make_tail (bfd *parent)
1955 {
1956   asection *id4, *id5, *id7;
1957   unsigned char *d4, *d5, *d7;
1958   int len;
1959   char *oname;
1960   bfd *abfd;
1961
1962   oname = xmalloc (20);
1963   sprintf (oname, "d%06d.o", tmp_seq);
1964   tmp_seq++;
1965
1966   abfd = bfd_create (oname, parent);
1967   bfd_find_target (pe_details->object_target, abfd);
1968   bfd_make_writable (abfd);
1969
1970   bfd_set_format (abfd, bfd_object);
1971   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1972
1973   symptr = 0;
1974   symtab = xmalloc (5 * sizeof (asymbol *));
1975   id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1976   id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1977   id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1978   quick_symbol (abfd, U (""), dll_symname, "_iname", id7, BSF_GLOBAL, 0);
1979
1980   bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
1981   d4 = xmalloc (PE_IDATA4_SIZE);
1982   id4->contents = d4;
1983   memset (d4, 0, PE_IDATA4_SIZE);
1984
1985   bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
1986   d5 = xmalloc (PE_IDATA5_SIZE);
1987   id5->contents = d5;
1988   memset (d5, 0, PE_IDATA5_SIZE);
1989
1990   len = strlen (dll_filename) + 1;
1991   if (len & 1)
1992     len++;
1993   bfd_set_section_size (abfd, id7, len);
1994   d7 = xmalloc (len);
1995   id7->contents = d7;
1996   strcpy ((char *) d7, dll_filename);
1997   /* If len was odd, the above
1998      strcpy leaves behind an undefined byte. That is harmless,
1999      but we set it to 0 just so the binary dumps are pretty.  */
2000   d7[len - 1] = 0;
2001
2002   bfd_set_symtab (abfd, symtab, symptr);
2003
2004   bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
2005   bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
2006   bfd_set_section_contents (abfd, id7, d7, 0, len);
2007
2008   bfd_make_readable (abfd);
2009   return abfd;
2010 }
2011
2012 /*      .text
2013         .global         _function
2014         .global         ___imp_function
2015         .global         __imp__function
2016   _function:
2017         jmp             *__imp__function:
2018
2019         .section        idata$7
2020         .long           __head_my_dll
2021
2022         .section        .idata$5
2023   ___imp_function:
2024   __imp__function:
2025   iat?
2026         .section        .idata$4
2027   iat?
2028         .section        .idata$6
2029   ID<ordinal>:
2030         .short          <hint>
2031         .asciz          "function" xlate? (add underscore, kill at)  */
2032
2033 static const unsigned char jmp_ix86_bytes[] =
2034 {
2035   0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
2036 };
2037
2038 /* _function:
2039         mov.l   ip+8,r0
2040         mov.l   @r0,r0
2041         jmp     @r0
2042         nop
2043         .dw     __imp_function   */
2044
2045 static const unsigned char jmp_sh_bytes[] =
2046 {
2047   0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
2048 };
2049
2050 /* _function:
2051         lui     $t0,<high:__imp_function>
2052         lw      $t0,<low:__imp_function>
2053         jr      $t0
2054         nop                              */
2055
2056 static const unsigned char jmp_mips_bytes[] =
2057 {
2058   0x00, 0x00, 0x08, 0x3c,  0x00, 0x00, 0x08, 0x8d,
2059   0x08, 0x00, 0x00, 0x01,  0x00, 0x00, 0x00, 0x00
2060 };
2061
2062 static const unsigned char jmp_arm_bytes[] =
2063 {
2064   0x00, 0xc0, 0x9f, 0xe5,       /* ldr  ip, [pc] */
2065   0x00, 0xf0, 0x9c, 0xe5,       /* ldr  pc, [ip] */
2066   0,    0,    0,    0
2067 };
2068
2069
2070 static bfd *
2071 make_one (def_file_export *exp, bfd *parent, bfd_boolean include_jmp_stub)
2072 {
2073   asection *tx, *id7, *id5, *id4, *id6;
2074   unsigned char *td = NULL, *d7, *d5, *d4, *d6 = NULL;
2075   int len;
2076   char *oname;
2077   bfd *abfd;
2078   const unsigned char *jmp_bytes = NULL;
2079   int jmp_byte_count = 0;
2080
2081   /* Include the jump stub section only if it is needed. A jump
2082      stub is needed if the symbol being imported <sym> is a function
2083      symbol and there is at least one undefined reference to that
2084      symbol. In other words, if all the import references to <sym> are
2085      explicitly through _declspec(dllimport) then the jump stub is not
2086      needed.  */
2087   if (include_jmp_stub)
2088     {
2089       switch (pe_details->pe_arch)
2090         {
2091         case PE_ARCH_i386:
2092           jmp_bytes = jmp_ix86_bytes;
2093           jmp_byte_count = sizeof (jmp_ix86_bytes);
2094           break;
2095         case PE_ARCH_sh:
2096           jmp_bytes = jmp_sh_bytes;
2097           jmp_byte_count = sizeof (jmp_sh_bytes);
2098           break;
2099         case PE_ARCH_mips:
2100           jmp_bytes = jmp_mips_bytes;
2101           jmp_byte_count = sizeof (jmp_mips_bytes);
2102           break;
2103         case PE_ARCH_arm:
2104         case PE_ARCH_arm_epoc:
2105         case PE_ARCH_arm_wince:
2106           jmp_bytes = jmp_arm_bytes;
2107           jmp_byte_count = sizeof (jmp_arm_bytes);
2108           break;
2109         default:
2110           abort ();
2111         }
2112     }
2113
2114   oname = xmalloc (20);
2115   sprintf (oname, "d%06d.o", tmp_seq);
2116   tmp_seq++;
2117
2118   abfd = bfd_create (oname, parent);
2119   bfd_find_target (pe_details->object_target, abfd);
2120   bfd_make_writable (abfd);
2121
2122   bfd_set_format (abfd, bfd_object);
2123   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2124
2125   symptr = 0;
2126   symtab = xmalloc (12 * sizeof (asymbol *));
2127
2128   tx  = quick_section (abfd, ".text", SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY, 2);
2129   id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
2130   id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
2131   id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2132   id6 = quick_section (abfd, ".idata$6", SEC_HAS_CONTENTS, 2);
2133
2134   if  (*exp->internal_name == '@')
2135     {
2136       quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
2137                     BSF_GLOBAL, 0);
2138       if (include_jmp_stub)
2139         quick_symbol (abfd, "", exp->internal_name, "", tx, BSF_GLOBAL, 0);
2140       quick_symbol (abfd, "__imp_", exp->internal_name, "", id5,
2141                     BSF_GLOBAL, 0);
2142       /* Fastcall applies only to functions,
2143          so no need for auto-import symbol.  */
2144     }
2145   else
2146     {
2147       quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
2148                     BSF_GLOBAL, 0);
2149       if (include_jmp_stub)
2150         quick_symbol (abfd, U (""), exp->internal_name, "", tx,
2151                       BSF_GLOBAL, 0);
2152       quick_symbol (abfd, "__imp_", U (""), exp->internal_name, id5,
2153                     BSF_GLOBAL, 0);
2154       /* Symbol to reference ord/name of imported
2155          data symbol, used to implement auto-import.  */
2156       if (exp->flag_data)
2157         quick_symbol (abfd, "__nm_", U (""), exp->internal_name, id6,
2158                       BSF_GLOBAL,0);
2159     }
2160   if (pe_dll_compat_implib)
2161     quick_symbol (abfd, "___imp_", exp->internal_name, "", id5,
2162                   BSF_GLOBAL, 0);
2163
2164   if (include_jmp_stub)
2165     {
2166       bfd_set_section_size (abfd, tx, jmp_byte_count);
2167       td = xmalloc (jmp_byte_count);
2168       tx->contents = td;
2169       memcpy (td, jmp_bytes, jmp_byte_count);
2170
2171       switch (pe_details->pe_arch)
2172         {
2173         case PE_ARCH_i386:
2174 #ifdef pe_use_x86_64
2175           quick_reloc (abfd, 2, BFD_RELOC_32_PCREL, 2);
2176 #else
2177           /* Mark this object as SAFESEH compatible.  */
2178           quick_symbol (abfd, "", "@feat.00", "", bfd_abs_section_ptr,
2179                         BSF_LOCAL, 1);
2180           quick_reloc (abfd, 2, BFD_RELOC_32, 2);
2181 #endif
2182           break;
2183         case PE_ARCH_sh:
2184           quick_reloc (abfd, 8, BFD_RELOC_32, 2);
2185           break;
2186         case PE_ARCH_mips:
2187           quick_reloc (abfd, 0, BFD_RELOC_HI16_S, 2);
2188           quick_reloc (abfd, 0, BFD_RELOC_LO16, 0); /* MIPS_R_PAIR */
2189           quick_reloc (abfd, 4, BFD_RELOC_LO16, 2);
2190           break;
2191         case PE_ARCH_arm:
2192         case PE_ARCH_arm_epoc:
2193         case PE_ARCH_arm_wince:
2194           quick_reloc (abfd, 8, BFD_RELOC_32, 2);
2195           break;
2196         default:
2197           abort ();
2198         }
2199       save_relocs (tx);
2200     }
2201   else
2202     bfd_set_section_size (abfd, tx, 0);
2203
2204   bfd_set_section_size (abfd, id7, 4);
2205   d7 = xmalloc (4);
2206   id7->contents = d7;
2207   memset (d7, 0, 4);
2208   quick_reloc (abfd, 0, BFD_RELOC_RVA, 5);
2209   save_relocs (id7);
2210
2211   bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
2212   d5 = xmalloc (PE_IDATA5_SIZE);
2213   id5->contents = d5;
2214   memset (d5, 0, PE_IDATA5_SIZE);
2215
2216   if (exp->flag_noname)
2217     {
2218       d5[0] = exp->ordinal;
2219       d5[1] = exp->ordinal >> 8;
2220       d5[PE_IDATA5_SIZE - 1] = 0x80;
2221     }
2222   else
2223     {
2224       quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
2225       save_relocs (id5);
2226     }
2227
2228   bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
2229   d4 = xmalloc (PE_IDATA4_SIZE);
2230   id4->contents = d4;
2231   memset (d4, 0, PE_IDATA4_SIZE);
2232
2233   if (exp->flag_noname)
2234     {
2235       d4[0] = exp->ordinal;
2236       d4[1] = exp->ordinal >> 8;
2237       d4[PE_IDATA4_SIZE - 1] = 0x80;
2238     }
2239   else
2240     {
2241       quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
2242       save_relocs (id4);
2243     }
2244
2245   if (exp->flag_noname)
2246     {
2247       len = 0;
2248       bfd_set_section_size (abfd, id6, 0);
2249     }
2250   else
2251     {
2252       /* { short, asciz }  */
2253       if (exp->its_name)
2254         len = 2 + strlen (exp->its_name) + 1;
2255       else
2256         len = 2 + strlen (exp->name) + 1;
2257       if (len & 1)
2258         len++;
2259       bfd_set_section_size (abfd, id6, len);
2260       d6 = xmalloc (len);
2261       id6->contents = d6;
2262       memset (d6, 0, len);
2263       d6[0] = exp->hint & 0xff;
2264       d6[1] = exp->hint >> 8;
2265       if (exp->its_name)
2266         strcpy ((char*) d6 + 2, exp->its_name);
2267       else
2268         strcpy ((char *) d6 + 2, exp->name);
2269     }
2270
2271   bfd_set_symtab (abfd, symtab, symptr);
2272
2273   if (include_jmp_stub)
2274     bfd_set_section_contents (abfd, tx, td, 0, jmp_byte_count);
2275   bfd_set_section_contents (abfd, id7, d7, 0, 4);
2276   bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
2277   bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
2278   if (!exp->flag_noname)
2279     bfd_set_section_contents (abfd, id6, d6, 0, len);
2280
2281   bfd_make_readable (abfd);
2282   return abfd;
2283 }
2284
2285 static bfd *
2286 make_singleton_name_imp (const char *import, bfd *parent)
2287 {
2288   /* Name thunks go to idata$4.  */
2289   asection *id5;
2290   unsigned char *d5;
2291   char *oname;
2292   bfd *abfd;
2293
2294   oname = xmalloc (20);
2295   sprintf (oname, "nmimp%06d.o", tmp_seq2);
2296   tmp_seq2++;
2297
2298   abfd = bfd_create (oname, parent);
2299   bfd_find_target (pe_details->object_target, abfd);
2300   bfd_make_writable (abfd);
2301
2302   bfd_set_format (abfd, bfd_object);
2303   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2304
2305   symptr = 0;
2306   symtab = xmalloc (3 * sizeof (asymbol *));
2307   id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
2308   quick_symbol (abfd, "__imp_", import, "", id5, BSF_GLOBAL, 0);
2309
2310   /* We need space for the real thunk and for the null terminator.  */
2311   bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE * 2);
2312   d5 = xmalloc (PE_IDATA5_SIZE * 2);
2313   id5->contents = d5;
2314   memset (d5, 0, PE_IDATA5_SIZE * 2);
2315   quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
2316   save_relocs (id5);
2317
2318   bfd_set_symtab (abfd, symtab, symptr);
2319
2320   bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA4_SIZE * 2);
2321
2322   bfd_make_readable (abfd);
2323   return abfd;
2324 }
2325
2326 static bfd *
2327 make_singleton_name_thunk (const char *import, bfd *parent)
2328 {
2329   /* Name thunks go to idata$4.  */
2330   asection *id4;
2331   unsigned char *d4;
2332   char *oname;
2333   bfd *abfd;
2334
2335   oname = xmalloc (20);
2336   sprintf (oname, "nmth%06d.o", tmp_seq);
2337   tmp_seq++;
2338
2339   abfd = bfd_create (oname, parent);
2340   bfd_find_target (pe_details->object_target, abfd);
2341   bfd_make_writable (abfd);
2342
2343   bfd_set_format (abfd, bfd_object);
2344   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2345
2346   symptr = 0;
2347   symtab = xmalloc (3 * sizeof (asymbol *));
2348   id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2349   quick_symbol (abfd, "__nm_thnk_", import, "", id4, BSF_GLOBAL, 0);
2350   quick_symbol (abfd, "__nm_", import, "", UNDSEC, BSF_GLOBAL, 0);
2351
2352   /* We need space for the real thunk and for the null terminator.  */
2353   bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE * 2);
2354   d4 = xmalloc (PE_IDATA4_SIZE * 2);
2355   id4->contents = d4;
2356   memset (d4, 0, PE_IDATA4_SIZE * 2);
2357   quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
2358   save_relocs (id4);
2359
2360   bfd_set_symtab (abfd, symtab, symptr);
2361
2362   bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE * 2);
2363
2364   bfd_make_readable (abfd);
2365   return abfd;
2366 }
2367
2368 static char *
2369 make_import_fixup_mark (arelent *rel)
2370 {
2371   /* We convert reloc to symbol, for later reference.  */
2372   static int counter;
2373   static char *fixup_name = NULL;
2374   static size_t buffer_len = 0;
2375
2376   struct bfd_symbol *sym = *rel->sym_ptr_ptr;
2377
2378   bfd *abfd = bfd_asymbol_bfd (sym);
2379   struct bfd_link_hash_entry *bh;
2380
2381   if (!fixup_name)
2382     {
2383       fixup_name = xmalloc (384);
2384       buffer_len = 384;
2385     }
2386
2387   if (strlen (sym->name) + 25 > buffer_len)
2388   /* Assume 25 chars for "__fu" + counter + "_".  If counter is
2389      bigger than 20 digits long, we've got worse problems than
2390      overflowing this buffer...  */
2391     {
2392       free (fixup_name);
2393       /* New buffer size is length of symbol, plus 25, but
2394          then rounded up to the nearest multiple of 128.  */
2395       buffer_len = ((strlen (sym->name) + 25) + 127) & ~127;
2396       fixup_name = xmalloc (buffer_len);
2397     }
2398
2399   sprintf (fixup_name, "__fu%d_%s", counter++, sym->name);
2400
2401   bh = NULL;
2402   bfd_coff_link_add_one_symbol (&link_info, abfd, fixup_name, BSF_GLOBAL,
2403                                 current_sec, /* sym->section, */
2404                                 rel->address, NULL, TRUE, FALSE, &bh);
2405
2406   return fixup_name;
2407 }
2408
2409 /*      .section        .idata$2
2410         .rva            __nm_thnk_SYM (singleton thunk with name of func)
2411         .long           0
2412         .long           0
2413         .rva            __my_dll_iname (name of dll)
2414         .rva            __fuNN_SYM (pointer to reference (address) in text)  */
2415
2416 static bfd *
2417 make_import_fixup_entry (const char *name,
2418                          const char *fixup_name,
2419                          const char *symname,
2420                          bfd *parent)
2421 {
2422   asection *id2;
2423   unsigned char *d2;
2424   char *oname;
2425   bfd *abfd;
2426
2427   oname = xmalloc (20);
2428   sprintf (oname, "fu%06d.o", tmp_seq);
2429   tmp_seq++;
2430
2431   abfd = bfd_create (oname, parent);
2432   bfd_find_target (pe_details->object_target, abfd);
2433   bfd_make_writable (abfd);
2434
2435   bfd_set_format (abfd, bfd_object);
2436   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2437
2438   symptr = 0;
2439   symtab = xmalloc (6 * sizeof (asymbol *));
2440   id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
2441
2442   quick_symbol (abfd, "__nm_thnk_", name, "", UNDSEC, BSF_GLOBAL, 0);
2443   quick_symbol (abfd, U (""), symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
2444   /* For relocator v2 we have to use the .idata$5 element and not
2445      fixup_name.  */
2446   if (link_info.pei386_runtime_pseudo_reloc == 2)
2447     quick_symbol (abfd, "__imp_", name, "", UNDSEC, BSF_GLOBAL, 0);
2448   else
2449     quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2450
2451   bfd_set_section_size (abfd, id2, 20);
2452   d2 = xmalloc (20);
2453   id2->contents = d2;
2454   memset (d2, 0, 20);
2455
2456   quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2457   quick_reloc (abfd, 12, BFD_RELOC_RVA, 2);
2458   quick_reloc (abfd, 16, BFD_RELOC_RVA, 3);
2459   save_relocs (id2);
2460
2461   bfd_set_symtab (abfd, symtab, symptr);
2462
2463   bfd_set_section_contents (abfd, id2, d2, 0, 20);
2464
2465   bfd_make_readable (abfd);
2466   return abfd;
2467 }
2468
2469 /*      .section        .rdata_runtime_pseudo_reloc
2470         .long           addend
2471         .rva            __fuNN_SYM (pointer to reference (address) in text)  */
2472
2473 static bfd *
2474 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED,
2475                            const char *fixup_name,
2476                            bfd_vma addend ATTRIBUTE_UNUSED,
2477                            bfd_vma bitsize,
2478                            bfd *parent)
2479 {
2480   asection *rt_rel;
2481   unsigned char *rt_rel_d;
2482   char *oname;
2483   bfd *abfd;
2484   oname = xmalloc (20);
2485   sprintf (oname, "rtr%06d.o", tmp_seq);
2486   tmp_seq++;
2487
2488   abfd = bfd_create (oname, parent);
2489   bfd_find_target (pe_details->object_target, abfd);
2490   bfd_make_writable (abfd);
2491
2492   bfd_set_format (abfd, bfd_object);
2493   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2494
2495   symptr = 0;
2496   if (link_info.pei386_runtime_pseudo_reloc == 2)
2497     {
2498       symtab = xmalloc ((runtime_pseudp_reloc_v2_init ? 3 : 6) * sizeof (asymbol *));
2499     }
2500   else
2501     {
2502       symtab = xmalloc (2 * sizeof (asymbol *));
2503     }
2504   rt_rel = quick_section (abfd, ".rdata_runtime_pseudo_reloc",
2505                           SEC_HAS_CONTENTS, 2);
2506
2507   quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2508
2509   if (link_info.pei386_runtime_pseudo_reloc == 2)
2510     {
2511           size_t size = 12;
2512           if (! runtime_pseudp_reloc_v2_init)
2513             {
2514                   size += 12;
2515                   runtime_pseudp_reloc_v2_init = 1;
2516             }
2517       quick_symbol (abfd, "__imp_", name, "", UNDSEC, BSF_GLOBAL, 0);
2518
2519       bfd_set_section_size (abfd, rt_rel, size);
2520       rt_rel_d = xmalloc (size);
2521       rt_rel->contents = rt_rel_d;
2522       memset (rt_rel_d, 0, size);
2523           quick_reloc (abfd, size - 8, BFD_RELOC_RVA, 1);
2524           quick_reloc (abfd, size - 12, BFD_RELOC_RVA, 2);
2525           bfd_put_32 (abfd, bitsize, rt_rel_d + (size - 4));
2526           if (size != 12)
2527             bfd_put_32 (abfd, 1, rt_rel_d + 8);
2528       save_relocs (rt_rel);
2529
2530       bfd_set_symtab (abfd, symtab, symptr);
2531
2532       bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, size);
2533    }
2534   else
2535    {
2536       bfd_set_section_size (abfd, rt_rel, 8);
2537       rt_rel_d = xmalloc (8);
2538       rt_rel->contents = rt_rel_d;
2539       memset (rt_rel_d, 0, 8);
2540
2541       bfd_put_32 (abfd, addend, rt_rel_d);
2542       quick_reloc (abfd, 4, BFD_RELOC_RVA, 1);
2543
2544       save_relocs (rt_rel);
2545
2546       bfd_set_symtab (abfd, symtab, symptr);
2547
2548       bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, 8);
2549    }
2550   bfd_make_readable (abfd);
2551   return abfd;
2552 }
2553
2554 /*      .section        .rdata
2555         .rva            __pei386_runtime_relocator  */
2556
2557 static bfd *
2558 pe_create_runtime_relocator_reference (bfd *parent)
2559 {
2560   asection *extern_rt_rel;
2561   unsigned char *extern_rt_rel_d;
2562   char *oname;
2563   bfd *abfd;
2564
2565   oname = xmalloc (20);
2566   sprintf (oname, "ertr%06d.o", tmp_seq);
2567   tmp_seq++;
2568
2569   abfd = bfd_create (oname, parent);
2570   bfd_find_target (pe_details->object_target, abfd);
2571   bfd_make_writable (abfd);
2572
2573   bfd_set_format (abfd, bfd_object);
2574   bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2575
2576   symptr = 0;
2577   symtab = xmalloc (2 * sizeof (asymbol *));
2578   extern_rt_rel = quick_section (abfd, ".rdata", SEC_HAS_CONTENTS, 2);
2579
2580   quick_symbol (abfd, "", U ("_pei386_runtime_relocator"), "", UNDSEC,
2581                 BSF_NO_FLAGS, 0);
2582
2583   bfd_set_section_size (abfd, extern_rt_rel, PE_IDATA5_SIZE);
2584   extern_rt_rel_d = xmalloc (PE_IDATA5_SIZE);
2585   extern_rt_rel->contents = extern_rt_rel_d;
2586
2587   quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2588   save_relocs (extern_rt_rel);
2589
2590   bfd_set_symtab (abfd, symtab, symptr);
2591
2592   bfd_set_section_contents (abfd, extern_rt_rel, extern_rt_rel_d, 0, PE_IDATA5_SIZE);
2593
2594   bfd_make_readable (abfd);
2595   return abfd;
2596 }
2597
2598 void
2599 pe_create_import_fixup (arelent *rel, asection *s, bfd_vma addend)
2600 {
2601   char buf[300];
2602   struct bfd_symbol *sym = *rel->sym_ptr_ptr;
2603   struct bfd_link_hash_entry *name_thunk_sym;
2604   struct bfd_link_hash_entry *name_imp_sym;
2605   const char *name = sym->name;
2606   char *fixup_name = make_import_fixup_mark (rel);
2607   bfd *b;
2608   int need_import_table = 1;
2609
2610   sprintf (buf, "__imp_%s", name);
2611   name_imp_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
2612
2613   sprintf (buf, "__nm_thnk_%s", name);
2614
2615   name_thunk_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
2616
2617   /* For version 2 pseudo relocation we don't need to add an import
2618      if the import symbol is already present.  */
2619   if (link_info.pei386_runtime_pseudo_reloc == 2
2620       && name_imp_sym
2621       && name_imp_sym->type == bfd_link_hash_defined)
2622     need_import_table = 0;
2623
2624   if (need_import_table == 1
2625       && (!name_thunk_sym || name_thunk_sym->type != bfd_link_hash_defined))
2626     {
2627       b = make_singleton_name_thunk (name, link_info.output_bfd);
2628       add_bfd_to_link (b, b->filename, &link_info);
2629
2630       /* If we ever use autoimport, we have to cast text section writable.
2631          But not for version 2.  */
2632       if (link_info.pei386_runtime_pseudo_reloc != 2)
2633         {
2634           config.text_read_only = FALSE;
2635           link_info.output_bfd->flags &= ~WP_TEXT;
2636         }
2637       if (link_info.pei386_runtime_pseudo_reloc == 2)
2638         {
2639           b = make_singleton_name_imp (name, link_info.output_bfd);
2640           add_bfd_to_link (b, b->filename, &link_info);
2641         }
2642     }
2643
2644   if ((addend == 0 || link_info.pei386_runtime_pseudo_reloc)
2645       && need_import_table == 1)
2646     {
2647       extern char * pe_data_import_dll;
2648       char * symname = pe_data_import_dll ? pe_data_import_dll : "unknown";
2649
2650       b = make_import_fixup_entry (name, fixup_name, symname,
2651                                    link_info.output_bfd);
2652       add_bfd_to_link (b, b->filename, &link_info);
2653     }
2654
2655     if ((link_info.pei386_runtime_pseudo_reloc != 0 && addend != 0)
2656         || link_info.pei386_runtime_pseudo_reloc == 2)
2657       {
2658         if (pe_dll_extra_pe_debug)
2659           printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2660                   fixup_name, (int) addend);
2661
2662         b = make_runtime_pseudo_reloc (name, fixup_name, addend, rel->howto->bitsize,
2663                                        link_info.output_bfd);
2664         add_bfd_to_link (b, b->filename, &link_info);
2665
2666         if (runtime_pseudo_relocs_created == 0)
2667           {
2668             b = pe_create_runtime_relocator_reference (link_info.output_bfd);
2669             add_bfd_to_link (b, b->filename, &link_info);
2670           }
2671         runtime_pseudo_relocs_created++;
2672       }
2673     else if (addend != 0)
2674       {
2675         einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
2676                s->owner, s, rel->address, sym->name);
2677         einfo ("%X");
2678       }
2679 }
2680
2681
2682 void
2683 pe_dll_generate_implib (def_file *def, const char *impfilename, struct bfd_link_info *info)
2684 {
2685   int i;
2686   bfd *ar_head;
2687   bfd *ar_tail;
2688   bfd *outarch;
2689   bfd *ibfd;
2690   bfd *head = 0;
2691
2692   dll_filename = (def->name) ? def->name : dll_name;
2693   dll_symname = xstrdup (dll_filename);
2694   for (i = 0; dll_symname[i]; i++)
2695     if (!ISALNUM (dll_symname[i]))
2696       dll_symname[i] = '_';
2697
2698   unlink_if_ordinary (impfilename);
2699
2700   outarch = bfd_openw (impfilename, 0);
2701
2702   if (!outarch)
2703     {
2704       /* xgettext:c-format */
2705       einfo (_("%XCan't open .lib file: %s\n"), impfilename);
2706       return;
2707     }
2708
2709   /* xgettext:c-format */
2710   info_msg (_("Creating library file: %s\n"), impfilename);
2711
2712   bfd_set_format (outarch, bfd_archive);
2713   outarch->has_armap = 1;
2714
2715   /* Work out a reasonable size of things to put onto one line.  */
2716   ar_head = make_head (outarch);
2717
2718   /* Iterate the input BFDs, looking for exclude-modules-for-implib.  */
2719   for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link_next)
2720     {
2721       /* Iterate the exclude list.  */
2722       struct exclude_list_struct *ex;
2723       char found;
2724       for (ex = excludes, found = 0; ex && !found; ex = ex->next)
2725         {
2726           if (ex->type != EXCLUDEFORIMPLIB)
2727             continue;
2728           found = (filename_cmp (ex->string, ibfd->filename) == 0);
2729         }
2730       /* If it matched, we must open a fresh BFD for it (the original
2731         input BFD is still needed for the DLL's final link) and add
2732         it into the archive member chain.  */
2733       if (found)
2734         {
2735           bfd *newbfd = bfd_openr (ibfd->my_archive
2736                 ? ibfd->my_archive->filename : ibfd->filename, NULL);
2737           if (!newbfd)
2738             {
2739               einfo (_("%Xbfd_openr %s: %E\n"), ibfd->filename);
2740               return;
2741             }
2742           if (ibfd->my_archive)
2743             {
2744               /* Must now iterate through archive until we find the
2745                 required member.  A minor shame that we'll open the
2746                 archive once per member that we require from it, and
2747                 leak those archive bfds rather than reuse them.  */
2748               bfd *arbfd = newbfd;
2749               if (!bfd_check_format_matches (arbfd, bfd_archive, NULL))
2750                 {
2751                   einfo (_("%X%s(%s): can't find member in non-archive file"),
2752                     ibfd->my_archive->filename, ibfd->filename);
2753                   return;
2754                 }
2755               newbfd = NULL;
2756               while ((newbfd = bfd_openr_next_archived_file (arbfd, newbfd)) != 0)
2757                 {
2758                   if (filename_cmp (newbfd->filename, ibfd->filename) == 0)
2759                     break;
2760                 }
2761               if (!newbfd)
2762                 {
2763                   einfo (_("%X%s(%s): can't find member in archive"),
2764                     ibfd->my_archive->filename, ibfd->filename);
2765                   return;
2766                 }
2767             }
2768           newbfd->archive_next = head;
2769           head = newbfd;
2770         }
2771     }
2772
2773   for (i = 0; i < def->num_exports; i++)
2774     {
2775       /* The import library doesn't know about the internal name.  */
2776       char *internal = def->exports[i].internal_name;
2777       bfd *n;
2778
2779       /* Don't add PRIVATE entries to import lib.  */
2780       if (pe_def_file->exports[i].flag_private)
2781         continue;
2782       def->exports[i].internal_name = def->exports[i].name;
2783       n = make_one (def->exports + i, outarch,
2784                     ! (def->exports + i)->flag_data);
2785       n->archive_next = head;
2786       head = n;
2787       def->exports[i].internal_name = internal;
2788     }
2789
2790   ar_tail = make_tail (outarch);
2791
2792   if (ar_head == NULL || ar_tail == NULL)
2793     return;
2794
2795   /* Now stick them all into the archive.  */
2796   ar_head->archive_next = head;
2797   ar_tail->archive_next = ar_head;
2798   head = ar_tail;
2799
2800   if (! bfd_set_archive_head (outarch, head))
2801     einfo ("%Xbfd_set_archive_head: %E\n");
2802
2803   if (! bfd_close (outarch))
2804     einfo ("%Xbfd_close %s: %E\n", impfilename);
2805
2806   while (head != NULL)
2807     {
2808       bfd *n = head->archive_next;
2809       bfd_close (head);
2810       head = n;
2811     }
2812 }
2813
2814 static struct bfd_link_hash_entry *found_sym;
2815
2816 static bfd_boolean
2817 pe_undef_alias_cdecl_match (struct bfd_link_hash_entry *h, void *inf)
2818 {
2819   int sl;
2820   char *string = inf;
2821   const char *hs = h->root.string;
2822
2823   sl = strlen (string);
2824   if (h->type == bfd_link_hash_undefined
2825       && ((*hs == '@' && (!pe_details->underscored || *string == '_')
2826            && strncmp (hs + 1, string + (pe_details->underscored != 0),
2827                        sl - (pe_details->underscored != 0)) == 0)
2828           || strncmp (hs, string, sl) == 0)
2829       && h->root.string[sl] == '@')
2830     {
2831       found_sym = h;
2832       return FALSE;
2833     }
2834   return TRUE;
2835 }
2836
2837 static struct bfd_link_hash_entry *
2838 pe_find_cdecl_alias_match (char *name)
2839 {
2840   found_sym = 0;
2841   bfd_link_hash_traverse (link_info.hash, pe_undef_alias_cdecl_match,
2842                           (char *) name);
2843   return found_sym;
2844 }
2845
2846 static void
2847 add_bfd_to_link (bfd *abfd, const char *name, struct bfd_link_info *linfo)
2848 {
2849   lang_input_statement_type *fake_file;
2850
2851   fake_file = lang_add_input_file (name,
2852                                    lang_input_file_is_fake_enum,
2853                                    NULL);
2854   fake_file->the_bfd = abfd;
2855   ldlang_add_file (fake_file);
2856
2857   if (!bfd_link_add_symbols (abfd, linfo))
2858     einfo ("%Xaddsym %s: %E\n", name);
2859 }
2860
2861 void
2862 pe_process_import_defs (bfd *output_bfd, struct bfd_link_info *linfo)
2863 {
2864   def_file_module *module;
2865
2866   pe_dll_id_target (bfd_get_target (output_bfd));
2867
2868   if (!pe_def_file)
2869     return;
2870
2871   for (module = pe_def_file->modules; module; module = module->next)
2872     {
2873       int i, do_this_dll;
2874
2875       dll_filename = module->name;
2876       dll_symname = xstrdup (module->name);
2877       for (i = 0; dll_symname[i]; i++)
2878         if (!ISALNUM (dll_symname[i]))
2879           dll_symname[i] = '_';
2880
2881       do_this_dll = 0;
2882
2883       for (i = 0; i < pe_def_file->num_imports; i++)
2884         if (pe_def_file->imports[i].module == module)
2885           {
2886             def_file_export exp;
2887             struct bfd_link_hash_entry *blhe;
2888             int lead_at = (*pe_def_file->imports[i].internal_name == '@');
2889             /* See if we need this import.  */
2890             size_t len = strlen (pe_def_file->imports[i].internal_name);
2891             char *name = xmalloc (len + 2 + 6);
2892             bfd_boolean include_jmp_stub = FALSE;
2893             bfd_boolean is_cdecl = FALSE;
2894             if (!lead_at && strchr (pe_def_file->imports[i].internal_name, '@') == NULL)
2895                 is_cdecl = TRUE;
2896
2897             if (lead_at)
2898               sprintf (name, "%s",
2899                        pe_def_file->imports[i].internal_name);
2900             else
2901               sprintf (name, "%s%s",U (""),
2902                        pe_def_file->imports[i].internal_name);
2903
2904             blhe = bfd_link_hash_lookup (linfo->hash, name,
2905                                          FALSE, FALSE, FALSE);
2906
2907             /* Include the jump stub for <sym> only if the <sym>
2908                is undefined.  */
2909             if (!blhe || (blhe && blhe->type != bfd_link_hash_undefined))
2910               {
2911                 if (lead_at)
2912                   sprintf (name, "%s%s", "__imp_",
2913                            pe_def_file->imports[i].internal_name);
2914                 else
2915                   sprintf (name, "%s%s%s", "__imp_", U (""),
2916                            pe_def_file->imports[i].internal_name);
2917
2918                 blhe = bfd_link_hash_lookup (linfo->hash, name,
2919                                              FALSE, FALSE, FALSE);
2920               }
2921             else
2922               include_jmp_stub = TRUE;
2923
2924             if (is_cdecl && !blhe)
2925               {
2926                 sprintf (name, "%s%s",U (""),
2927                          pe_def_file->imports[i].internal_name);
2928                 blhe = pe_find_cdecl_alias_match (name);
2929                 include_jmp_stub = TRUE;
2930               }
2931
2932             free (name);
2933
2934             if (blhe && blhe->type == bfd_link_hash_undefined)
2935               {
2936                 bfd *one;
2937                 /* We do.  */
2938                 if (!do_this_dll)
2939                   {
2940                     bfd *ar_head = make_head (output_bfd);
2941                     add_bfd_to_link (ar_head, ar_head->filename, linfo);
2942                     do_this_dll = 1;
2943                   }
2944                 exp.internal_name = pe_def_file->imports[i].internal_name;
2945                 exp.name = pe_def_file->imports[i].name;
2946                 exp.its_name = pe_def_file->imports[i].its_name;
2947                 exp.ordinal = pe_def_file->imports[i].ordinal;
2948                 exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
2949                 exp.flag_private = 0;
2950                 exp.flag_constant = 0;
2951                 exp.flag_data = pe_def_file->imports[i].data;
2952                 exp.flag_noname = exp.name ? 0 : 1;
2953                 one = make_one (&exp, output_bfd, (! exp.flag_data) && include_jmp_stub);
2954                 add_bfd_to_link (one, one->filename, linfo);
2955               }
2956           }
2957       if (do_this_dll)
2958         {
2959           bfd *ar_tail = make_tail (output_bfd);
2960           add_bfd_to_link (ar_tail, ar_tail->filename, linfo);
2961         }
2962
2963       free (dll_symname);
2964     }
2965 }
2966
2967 /* We were handed a *.DLL file.  Parse it and turn it into a set of
2968    IMPORTS directives in the def file.  Return TRUE if the file was
2969    handled, FALSE if not.  */
2970
2971 static unsigned int
2972 pe_get16 (bfd *abfd, int where)
2973 {
2974   unsigned char b[2];
2975
2976   bfd_seek (abfd, (file_ptr) where, SEEK_SET);
2977   bfd_bread (b, (bfd_size_type) 2, abfd);
2978   return b[0] + (b[1] << 8);
2979 }
2980
2981 static unsigned int
2982 pe_get32 (bfd *abfd, int where)
2983 {
2984   unsigned char b[4];
2985
2986   bfd_seek (abfd, (file_ptr) where, SEEK_SET);
2987   bfd_bread (b, (bfd_size_type) 4, abfd);
2988   return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
2989 }
2990
2991 static unsigned int
2992 pe_as32 (void *ptr)
2993 {
2994   unsigned char *b = ptr;
2995
2996   return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
2997 }
2998
2999 bfd_boolean
3000 pe_implied_import_dll (const char *filename)
3001 {
3002   bfd *dll;
3003   bfd_vma pe_header_offset, opthdr_ofs, num_entries, i;
3004   bfd_vma export_rva, export_size, nsections, secptr, expptr;
3005   bfd_vma exp_funcbase;
3006   unsigned char *expdata;
3007   char *erva;
3008   bfd_vma name_rvas, nexp;
3009   const char *dllname;
3010   /* Initialization with start > end guarantees that is_data
3011      will not be set by mistake, and avoids compiler warning.  */
3012   bfd_vma data_start = 1;
3013   bfd_vma data_end = 0;
3014   bfd_vma rdata_start = 1;
3015   bfd_vma rdata_end = 0;
3016   bfd_vma bss_start = 1;
3017   bfd_vma bss_end = 0;
3018
3019   /* No, I can't use bfd here.  kernel32.dll puts its export table in
3020      the middle of the .rdata section.  */
3021   dll = bfd_openr (filename, pe_details->target_name);
3022   if (!dll)
3023     {
3024       einfo ("%Xopen %s: %E\n", filename);
3025       return FALSE;
3026     }
3027
3028   /* PEI dlls seem to be bfd_objects.  */
3029   if (!bfd_check_format (dll, bfd_object))
3030     {
3031       einfo ("%X%s: this doesn't appear to be a DLL\n", filename);
3032       return FALSE;
3033     }
3034
3035   /* Get pe_header, optional header and numbers of directory entries.  */
3036   pe_header_offset = pe_get32 (dll, 0x3c);
3037   opthdr_ofs = pe_header_offset + 4 + 20;
3038 #ifdef pe_use_x86_64
3039   num_entries = pe_get32 (dll, opthdr_ofs + 92 + 4 * 4); /*  & NumberOfRvaAndSizes.  */
3040 #else
3041   num_entries = pe_get32 (dll, opthdr_ofs + 92);
3042 #endif
3043
3044   /* No import or export directory entry.  */
3045   if (num_entries < 1)
3046     return FALSE;
3047
3048 #ifdef pe_use_x86_64
3049   export_rva  = pe_get32 (dll, opthdr_ofs + 96 + 4 * 4);
3050   export_size = pe_get32 (dll, opthdr_ofs + 100 + 4 * 4);
3051 #else
3052   export_rva = pe_get32 (dll, opthdr_ofs + 96);
3053   export_size = pe_get32 (dll, opthdr_ofs + 100);
3054 #endif
3055
3056   /* No export table - nothing to export.  */
3057   if (export_size == 0)
3058     return FALSE;
3059
3060   nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
3061   secptr = (pe_header_offset + 4 + 20 +
3062             pe_get16 (dll, pe_header_offset + 4 + 16));
3063   expptr = 0;
3064
3065   /* Get the rva and size of the export section.  */
3066   for (i = 0; i < nsections; i++)
3067     {
3068       char sname[8];
3069       bfd_vma secptr1 = secptr + 40 * i;
3070       bfd_vma vaddr = pe_get32 (dll, secptr1 + 12);
3071       bfd_vma vsize = pe_get32 (dll, secptr1 + 16);
3072       bfd_vma fptr = pe_get32 (dll, secptr1 + 20);
3073
3074       bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
3075       bfd_bread (sname, (bfd_size_type) 8, dll);
3076
3077       if (vaddr <= export_rva && vaddr + vsize > export_rva)
3078         {
3079           expptr = fptr + (export_rva - vaddr);
3080           if (export_rva + export_size > vaddr + vsize)
3081             export_size = vsize - (export_rva - vaddr);
3082           break;
3083         }
3084     }
3085
3086   /* Scan sections and store the base and size of the
3087      data and bss segments in data/base_start/end.  */
3088   for (i = 0; i < nsections; i++)
3089     {
3090       bfd_vma secptr1 = secptr + 40 * i;
3091       bfd_vma vsize = pe_get32 (dll, secptr1 + 8);
3092       bfd_vma vaddr = pe_get32 (dll, secptr1 + 12);
3093       bfd_vma flags = pe_get32 (dll, secptr1 + 36);
3094       char sec_name[9];
3095
3096       sec_name[8] = '\0';
3097       bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET);
3098       bfd_bread (sec_name, (bfd_size_type) 8, dll);
3099
3100       if (strcmp(sec_name,".data") == 0)
3101         {
3102           data_start = vaddr;
3103           data_end = vaddr + vsize;
3104
3105           if (pe_dll_extra_pe_debug)
3106             printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3107                     __FUNCTION__, sec_name, (unsigned long) vaddr,
3108                     (unsigned long) (vaddr + vsize), (unsigned long) flags);
3109         }
3110       else if (strcmp(sec_name,".rdata") == 0)
3111         {
3112           rdata_start = vaddr;
3113           rdata_end = vaddr + vsize;
3114
3115           if (pe_dll_extra_pe_debug)
3116             printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3117                     __FUNCTION__, sec_name, (unsigned long) vaddr,
3118                     (unsigned long) (vaddr + vsize), (unsigned long) flags);
3119         }
3120       else if (strcmp (sec_name,".bss") == 0)
3121         {
3122           bss_start = vaddr;
3123           bss_end = vaddr + vsize;
3124
3125           if (pe_dll_extra_pe_debug)
3126             printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3127                     __FUNCTION__, sec_name, (unsigned long) vaddr,
3128                     (unsigned long) (vaddr + vsize), (unsigned long) flags);
3129         }
3130     }
3131
3132   expdata = xmalloc (export_size);
3133   bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
3134   bfd_bread (expdata, (bfd_size_type) export_size, dll);
3135   erva = (char *) expdata - export_rva;
3136
3137   if (pe_def_file == 0)
3138     pe_def_file = def_file_empty ();
3139
3140   nexp = pe_as32 (expdata + 24);
3141   name_rvas = pe_as32 (expdata + 32);
3142   exp_funcbase = pe_as32 (expdata + 28);
3143
3144   /* Use internal dll name instead of filename
3145      to enable symbolic dll linking.  */
3146   dllname = erva + pe_as32 (expdata + 12);
3147
3148   /* Check to see if the dll has already been added to
3149      the definition list and if so return without error.
3150      This avoids multiple symbol definitions.  */
3151   if (def_get_module (pe_def_file, dllname))
3152     {
3153       if (pe_dll_extra_pe_debug)
3154         printf ("%s is already loaded\n", dllname);
3155       return TRUE;
3156     }
3157
3158   /* Iterate through the list of symbols.  */
3159   for (i = 0; i < nexp; i++)
3160     {
3161       /* Pointer to the names vector.  */
3162       bfd_vma name_rva = pe_as32 (erva + name_rvas + i * 4);
3163       def_file_import *imp;
3164       /* Pointer to the function address vector.  */
3165       bfd_vma func_rva = pe_as32 (erva + exp_funcbase + i * 4);
3166       int is_data = 0;
3167
3168       /* Skip unwanted symbols, which are
3169          exported in buggy auto-import releases.  */
3170       if (! CONST_STRNEQ (erva + name_rva, "__nm_"))
3171         {
3172           int is_dup = 0;
3173           /* is_data is true if the address is in the data, rdata or bss
3174              segment.  */
3175           is_data =
3176             (func_rva >= data_start && func_rva < data_end)
3177             || (func_rva >= rdata_start && func_rva < rdata_end)
3178             || (func_rva >= bss_start && func_rva < bss_end);
3179
3180           imp = def_file_add_import (pe_def_file, erva + name_rva,
3181                                      dllname, i, 0, NULL, &is_dup);
3182           /* Mark symbol type.  */
3183           if (!is_dup)
3184             imp->data = is_data;
3185
3186           if (pe_dll_extra_pe_debug)
3187             printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3188                     __FUNCTION__, dllname, erva + name_rva,
3189                     (unsigned long) func_rva, is_data ? "(data)" : "");
3190         }
3191     }
3192
3193   return TRUE;
3194 }
3195
3196 void
3197 pe_output_file_set_long_section_names (bfd *abfd)
3198 {
3199   if (pe_use_coff_long_section_names < 0)
3200     return;
3201   if (!bfd_coff_set_long_section_names (abfd, pe_use_coff_long_section_names))
3202     einfo (_("%XError: can't use long section names on this arch\n"));
3203 }
3204
3205 /* These are the main functions, called from the emulation.  The first
3206    is called after the bfds are read, so we can guess at how much space
3207    we need.  The second is called after everything is placed, so we
3208    can put the right values in place.  */
3209
3210 void
3211 pe_dll_build_sections (bfd *abfd, struct bfd_link_info *info)
3212 {
3213   pe_dll_id_target (bfd_get_target (abfd));
3214   pe_output_file_set_long_section_names (abfd);
3215   process_def_file_and_drectve (abfd, info);
3216
3217   if (pe_def_file->num_exports == 0 && !info->shared)
3218     return;
3219
3220   generate_edata (abfd, info);
3221   build_filler_bfd (1);
3222   pe_output_file_set_long_section_names (filler_bfd);
3223 }
3224
3225 void
3226 pe_exe_build_sections (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
3227 {
3228   pe_dll_id_target (bfd_get_target (abfd));
3229   pe_output_file_set_long_section_names (abfd);
3230   build_filler_bfd (0);
3231   pe_output_file_set_long_section_names (filler_bfd);
3232 }
3233
3234 void
3235 pe_dll_fill_sections (bfd *abfd, struct bfd_link_info *info)
3236 {
3237   pe_dll_id_target (bfd_get_target (abfd));
3238   pe_output_file_set_long_section_names (abfd);
3239   image_base = pe_data (abfd)->pe_opthdr.ImageBase;
3240
3241   generate_reloc (abfd, info);
3242   if (reloc_sz > 0)
3243     {
3244       bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
3245
3246       /* Resize the sections.  */
3247       lang_reset_memory_regions ();
3248       lang_size_sections (NULL, TRUE);
3249
3250       /* Redo special stuff.  */
3251       ldemul_after_allocation ();
3252
3253       /* Do the assignments again.  */
3254       lang_do_assignments (lang_final_phase_enum);
3255     }
3256
3257   fill_edata (abfd, info);
3258
3259   if (info->shared && !info->pie)
3260     pe_data (abfd)->dll = 1;
3261
3262   edata_s->contents = edata_d;
3263   reloc_s->contents = reloc_d;
3264 }
3265
3266 void
3267 pe_exe_fill_sections (bfd *abfd, struct bfd_link_info *info)
3268 {
3269   pe_dll_id_target (bfd_get_target (abfd));
3270   pe_output_file_set_long_section_names (abfd);
3271   image_base = pe_data (abfd)->pe_opthdr.ImageBase;
3272
3273   generate_reloc (abfd, info);
3274   if (reloc_sz > 0)
3275     {
3276       bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
3277
3278       /* Resize the sections.  */
3279       lang_reset_memory_regions ();
3280       lang_size_sections (NULL, TRUE);
3281
3282       /* Redo special stuff.  */
3283       ldemul_after_allocation ();
3284
3285       /* Do the assignments again.  */
3286       lang_do_assignments (lang_final_phase_enum);
3287     }
3288   reloc_s->contents = reloc_d;
3289 }
3290
3291 bfd_boolean
3292 pe_bfd_is_dll (bfd *abfd)
3293 {
3294   return (bfd_get_format (abfd) == bfd_object
3295           && obj_pe (abfd)
3296           && pe_data (abfd)->dll);
3297 }