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