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 866

Go to most recent revision | 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.