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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [bfd/] [peXXigen.c] - Blame information for rev 156

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* Support for the generic parts of PE/PEI; the common executable parts.
2
   Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3
   2005, 2006, 2007 Free Software Foundation, Inc.
4
   Written by Cygnus Solutions.
5
 
6
   This file is part of BFD, the Binary File Descriptor library.
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
 
24
/* Most of this hacked by Steve Chamberlain <sac@cygnus.com>.
25
 
26
   PE/PEI rearrangement (and code added): Donn Terry
27
                                          Softway Systems, Inc.  */
28
 
29
/* Hey look, some documentation [and in a place you expect to find it]!
30
 
31
   The main reference for the pei format is "Microsoft Portable Executable
32
   and Common Object File Format Specification 4.1".  Get it if you need to
33
   do some serious hacking on this code.
34
 
35
   Another reference:
36
   "Peering Inside the PE: A Tour of the Win32 Portable Executable
37
   File Format", MSJ 1994, Volume 9.
38
 
39
   The *sole* difference between the pe format and the pei format is that the
40
   latter has an MSDOS 2.0 .exe header on the front that prints the message
41
   "This app must be run under Windows." (or some such).
42
   (FIXME: Whether that statement is *really* true or not is unknown.
43
   Are there more subtle differences between pe and pei formats?
44
   For now assume there aren't.  If you find one, then for God sakes
45
   document it here!)
46
 
47
   The Microsoft docs use the word "image" instead of "executable" because
48
   the former can also refer to a DLL (shared library).  Confusion can arise
49
   because the `i' in `pei' also refers to "image".  The `pe' format can
50
   also create images (i.e. executables), it's just that to run on a win32
51
   system you need to use the pei format.
52
 
53
   FIXME: Please add more docs here so the next poor fool that has to hack
54
   on this code has a chance of getting something accomplished without
55
   wasting too much time.  */
56
 
57
/* This expands into COFF_WITH_pe, COFF_WITH_pep, or COFF_WITH_pex64
58
   depending on whether we're compiling for straight PE or PE+.  */
59
#define COFF_WITH_XX
60
 
61
#include "sysdep.h"
62
#include "bfd.h"
63
#include "libbfd.h"
64
#include "coff/internal.h"
65
 
66
/* NOTE: it's strange to be including an architecture specific header
67
   in what's supposed to be general (to PE/PEI) code.  However, that's
68
   where the definitions are, and they don't vary per architecture
69
   within PE/PEI, so we get them from there.  FIXME: The lack of
70
   variance is an assumption which may prove to be incorrect if new
71
   PE/PEI targets are created.  */
72
#if defined COFF_WITH_pex64
73
# include "coff/x86_64.h"
74
#elif defined COFF_WITH_pep
75
# include "coff/ia64.h"
76
#else
77
# include "coff/i386.h"
78
#endif
79
 
80
#include "coff/pe.h"
81
#include "libcoff.h"
82
#include "libpei.h"
83
 
84
#if defined COFF_WITH_pep || defined COFF_WITH_pex64
85
# undef AOUTSZ
86
# define AOUTSZ         PEPAOUTSZ
87
# define PEAOUTHDR      PEPAOUTHDR
88
#endif
89
 
90
/* FIXME: This file has various tests of POWERPC_LE_PE.  Those tests
91
   worked when the code was in peicode.h, but no longer work now that
92
   the code is in peigen.c.  PowerPC NT is said to be dead.  If
93
   anybody wants to revive the code, you will have to figure out how
94
   to handle those issues.  */
95
 
96
void
97
_bfd_XXi_swap_sym_in (bfd * abfd, void * ext1, void * in1)
98
{
99
  SYMENT *ext = (SYMENT *) ext1;
100
  struct internal_syment *in = (struct internal_syment *) in1;
101
 
102
  if (ext->e.e_name[0] == 0)
103
    {
104
      in->_n._n_n._n_zeroes = 0;
105
      in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
106
    }
107
  else
108
    memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);
109
 
110
  in->n_value = H_GET_32 (abfd, ext->e_value);
111
  in->n_scnum = H_GET_16 (abfd, ext->e_scnum);
112
 
113
  if (sizeof (ext->e_type) == 2)
114
    in->n_type = H_GET_16 (abfd, ext->e_type);
115
  else
116
    in->n_type = H_GET_32 (abfd, ext->e_type);
117
 
118
  in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
119
  in->n_numaux = H_GET_8 (abfd, ext->e_numaux);
120
 
121
#ifndef STRICT_PE_FORMAT
122
  /* This is for Gnu-created DLLs.  */
123
 
124
  /* The section symbols for the .idata$ sections have class 0x68
125
     (C_SECTION), which MS documentation indicates is a section
126
     symbol.  Unfortunately, the value field in the symbol is simply a
127
     copy of the .idata section's flags rather than something useful.
128
     When these symbols are encountered, change the value to 0 so that
129
     they will be handled somewhat correctly in the bfd code.  */
130
  if (in->n_sclass == C_SECTION)
131
    {
132
      in->n_value = 0x0;
133
 
134
      /* Create synthetic empty sections as needed.  DJ */
135
      if (in->n_scnum == 0)
136
        {
137
          asection *sec;
138
 
139
          for (sec = abfd->sections; sec; sec = sec->next)
140
            {
141
              if (strcmp (sec->name, in->n_name) == 0)
142
                {
143
                  in->n_scnum = sec->target_index;
144
                  break;
145
                }
146
            }
147
        }
148
 
149
      if (in->n_scnum == 0)
150
        {
151
          int unused_section_number = 0;
152
          asection *sec;
153
          char *name;
154
          flagword flags;
155
 
156
          for (sec = abfd->sections; sec; sec = sec->next)
157
            if (unused_section_number <= sec->target_index)
158
              unused_section_number = sec->target_index + 1;
159
 
160
          name = bfd_alloc (abfd, (bfd_size_type) strlen (in->n_name) + 10);
161
          if (name == NULL)
162
            return;
163
          strcpy (name, in->n_name);
164
          flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_DATA | SEC_LOAD;
165
          sec = bfd_make_section_anyway_with_flags (abfd, name, flags);
166
 
167
          sec->vma = 0;
168
          sec->lma = 0;
169
          sec->size = 0;
170
          sec->filepos = 0;
171
          sec->rel_filepos = 0;
172
          sec->reloc_count = 0;
173
          sec->line_filepos = 0;
174
          sec->lineno_count = 0;
175
          sec->userdata = NULL;
176
          sec->next = NULL;
177
          sec->alignment_power = 2;
178
 
179
          sec->target_index = unused_section_number;
180
 
181
          in->n_scnum = unused_section_number;
182
        }
183
      in->n_sclass = C_STAT;
184
    }
185
#endif
186
 
187
#ifdef coff_swap_sym_in_hook
188
  /* This won't work in peigen.c, but since it's for PPC PE, it's not
189
     worth fixing.  */
190
  coff_swap_sym_in_hook (abfd, ext1, in1);
191
#endif
192
}
193
 
194
unsigned int
195
_bfd_XXi_swap_sym_out (bfd * abfd, void * inp, void * extp)
196
{
197
  struct internal_syment *in = (struct internal_syment *) inp;
198
  SYMENT *ext = (SYMENT *) extp;
199
 
200
  if (in->_n._n_name[0] == 0)
201
    {
202
      H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
203
      H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
204
    }
205
  else
206
    memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);
207
 
208
  H_PUT_32 (abfd, in->n_value, ext->e_value);
209
  H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);
210
 
211
  if (sizeof (ext->e_type) == 2)
212
    H_PUT_16 (abfd, in->n_type, ext->e_type);
213
  else
214
    H_PUT_32 (abfd, in->n_type, ext->e_type);
215
 
216
  H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
217
  H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);
218
 
219
  return SYMESZ;
220
}
221
 
222
void
223
_bfd_XXi_swap_aux_in (bfd *     abfd,
224
                      void *    ext1,
225
                      int       type,
226
                      int       class,
227
                      int       indx ATTRIBUTE_UNUSED,
228
                      int       numaux ATTRIBUTE_UNUSED,
229
                      void *    in1)
230
{
231
  AUXENT *ext = (AUXENT *) ext1;
232
  union internal_auxent *in = (union internal_auxent *) in1;
233
 
234
  switch (class)
235
    {
236
    case C_FILE:
237
      if (ext->x_file.x_fname[0] == 0)
238
        {
239
          in->x_file.x_n.x_zeroes = 0;
240
          in->x_file.x_n.x_offset = H_GET_32 (abfd, ext->x_file.x_n.x_offset);
241
        }
242
      else
243
        memcpy (in->x_file.x_fname, ext->x_file.x_fname, FILNMLEN);
244
      return;
245
 
246
    case C_STAT:
247
    case C_LEAFSTAT:
248
    case C_HIDDEN:
249
      if (type == T_NULL)
250
        {
251
          in->x_scn.x_scnlen = GET_SCN_SCNLEN (abfd, ext);
252
          in->x_scn.x_nreloc = GET_SCN_NRELOC (abfd, ext);
253
          in->x_scn.x_nlinno = GET_SCN_NLINNO (abfd, ext);
254
          in->x_scn.x_checksum = H_GET_32 (abfd, ext->x_scn.x_checksum);
255
          in->x_scn.x_associated = H_GET_16 (abfd, ext->x_scn.x_associated);
256
          in->x_scn.x_comdat = H_GET_8 (abfd, ext->x_scn.x_comdat);
257
          return;
258
        }
259
      break;
260
    }
261
 
262
  in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->x_sym.x_tagndx);
263
  in->x_sym.x_tvndx = H_GET_16 (abfd, ext->x_sym.x_tvndx);
264
 
265
  if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
266
    {
267
      in->x_sym.x_fcnary.x_fcn.x_lnnoptr = GET_FCN_LNNOPTR (abfd, ext);
268
      in->x_sym.x_fcnary.x_fcn.x_endndx.l = GET_FCN_ENDNDX (abfd, ext);
269
    }
270
  else
271
    {
272
      in->x_sym.x_fcnary.x_ary.x_dimen[0] =
273
        H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
274
      in->x_sym.x_fcnary.x_ary.x_dimen[1] =
275
        H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
276
      in->x_sym.x_fcnary.x_ary.x_dimen[2] =
277
        H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
278
      in->x_sym.x_fcnary.x_ary.x_dimen[3] =
279
        H_GET_16 (abfd, ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
280
    }
281
 
282
  if (ISFCN (type))
283
    {
284
      in->x_sym.x_misc.x_fsize = H_GET_32 (abfd, ext->x_sym.x_misc.x_fsize);
285
    }
286
  else
287
    {
288
      in->x_sym.x_misc.x_lnsz.x_lnno = GET_LNSZ_LNNO (abfd, ext);
289
      in->x_sym.x_misc.x_lnsz.x_size = GET_LNSZ_SIZE (abfd, ext);
290
    }
291
}
292
 
293
unsigned int
294
_bfd_XXi_swap_aux_out (bfd *  abfd,
295
                       void * inp,
296
                       int    type,
297
                       int    class,
298
                       int    indx ATTRIBUTE_UNUSED,
299
                       int    numaux ATTRIBUTE_UNUSED,
300
                       void * extp)
301
{
302
  union internal_auxent *in = (union internal_auxent *) inp;
303
  AUXENT *ext = (AUXENT *) extp;
304
 
305
  memset (ext, 0, AUXESZ);
306
 
307
  switch (class)
308
    {
309
    case C_FILE:
310
      if (in->x_file.x_fname[0] == 0)
311
        {
312
          H_PUT_32 (abfd, 0, ext->x_file.x_n.x_zeroes);
313
          H_PUT_32 (abfd, in->x_file.x_n.x_offset, ext->x_file.x_n.x_offset);
314
        }
315
      else
316
        memcpy (ext->x_file.x_fname, in->x_file.x_fname, FILNMLEN);
317
 
318
      return AUXESZ;
319
 
320
    case C_STAT:
321
    case C_LEAFSTAT:
322
    case C_HIDDEN:
323
      if (type == T_NULL)
324
        {
325
          PUT_SCN_SCNLEN (abfd, in->x_scn.x_scnlen, ext);
326
          PUT_SCN_NRELOC (abfd, in->x_scn.x_nreloc, ext);
327
          PUT_SCN_NLINNO (abfd, in->x_scn.x_nlinno, ext);
328
          H_PUT_32 (abfd, in->x_scn.x_checksum, ext->x_scn.x_checksum);
329
          H_PUT_16 (abfd, in->x_scn.x_associated, ext->x_scn.x_associated);
330
          H_PUT_8 (abfd, in->x_scn.x_comdat, ext->x_scn.x_comdat);
331
          return AUXESZ;
332
        }
333
      break;
334
    }
335
 
336
  H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->x_sym.x_tagndx);
337
  H_PUT_16 (abfd, in->x_sym.x_tvndx, ext->x_sym.x_tvndx);
338
 
339
  if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
340
    {
341
      PUT_FCN_LNNOPTR (abfd, in->x_sym.x_fcnary.x_fcn.x_lnnoptr,  ext);
342
      PUT_FCN_ENDNDX  (abfd, in->x_sym.x_fcnary.x_fcn.x_endndx.l, ext);
343
    }
344
  else
345
    {
346
      H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[0],
347
                ext->x_sym.x_fcnary.x_ary.x_dimen[0]);
348
      H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[1],
349
                ext->x_sym.x_fcnary.x_ary.x_dimen[1]);
350
      H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[2],
351
                ext->x_sym.x_fcnary.x_ary.x_dimen[2]);
352
      H_PUT_16 (abfd, in->x_sym.x_fcnary.x_ary.x_dimen[3],
353
                ext->x_sym.x_fcnary.x_ary.x_dimen[3]);
354
    }
355
 
356
  if (ISFCN (type))
357
    H_PUT_32 (abfd, in->x_sym.x_misc.x_fsize, ext->x_sym.x_misc.x_fsize);
358
  else
359
    {
360
      PUT_LNSZ_LNNO (abfd, in->x_sym.x_misc.x_lnsz.x_lnno, ext);
361
      PUT_LNSZ_SIZE (abfd, in->x_sym.x_misc.x_lnsz.x_size, ext);
362
    }
363
 
364
  return AUXESZ;
365
}
366
 
367
void
368
_bfd_XXi_swap_lineno_in (bfd * abfd, void * ext1, void * in1)
369
{
370
  LINENO *ext = (LINENO *) ext1;
371
  struct internal_lineno *in = (struct internal_lineno *) in1;
372
 
373
  in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
374
  in->l_lnno = GET_LINENO_LNNO (abfd, ext);
375
}
376
 
377
unsigned int
378
_bfd_XXi_swap_lineno_out (bfd * abfd, void * inp, void * outp)
379
{
380
  struct internal_lineno *in = (struct internal_lineno *) inp;
381
  struct external_lineno *ext = (struct external_lineno *) outp;
382
  H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);
383
 
384
  PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
385
  return LINESZ;
386
}
387
 
388
void
389
_bfd_XXi_swap_aouthdr_in (bfd * abfd,
390
                          void * aouthdr_ext1,
391
                          void * aouthdr_int1)
392
{
393
  PEAOUTHDR * src = (PEAOUTHDR *) aouthdr_ext1;
394
  AOUTHDR * aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
395
  struct internal_aouthdr *aouthdr_int
396
    = (struct internal_aouthdr *) aouthdr_int1;
397
  struct internal_extra_pe_aouthdr *a = &aouthdr_int->pe;
398
 
399
  aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic);
400
  aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp);
401
  aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize);
402
  aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize);
403
  aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize);
404
  aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry);
405
  aouthdr_int->text_start =
406
    GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start);
407
#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
408
  /* PE32+ does not have data_start member!  */
409
  aouthdr_int->data_start =
410
    GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start);
411
  a->BaseOfData = aouthdr_int->data_start;
412
#endif
413
 
414
  a->Magic = aouthdr_int->magic;
415
  a->MajorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp);
416
  a->MinorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp + 1);
417
  a->SizeOfCode = aouthdr_int->tsize ;
418
  a->SizeOfInitializedData = aouthdr_int->dsize ;
419
  a->SizeOfUninitializedData = aouthdr_int->bsize ;
420
  a->AddressOfEntryPoint = aouthdr_int->entry;
421
  a->BaseOfCode = aouthdr_int->text_start;
422
  a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, src->ImageBase);
423
  a->SectionAlignment = H_GET_32 (abfd, src->SectionAlignment);
424
  a->FileAlignment = H_GET_32 (abfd, src->FileAlignment);
425
  a->MajorOperatingSystemVersion =
426
    H_GET_16 (abfd, src->MajorOperatingSystemVersion);
427
  a->MinorOperatingSystemVersion =
428
    H_GET_16 (abfd, src->MinorOperatingSystemVersion);
429
  a->MajorImageVersion = H_GET_16 (abfd, src->MajorImageVersion);
430
  a->MinorImageVersion = H_GET_16 (abfd, src->MinorImageVersion);
431
  a->MajorSubsystemVersion = H_GET_16 (abfd, src->MajorSubsystemVersion);
432
  a->MinorSubsystemVersion = H_GET_16 (abfd, src->MinorSubsystemVersion);
433
  a->Reserved1 = H_GET_32 (abfd, src->Reserved1);
434
  a->SizeOfImage = H_GET_32 (abfd, src->SizeOfImage);
435
  a->SizeOfHeaders = H_GET_32 (abfd, src->SizeOfHeaders);
436
  a->CheckSum = H_GET_32 (abfd, src->CheckSum);
437
  a->Subsystem = H_GET_16 (abfd, src->Subsystem);
438
  a->DllCharacteristics = H_GET_16 (abfd, src->DllCharacteristics);
439
  a->SizeOfStackReserve =
440
    GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, src->SizeOfStackReserve);
441
  a->SizeOfStackCommit =
442
    GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, src->SizeOfStackCommit);
443
  a->SizeOfHeapReserve =
444
    GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, src->SizeOfHeapReserve);
445
  a->SizeOfHeapCommit =
446
    GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, src->SizeOfHeapCommit);
447
  a->LoaderFlags = H_GET_32 (abfd, src->LoaderFlags);
448
  a->NumberOfRvaAndSizes = H_GET_32 (abfd, src->NumberOfRvaAndSizes);
449
 
450
  {
451
    int idx;
452
 
453
    for (idx = 0; idx < 16; idx++)
454
      {
455
        /* If data directory is empty, rva also should be 0.  */
456
        int size =
457
          H_GET_32 (abfd, src->DataDirectory[idx][1]);
458
 
459
        a->DataDirectory[idx].Size = size;
460
 
461
        if (size)
462
          a->DataDirectory[idx].VirtualAddress =
463
            H_GET_32 (abfd, src->DataDirectory[idx][0]);
464
        else
465
          a->DataDirectory[idx].VirtualAddress = 0;
466
      }
467
  }
468
 
469
  if (aouthdr_int->entry)
470
    {
471
      aouthdr_int->entry += a->ImageBase;
472
#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
473
      aouthdr_int->entry &= 0xffffffff;
474
#endif
475
    }
476
 
477
  if (aouthdr_int->tsize)
478
    {
479
      aouthdr_int->text_start += a->ImageBase;
480
#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
481
      aouthdr_int->text_start &= 0xffffffff;
482
#endif
483
    }
484
 
485
#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
486
  /* PE32+ does not have data_start member!  */
487
  if (aouthdr_int->dsize)
488
    {
489
      aouthdr_int->data_start += a->ImageBase;
490
      aouthdr_int->data_start &= 0xffffffff;
491
    }
492
#endif
493
 
494
#ifdef POWERPC_LE_PE
495
  /* These three fields are normally set up by ppc_relocate_section.
496
     In the case of reading a file in, we can pick them up from the
497
     DataDirectory.  */
498
  first_thunk_address = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress;
499
  thunk_size = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size;
500
  import_table_size = a->DataDirectory[PE_IMPORT_TABLE].Size;
501
#endif
502
}
503
 
504
/* A support function for below.  */
505
 
506
static void
507
add_data_entry (bfd * abfd,
508
                struct internal_extra_pe_aouthdr *aout,
509
                int idx,
510
                char *name,
511
                bfd_vma base)
512
{
513
  asection *sec = bfd_get_section_by_name (abfd, name);
514
 
515
  /* Add import directory information if it exists.  */
516
  if ((sec != NULL)
517
      && (coff_section_data (abfd, sec) != NULL)
518
      && (pei_section_data (abfd, sec) != NULL))
519
    {
520
      /* If data directory is empty, rva also should be 0.  */
521
      int size = pei_section_data (abfd, sec)->virt_size;
522
      aout->DataDirectory[idx].Size = size;
523
 
524
      if (size)
525
        {
526
          aout->DataDirectory[idx].VirtualAddress =
527
            (sec->vma - base) & 0xffffffff;
528
          sec->flags |= SEC_DATA;
529
        }
530
    }
531
}
532
 
533
unsigned int
534
_bfd_XXi_swap_aouthdr_out (bfd * abfd, void * in, void * out)
535
{
536
  struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in;
537
  pe_data_type *pe = pe_data (abfd);
538
  struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
539
  PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out;
540
  bfd_vma sa, fa, ib;
541
  IMAGE_DATA_DIRECTORY idata2, idata5, tls;
542
 
543
  if (pe->force_minimum_alignment)
544
    {
545
      if (!extra->FileAlignment)
546
        extra->FileAlignment = PE_DEF_FILE_ALIGNMENT;
547
      if (!extra->SectionAlignment)
548
        extra->SectionAlignment = PE_DEF_SECTION_ALIGNMENT;
549
    }
550
 
551
  if (extra->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN)
552
    extra->Subsystem = pe->target_subsystem;
553
 
554
  sa = extra->SectionAlignment;
555
  fa = extra->FileAlignment;
556
  ib = extra->ImageBase;
557
 
558
  idata2 = pe->pe_opthdr.DataDirectory[PE_IMPORT_TABLE];
559
  idata5 = pe->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE];
560
  tls = pe->pe_opthdr.DataDirectory[PE_TLS_TABLE];
561
 
562
  if (aouthdr_in->tsize)
563
    {
564
      aouthdr_in->text_start -= ib;
565
#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
566
      aouthdr_in->text_start &= 0xffffffff;
567
#endif
568
    }
569
 
570
  if (aouthdr_in->dsize)
571
    {
572
      aouthdr_in->data_start -= ib;
573
#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
574
      aouthdr_in->data_start &= 0xffffffff;
575
#endif
576
    }
577
 
578
  if (aouthdr_in->entry)
579
    {
580
      aouthdr_in->entry -= ib;
581
#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
582
      aouthdr_in->entry &= 0xffffffff;
583
#endif
584
    }
585
 
586
#define FA(x) (((x) + fa -1 ) & (- fa))
587
#define SA(x) (((x) + sa -1 ) & (- sa))
588
 
589
  /* We like to have the sizes aligned.  */
590
  aouthdr_in->bsize = FA (aouthdr_in->bsize);
591
 
592
  extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
593
 
594
  /* First null out all data directory entries.  */
595
  memset (extra->DataDirectory, 0, sizeof (extra->DataDirectory));
596
 
597
  add_data_entry (abfd, extra, 0, ".edata", ib);
598
  add_data_entry (abfd, extra, 2, ".rsrc", ib);
599
  add_data_entry (abfd, extra, 3, ".pdata", ib);
600
 
601
  /* In theory we do not need to call add_data_entry for .idata$2 or
602
     .idata$5.  It will be done in bfd_coff_final_link where all the
603
     required information is available.  If however, we are not going
604
     to perform a final link, eg because we have been invoked by objcopy
605
     or strip, then we need to make sure that these Data Directory
606
     entries are initialised properly.
607
 
608
     So - we copy the input values into the output values, and then, if
609
     a final link is going to be performed, it can overwrite them.  */
610
  extra->DataDirectory[PE_IMPORT_TABLE]  = idata2;
611
  extra->DataDirectory[PE_IMPORT_ADDRESS_TABLE] = idata5;
612
  extra->DataDirectory[PE_TLS_TABLE] = tls;
613
 
614
  if (extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress == 0)
615
    /* Until other .idata fixes are made (pending patch), the entry for
616
       .idata is needed for backwards compatibility.  FIXME.  */
617
    add_data_entry (abfd, extra, 1, ".idata", ib);
618
 
619
  /* For some reason, the virtual size (which is what's set by
620
     add_data_entry) for .reloc is not the same as the size recorded
621
     in this slot by MSVC; it doesn't seem to cause problems (so far),
622
     but since it's the best we've got, use it.  It does do the right
623
     thing for .pdata.  */
624
  if (pe->has_reloc_section)
625
    add_data_entry (abfd, extra, 5, ".reloc", ib);
626
 
627
  {
628
    asection *sec;
629
    bfd_vma hsize = 0;
630
    bfd_vma dsize = 0;
631
    bfd_vma isize = 0;
632
    bfd_vma tsize = 0;
633
 
634
    for (sec = abfd->sections; sec; sec = sec->next)
635
      {
636
        int rounded = FA (sec->size);
637
 
638
        /* The first non-zero section filepos is the header size.
639
           Sections without contents will have a filepos of 0.  */
640
        if (hsize == 0)
641
          hsize = sec->filepos;
642
        if (sec->flags & SEC_DATA)
643
          dsize += rounded;
644
        if (sec->flags & SEC_CODE)
645
          tsize += rounded;
646
        /* The image size is the total VIRTUAL size (which is what is
647
           in the virt_size field).  Files have been seen (from MSVC
648
           5.0 link.exe) where the file size of the .data segment is
649
           quite small compared to the virtual size.  Without this
650
           fix, strip munges the file.
651
 
652
           FIXME: We need to handle holes between sections, which may
653
           happpen when we covert from another format.  We just use
654
           the virtual address and virtual size of the last section
655
           for the image size.  */
656
        if (coff_section_data (abfd, sec) != NULL
657
            && pei_section_data (abfd, sec) != NULL)
658
          isize = (sec->vma - extra->ImageBase
659
                   + SA (FA (pei_section_data (abfd, sec)->virt_size)));
660
      }
661
 
662
    aouthdr_in->dsize = dsize;
663
    aouthdr_in->tsize = tsize;
664
    extra->SizeOfHeaders = hsize;
665
    extra->SizeOfImage = isize;
666
  }
667
 
668
  H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);
669
 
670
#define LINKER_VERSION 256 /* That is, 2.56 */
671
 
672
  /* This piece of magic sets the "linker version" field to
673
     LINKER_VERSION.  */
674
  H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256),
675
            aouthdr_out->standard.vstamp);
676
 
677
  PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize);
678
  PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize);
679
  PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize);
680
  PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry);
681
  PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
682
                          aouthdr_out->standard.text_start);
683
 
684
#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
685
  /* PE32+ does not have data_start member!  */
686
  PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
687
                          aouthdr_out->standard.data_start);
688
#endif
689
 
690
  PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase);
691
  H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment);
692
  H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment);
693
  H_PUT_16 (abfd, extra->MajorOperatingSystemVersion,
694
            aouthdr_out->MajorOperatingSystemVersion);
695
  H_PUT_16 (abfd, extra->MinorOperatingSystemVersion,
696
            aouthdr_out->MinorOperatingSystemVersion);
697
  H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion);
698
  H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion);
699
  H_PUT_16 (abfd, extra->MajorSubsystemVersion,
700
            aouthdr_out->MajorSubsystemVersion);
701
  H_PUT_16 (abfd, extra->MinorSubsystemVersion,
702
            aouthdr_out->MinorSubsystemVersion);
703
  H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1);
704
  H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage);
705
  H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders);
706
  H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum);
707
  H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem);
708
  H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics);
709
  PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
710
                                    aouthdr_out->SizeOfStackReserve);
711
  PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
712
                                   aouthdr_out->SizeOfStackCommit);
713
  PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
714
                                   aouthdr_out->SizeOfHeapReserve);
715
  PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
716
                                  aouthdr_out->SizeOfHeapCommit);
717
  H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags);
718
  H_PUT_32 (abfd, extra->NumberOfRvaAndSizes,
719
            aouthdr_out->NumberOfRvaAndSizes);
720
  {
721
    int idx;
722
 
723
    for (idx = 0; idx < 16; idx++)
724
      {
725
        H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
726
                  aouthdr_out->DataDirectory[idx][0]);
727
        H_PUT_32 (abfd, extra->DataDirectory[idx].Size,
728
                  aouthdr_out->DataDirectory[idx][1]);
729
      }
730
  }
731
 
732
  return AOUTSZ;
733
}
734
 
735
unsigned int
736
_bfd_XXi_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
737
{
738
  int idx;
739
  struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
740
  struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out;
741
 
742
  if (pe_data (abfd)->has_reloc_section)
743
    filehdr_in->f_flags &= ~F_RELFLG;
744
 
745
  if (pe_data (abfd)->dll)
746
    filehdr_in->f_flags |= F_DLL;
747
 
748
  filehdr_in->pe.e_magic    = DOSMAGIC;
749
  filehdr_in->pe.e_cblp     = 0x90;
750
  filehdr_in->pe.e_cp       = 0x3;
751
  filehdr_in->pe.e_crlc     = 0x0;
752
  filehdr_in->pe.e_cparhdr  = 0x4;
753
  filehdr_in->pe.e_minalloc = 0x0;
754
  filehdr_in->pe.e_maxalloc = 0xffff;
755
  filehdr_in->pe.e_ss       = 0x0;
756
  filehdr_in->pe.e_sp       = 0xb8;
757
  filehdr_in->pe.e_csum     = 0x0;
758
  filehdr_in->pe.e_ip       = 0x0;
759
  filehdr_in->pe.e_cs       = 0x0;
760
  filehdr_in->pe.e_lfarlc   = 0x40;
761
  filehdr_in->pe.e_ovno     = 0x0;
762
 
763
  for (idx = 0; idx < 4; idx++)
764
    filehdr_in->pe.e_res[idx] = 0x0;
765
 
766
  filehdr_in->pe.e_oemid   = 0x0;
767
  filehdr_in->pe.e_oeminfo = 0x0;
768
 
769
  for (idx = 0; idx < 10; idx++)
770
    filehdr_in->pe.e_res2[idx] = 0x0;
771
 
772
  filehdr_in->pe.e_lfanew = 0x80;
773
 
774
  /* This next collection of data are mostly just characters.  It
775
     appears to be constant within the headers put on NT exes.  */
776
  filehdr_in->pe.dos_message[0]  = 0x0eba1f0e;
777
  filehdr_in->pe.dos_message[1]  = 0xcd09b400;
778
  filehdr_in->pe.dos_message[2]  = 0x4c01b821;
779
  filehdr_in->pe.dos_message[3]  = 0x685421cd;
780
  filehdr_in->pe.dos_message[4]  = 0x70207369;
781
  filehdr_in->pe.dos_message[5]  = 0x72676f72;
782
  filehdr_in->pe.dos_message[6]  = 0x63206d61;
783
  filehdr_in->pe.dos_message[7]  = 0x6f6e6e61;
784
  filehdr_in->pe.dos_message[8]  = 0x65622074;
785
  filehdr_in->pe.dos_message[9]  = 0x6e757220;
786
  filehdr_in->pe.dos_message[10] = 0x206e6920;
787
  filehdr_in->pe.dos_message[11] = 0x20534f44;
788
  filehdr_in->pe.dos_message[12] = 0x65646f6d;
789
  filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
790
  filehdr_in->pe.dos_message[14] = 0x24;
791
  filehdr_in->pe.dos_message[15] = 0x0;
792
  filehdr_in->pe.nt_signature = NT_SIGNATURE;
793
 
794
  H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
795
  H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
796
 
797
  H_PUT_32 (abfd, time (0), filehdr_out->f_timdat);
798
  PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
799
                      filehdr_out->f_symptr);
800
  H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
801
  H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
802
  H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
803
 
804
  /* Put in extra dos header stuff.  This data remains essentially
805
     constant, it just has to be tacked on to the beginning of all exes
806
     for NT.  */
807
  H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);
808
  H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);
809
  H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);
810
  H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);
811
  H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);
812
  H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);
813
  H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);
814
  H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);
815
  H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);
816
  H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);
817
  H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);
818
  H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);
819
  H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);
820
  H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);
821
 
822
  for (idx = 0; idx < 4; idx++)
823
    H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);
824
 
825
  H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);
826
  H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);
827
 
828
  for (idx = 0; idx < 10; idx++)
829
    H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);
830
 
831
  H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);
832
 
833
  for (idx = 0; idx < 16; idx++)
834
    H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx],
835
              filehdr_out->dos_message[idx]);
836
 
837
  /* Also put in the NT signature.  */
838
  H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);
839
 
840
  return FILHSZ;
841
}
842
 
843
unsigned int
844
_bfd_XX_only_swap_filehdr_out (bfd * abfd, void * in, void * out)
845
{
846
  struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
847
  FILHDR *filehdr_out = (FILHDR *) out;
848
 
849
  H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
850
  H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
851
  H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
852
  PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
853
  H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
854
  H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
855
  H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);
856
 
857
  return FILHSZ;
858
}
859
 
860
unsigned int
861
_bfd_XXi_swap_scnhdr_out (bfd * abfd, void * in, void * out)
862
{
863
  struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
864
  SCNHDR *scnhdr_ext = (SCNHDR *) out;
865
  unsigned int ret = SCNHSZ;
866
  bfd_vma ps;
867
  bfd_vma ss;
868
 
869
  memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));
870
 
871
  PUT_SCNHDR_VADDR (abfd,
872
                    ((scnhdr_int->s_vaddr
873
                      - pe_data (abfd)->pe_opthdr.ImageBase)
874
                     & 0xffffffff),
875
                    scnhdr_ext->s_vaddr);
876
 
877
  /* NT wants the size data to be rounded up to the next
878
     NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
879
     sometimes).  */
880
  if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
881
    {
882
      if (bfd_pe_executable_p (abfd))
883
        {
884
          ps = scnhdr_int->s_size;
885
          ss = 0;
886
        }
887
      else
888
       {
889
         ps = 0;
890
         ss = scnhdr_int->s_size;
891
       }
892
    }
893
  else
894
    {
895
      if (bfd_pe_executable_p (abfd))
896
        ps = scnhdr_int->s_paddr;
897
      else
898
        ps = 0;
899
 
900
      ss = scnhdr_int->s_size;
901
    }
902
 
903
  PUT_SCNHDR_SIZE (abfd, ss,
904
                   scnhdr_ext->s_size);
905
 
906
  /* s_paddr in PE is really the virtual size.  */
907
  PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);
908
 
909
  PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
910
                     scnhdr_ext->s_scnptr);
911
  PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
912
                     scnhdr_ext->s_relptr);
913
  PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
914
                      scnhdr_ext->s_lnnoptr);
915
 
916
  {
917
    /* Extra flags must be set when dealing with PE.  All sections should also
918
       have the IMAGE_SCN_MEM_READ (0x40000000) flag set.  In addition, the
919
       .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
920
       sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
921
       (this is especially important when dealing with the .idata section since
922
       the addresses for routines from .dlls must be overwritten).  If .reloc
923
       section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
924
       (0x02000000).  Also, the resource data should also be read and
925
       writable.  */
926
 
927
    /* FIXME: Alignment is also encoded in this field, at least on PPC and
928
       ARM-WINCE.  Although - how do we get the original alignment field
929
       back ?  */
930
 
931
    typedef struct
932
    {
933
      const char *      section_name;
934
      unsigned long     must_have;
935
    }
936
    pe_required_section_flags;
937
 
938
    pe_required_section_flags known_sections [] =
939
      {
940
        { ".arch",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES },
941
        { ".bss",   IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
942
        { ".data",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
943
        { ".edata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
944
        { ".idata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
945
        { ".pdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
946
        { ".rdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
947
        { ".reloc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE },
948
        { ".rsrc",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
949
        { ".text" , IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE },
950
        { ".tls",   IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
951
        { ".xdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
952
        { NULL, 0}
953
      };
954
 
955
    pe_required_section_flags * p;
956
 
957
    /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
958
       we know exactly what this specific section wants so we remove it
959
       and then allow the must_have field to add it back in if necessary.
960
       However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
961
       default WP_TEXT file flag has been cleared.  WP_TEXT may be cleared
962
       by ld --enable-auto-import (if auto-import is actually needed),
963
       by ld --omagic, or by obcopy --writable-text.  */
964
 
965
    for (p = known_sections; p->section_name; p++)
966
      if (strcmp (scnhdr_int->s_name, p->section_name) == 0)
967
        {
968
          if (strcmp (scnhdr_int->s_name, ".text")
969
              || (bfd_get_file_flags (abfd) & WP_TEXT))
970
            scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE;
971
          scnhdr_int->s_flags |= p->must_have;
972
          break;
973
        }
974
 
975
    H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
976
  }
977
 
978
  if (coff_data (abfd)->link_info
979
      && ! coff_data (abfd)->link_info->relocatable
980
      && ! coff_data (abfd)->link_info->shared
981
      && strcmp (scnhdr_int->s_name, ".text") == 0)
982
    {
983
      /* By inference from looking at MS output, the 32 bit field
984
         which is the combination of the number_of_relocs and
985
         number_of_linenos is used for the line number count in
986
         executables.  A 16-bit field won't do for cc1.  The MS
987
         document says that the number of relocs is zero for
988
         executables, but the 17-th bit has been observed to be there.
989
         Overflow is not an issue: a 4G-line program will overflow a
990
         bunch of other fields long before this!  */
991
      H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
992
      H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
993
    }
994
  else
995
    {
996
      if (scnhdr_int->s_nlnno <= 0xffff)
997
        H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
998
      else
999
        {
1000
          (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
1001
                                 bfd_get_filename (abfd),
1002
                                 scnhdr_int->s_nlnno);
1003
          bfd_set_error (bfd_error_file_truncated);
1004
          H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
1005
          ret = 0;
1006
        }
1007
 
1008
      /* Although we could encode 0xffff relocs here, we do not, to be
1009
         consistent with other parts of bfd. Also it lets us warn, as
1010
         we should never see 0xffff here w/o having the overflow flag
1011
         set.  */
1012
      if (scnhdr_int->s_nreloc < 0xffff)
1013
        H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
1014
      else
1015
        {
1016
          /* PE can deal with large #s of relocs, but not here.  */
1017
          H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
1018
          scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
1019
          H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
1020
        }
1021
    }
1022
  return ret;
1023
}
1024
 
1025
static char * dir_names[IMAGE_NUMBEROF_DIRECTORY_ENTRIES] =
1026
{
1027
  N_("Export Directory [.edata (or where ever we found it)]"),
1028
  N_("Import Directory [parts of .idata]"),
1029
  N_("Resource Directory [.rsrc]"),
1030
  N_("Exception Directory [.pdata]"),
1031
  N_("Security Directory"),
1032
  N_("Base Relocation Directory [.reloc]"),
1033
  N_("Debug Directory"),
1034
  N_("Description Directory"),
1035
  N_("Special Directory"),
1036
  N_("Thread Storage Directory [.tls]"),
1037
  N_("Load Configuration Directory"),
1038
  N_("Bound Import Directory"),
1039
  N_("Import Address Table Directory"),
1040
  N_("Delay Import Directory"),
1041
  N_("CLR Runtime Header"),
1042
  N_("Reserved")
1043
};
1044
 
1045
#ifdef POWERPC_LE_PE
1046
/* The code for the PPC really falls in the "architecture dependent"
1047
   category.  However, it's not clear that anyone will ever care, so
1048
   we're ignoring the issue for now; if/when PPC matters, some of this
1049
   may need to go into peicode.h, or arguments passed to enable the
1050
   PPC- specific code.  */
1051
#endif
1052
 
1053
static bfd_boolean
1054
pe_print_idata (bfd * abfd, void * vfile)
1055
{
1056
  FILE *file = (FILE *) vfile;
1057
  bfd_byte *data;
1058
  asection *section;
1059
  bfd_signed_vma adj;
1060
 
1061
#ifdef POWERPC_LE_PE
1062
  asection *rel_section = bfd_get_section_by_name (abfd, ".reldata");
1063
#endif
1064
 
1065
  bfd_size_type datasize = 0;
1066
  bfd_size_type dataoff;
1067
  bfd_size_type i;
1068
  int onaline = 20;
1069
 
1070
  pe_data_type *pe = pe_data (abfd);
1071
  struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1072
 
1073
  bfd_vma addr;
1074
 
1075
  addr = extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress;
1076
 
1077
  if (addr == 0 && extra->DataDirectory[PE_IMPORT_TABLE].Size == 0)
1078
    {
1079
      /* Maybe the extra header isn't there.  Look for the section.  */
1080
      section = bfd_get_section_by_name (abfd, ".idata");
1081
      if (section == NULL)
1082
        return TRUE;
1083
 
1084
      addr = section->vma;
1085
      datasize = section->size;
1086
      if (datasize == 0)
1087
        return TRUE;
1088
    }
1089
  else
1090
    {
1091
      addr += extra->ImageBase;
1092
      for (section = abfd->sections; section != NULL; section = section->next)
1093
        {
1094
          datasize = section->size;
1095
          if (addr >= section->vma && addr < section->vma + datasize)
1096
            break;
1097
        }
1098
 
1099
      if (section == NULL)
1100
        {
1101
          fprintf (file,
1102
                   _("\nThere is an import table, but the section containing it could not be found\n"));
1103
          return TRUE;
1104
        }
1105
    }
1106
 
1107
  fprintf (file, _("\nThere is an import table in %s at 0x%lx\n"),
1108
           section->name, (unsigned long) addr);
1109
 
1110
  dataoff = addr - section->vma;
1111
  datasize -= dataoff;
1112
 
1113
#ifdef POWERPC_LE_PE
1114
  if (rel_section != 0 && rel_section->size != 0)
1115
    {
1116
      /* The toc address can be found by taking the starting address,
1117
         which on the PPC locates a function descriptor. The
1118
         descriptor consists of the function code starting address
1119
         followed by the address of the toc. The starting address we
1120
         get from the bfd, and the descriptor is supposed to be in the
1121
         .reldata section.  */
1122
 
1123
      bfd_vma loadable_toc_address;
1124
      bfd_vma toc_address;
1125
      bfd_vma start_address;
1126
      bfd_byte *data;
1127
      bfd_vma offset;
1128
 
1129
      if (!bfd_malloc_and_get_section (abfd, rel_section, &data))
1130
        {
1131
          if (data != NULL)
1132
            free (data);
1133
          return FALSE;
1134
        }
1135
 
1136
      offset = abfd->start_address - rel_section->vma;
1137
 
1138
      if (offset >= rel_section->size || offset + 8 > rel_section->size)
1139
        {
1140
          if (data != NULL)
1141
            free (data);
1142
          return FALSE;
1143
        }
1144
 
1145
      start_address = bfd_get_32 (abfd, data + offset);
1146
      loadable_toc_address = bfd_get_32 (abfd, data + offset + 4);
1147
      toc_address = loadable_toc_address - 32768;
1148
 
1149
      fprintf (file,
1150
               _("\nFunction descriptor located at the start address: %04lx\n"),
1151
               (unsigned long int) (abfd->start_address));
1152
      fprintf (file,
1153
               _("\tcode-base %08lx toc (loadable/actual) %08lx/%08lx\n"),
1154
               start_address, loadable_toc_address, toc_address);
1155
      if (data != NULL)
1156
        free (data);
1157
    }
1158
  else
1159
    {
1160
      fprintf (file,
1161
               _("\nNo reldata section! Function descriptor not decoded.\n"));
1162
    }
1163
#endif
1164
 
1165
  fprintf (file,
1166
           _("\nThe Import Tables (interpreted %s section contents)\n"),
1167
           section->name);
1168
  fprintf (file,
1169
           _("\
1170
 vma:            Hint    Time      Forward  DLL       First\n\
1171
                 Table   Stamp     Chain    Name      Thunk\n"));
1172
 
1173
  /* Read the whole section.  Some of the fields might be before dataoff.  */
1174
  if (!bfd_malloc_and_get_section (abfd, section, &data))
1175
    {
1176
      if (data != NULL)
1177
        free (data);
1178
      return FALSE;
1179
    }
1180
 
1181
  adj = section->vma - extra->ImageBase;
1182
 
1183
  /* Print all image import descriptors.  */
1184
  for (i = 0; i < datasize; i += onaline)
1185
    {
1186
      bfd_vma hint_addr;
1187
      bfd_vma time_stamp;
1188
      bfd_vma forward_chain;
1189
      bfd_vma dll_name;
1190
      bfd_vma first_thunk;
1191
      int idx = 0;
1192
      bfd_size_type j;
1193
      char *dll;
1194
 
1195
      /* Print (i + extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress).  */
1196
      fprintf (file, " %08lx\t", (unsigned long) (i + adj + dataoff));
1197
      hint_addr = bfd_get_32 (abfd, data + i + dataoff);
1198
      time_stamp = bfd_get_32 (abfd, data + i + 4 + dataoff);
1199
      forward_chain = bfd_get_32 (abfd, data + i + 8 + dataoff);
1200
      dll_name = bfd_get_32 (abfd, data + i + 12 + dataoff);
1201
      first_thunk = bfd_get_32 (abfd, data + i + 16 + dataoff);
1202
 
1203
      fprintf (file, "%08lx %08lx %08lx %08lx %08lx\n",
1204
               (unsigned long) hint_addr,
1205
               (unsigned long) time_stamp,
1206
               (unsigned long) forward_chain,
1207
               (unsigned long) dll_name,
1208
               (unsigned long) first_thunk);
1209
 
1210
      if (hint_addr == 0 && first_thunk == 0)
1211
        break;
1212
 
1213
      if (dll_name - adj >= section->size)
1214
        break;
1215
 
1216
      dll = (char *) data + dll_name - adj;
1217
      fprintf (file, _("\n\tDLL Name: %s\n"), dll);
1218
 
1219
      if (hint_addr != 0)
1220
        {
1221
          bfd_byte *ft_data;
1222
          asection *ft_section;
1223
          bfd_vma ft_addr;
1224
          bfd_size_type ft_datasize;
1225
          int ft_idx;
1226
          int ft_allocated = 0;
1227
 
1228
          fprintf (file, _("\tvma:  Hint/Ord Member-Name Bound-To\n"));
1229
 
1230
          idx = hint_addr - adj;
1231
 
1232
          ft_addr = first_thunk + extra->ImageBase;
1233
          ft_data = data;
1234
          ft_idx = first_thunk - adj;
1235
          ft_allocated = 0;
1236
 
1237
          if (first_thunk != hint_addr)
1238
            {
1239
              /* Find the section which contains the first thunk.  */
1240
              for (ft_section = abfd->sections;
1241
                   ft_section != NULL;
1242
                   ft_section = ft_section->next)
1243
                {
1244
                  ft_datasize = ft_section->size;
1245
                  if (ft_addr >= ft_section->vma
1246
                      && ft_addr < ft_section->vma + ft_datasize)
1247
                    break;
1248
                }
1249
 
1250
              if (ft_section == NULL)
1251
                {
1252
                  fprintf (file,
1253
                       _("\nThere is a first thunk, but the section containing it could not be found\n"));
1254
                  continue;
1255
                }
1256
 
1257
              /* Now check to see if this section is the same as our current
1258
                 section.  If it is not then we will have to load its data in.  */
1259
              if (ft_section == section)
1260
                {
1261
                  ft_data = data;
1262
                  ft_idx = first_thunk - adj;
1263
                }
1264
              else
1265
                {
1266
                  ft_idx = first_thunk - (ft_section->vma - extra->ImageBase);
1267
                  ft_data = bfd_malloc (datasize);
1268
                  if (ft_data == NULL)
1269
                    continue;
1270
 
1271
                  /* Read datasize bfd_bytes starting at offset ft_idx.  */
1272
                  if (! bfd_get_section_contents
1273
                      (abfd, ft_section, ft_data, (bfd_vma) ft_idx, datasize))
1274
                    {
1275
                      free (ft_data);
1276
                      continue;
1277
                    }
1278
 
1279
                  ft_idx = 0;
1280
                  ft_allocated = 1;
1281
                }
1282
            }
1283
 
1284
          /* Print HintName vector entries.  */
1285
#ifdef COFF_WITH_pex64
1286
          for (j = 0; j < datasize; j += 8)
1287
            {
1288
              unsigned long member = bfd_get_32 (abfd, data + idx + j);
1289
              unsigned long member_high = bfd_get_32 (abfd, data + idx + j + 4);
1290
 
1291
              if (!member && !member_high)
1292
                break;
1293
 
1294
              if (member_high & 0x80000000)
1295
                fprintf (file, "\t%lx%08lx\t %4lx%08lx  <none>",
1296
                         member_high,member, member_high & 0x7fffffff, member);
1297
              else
1298
                {
1299
                  int ordinal;
1300
                  char *member_name;
1301
 
1302
                  ordinal = bfd_get_16 (abfd, data + member - adj);
1303
                  member_name = (char *) data + member - adj + 2;
1304
                  fprintf (file, "\t%04lx\t %4d  %s",member, ordinal, member_name);
1305
                }
1306
 
1307
              /* If the time stamp is not zero, the import address
1308
                 table holds actual addresses.  */
1309
              if (time_stamp != 0
1310
                  && first_thunk != 0
1311
                  && first_thunk != hint_addr)
1312
                fprintf (file, "\t%04lx",
1313
                         (long) bfd_get_32 (abfd, ft_data + ft_idx + j));
1314
              fprintf (file, "\n");
1315
            }
1316
#else
1317
          for (j = 0; j < datasize; j += 4)
1318
            {
1319
              unsigned long member = bfd_get_32 (abfd, data + idx + j);
1320
 
1321
              /* Print single IMAGE_IMPORT_BY_NAME vector.  */
1322
              if (member == 0)
1323
                break;
1324
 
1325
              if (member & 0x80000000)
1326
                fprintf (file, "\t%04lx\t %4lu  <none>",
1327
                         member, member & 0x7fffffff);
1328
              else
1329
                {
1330
                  int ordinal;
1331
                  char *member_name;
1332
 
1333
                  ordinal = bfd_get_16 (abfd, data + member - adj);
1334
                  member_name = (char *) data + member - adj + 2;
1335
                  fprintf (file, "\t%04lx\t %4d  %s",
1336
                           member, ordinal, member_name);
1337
                }
1338
 
1339
              /* If the time stamp is not zero, the import address
1340
                 table holds actual addresses.  */
1341
              if (time_stamp != 0
1342
                  && first_thunk != 0
1343
                  && first_thunk != hint_addr)
1344
                fprintf (file, "\t%04lx",
1345
                         (long) bfd_get_32 (abfd, ft_data + ft_idx + j));
1346
 
1347
              fprintf (file, "\n");
1348
            }
1349
#endif
1350
          if (ft_allocated)
1351
            free (ft_data);
1352
        }
1353
 
1354
      fprintf (file, "\n");
1355
    }
1356
 
1357
  free (data);
1358
 
1359
  return TRUE;
1360
}
1361
 
1362
static bfd_boolean
1363
pe_print_edata (bfd * abfd, void * vfile)
1364
{
1365
  FILE *file = (FILE *) vfile;
1366
  bfd_byte *data;
1367
  asection *section;
1368
  bfd_size_type datasize = 0;
1369
  bfd_size_type dataoff;
1370
  bfd_size_type i;
1371
  bfd_signed_vma adj;
1372
  struct EDT_type
1373
  {
1374
    long export_flags;          /* Reserved - should be zero.  */
1375
    long time_stamp;
1376
    short major_ver;
1377
    short minor_ver;
1378
    bfd_vma name;               /* RVA - relative to image base.  */
1379
    long base;                  /* Ordinal base.  */
1380
    unsigned long num_functions;/* Number in the export address table.  */
1381
    unsigned long num_names;    /* Number in the name pointer table.  */
1382
    bfd_vma eat_addr;           /* RVA to the export address table.  */
1383
    bfd_vma npt_addr;           /* RVA to the Export Name Pointer Table.  */
1384
    bfd_vma ot_addr;            /* RVA to the Ordinal Table.  */
1385
  } edt;
1386
 
1387
  pe_data_type *pe = pe_data (abfd);
1388
  struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
1389
 
1390
  bfd_vma addr;
1391
 
1392
  addr = extra->DataDirectory[PE_EXPORT_TABLE].VirtualAddress;
1393
 
1394
  if (addr == 0 && extra->DataDirectory[PE_EXPORT_TABLE].Size == 0)
1395
    {
1396
      /* Maybe the extra header isn't there.  Look for the section.  */
1397
      section = bfd_get_section_by_name (abfd, ".edata");
1398
      if (section == NULL)
1399
        return TRUE;
1400
 
1401
      addr = section->vma;
1402
      dataoff = 0;
1403
      datasize = section->size;
1404
      if (datasize == 0)
1405
        return TRUE;
1406
    }
1407
  else
1408
    {
1409
      addr += extra->ImageBase;
1410
 
1411
      for (section = abfd->sections; section != NULL; section = section->next)
1412
        if (addr >= section->vma && addr < section->vma + section->size)
1413
          break;
1414
 
1415
      if (section == NULL)
1416
        {
1417
          fprintf (file,
1418
                   _("\nThere is an export table, but the section containing it could not be found\n"));
1419
          return TRUE;
1420
        }
1421
 
1422
      dataoff = addr - section->vma;
1423
      datasize = extra->DataDirectory[PE_EXPORT_TABLE].Size;
1424
      if (datasize > section->size - dataoff)
1425
        {
1426
          fprintf (file,
1427
                   _("\nThere is an export table in %s, but it does not fit into that section\n"),
1428
                   section->name);
1429
          return TRUE;
1430
        }
1431
    }
1432
 
1433
  fprintf (file, _("\nThere is an export table in %s at 0x%lx\n"),
1434
           section->name, (unsigned long) addr);
1435
 
1436
  data = bfd_malloc (datasize);
1437
  if (data == NULL)
1438
    return FALSE;
1439
 
1440
  if (! bfd_get_section_contents (abfd, section, data,
1441
                                  (file_ptr) dataoff, datasize))
1442
    return FALSE;
1443
 
1444
  /* Go get Export Directory Table.  */
1445
  edt.export_flags   = bfd_get_32 (abfd, data +  0);
1446
  edt.time_stamp     = bfd_get_32 (abfd, data +  4);
1447
  edt.major_ver      = bfd_get_16 (abfd, data +  8);
1448
  edt.minor_ver      = bfd_get_16 (abfd, data + 10);
1449
  edt.name           = bfd_get_32 (abfd, data + 12);
1450
  edt.base           = bfd_get_32 (abfd, data + 16);
1451
  edt.num_functions  = bfd_get_32 (abfd, data + 20);
1452
  edt.num_names      = bfd_get_32 (abfd, data + 24);
1453
  edt.eat_addr       = bfd_get_32 (abfd, data + 28);
1454
  edt.npt_addr       = bfd_get_32 (abfd, data + 32);
1455
  edt.ot_addr        = bfd_get_32 (abfd, data + 36);
1456
 
1457
  adj = section->vma - extra->ImageBase + dataoff;
1458
 
1459
  /* Dump the EDT first.  */
1460
  fprintf (file,
1461
           _("\nThe Export Tables (interpreted %s section contents)\n\n"),
1462
           section->name);
1463
 
1464
  fprintf (file,
1465
           _("Export Flags \t\t\t%lx\n"), (unsigned long) edt.export_flags);
1466
 
1467
  fprintf (file,
1468
           _("Time/Date stamp \t\t%lx\n"), (unsigned long) edt.time_stamp);
1469
 
1470
  fprintf (file,
1471
           _("Major/Minor \t\t\t%d/%d\n"), edt.major_ver, edt.minor_ver);
1472
 
1473
  fprintf (file,
1474
           _("Name \t\t\t\t"));
1475
  fprintf_vma (file, edt.name);
1476
  fprintf (file,
1477
           " %s\n", data + edt.name - adj);
1478
 
1479
  fprintf (file,
1480
           _("Ordinal Base \t\t\t%ld\n"), edt.base);
1481
 
1482
  fprintf (file,
1483
           _("Number in:\n"));
1484
 
1485
  fprintf (file,
1486
           _("\tExport Address Table \t\t%08lx\n"),
1487
           edt.num_functions);
1488
 
1489
  fprintf (file,
1490
           _("\t[Name Pointer/Ordinal] Table\t%08lx\n"), edt.num_names);
1491
 
1492
  fprintf (file,
1493
           _("Table Addresses\n"));
1494
 
1495
  fprintf (file,
1496
           _("\tExport Address Table \t\t"));
1497
  fprintf_vma (file, edt.eat_addr);
1498
  fprintf (file, "\n");
1499
 
1500
  fprintf (file,
1501
           _("\tName Pointer Table \t\t"));
1502
  fprintf_vma (file, edt.npt_addr);
1503
  fprintf (file, "\n");
1504
 
1505
  fprintf (file,
1506
           _("\tOrdinal Table \t\t\t"));
1507
  fprintf_vma (file, edt.ot_addr);
1508
  fprintf (file, "\n");
1509
 
1510
  /* The next table to find is the Export Address Table. It's basically
1511
     a list of pointers that either locate a function in this dll, or
1512
     forward the call to another dll. Something like:
1513
      typedef union
1514
      {
1515
        long export_rva;
1516
        long forwarder_rva;
1517
      } export_address_table_entry;  */
1518
 
1519
  fprintf (file,
1520
          _("\nExport Address Table -- Ordinal Base %ld\n"),
1521
          edt.base);
1522
 
1523
  for (i = 0; i < edt.num_functions; ++i)
1524
    {
1525
      bfd_vma eat_member = bfd_get_32 (abfd,
1526
                                       data + edt.eat_addr + (i * 4) - adj);
1527
      if (eat_member == 0)
1528
        continue;
1529
 
1530
      if (eat_member - adj <= datasize)
1531
        {
1532
          /* This rva is to a name (forwarding function) in our section.  */
1533
          /* Should locate a function descriptor.  */
1534
          fprintf (file,
1535
                   "\t[%4ld] +base[%4ld] %04lx %s -- %s\n",
1536
                   (long) i,
1537
                   (long) (i + edt.base),
1538
                   (unsigned long) eat_member,
1539
                   _("Forwarder RVA"),
1540
                   data + eat_member - adj);
1541
        }
1542
      else
1543
        {
1544
          /* Should locate a function descriptor in the reldata section.  */
1545
          fprintf (file,
1546
                   "\t[%4ld] +base[%4ld] %04lx %s\n",
1547
                   (long) i,
1548
                   (long) (i + edt.base),
1549
                   (unsigned long) eat_member,
1550
                   _("Export RVA"));
1551
        }
1552
    }
1553
 
1554
  /* The Export Name Pointer Table is paired with the Export Ordinal Table.  */
1555
  /* Dump them in parallel for clarity.  */
1556
  fprintf (file,
1557
           _("\n[Ordinal/Name Pointer] Table\n"));
1558
 
1559
  for (i = 0; i < edt.num_names; ++i)
1560
    {
1561
      bfd_vma name_ptr = bfd_get_32 (abfd,
1562
                                    data +
1563
                                    edt.npt_addr
1564
                                    + (i*4) - adj);
1565
 
1566
      char *name = (char *) data + name_ptr - adj;
1567
 
1568
      bfd_vma ord = bfd_get_16 (abfd,
1569
                                    data +
1570
                                    edt.ot_addr
1571
                                    + (i*2) - adj);
1572
      fprintf (file,
1573
              "\t[%4ld] %s\n", (long) ord, name);
1574
    }
1575
 
1576
  free (data);
1577
 
1578
  return TRUE;
1579
}
1580
 
1581
/* This really is architecture dependent.  On IA-64, a .pdata entry
1582
   consists of three dwords containing relative virtual addresses that
1583
   specify the start and end address of the code range the entry
1584
   covers and the address of the corresponding unwind info data.  */
1585
 
1586
static bfd_boolean
1587
pe_print_pdata (bfd * abfd, void * vfile)
1588
{
1589
#if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1590
# define PDATA_ROW_SIZE (3 * 8)
1591
#else
1592
# define PDATA_ROW_SIZE (5 * 4)
1593
#endif
1594
  FILE *file = (FILE *) vfile;
1595
  bfd_byte *data = 0;
1596
  asection *section = bfd_get_section_by_name (abfd, ".pdata");
1597
  bfd_size_type datasize = 0;
1598
  bfd_size_type i;
1599
  bfd_size_type start, stop;
1600
  int onaline = PDATA_ROW_SIZE;
1601
 
1602
  if (section == NULL
1603
      || coff_section_data (abfd, section) == NULL
1604
      || pei_section_data (abfd, section) == NULL)
1605
    return TRUE;
1606
 
1607
  stop = pei_section_data (abfd, section)->virt_size;
1608
  if ((stop % onaline) != 0)
1609
    fprintf (file,
1610
             _("Warning, .pdata section size (%ld) is not a multiple of %d\n"),
1611
             (long) stop, onaline);
1612
 
1613
  fprintf (file,
1614
           _("\nThe Function Table (interpreted .pdata section contents)\n"));
1615
#if defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1616
  fprintf (file,
1617
           _(" vma:\t\t\tBegin Address    End Address      Unwind Info\n"));
1618
#else
1619
  fprintf (file, _("\
1620
 vma:\t\tBegin    End      EH       EH       PrologEnd  Exception\n\
1621
     \t\tAddress  Address  Handler  Data     Address    Mask\n"));
1622
#endif
1623
 
1624
  datasize = section->size;
1625
  if (datasize == 0)
1626
    return TRUE;
1627
 
1628
  if (! bfd_malloc_and_get_section (abfd, section, &data))
1629
    {
1630
      if (data != NULL)
1631
        free (data);
1632
      return FALSE;
1633
    }
1634
 
1635
  start = 0;
1636
 
1637
  for (i = start; i < stop; i += onaline)
1638
    {
1639
      bfd_vma begin_addr;
1640
      bfd_vma end_addr;
1641
      bfd_vma eh_handler;
1642
      bfd_vma eh_data;
1643
      bfd_vma prolog_end_addr;
1644
      int em_data;
1645
 
1646
      if (i + PDATA_ROW_SIZE > stop)
1647
        break;
1648
 
1649
      begin_addr      = GET_PDATA_ENTRY (abfd, data + i     );
1650
      end_addr        = GET_PDATA_ENTRY (abfd, data + i +  4);
1651
      eh_handler      = GET_PDATA_ENTRY (abfd, data + i +  8);
1652
      eh_data         = GET_PDATA_ENTRY (abfd, data + i + 12);
1653
      prolog_end_addr = GET_PDATA_ENTRY (abfd, data + i + 16);
1654
 
1655
      if (begin_addr == 0 && end_addr == 0 && eh_handler == 0
1656
          && eh_data == 0 && prolog_end_addr == 0)
1657
        /* We are probably into the padding of the section now.  */
1658
        break;
1659
 
1660
      em_data = ((eh_handler & 0x1) << 2) | (prolog_end_addr & 0x3);
1661
      eh_handler &= ~(bfd_vma) 0x3;
1662
      prolog_end_addr &= ~(bfd_vma) 0x3;
1663
 
1664
      fputc (' ', file);
1665
      fprintf_vma (file, i + section->vma); fputc ('\t', file);
1666
      fprintf_vma (file, begin_addr); fputc (' ', file);
1667
      fprintf_vma (file, end_addr); fputc (' ', file);
1668
      fprintf_vma (file, eh_handler);
1669
#if !defined(COFF_WITH_pep) || defined(COFF_WITH_pex64)
1670
      fputc (' ', file);
1671
      fprintf_vma (file, eh_data); fputc (' ', file);
1672
      fprintf_vma (file, prolog_end_addr);
1673
      fprintf (file, "   %x", em_data);
1674
#endif
1675
 
1676
#ifdef POWERPC_LE_PE
1677
      if (eh_handler == 0 && eh_data != 0)
1678
        {
1679
          /* Special bits here, although the meaning may be a little
1680
             mysterious. The only one I know for sure is 0x03
1681
             Code Significance
1682
             0x00 None
1683
             0x01 Register Save Millicode
1684
             0x02 Register Restore Millicode
1685
             0x03 Glue Code Sequence.  */
1686
          switch (eh_data)
1687
            {
1688
            case 0x01:
1689
              fprintf (file, _(" Register save millicode"));
1690
              break;
1691
            case 0x02:
1692
              fprintf (file, _(" Register restore millicode"));
1693
              break;
1694
            case 0x03:
1695
              fprintf (file, _(" Glue code sequence"));
1696
              break;
1697
            default:
1698
              break;
1699
            }
1700
        }
1701
#endif
1702
      fprintf (file, "\n");
1703
    }
1704
 
1705
  free (data);
1706
 
1707
  return TRUE;
1708
}
1709
 
1710
#define IMAGE_REL_BASED_HIGHADJ 4
1711
static const char * const tbl[] =
1712
{
1713
  "ABSOLUTE",
1714
  "HIGH",
1715
  "LOW",
1716
  "HIGHLOW",
1717
  "HIGHADJ",
1718
  "MIPS_JMPADDR",
1719
  "SECTION",
1720
  "REL32",
1721
  "RESERVED1",
1722
  "MIPS_JMPADDR16",
1723
  "DIR64",
1724
  "HIGH3ADJ",
1725
  "UNKNOWN",   /* MUST be last.  */
1726
};
1727
 
1728
static bfd_boolean
1729
pe_print_reloc (bfd * abfd, void * vfile)
1730
{
1731
  FILE *file = (FILE *) vfile;
1732
  bfd_byte *data = 0;
1733
  asection *section = bfd_get_section_by_name (abfd, ".reloc");
1734
  bfd_size_type datasize;
1735
  bfd_size_type i;
1736
  bfd_size_type start, stop;
1737
 
1738
  if (section == NULL)
1739
    return TRUE;
1740
 
1741
  if (section->size == 0)
1742
    return TRUE;
1743
 
1744
  fprintf (file,
1745
           _("\n\nPE File Base Relocations (interpreted .reloc section contents)\n"));
1746
 
1747
  datasize = section->size;
1748
  if (! bfd_malloc_and_get_section (abfd, section, &data))
1749
    {
1750
      if (data != NULL)
1751
        free (data);
1752
      return FALSE;
1753
    }
1754
 
1755
  start = 0;
1756
 
1757
  stop = section->size;
1758
 
1759
  for (i = start; i < stop;)
1760
    {
1761
      int j;
1762
      bfd_vma virtual_address;
1763
      long number, size;
1764
 
1765
      /* The .reloc section is a sequence of blocks, with a header consisting
1766
         of two 32 bit quantities, followed by a number of 16 bit entries.  */
1767
      virtual_address = bfd_get_32 (abfd, data+i);
1768
      size = bfd_get_32 (abfd, data+i+4);
1769
      number = (size - 8) / 2;
1770
 
1771
      if (size == 0)
1772
        break;
1773
 
1774
      fprintf (file,
1775
               _("\nVirtual Address: %08lx Chunk size %ld (0x%lx) Number of fixups %ld\n"),
1776
               (unsigned long) virtual_address, size, size, number);
1777
 
1778
      for (j = 0; j < number; ++j)
1779
        {
1780
          unsigned short e = bfd_get_16 (abfd, data + i + 8 + j * 2);
1781
          unsigned int t = (e & 0xF000) >> 12;
1782
          int off = e & 0x0FFF;
1783
 
1784
          if (t >= sizeof (tbl) / sizeof (tbl[0]))
1785
            t = (sizeof (tbl) / sizeof (tbl[0])) - 1;
1786
 
1787
          fprintf (file,
1788
                   _("\treloc %4d offset %4x [%4lx] %s"),
1789
                   j, off, (long) (off + virtual_address), tbl[t]);
1790
 
1791
          /* HIGHADJ takes an argument, - the next record *is* the
1792
             low 16 bits of addend.  */
1793
          if (t == IMAGE_REL_BASED_HIGHADJ)
1794
            {
1795
              fprintf (file, " (%4x)",
1796
                       ((unsigned int)
1797
                        bfd_get_16 (abfd, data + i + 8 + j * 2 + 2)));
1798
              j++;
1799
            }
1800
 
1801
          fprintf (file, "\n");
1802
        }
1803
 
1804
      i += size;
1805
    }
1806
 
1807
  free (data);
1808
 
1809
  return TRUE;
1810
}
1811
 
1812
/* Print out the program headers.  */
1813
 
1814
bfd_boolean
1815
_bfd_XX_print_private_bfd_data_common (bfd * abfd, void * vfile)
1816
{
1817
  FILE *file = (FILE *) vfile;
1818
  int j;
1819
  pe_data_type *pe = pe_data (abfd);
1820
  struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
1821
  const char *subsystem_name = NULL;
1822
  const char *name;
1823
 
1824
  /* The MS dumpbin program reportedly ands with 0xff0f before
1825
     printing the characteristics field.  Not sure why.  No reason to
1826
     emulate it here.  */
1827
  fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
1828
#undef PF
1829
#define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
1830
  PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
1831
  PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
1832
  PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
1833
  PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
1834
  PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
1835
  PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
1836
  PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
1837
  PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
1838
  PF (IMAGE_FILE_SYSTEM, "system file");
1839
  PF (IMAGE_FILE_DLL, "DLL");
1840
  PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
1841
#undef PF
1842
 
1843
  /* ctime implies '\n'.  */
1844
  {
1845
    time_t t = pe->coff.timestamp;
1846
    fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
1847
  }
1848
 
1849
#ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
1850
# define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
1851
#endif
1852
#ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
1853
# define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
1854
#endif
1855
#ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
1856
# define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
1857
#endif
1858
 
1859
  switch (i->Magic)
1860
    {
1861
    case IMAGE_NT_OPTIONAL_HDR_MAGIC:
1862
      name = "PE32";
1863
      break;
1864
    case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
1865
      name = "PE32+";
1866
      break;
1867
    case IMAGE_NT_OPTIONAL_HDRROM_MAGIC:
1868
      name = "ROM";
1869
      break;
1870
    default:
1871
      name = NULL;
1872
      break;
1873
    }
1874
  fprintf (file, "Magic\t\t\t%04x", i->Magic);
1875
  if (name)
1876
    fprintf (file, "\t(%s)",name);
1877
  fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion);
1878
  fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion);
1879
  fprintf (file, "SizeOfCode\t\t%08lx\n", i->SizeOfCode);
1880
  fprintf (file, "SizeOfInitializedData\t%08lx\n",
1881
           i->SizeOfInitializedData);
1882
  fprintf (file, "SizeOfUninitializedData\t%08lx\n",
1883
           i->SizeOfUninitializedData);
1884
  fprintf (file, "AddressOfEntryPoint\t");
1885
  fprintf_vma (file, i->AddressOfEntryPoint);
1886
  fprintf (file, "\nBaseOfCode\t\t");
1887
  fprintf_vma (file, i->BaseOfCode);
1888
#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
1889
  /* PE32+ does not have BaseOfData member!  */
1890
  fprintf (file, "\nBaseOfData\t\t");
1891
  fprintf_vma (file, i->BaseOfData);
1892
#endif
1893
 
1894
  fprintf (file, "\nImageBase\t\t");
1895
  fprintf_vma (file, i->ImageBase);
1896
  fprintf (file, "\nSectionAlignment\t");
1897
  fprintf_vma (file, i->SectionAlignment);
1898
  fprintf (file, "\nFileAlignment\t\t");
1899
  fprintf_vma (file, i->FileAlignment);
1900
  fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
1901
  fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
1902
  fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
1903
  fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
1904
  fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
1905
  fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
1906
  fprintf (file, "Win32Version\t\t%08lx\n", i->Reserved1);
1907
  fprintf (file, "SizeOfImage\t\t%08lx\n", i->SizeOfImage);
1908
  fprintf (file, "SizeOfHeaders\t\t%08lx\n", i->SizeOfHeaders);
1909
  fprintf (file, "CheckSum\t\t%08lx\n", i->CheckSum);
1910
 
1911
  switch (i->Subsystem)
1912
    {
1913
    case IMAGE_SUBSYSTEM_UNKNOWN:
1914
      subsystem_name = "unspecified";
1915
      break;
1916
    case IMAGE_SUBSYSTEM_NATIVE:
1917
      subsystem_name = "NT native";
1918
      break;
1919
    case IMAGE_SUBSYSTEM_WINDOWS_GUI:
1920
      subsystem_name = "Windows GUI";
1921
      break;
1922
    case IMAGE_SUBSYSTEM_WINDOWS_CUI:
1923
      subsystem_name = "Windows CUI";
1924
      break;
1925
    case IMAGE_SUBSYSTEM_POSIX_CUI:
1926
      subsystem_name = "POSIX CUI";
1927
      break;
1928
    case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
1929
      subsystem_name = "Wince CUI";
1930
      break;
1931
    case IMAGE_SUBSYSTEM_EFI_APPLICATION:
1932
      subsystem_name = "EFI application";
1933
      break;
1934
    case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
1935
      subsystem_name = "EFI boot service driver";
1936
      break;
1937
    case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
1938
      subsystem_name = "EFI runtime driver";
1939
      break;
1940
    // These are from revision 8.0 of the MS PE/COFF spec
1941
    case IMAGE_SUBSYSTEM_EFI_ROM:
1942
      subsystem_name = "EFI ROM";
1943
      break;
1944
    case IMAGE_SUBSYSTEM_XBOX:
1945
      subsystem_name = "XBOX";
1946
      break;
1947
    // Added default case for clarity - subsystem_name is NULL anyway.
1948
    default:
1949
      subsystem_name = NULL;
1950
    }
1951
 
1952
  fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
1953
  if (subsystem_name)
1954
    fprintf (file, "\t(%s)", subsystem_name);
1955
  fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
1956
  fprintf (file, "SizeOfStackReserve\t");
1957
  fprintf_vma (file, i->SizeOfStackReserve);
1958
  fprintf (file, "\nSizeOfStackCommit\t");
1959
  fprintf_vma (file, i->SizeOfStackCommit);
1960
  fprintf (file, "\nSizeOfHeapReserve\t");
1961
  fprintf_vma (file, i->SizeOfHeapReserve);
1962
  fprintf (file, "\nSizeOfHeapCommit\t");
1963
  fprintf_vma (file, i->SizeOfHeapCommit);
1964
  fprintf (file, "\nLoaderFlags\t\t%08lx\n", i->LoaderFlags);
1965
  fprintf (file, "NumberOfRvaAndSizes\t%08lx\n", i->NumberOfRvaAndSizes);
1966
 
1967
  fprintf (file, "\nThe Data Directory\n");
1968
  for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
1969
    {
1970
      fprintf (file, "Entry %1x ", j);
1971
      fprintf_vma (file, i->DataDirectory[j].VirtualAddress);
1972
      fprintf (file, " %08lx ", i->DataDirectory[j].Size);
1973
      fprintf (file, "%s\n", dir_names[j]);
1974
    }
1975
 
1976
  pe_print_idata (abfd, vfile);
1977
  pe_print_edata (abfd, vfile);
1978
  pe_print_pdata (abfd, vfile);
1979
  pe_print_reloc (abfd, vfile);
1980
 
1981
  return TRUE;
1982
}
1983
 
1984
/* Copy any private info we understand from the input bfd
1985
   to the output bfd.  */
1986
 
1987
bfd_boolean
1988
_bfd_XX_bfd_copy_private_bfd_data_common (bfd * ibfd, bfd * obfd)
1989
{
1990
  pe_data_type *ipe, *ope;
1991
 
1992
  /* One day we may try to grok other private data.  */
1993
  if (ibfd->xvec->flavour != bfd_target_coff_flavour
1994
      || obfd->xvec->flavour != bfd_target_coff_flavour)
1995
    return TRUE;
1996
 
1997
  ipe = pe_data (ibfd);
1998
  ope = pe_data (obfd);
1999
 
2000
  ope->pe_opthdr = ipe->pe_opthdr;
2001
  ope->dll = ipe->dll;
2002
 
2003
  /* Don't copy input subsystem if output is different from input.  */
2004
  if (obfd->xvec != ibfd->xvec)
2005
    ope->pe_opthdr.Subsystem = IMAGE_SUBSYSTEM_UNKNOWN;
2006
 
2007
  /* For strip: if we removed .reloc, we'll make a real mess of things
2008
     if we don't remove this entry as well.  */
2009
  if (! pe_data (obfd)->has_reloc_section)
2010
    {
2011
      pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0;
2012
      pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0;
2013
    }
2014
  return TRUE;
2015
}
2016
 
2017
/* Copy private section data.  */
2018
 
2019
bfd_boolean
2020
_bfd_XX_bfd_copy_private_section_data (bfd *ibfd,
2021
                                       asection *isec,
2022
                                       bfd *obfd,
2023
                                       asection *osec)
2024
{
2025
  if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
2026
      || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
2027
    return TRUE;
2028
 
2029
  if (coff_section_data (ibfd, isec) != NULL
2030
      && pei_section_data (ibfd, isec) != NULL)
2031
    {
2032
      if (coff_section_data (obfd, osec) == NULL)
2033
        {
2034
          bfd_size_type amt = sizeof (struct coff_section_tdata);
2035
          osec->used_by_bfd = bfd_zalloc (obfd, amt);
2036
          if (osec->used_by_bfd == NULL)
2037
            return FALSE;
2038
        }
2039
 
2040
      if (pei_section_data (obfd, osec) == NULL)
2041
        {
2042
          bfd_size_type amt = sizeof (struct pei_section_tdata);
2043
          coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt);
2044
          if (coff_section_data (obfd, osec)->tdata == NULL)
2045
            return FALSE;
2046
        }
2047
 
2048
      pei_section_data (obfd, osec)->virt_size =
2049
        pei_section_data (ibfd, isec)->virt_size;
2050
      pei_section_data (obfd, osec)->pe_flags =
2051
        pei_section_data (ibfd, isec)->pe_flags;
2052
    }
2053
 
2054
  return TRUE;
2055
}
2056
 
2057
void
2058
_bfd_XX_get_symbol_info (bfd * abfd, asymbol *symbol, symbol_info *ret)
2059
{
2060
  coff_get_symbol_info (abfd, symbol, ret);
2061
}
2062
 
2063
/* Handle the .idata section and other things that need symbol table
2064
   access.  */
2065
 
2066
bfd_boolean
2067
_bfd_XXi_final_link_postscript (bfd * abfd, struct coff_final_link_info *pfinfo)
2068
{
2069
  struct coff_link_hash_entry *h1;
2070
  struct bfd_link_info *info = pfinfo->info;
2071
  bfd_boolean result = TRUE;
2072
 
2073
  /* There are a few fields that need to be filled in now while we
2074
     have symbol table access.
2075
 
2076
     The .idata subsections aren't directly available as sections, but
2077
     they are in the symbol table, so get them from there.  */
2078
 
2079
  /* The import directory.  This is the address of .idata$2, with size
2080
     of .idata$2 + .idata$3.  */
2081
  h1 = coff_link_hash_lookup (coff_hash_table (info),
2082
                              ".idata$2", FALSE, FALSE, TRUE);
2083
  if (h1 != NULL)
2084
    {
2085
      /* PR ld/2729: We cannot rely upon all the output sections having been
2086
         created properly, so check before referencing them.  Issue a warning
2087
         message for any sections tht could not be found.  */
2088
      if (h1->root.u.def.section != NULL
2089
          && h1->root.u.def.section->output_section != NULL)
2090
        pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress =
2091
          (h1->root.u.def.value
2092
           + h1->root.u.def.section->output_section->vma
2093
           + h1->root.u.def.section->output_offset);
2094
      else
2095
        {
2096
          _bfd_error_handler
2097
            (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"),
2098
             abfd);
2099
          result = FALSE;
2100
        }
2101
 
2102
      h1 = coff_link_hash_lookup (coff_hash_table (info),
2103
                                  ".idata$4", FALSE, FALSE, TRUE);
2104
      if (h1 != NULL
2105
          && h1->root.u.def.section != NULL
2106
          && h1->root.u.def.section->output_section != NULL)
2107
        pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size =
2108
          ((h1->root.u.def.value
2109
            + h1->root.u.def.section->output_section->vma
2110
            + h1->root.u.def.section->output_offset)
2111
           - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress);
2112
      else
2113
        {
2114
          _bfd_error_handler
2115
            (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"),
2116
             abfd);
2117
          result = FALSE;
2118
        }
2119
 
2120
      /* The import address table.  This is the size/address of
2121
         .idata$5.  */
2122
      h1 = coff_link_hash_lookup (coff_hash_table (info),
2123
                                  ".idata$5", FALSE, FALSE, TRUE);
2124
      if (h1 != NULL
2125
          && h1->root.u.def.section != NULL
2126
          && h1->root.u.def.section->output_section != NULL)
2127
        pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
2128
          (h1->root.u.def.value
2129
           + h1->root.u.def.section->output_section->vma
2130
           + h1->root.u.def.section->output_offset);
2131
      else
2132
        {
2133
          _bfd_error_handler
2134
            (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"),
2135
             abfd);
2136
          result = FALSE;
2137
        }
2138
 
2139
      h1 = coff_link_hash_lookup (coff_hash_table (info),
2140
                                  ".idata$6", FALSE, FALSE, TRUE);
2141
      if (h1 != NULL
2142
          && h1->root.u.def.section != NULL
2143
          && h1->root.u.def.section->output_section != NULL)
2144
        pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
2145
          ((h1->root.u.def.value
2146
            + h1->root.u.def.section->output_section->vma
2147
            + h1->root.u.def.section->output_offset)
2148
           - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress);
2149
      else
2150
        {
2151
          _bfd_error_handler
2152
            (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"),
2153
             abfd);
2154
          result = FALSE;
2155
        }
2156
    }
2157
 
2158
  h1 = coff_link_hash_lookup (coff_hash_table (info),
2159
                              "__tls_used", FALSE, FALSE, TRUE);
2160
  if (h1 != NULL)
2161
    {
2162
      if (h1->root.u.def.section != NULL
2163
          && h1->root.u.def.section->output_section != NULL)
2164
        pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress =
2165
          (h1->root.u.def.value
2166
           + h1->root.u.def.section->output_section->vma
2167
           + h1->root.u.def.section->output_offset
2168
           - pe_data (abfd)->pe_opthdr.ImageBase);
2169
      else
2170
        {
2171
          _bfd_error_handler
2172
            (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"),
2173
             abfd);
2174
          result = FALSE;
2175
        }
2176
 
2177
      pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18;
2178
    }
2179
 
2180
  /* If we couldn't find idata$2, we either have an excessively
2181
     trivial program or are in DEEP trouble; we have to assume trivial
2182
     program....  */
2183
  return result;
2184
}

powered by: WebSVN 2.1.0

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