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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [ld/] [pe-dll.c] - Blame information for rev 856

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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