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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [bfd/] [peXXigen.c] - Blame information for rev 840

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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