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