OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [ld/] [pe-dll.c] - Blame information for rev 818

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.