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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [bfd/] [peXXigen.c] - Blame information for rev 227

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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