Back to index

cell-binutils  2.17cvs20070401
Defines | Functions
libpei.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines

#define GET_FCN_LNNOPTR(abfd, ext)   H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
#define GET_FCN_ENDNDX(abfd, ext)   H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_endndx)
#define PUT_FCN_LNNOPTR(abfd, in, ext)   H_PUT_32(abfd, in, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)
#define PUT_FCN_ENDNDX(abfd, in, ext)   H_PUT_32(abfd, in, ext->x_sym.x_fcnary.x_fcn.x_endndx)
#define GET_LNSZ_LNNO(abfd, ext)   H_GET_16 (abfd, ext->x_sym.x_misc.x_lnsz.x_lnno)
#define GET_LNSZ_SIZE(abfd, ext)   H_GET_16 (abfd, ext->x_sym.x_misc.x_lnsz.x_size)
#define PUT_LNSZ_LNNO(abfd, in, ext)   H_PUT_16(abfd, in, ext->x_sym.x_misc.x_lnsz.x_lnno)
#define PUT_LNSZ_SIZE(abfd, in, ext)   H_PUT_16(abfd, in, ext->x_sym.x_misc.x_lnsz.x_size)
#define GET_SCN_SCNLEN(abfd, ext)   H_GET_32 (abfd, ext->x_scn.x_scnlen)
#define GET_SCN_NRELOC(abfd, ext)   H_GET_16 (abfd, ext->x_scn.x_nreloc)
#define GET_SCN_NLINNO(abfd, ext)   H_GET_16 (abfd, ext->x_scn.x_nlinno)
#define PUT_SCN_SCNLEN(abfd, in, ext)   H_PUT_32(abfd, in, ext->x_scn.x_scnlen)
#define PUT_SCN_NRELOC(abfd, in, ext)   H_PUT_16(abfd, in, ext->x_scn.x_nreloc)
#define PUT_SCN_NLINNO(abfd, in, ext)   H_PUT_16(abfd,in, ext->x_scn.x_nlinno)
#define GET_LINENO_LNNO(abfd, ext)   H_GET_16 (abfd, ext->l_lnno);
#define PUT_LINENO_LNNO(abfd, val, ext)   H_PUT_16(abfd,val, ext->l_lnno);
#define GET_FILEHDR_SYMPTR   H_GET_32
#define PUT_FILEHDR_SYMPTR   H_PUT_32
#define GET_AOUTHDR_TSIZE   H_GET_32
#define PUT_AOUTHDR_TSIZE   H_PUT_32
#define GET_AOUTHDR_DSIZE   H_GET_32
#define PUT_AOUTHDR_DSIZE   H_PUT_32
#define GET_AOUTHDR_BSIZE   H_GET_32
#define PUT_AOUTHDR_BSIZE   H_PUT_32
#define GET_AOUTHDR_ENTRY   H_GET_32
#define PUT_AOUTHDR_ENTRY   H_PUT_32
#define GET_AOUTHDR_TEXT_START   H_GET_32
#define PUT_AOUTHDR_TEXT_START   H_PUT_32
#define GET_AOUTHDR_DATA_START   H_GET_32
#define PUT_AOUTHDR_DATA_START   H_PUT_32
#define GET_SCNHDR_PADDR   H_GET_32
#define PUT_SCNHDR_PADDR   H_PUT_32
#define GET_SCNHDR_VADDR   H_GET_32
#define PUT_SCNHDR_VADDR   H_PUT_32
#define GET_SCNHDR_SIZE   H_GET_32
#define PUT_SCNHDR_SIZE   H_PUT_32
#define GET_SCNHDR_SCNPTR   H_GET_32
#define PUT_SCNHDR_SCNPTR   H_PUT_32
#define GET_SCNHDR_RELPTR   H_GET_32
#define PUT_SCNHDR_RELPTR   H_PUT_32
#define GET_SCNHDR_LNNOPTR   H_GET_32
#define PUT_SCNHDR_LNNOPTR   H_PUT_32
#define GET_OPTHDR_IMAGE_BASE   H_GET_32
#define PUT_OPTHDR_IMAGE_BASE   H_PUT_32
#define GET_OPTHDR_SIZE_OF_STACK_RESERVE   H_GET_32
#define PUT_OPTHDR_SIZE_OF_STACK_RESERVE   H_PUT_32
#define GET_OPTHDR_SIZE_OF_STACK_COMMIT   H_GET_32
#define PUT_OPTHDR_SIZE_OF_STACK_COMMIT   H_PUT_32
#define GET_OPTHDR_SIZE_OF_HEAP_RESERVE   H_GET_32
#define PUT_OPTHDR_SIZE_OF_HEAP_RESERVE   H_PUT_32
#define GET_OPTHDR_SIZE_OF_HEAP_COMMIT   H_GET_32
#define PUT_OPTHDR_SIZE_OF_HEAP_COMMIT   H_PUT_32
#define GET_PDATA_ENTRY   bfd_get_32
#define _bfd_XX_bfd_copy_private_bfd_data_common   _bfd_pe_bfd_copy_private_bfd_data_common
#define _bfd_XX_bfd_copy_private_section_data   _bfd_pe_bfd_copy_private_section_data
#define _bfd_XX_get_symbol_info   _bfd_pe_get_symbol_info
#define _bfd_XX_only_swap_filehdr_out   _bfd_pe_only_swap_filehdr_out
#define _bfd_XX_print_private_bfd_data_common   _bfd_pe_print_private_bfd_data_common
#define _bfd_XXi_final_link_postscript   _bfd_pei_final_link_postscript
#define _bfd_XXi_final_link_postscript   _bfd_pei_final_link_postscript
#define _bfd_XXi_only_swap_filehdr_out   _bfd_pei_only_swap_filehdr_out
#define _bfd_XXi_swap_aouthdr_in   _bfd_pei_swap_aouthdr_in
#define _bfd_XXi_swap_aouthdr_out   _bfd_pei_swap_aouthdr_out
#define _bfd_XXi_swap_aux_in   _bfd_pei_swap_aux_in
#define _bfd_XXi_swap_aux_out   _bfd_pei_swap_aux_out
#define _bfd_XXi_swap_lineno_in   _bfd_pei_swap_lineno_in
#define _bfd_XXi_swap_lineno_out   _bfd_pei_swap_lineno_out
#define _bfd_XXi_swap_scnhdr_out   _bfd_pei_swap_scnhdr_out
#define _bfd_XXi_swap_sym_in   _bfd_pei_swap_sym_in
#define _bfd_XXi_swap_sym_out   _bfd_pei_swap_sym_out
#define bfd_pe_executable_p(abfd)
#define coff_swap_sym_in   _bfd_XXi_swap_sym_in
#define coff_swap_sym_out   _bfd_XXi_swap_sym_out
#define coff_swap_aux_in   _bfd_XXi_swap_aux_in
#define coff_swap_aux_out   _bfd_XXi_swap_aux_out
#define coff_swap_lineno_in   _bfd_XXi_swap_lineno_in
#define coff_swap_lineno_out   _bfd_XXi_swap_lineno_out
#define coff_swap_aouthdr_in   _bfd_XXi_swap_aouthdr_in
#define coff_swap_aouthdr_out   _bfd_XXi_swap_aouthdr_out
#define coff_swap_scnhdr_out   _bfd_XXi_swap_scnhdr_out
#define coff_final_link_postscript   _bfd_XXi_final_link_postscript

Functions

void _bfd_XXi_swap_sym_in (bfd *, void *, void *)
unsigned _bfd_XXi_swap_sym_out (bfd *, void *, void *)
void _bfd_XXi_swap_aux_in (bfd *, void *, int, int, int, int, void *)
unsigned _bfd_XXi_swap_aux_out (bfd *, void *, int, int, int, int, void *)
void _bfd_XXi_swap_lineno_in (bfd *, void *, void *)
unsigned _bfd_XXi_swap_lineno_out (bfd *, void *, void *)
void _bfd_XXi_swap_aouthdr_in (bfd *, void *, void *)
unsigned _bfd_XXi_swap_aouthdr_out (bfd *, void *, void *)
unsigned _bfd_XXi_swap_scnhdr_out (bfd *, void *, void *)
bfd_boolean _bfd_XX_print_private_bfd_data_common (bfd *, void *)
bfd_boolean _bfd_XX_bfd_copy_private_bfd_data_common (bfd *, bfd *)
void _bfd_XX_get_symbol_info (bfd *, asymbol *, symbol_info *)
bfd_boolean _bfd_XXi_final_link_postscript (bfd *, struct coff_final_link_info *)
unsigned _bfd_XX_only_swap_filehdr_out (bfd *, void *, void *)
unsigned _bfd_XXi_only_swap_filehdr_out (bfd *, void *, void *)
bfd_boolean _bfd_XX_bfd_copy_private_section_data (bfd *, asection *, bfd *, asection *)

Define Documentation

#define _bfd_XX_bfd_copy_private_bfd_data_common   _bfd_pe_bfd_copy_private_bfd_data_common

Definition at line 285 of file libpei.h.

#define _bfd_XX_bfd_copy_private_section_data   _bfd_pe_bfd_copy_private_section_data

Definition at line 286 of file libpei.h.

#define _bfd_XX_get_symbol_info   _bfd_pe_get_symbol_info

Definition at line 287 of file libpei.h.

#define _bfd_XX_only_swap_filehdr_out   _bfd_pe_only_swap_filehdr_out

Definition at line 288 of file libpei.h.

#define _bfd_XX_print_private_bfd_data_common   _bfd_pe_print_private_bfd_data_common

Definition at line 289 of file libpei.h.

#define _bfd_XXi_final_link_postscript   _bfd_pei_final_link_postscript

Definition at line 291 of file libpei.h.

#define _bfd_XXi_final_link_postscript   _bfd_pei_final_link_postscript

Definition at line 291 of file libpei.h.

#define _bfd_XXi_only_swap_filehdr_out   _bfd_pei_only_swap_filehdr_out

Definition at line 292 of file libpei.h.

#define _bfd_XXi_swap_aouthdr_in   _bfd_pei_swap_aouthdr_in

Definition at line 293 of file libpei.h.

#define _bfd_XXi_swap_aouthdr_out   _bfd_pei_swap_aouthdr_out

Definition at line 294 of file libpei.h.

#define _bfd_XXi_swap_aux_in   _bfd_pei_swap_aux_in

Definition at line 295 of file libpei.h.

#define _bfd_XXi_swap_aux_out   _bfd_pei_swap_aux_out

Definition at line 296 of file libpei.h.

#define _bfd_XXi_swap_lineno_in   _bfd_pei_swap_lineno_in

Definition at line 297 of file libpei.h.

#define _bfd_XXi_swap_lineno_out   _bfd_pei_swap_lineno_out

Definition at line 298 of file libpei.h.

#define _bfd_XXi_swap_scnhdr_out   _bfd_pei_swap_scnhdr_out

Definition at line 299 of file libpei.h.

#define _bfd_XXi_swap_sym_in   _bfd_pei_swap_sym_in

Definition at line 300 of file libpei.h.

#define _bfd_XXi_swap_sym_out   _bfd_pei_swap_sym_out

Definition at line 301 of file libpei.h.

#define bfd_pe_executable_p (   abfd)
Value:
(CONST_STRNEQ ((abfd)->xvec->name, "pei-")              \
   || CONST_STRNEQ ((abfd)->xvec->name, "efi-app-"))

Definition at line 306 of file libpei.h.

Definition at line 333 of file libpei.h.

Definition at line 328 of file libpei.h.

Definition at line 329 of file libpei.h.

Definition at line 324 of file libpei.h.

Definition at line 325 of file libpei.h.

Definition at line 326 of file libpei.h.

Definition at line 327 of file libpei.h.

Definition at line 330 of file libpei.h.

Definition at line 322 of file libpei.h.

Definition at line 323 of file libpei.h.

Definition at line 145 of file libpei.h.

Definition at line 163 of file libpei.h.

Definition at line 139 of file libpei.h.

Definition at line 151 of file libpei.h.

Definition at line 157 of file libpei.h.

Definition at line 133 of file libpei.h.

#define GET_FCN_ENDNDX (   abfd,
  ext 
)    H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_endndx)

Definition at line 62 of file libpei.h.

#define GET_FCN_LNNOPTR (   abfd,
  ext 
)    H_GET_32 (abfd, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)

Definition at line 57 of file libpei.h.

Definition at line 125 of file libpei.h.

#define GET_LINENO_LNNO (   abfd,
  ext 
)    H_GET_16 (abfd, ext->l_lnno);

Definition at line 115 of file libpei.h.

#define GET_LNSZ_LNNO (   abfd,
  ext 
)    H_GET_16 (abfd, ext->x_sym.x_misc.x_lnsz.x_lnno)

Definition at line 75 of file libpei.h.

#define GET_LNSZ_SIZE (   abfd,
  ext 
)    H_GET_16 (abfd, ext->x_sym.x_misc.x_lnsz.x_size)

Definition at line 79 of file libpei.h.

Definition at line 273 of file libpei.h.

Definition at line 281 of file libpei.h.

Definition at line 279 of file libpei.h.

Definition at line 277 of file libpei.h.

Definition at line 275 of file libpei.h.

Definition at line 283 of file libpei.h.

#define GET_SCN_NLINNO (   abfd,
  ext 
)    H_GET_16 (abfd, ext->x_scn.x_nlinno)

Definition at line 99 of file libpei.h.

#define GET_SCN_NRELOC (   abfd,
  ext 
)    H_GET_16 (abfd, ext->x_scn.x_nreloc)

Definition at line 95 of file libpei.h.

#define GET_SCN_SCNLEN (   abfd,
  ext 
)    H_GET_32 (abfd, ext->x_scn.x_scnlen)

Definition at line 91 of file libpei.h.

Definition at line 201 of file libpei.h.

#define GET_SCNHDR_PADDR   H_GET_32

Definition at line 171 of file libpei.h.

Definition at line 195 of file libpei.h.

Definition at line 189 of file libpei.h.

#define GET_SCNHDR_SIZE   H_GET_32

Definition at line 183 of file libpei.h.

#define GET_SCNHDR_VADDR   H_GET_32

Definition at line 177 of file libpei.h.

Definition at line 148 of file libpei.h.

Definition at line 166 of file libpei.h.

Definition at line 142 of file libpei.h.

Definition at line 154 of file libpei.h.

Definition at line 160 of file libpei.h.

Definition at line 136 of file libpei.h.

#define PUT_FCN_ENDNDX (   abfd,
  in,
  ext 
)    H_PUT_32(abfd, in, ext->x_sym.x_fcnary.x_fcn.x_endndx)

Definition at line 71 of file libpei.h.

#define PUT_FCN_LNNOPTR (   abfd,
  in,
  ext 
)    H_PUT_32(abfd, in, ext->x_sym.x_fcnary.x_fcn.x_lnnoptr)

Definition at line 67 of file libpei.h.

Definition at line 128 of file libpei.h.

#define PUT_LINENO_LNNO (   abfd,
  val,
  ext 
)    H_PUT_16(abfd,val, ext->l_lnno);

Definition at line 119 of file libpei.h.

#define PUT_LNSZ_LNNO (   abfd,
  in,
  ext 
)    H_PUT_16(abfd, in, ext->x_sym.x_misc.x_lnsz.x_lnno)

Definition at line 83 of file libpei.h.

#define PUT_LNSZ_SIZE (   abfd,
  in,
  ext 
)    H_PUT_16(abfd, in, ext->x_sym.x_misc.x_lnsz.x_size)

Definition at line 87 of file libpei.h.

Definition at line 274 of file libpei.h.

Definition at line 282 of file libpei.h.

Definition at line 280 of file libpei.h.

Definition at line 278 of file libpei.h.

Definition at line 276 of file libpei.h.

#define PUT_SCN_NLINNO (   abfd,
  in,
  ext 
)    H_PUT_16(abfd,in, ext->x_scn.x_nlinno)

Definition at line 111 of file libpei.h.

#define PUT_SCN_NRELOC (   abfd,
  in,
  ext 
)    H_PUT_16(abfd, in, ext->x_scn.x_nreloc)

Definition at line 107 of file libpei.h.

#define PUT_SCN_SCNLEN (   abfd,
  in,
  ext 
)    H_PUT_32(abfd, in, ext->x_scn.x_scnlen)

Definition at line 103 of file libpei.h.

Definition at line 204 of file libpei.h.

#define PUT_SCNHDR_PADDR   H_PUT_32

Definition at line 174 of file libpei.h.

Definition at line 198 of file libpei.h.

Definition at line 192 of file libpei.h.

#define PUT_SCNHDR_SIZE   H_PUT_32

Definition at line 186 of file libpei.h.

#define PUT_SCNHDR_VADDR   H_PUT_32

Definition at line 180 of file libpei.h.


Function Documentation

Definition at line 1986 of file peXXigen.c.

{
  /* One day we may try to grok other private data.  */
  if (ibfd->xvec->flavour != bfd_target_coff_flavour
      || obfd->xvec->flavour != bfd_target_coff_flavour)
    return TRUE;

  pe_data (obfd)->pe_opthdr = pe_data (ibfd)->pe_opthdr;
  pe_data (obfd)->dll = pe_data (ibfd)->dll;

  /* For strip: if we removed .reloc, we'll make a real mess of things
     if we don't remove this entry as well.  */
  if (! pe_data (obfd)->has_reloc_section)
    {
      pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].VirtualAddress = 0;
      pe_data (obfd)->pe_opthdr.DataDirectory[PE_BASE_RELOCATION_TABLE].Size = 0;
    }
  return TRUE;
}

Definition at line 2009 of file peXXigen.c.

{
  if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour
      || bfd_get_flavour (obfd) != bfd_target_coff_flavour)
    return TRUE;

  if (coff_section_data (ibfd, isec) != NULL
      && pei_section_data (ibfd, isec) != NULL)
    {
      if (coff_section_data (obfd, osec) == NULL)
       {
         bfd_size_type amt = sizeof (struct coff_section_tdata);
         osec->used_by_bfd = bfd_zalloc (obfd, amt);
         if (osec->used_by_bfd == NULL)
           return FALSE;
       }

      if (pei_section_data (obfd, osec) == NULL)
       {
         bfd_size_type amt = sizeof (struct pei_section_tdata);
         coff_section_data (obfd, osec)->tdata = bfd_zalloc (obfd, amt);
         if (coff_section_data (obfd, osec)->tdata == NULL)
           return FALSE;
       }

      pei_section_data (obfd, osec)->virt_size =
       pei_section_data (ibfd, isec)->virt_size;
      pei_section_data (obfd, osec)->pe_flags =
       pei_section_data (ibfd, isec)->pe_flags;
    }

  return TRUE;
}

Here is the call graph for this function:

void _bfd_XX_get_symbol_info ( bfd ,
asymbol ,
symbol_info  
)

Definition at line 2047 of file peXXigen.c.

unsigned _bfd_XX_only_swap_filehdr_out ( bfd ,
void *  ,
void *   
)

Definition at line 842 of file peXXigen.c.

{
  struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
  FILHDR *filehdr_out = (FILHDR *) out;

  H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
  H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);
  H_PUT_32 (abfd, filehdr_in->f_timdat, filehdr_out->f_timdat);
  PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr, filehdr_out->f_symptr);
  H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
  H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
  H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);

  return FILHSZ;
}

Definition at line 1813 of file peXXigen.c.

{
  FILE *file = (FILE *) vfile;
  int j;
  pe_data_type *pe = pe_data (abfd);
  struct internal_extra_pe_aouthdr *i = &pe->pe_opthdr;
  const char *subsystem_name = NULL;
  const char *name;

  /* The MS dumpbin program reportedly ands with 0xff0f before
     printing the characteristics field.  Not sure why.  No reason to
     emulate it here.  */
  fprintf (file, _("\nCharacteristics 0x%x\n"), pe->real_flags);
#undef PF
#define PF(x, y) if (pe->real_flags & x) { fprintf (file, "\t%s\n", y); }
  PF (IMAGE_FILE_RELOCS_STRIPPED, "relocations stripped");
  PF (IMAGE_FILE_EXECUTABLE_IMAGE, "executable");
  PF (IMAGE_FILE_LINE_NUMS_STRIPPED, "line numbers stripped");
  PF (IMAGE_FILE_LOCAL_SYMS_STRIPPED, "symbols stripped");
  PF (IMAGE_FILE_LARGE_ADDRESS_AWARE, "large address aware");
  PF (IMAGE_FILE_BYTES_REVERSED_LO, "little endian");
  PF (IMAGE_FILE_32BIT_MACHINE, "32 bit words");
  PF (IMAGE_FILE_DEBUG_STRIPPED, "debugging information removed");
  PF (IMAGE_FILE_SYSTEM, "system file");
  PF (IMAGE_FILE_DLL, "DLL");
  PF (IMAGE_FILE_BYTES_REVERSED_HI, "big endian");
#undef PF

  /* ctime implies '\n'.  */
  {
    time_t t = pe->coff.timestamp;
    fprintf (file, "\nTime/Date\t\t%s", ctime (&t));
  }

#ifndef IMAGE_NT_OPTIONAL_HDR_MAGIC
# define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
#endif
#ifndef IMAGE_NT_OPTIONAL_HDR64_MAGIC
# define IMAGE_NT_OPTIONAL_HDR64_MAGIC 0x20b
#endif
#ifndef IMAGE_NT_OPTIONAL_HDRROM_MAGIC
# define IMAGE_NT_OPTIONAL_HDRROM_MAGIC 0x107
#endif

  switch (i->Magic)
    {
    case IMAGE_NT_OPTIONAL_HDR_MAGIC:
      name = "PE32";
      break;
    case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
      name = "PE32+";
      break;
    case IMAGE_NT_OPTIONAL_HDRROM_MAGIC:
      name = "ROM";
      break;
    default:
      name = NULL;
      break;
    }
  fprintf (file, "Magic\t\t\t%04x", i->Magic);
  if (name)
    fprintf (file, "\t(%s)",name);
  fprintf (file, "\nMajorLinkerVersion\t%d\n", i->MajorLinkerVersion);
  fprintf (file, "MinorLinkerVersion\t%d\n", i->MinorLinkerVersion);
  fprintf (file, "SizeOfCode\t\t%08lx\n", i->SizeOfCode);
  fprintf (file, "SizeOfInitializedData\t%08lx\n",
          i->SizeOfInitializedData);
  fprintf (file, "SizeOfUninitializedData\t%08lx\n",
          i->SizeOfUninitializedData);
  fprintf (file, "AddressOfEntryPoint\t");
  fprintf_vma (file, i->AddressOfEntryPoint);
  fprintf (file, "\nBaseOfCode\t\t");
  fprintf_vma (file, i->BaseOfCode);
#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
  /* PE32+ does not have BaseOfData member!  */
  fprintf (file, "\nBaseOfData\t\t");
  fprintf_vma (file, i->BaseOfData);
#endif

  fprintf (file, "\nImageBase\t\t");
  fprintf_vma (file, i->ImageBase);
  fprintf (file, "\nSectionAlignment\t");
  fprintf_vma (file, i->SectionAlignment);
  fprintf (file, "\nFileAlignment\t\t");
  fprintf_vma (file, i->FileAlignment);
  fprintf (file, "\nMajorOSystemVersion\t%d\n", i->MajorOperatingSystemVersion);
  fprintf (file, "MinorOSystemVersion\t%d\n", i->MinorOperatingSystemVersion);
  fprintf (file, "MajorImageVersion\t%d\n", i->MajorImageVersion);
  fprintf (file, "MinorImageVersion\t%d\n", i->MinorImageVersion);
  fprintf (file, "MajorSubsystemVersion\t%d\n", i->MajorSubsystemVersion);
  fprintf (file, "MinorSubsystemVersion\t%d\n", i->MinorSubsystemVersion);
  fprintf (file, "Win32Version\t\t%08lx\n", i->Reserved1);
  fprintf (file, "SizeOfImage\t\t%08lx\n", i->SizeOfImage);
  fprintf (file, "SizeOfHeaders\t\t%08lx\n", i->SizeOfHeaders);
  fprintf (file, "CheckSum\t\t%08lx\n", i->CheckSum);

  switch (i->Subsystem)
    {
    case IMAGE_SUBSYSTEM_UNKNOWN:
      subsystem_name = "unspecified";
      break;
    case IMAGE_SUBSYSTEM_NATIVE:
      subsystem_name = "NT native";
      break;
    case IMAGE_SUBSYSTEM_WINDOWS_GUI:
      subsystem_name = "Windows GUI";
      break;
    case IMAGE_SUBSYSTEM_WINDOWS_CUI:
      subsystem_name = "Windows CUI";
      break;
    case IMAGE_SUBSYSTEM_POSIX_CUI:
      subsystem_name = "POSIX CUI";
      break;
    case IMAGE_SUBSYSTEM_WINDOWS_CE_GUI:
      subsystem_name = "Wince CUI";
      break;
    case IMAGE_SUBSYSTEM_EFI_APPLICATION:
      subsystem_name = "EFI application";
      break;
    case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
      subsystem_name = "EFI boot service driver";
      break;
    case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
      subsystem_name = "EFI runtime driver";
      break;
    // These are from revision 8.0 of the MS PE/COFF spec
    case IMAGE_SUBSYSTEM_EFI_ROM:
      subsystem_name = "EFI ROM";
      break;
    case IMAGE_SUBSYSTEM_XBOX:
      subsystem_name = "XBOX";
      break;
    // Added default case for clarity - subsystem_name is NULL anyway.
    default:
      subsystem_name = NULL;
    }

  fprintf (file, "Subsystem\t\t%08x", i->Subsystem);
  if (subsystem_name)
    fprintf (file, "\t(%s)", subsystem_name);
  fprintf (file, "\nDllCharacteristics\t%08x\n", i->DllCharacteristics);
  fprintf (file, "SizeOfStackReserve\t");
  fprintf_vma (file, i->SizeOfStackReserve);
  fprintf (file, "\nSizeOfStackCommit\t");
  fprintf_vma (file, i->SizeOfStackCommit);
  fprintf (file, "\nSizeOfHeapReserve\t");
  fprintf_vma (file, i->SizeOfHeapReserve);
  fprintf (file, "\nSizeOfHeapCommit\t");
  fprintf_vma (file, i->SizeOfHeapCommit);
  fprintf (file, "\nLoaderFlags\t\t%08lx\n", i->LoaderFlags);
  fprintf (file, "NumberOfRvaAndSizes\t%08lx\n", i->NumberOfRvaAndSizes);

  fprintf (file, "\nThe Data Directory\n");
  for (j = 0; j < IMAGE_NUMBEROF_DIRECTORY_ENTRIES; j++)
    {
      fprintf (file, "Entry %1x ", j);
      fprintf_vma (file, i->DataDirectory[j].VirtualAddress);
      fprintf (file, " %08lx ", i->DataDirectory[j].Size);
      fprintf (file, "%s\n", dir_names[j]);
    }

  pe_print_idata (abfd, vfile);
  pe_print_edata (abfd, vfile);
  pe_print_pdata (abfd, vfile);
  pe_print_reloc (abfd, vfile);

  return TRUE;
}

Here is the call graph for this function:

Definition at line 2056 of file peXXigen.c.

{
  struct coff_link_hash_entry *h1;
  struct bfd_link_info *info = pfinfo->info;
  bfd_boolean result = TRUE;

  /* There are a few fields that need to be filled in now while we
     have symbol table access.

     The .idata subsections aren't directly available as sections, but
     they are in the symbol table, so get them from there.  */

  /* The import directory.  This is the address of .idata$2, with size
     of .idata$2 + .idata$3.  */
  h1 = coff_link_hash_lookup (coff_hash_table (info),
                           ".idata$2", FALSE, FALSE, TRUE);
  if (h1 != NULL)
    {
      /* PR ld/2729: We cannot rely upon all the output sections having been 
        created properly, so check before referencing them.  Issue a warning
        message for any sections tht could not be found.  */
      if (h1->root.u.def.section != NULL
         && h1->root.u.def.section->output_section != NULL)
       pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress =
         (h1->root.u.def.value
          + h1->root.u.def.section->output_section->vma
          + h1->root.u.def.section->output_offset);
      else
       {
         _bfd_error_handler
           (_("%B: unable to fill in DataDictionary[1] because .idata$2 is missing"), 
            abfd);
         result = FALSE;
       }

      h1 = coff_link_hash_lookup (coff_hash_table (info),
                              ".idata$4", FALSE, FALSE, TRUE);
      if (h1 != NULL
         && h1->root.u.def.section != NULL
         && h1->root.u.def.section->output_section != NULL)
       pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].Size =
         ((h1->root.u.def.value
           + h1->root.u.def.section->output_section->vma
           + h1->root.u.def.section->output_offset)
          - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_TABLE].VirtualAddress);
      else
       {
         _bfd_error_handler
           (_("%B: unable to fill in DataDictionary[1] because .idata$4 is missing"), 
            abfd);
         result = FALSE;
       }

      /* The import address table.  This is the size/address of
         .idata$5.  */
      h1 = coff_link_hash_lookup (coff_hash_table (info),
                              ".idata$5", FALSE, FALSE, TRUE);
      if (h1 != NULL
         && h1->root.u.def.section != NULL
         && h1->root.u.def.section->output_section != NULL)
       pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress =
         (h1->root.u.def.value
          + h1->root.u.def.section->output_section->vma
          + h1->root.u.def.section->output_offset);
      else
       {
         _bfd_error_handler
           (_("%B: unable to fill in DataDictionary[12] because .idata$5 is missing"), 
            abfd);
         result = FALSE;
       }

      h1 = coff_link_hash_lookup (coff_hash_table (info),
                              ".idata$6", FALSE, FALSE, TRUE);
      if (h1 != NULL
         && h1->root.u.def.section != NULL
         && h1->root.u.def.section->output_section != NULL)
       pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size =
         ((h1->root.u.def.value
           + h1->root.u.def.section->output_section->vma
           + h1->root.u.def.section->output_offset)
          - pe_data (abfd)->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress);      
      else
       {
         _bfd_error_handler
           (_("%B: unable to fill in DataDictionary[PE_IMPORT_ADDRESS_TABLE (12)] because .idata$6 is missing"), 
            abfd);
         result = FALSE;
       }
    }

  h1 = coff_link_hash_lookup (coff_hash_table (info),
                           "__tls_used", FALSE, FALSE, TRUE);
  if (h1 != NULL)
    {
      if (h1->root.u.def.section != NULL
         && h1->root.u.def.section->output_section != NULL)
       pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].VirtualAddress =
         (h1->root.u.def.value
          + h1->root.u.def.section->output_section->vma
          + h1->root.u.def.section->output_offset
          - pe_data (abfd)->pe_opthdr.ImageBase);
      else
       {
         _bfd_error_handler
           (_("%B: unable to fill in DataDictionary[9] because __tls_used is missing"), 
            abfd);
         result = FALSE;
       }

      pe_data (abfd)->pe_opthdr.DataDirectory[PE_TLS_TABLE].Size = 0x18;
    }

  /* If we couldn't find idata$2, we either have an excessively
     trivial program or are in DEEP trouble; we have to assume trivial
     program....  */
  return result;
}
unsigned _bfd_XXi_only_swap_filehdr_out ( bfd ,
void *  ,
void *   
)

Definition at line 734 of file peXXigen.c.

{
  int idx;
  struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
  struct external_PEI_filehdr *filehdr_out = (struct external_PEI_filehdr *) out;

  if (pe_data (abfd)->has_reloc_section)
    filehdr_in->f_flags &= ~F_RELFLG;

  if (pe_data (abfd)->dll)
    filehdr_in->f_flags |= F_DLL;

  filehdr_in->pe.e_magic    = DOSMAGIC;
  filehdr_in->pe.e_cblp     = 0x90;
  filehdr_in->pe.e_cp       = 0x3;
  filehdr_in->pe.e_crlc     = 0x0;
  filehdr_in->pe.e_cparhdr  = 0x4;
  filehdr_in->pe.e_minalloc = 0x0;
  filehdr_in->pe.e_maxalloc = 0xffff;
  filehdr_in->pe.e_ss       = 0x0;
  filehdr_in->pe.e_sp       = 0xb8;
  filehdr_in->pe.e_csum     = 0x0;
  filehdr_in->pe.e_ip       = 0x0;
  filehdr_in->pe.e_cs       = 0x0;
  filehdr_in->pe.e_lfarlc   = 0x40;
  filehdr_in->pe.e_ovno     = 0x0;

  for (idx = 0; idx < 4; idx++)
    filehdr_in->pe.e_res[idx] = 0x0;

  filehdr_in->pe.e_oemid   = 0x0;
  filehdr_in->pe.e_oeminfo = 0x0;

  for (idx = 0; idx < 10; idx++)
    filehdr_in->pe.e_res2[idx] = 0x0;

  filehdr_in->pe.e_lfanew = 0x80;

  /* This next collection of data are mostly just characters.  It
     appears to be constant within the headers put on NT exes.  */
  filehdr_in->pe.dos_message[0]  = 0x0eba1f0e;
  filehdr_in->pe.dos_message[1]  = 0xcd09b400;
  filehdr_in->pe.dos_message[2]  = 0x4c01b821;
  filehdr_in->pe.dos_message[3]  = 0x685421cd;
  filehdr_in->pe.dos_message[4]  = 0x70207369;
  filehdr_in->pe.dos_message[5]  = 0x72676f72;
  filehdr_in->pe.dos_message[6]  = 0x63206d61;
  filehdr_in->pe.dos_message[7]  = 0x6f6e6e61;
  filehdr_in->pe.dos_message[8]  = 0x65622074;
  filehdr_in->pe.dos_message[9]  = 0x6e757220;
  filehdr_in->pe.dos_message[10] = 0x206e6920;
  filehdr_in->pe.dos_message[11] = 0x20534f44;
  filehdr_in->pe.dos_message[12] = 0x65646f6d;
  filehdr_in->pe.dos_message[13] = 0x0a0d0d2e;
  filehdr_in->pe.dos_message[14] = 0x24;
  filehdr_in->pe.dos_message[15] = 0x0;
  filehdr_in->pe.nt_signature = NT_SIGNATURE;

  H_PUT_16 (abfd, filehdr_in->f_magic, filehdr_out->f_magic);
  H_PUT_16 (abfd, filehdr_in->f_nscns, filehdr_out->f_nscns);

  H_PUT_32 (abfd, time (0), filehdr_out->f_timdat);
  PUT_FILEHDR_SYMPTR (abfd, filehdr_in->f_symptr,
                    filehdr_out->f_symptr);
  H_PUT_32 (abfd, filehdr_in->f_nsyms, filehdr_out->f_nsyms);
  H_PUT_16 (abfd, filehdr_in->f_opthdr, filehdr_out->f_opthdr);
  H_PUT_16 (abfd, filehdr_in->f_flags, filehdr_out->f_flags);

  /* Put in extra dos header stuff.  This data remains essentially
     constant, it just has to be tacked on to the beginning of all exes
     for NT.  */
  H_PUT_16 (abfd, filehdr_in->pe.e_magic, filehdr_out->e_magic);
  H_PUT_16 (abfd, filehdr_in->pe.e_cblp, filehdr_out->e_cblp);
  H_PUT_16 (abfd, filehdr_in->pe.e_cp, filehdr_out->e_cp);
  H_PUT_16 (abfd, filehdr_in->pe.e_crlc, filehdr_out->e_crlc);
  H_PUT_16 (abfd, filehdr_in->pe.e_cparhdr, filehdr_out->e_cparhdr);
  H_PUT_16 (abfd, filehdr_in->pe.e_minalloc, filehdr_out->e_minalloc);
  H_PUT_16 (abfd, filehdr_in->pe.e_maxalloc, filehdr_out->e_maxalloc);
  H_PUT_16 (abfd, filehdr_in->pe.e_ss, filehdr_out->e_ss);
  H_PUT_16 (abfd, filehdr_in->pe.e_sp, filehdr_out->e_sp);
  H_PUT_16 (abfd, filehdr_in->pe.e_csum, filehdr_out->e_csum);
  H_PUT_16 (abfd, filehdr_in->pe.e_ip, filehdr_out->e_ip);
  H_PUT_16 (abfd, filehdr_in->pe.e_cs, filehdr_out->e_cs);
  H_PUT_16 (abfd, filehdr_in->pe.e_lfarlc, filehdr_out->e_lfarlc);
  H_PUT_16 (abfd, filehdr_in->pe.e_ovno, filehdr_out->e_ovno);

  for (idx = 0; idx < 4; idx++)
    H_PUT_16 (abfd, filehdr_in->pe.e_res[idx], filehdr_out->e_res[idx]);

  H_PUT_16 (abfd, filehdr_in->pe.e_oemid, filehdr_out->e_oemid);
  H_PUT_16 (abfd, filehdr_in->pe.e_oeminfo, filehdr_out->e_oeminfo);

  for (idx = 0; idx < 10; idx++)
    H_PUT_16 (abfd, filehdr_in->pe.e_res2[idx], filehdr_out->e_res2[idx]);

  H_PUT_32 (abfd, filehdr_in->pe.e_lfanew, filehdr_out->e_lfanew);

  for (idx = 0; idx < 16; idx++)
    H_PUT_32 (abfd, filehdr_in->pe.dos_message[idx],
             filehdr_out->dos_message[idx]);

  /* Also put in the NT signature.  */
  H_PUT_32 (abfd, filehdr_in->pe.nt_signature, filehdr_out->nt_signature);

  return FILHSZ;
}
void _bfd_XXi_swap_aouthdr_in ( bfd ,
void *  ,
void *   
)

Definition at line 387 of file peXXigen.c.

{
  PEAOUTHDR * src = (PEAOUTHDR *) aouthdr_ext1;
  AOUTHDR * aouthdr_ext = (AOUTHDR *) aouthdr_ext1;
  struct internal_aouthdr *aouthdr_int
    = (struct internal_aouthdr *) aouthdr_int1;
  struct internal_extra_pe_aouthdr *a = &aouthdr_int->pe;

  aouthdr_int->magic = H_GET_16 (abfd, aouthdr_ext->magic);
  aouthdr_int->vstamp = H_GET_16 (abfd, aouthdr_ext->vstamp);
  aouthdr_int->tsize = GET_AOUTHDR_TSIZE (abfd, aouthdr_ext->tsize);
  aouthdr_int->dsize = GET_AOUTHDR_DSIZE (abfd, aouthdr_ext->dsize);
  aouthdr_int->bsize = GET_AOUTHDR_BSIZE (abfd, aouthdr_ext->bsize);
  aouthdr_int->entry = GET_AOUTHDR_ENTRY (abfd, aouthdr_ext->entry);
  aouthdr_int->text_start =
    GET_AOUTHDR_TEXT_START (abfd, aouthdr_ext->text_start);
#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
  /* PE32+ does not have data_start member!  */
  aouthdr_int->data_start =
    GET_AOUTHDR_DATA_START (abfd, aouthdr_ext->data_start);
  a->BaseOfData = aouthdr_int->data_start;
#endif

  a->Magic = aouthdr_int->magic;
  a->MajorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp);
  a->MinorLinkerVersion = H_GET_8 (abfd, aouthdr_ext->vstamp + 1);
  a->SizeOfCode = aouthdr_int->tsize ;
  a->SizeOfInitializedData = aouthdr_int->dsize ;
  a->SizeOfUninitializedData = aouthdr_int->bsize ;
  a->AddressOfEntryPoint = aouthdr_int->entry;
  a->BaseOfCode = aouthdr_int->text_start;
  a->ImageBase = GET_OPTHDR_IMAGE_BASE (abfd, src->ImageBase);
  a->SectionAlignment = H_GET_32 (abfd, src->SectionAlignment);
  a->FileAlignment = H_GET_32 (abfd, src->FileAlignment);
  a->MajorOperatingSystemVersion =
    H_GET_16 (abfd, src->MajorOperatingSystemVersion);
  a->MinorOperatingSystemVersion =
    H_GET_16 (abfd, src->MinorOperatingSystemVersion);
  a->MajorImageVersion = H_GET_16 (abfd, src->MajorImageVersion);
  a->MinorImageVersion = H_GET_16 (abfd, src->MinorImageVersion);
  a->MajorSubsystemVersion = H_GET_16 (abfd, src->MajorSubsystemVersion);
  a->MinorSubsystemVersion = H_GET_16 (abfd, src->MinorSubsystemVersion);
  a->Reserved1 = H_GET_32 (abfd, src->Reserved1);
  a->SizeOfImage = H_GET_32 (abfd, src->SizeOfImage);
  a->SizeOfHeaders = H_GET_32 (abfd, src->SizeOfHeaders);
  a->CheckSum = H_GET_32 (abfd, src->CheckSum);
  a->Subsystem = H_GET_16 (abfd, src->Subsystem);
  a->DllCharacteristics = H_GET_16 (abfd, src->DllCharacteristics);
  a->SizeOfStackReserve =
    GET_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, src->SizeOfStackReserve);
  a->SizeOfStackCommit =
    GET_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, src->SizeOfStackCommit);
  a->SizeOfHeapReserve =
    GET_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, src->SizeOfHeapReserve);
  a->SizeOfHeapCommit =
    GET_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, src->SizeOfHeapCommit);
  a->LoaderFlags = H_GET_32 (abfd, src->LoaderFlags);
  a->NumberOfRvaAndSizes = H_GET_32 (abfd, src->NumberOfRvaAndSizes);

  {
    int idx;

    for (idx = 0; idx < 16; idx++)
      {
        /* If data directory is empty, rva also should be 0.  */
       int size =
         H_GET_32 (abfd, src->DataDirectory[idx][1]);

       a->DataDirectory[idx].Size = size;

       if (size)
         a->DataDirectory[idx].VirtualAddress =
           H_GET_32 (abfd, src->DataDirectory[idx][0]);
       else
         a->DataDirectory[idx].VirtualAddress = 0;
      }
  }

  if (aouthdr_int->entry)
    {
      aouthdr_int->entry += a->ImageBase;
#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
      aouthdr_int->entry &= 0xffffffff;
#endif
    }

  if (aouthdr_int->tsize)
    {
      aouthdr_int->text_start += a->ImageBase;
#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
      aouthdr_int->text_start &= 0xffffffff;
#endif
    }

#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
  /* PE32+ does not have data_start member!  */
  if (aouthdr_int->dsize)
    {
      aouthdr_int->data_start += a->ImageBase;
      aouthdr_int->data_start &= 0xffffffff;
    }
#endif

#ifdef POWERPC_LE_PE
  /* These three fields are normally set up by ppc_relocate_section.
     In the case of reading a file in, we can pick them up from the
     DataDirectory.  */
  first_thunk_address = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].VirtualAddress;
  thunk_size = a->DataDirectory[PE_IMPORT_ADDRESS_TABLE].Size;
  import_table_size = a->DataDirectory[PE_IMPORT_TABLE].Size;
#endif
}
unsigned _bfd_XXi_swap_aouthdr_out ( bfd ,
void *  ,
void *   
)

Definition at line 532 of file peXXigen.c.

{
  struct internal_aouthdr *aouthdr_in = (struct internal_aouthdr *) in;
  pe_data_type *pe = pe_data (abfd);
  struct internal_extra_pe_aouthdr *extra = &pe->pe_opthdr;
  PEAOUTHDR *aouthdr_out = (PEAOUTHDR *) out;
  bfd_vma sa, fa, ib;
  IMAGE_DATA_DIRECTORY idata2, idata5, tls;
  
  if (pe->force_minimum_alignment)
    {
      if (!extra->FileAlignment)
       extra->FileAlignment = PE_DEF_FILE_ALIGNMENT;
      if (!extra->SectionAlignment)
       extra->SectionAlignment = PE_DEF_SECTION_ALIGNMENT;
    }

  if (extra->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN)
    extra->Subsystem = pe->target_subsystem;

  sa = extra->SectionAlignment;
  fa = extra->FileAlignment;
  ib = extra->ImageBase;

  idata2 = pe->pe_opthdr.DataDirectory[PE_IMPORT_TABLE];
  idata5 = pe->pe_opthdr.DataDirectory[PE_IMPORT_ADDRESS_TABLE];
  tls = pe->pe_opthdr.DataDirectory[PE_TLS_TABLE];
  
  if (aouthdr_in->tsize)
    {
      aouthdr_in->text_start -= ib;
#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
      aouthdr_in->text_start &= 0xffffffff;
#endif
    }

  if (aouthdr_in->dsize)
    {
      aouthdr_in->data_start -= ib;
#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
      aouthdr_in->data_start &= 0xffffffff;
#endif
    }

  if (aouthdr_in->entry)
    {
      aouthdr_in->entry -= ib;
#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
      aouthdr_in->entry &= 0xffffffff;
#endif
    }

#define FA(x) (((x) + fa -1 ) & (- fa))
#define SA(x) (((x) + sa -1 ) & (- sa))

  /* We like to have the sizes aligned.  */
  aouthdr_in->bsize = FA (aouthdr_in->bsize);

  extra->NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;

  /* First null out all data directory entries.  */
  memset (extra->DataDirectory, 0, sizeof (extra->DataDirectory));

  add_data_entry (abfd, extra, 0, ".edata", ib);
  add_data_entry (abfd, extra, 2, ".rsrc", ib);
  add_data_entry (abfd, extra, 3, ".pdata", ib);

  /* In theory we do not need to call add_data_entry for .idata$2 or
     .idata$5.  It will be done in bfd_coff_final_link where all the
     required information is available.  If however, we are not going
     to perform a final link, eg because we have been invoked by objcopy
     or strip, then we need to make sure that these Data Directory
     entries are initialised properly.

     So - we copy the input values into the output values, and then, if
     a final link is going to be performed, it can overwrite them.  */
  extra->DataDirectory[PE_IMPORT_TABLE]  = idata2;
  extra->DataDirectory[PE_IMPORT_ADDRESS_TABLE] = idata5;
  extra->DataDirectory[PE_TLS_TABLE] = tls;

  if (extra->DataDirectory[PE_IMPORT_TABLE].VirtualAddress == 0)
    /* Until other .idata fixes are made (pending patch), the entry for
       .idata is needed for backwards compatibility.  FIXME.  */
    add_data_entry (abfd, extra, 1, ".idata", ib);
    
  /* For some reason, the virtual size (which is what's set by
     add_data_entry) for .reloc is not the same as the size recorded
     in this slot by MSVC; it doesn't seem to cause problems (so far),
     but since it's the best we've got, use it.  It does do the right
     thing for .pdata.  */
  if (pe->has_reloc_section)
    add_data_entry (abfd, extra, 5, ".reloc", ib);

  {
    asection *sec;
    bfd_vma hsize = 0;
    bfd_vma dsize = 0;
    bfd_vma isize = 0;
    bfd_vma tsize = 0;

    for (sec = abfd->sections; sec; sec = sec->next)
      {
       int rounded = FA (sec->size);

       /* The first non-zero section filepos is the header size.
          Sections without contents will have a filepos of 0.  */
       if (hsize == 0)
         hsize = sec->filepos;
       if (sec->flags & SEC_DATA)
         dsize += rounded;
       if (sec->flags & SEC_CODE)
         tsize += rounded;
       /* The image size is the total VIRTUAL size (which is what is
          in the virt_size field).  Files have been seen (from MSVC
          5.0 link.exe) where the file size of the .data segment is
          quite small compared to the virtual size.  Without this
          fix, strip munges the file.

          FIXME: We need to handle holes between sections, which may
          happpen when we covert from another format.  We just use
          the virtual address and virtual size of the last section
          for the image size.  */
       if (coff_section_data (abfd, sec) != NULL
           && pei_section_data (abfd, sec) != NULL)
         isize = (sec->vma - extra->ImageBase
                 + SA (FA (pei_section_data (abfd, sec)->virt_size)));
      }

    aouthdr_in->dsize = dsize;
    aouthdr_in->tsize = tsize;
    extra->SizeOfHeaders = hsize;
    extra->SizeOfImage = isize;
  }

  H_PUT_16 (abfd, aouthdr_in->magic, aouthdr_out->standard.magic);

#define LINKER_VERSION 256 /* That is, 2.56 */

  /* This piece of magic sets the "linker version" field to
     LINKER_VERSION.  */
  H_PUT_16 (abfd, (LINKER_VERSION / 100 + (LINKER_VERSION % 100) * 256),
           aouthdr_out->standard.vstamp);

  PUT_AOUTHDR_TSIZE (abfd, aouthdr_in->tsize, aouthdr_out->standard.tsize);
  PUT_AOUTHDR_DSIZE (abfd, aouthdr_in->dsize, aouthdr_out->standard.dsize);
  PUT_AOUTHDR_BSIZE (abfd, aouthdr_in->bsize, aouthdr_out->standard.bsize);
  PUT_AOUTHDR_ENTRY (abfd, aouthdr_in->entry, aouthdr_out->standard.entry);
  PUT_AOUTHDR_TEXT_START (abfd, aouthdr_in->text_start,
                       aouthdr_out->standard.text_start);

#if !defined(COFF_WITH_pep) && !defined(COFF_WITH_pex64)
  /* PE32+ does not have data_start member!  */
  PUT_AOUTHDR_DATA_START (abfd, aouthdr_in->data_start,
                       aouthdr_out->standard.data_start);
#endif

  PUT_OPTHDR_IMAGE_BASE (abfd, extra->ImageBase, aouthdr_out->ImageBase);
  H_PUT_32 (abfd, extra->SectionAlignment, aouthdr_out->SectionAlignment);
  H_PUT_32 (abfd, extra->FileAlignment, aouthdr_out->FileAlignment);
  H_PUT_16 (abfd, extra->MajorOperatingSystemVersion,
           aouthdr_out->MajorOperatingSystemVersion);
  H_PUT_16 (abfd, extra->MinorOperatingSystemVersion,
           aouthdr_out->MinorOperatingSystemVersion);
  H_PUT_16 (abfd, extra->MajorImageVersion, aouthdr_out->MajorImageVersion);
  H_PUT_16 (abfd, extra->MinorImageVersion, aouthdr_out->MinorImageVersion);
  H_PUT_16 (abfd, extra->MajorSubsystemVersion,
           aouthdr_out->MajorSubsystemVersion);
  H_PUT_16 (abfd, extra->MinorSubsystemVersion,
           aouthdr_out->MinorSubsystemVersion);
  H_PUT_32 (abfd, extra->Reserved1, aouthdr_out->Reserved1);
  H_PUT_32 (abfd, extra->SizeOfImage, aouthdr_out->SizeOfImage);
  H_PUT_32 (abfd, extra->SizeOfHeaders, aouthdr_out->SizeOfHeaders);
  H_PUT_32 (abfd, extra->CheckSum, aouthdr_out->CheckSum);
  H_PUT_16 (abfd, extra->Subsystem, aouthdr_out->Subsystem);
  H_PUT_16 (abfd, extra->DllCharacteristics, aouthdr_out->DllCharacteristics);
  PUT_OPTHDR_SIZE_OF_STACK_RESERVE (abfd, extra->SizeOfStackReserve,
                                aouthdr_out->SizeOfStackReserve);
  PUT_OPTHDR_SIZE_OF_STACK_COMMIT (abfd, extra->SizeOfStackCommit,
                               aouthdr_out->SizeOfStackCommit);
  PUT_OPTHDR_SIZE_OF_HEAP_RESERVE (abfd, extra->SizeOfHeapReserve,
                               aouthdr_out->SizeOfHeapReserve);
  PUT_OPTHDR_SIZE_OF_HEAP_COMMIT (abfd, extra->SizeOfHeapCommit,
                              aouthdr_out->SizeOfHeapCommit);
  H_PUT_32 (abfd, extra->LoaderFlags, aouthdr_out->LoaderFlags);
  H_PUT_32 (abfd, extra->NumberOfRvaAndSizes,
           aouthdr_out->NumberOfRvaAndSizes);
  {
    int idx;

    for (idx = 0; idx < 16; idx++)
      {
       H_PUT_32 (abfd, extra->DataDirectory[idx].VirtualAddress,
                aouthdr_out->DataDirectory[idx][0]);
       H_PUT_32 (abfd, extra->DataDirectory[idx].Size,
                aouthdr_out->DataDirectory[idx][1]);
      }
  }

  return AOUTSZ;
}

Here is the call graph for this function:

void _bfd_XXi_swap_aux_in ( bfd ,
void *  ,
int  ,
int  ,
int  ,
int  ,
void *   
)
unsigned _bfd_XXi_swap_aux_out ( bfd ,
void *  ,
int  ,
int  ,
int  ,
int  ,
void *   
)
void _bfd_XXi_swap_lineno_in ( bfd ,
void *  ,
void *   
)

Definition at line 366 of file peXXigen.c.

{
  LINENO *ext = (LINENO *) ext1;
  struct internal_lineno *in = (struct internal_lineno *) in1;

  in->l_addr.l_symndx = H_GET_32 (abfd, ext->l_addr.l_symndx);
  in->l_lnno = GET_LINENO_LNNO (abfd, ext);
}
unsigned _bfd_XXi_swap_lineno_out ( bfd ,
void *  ,
void *   
)

Definition at line 376 of file peXXigen.c.

{
  struct internal_lineno *in = (struct internal_lineno *) inp;
  struct external_lineno *ext = (struct external_lineno *) outp;
  H_PUT_32 (abfd, in->l_addr.l_symndx, ext->l_addr.l_symndx);

  PUT_LINENO_LNNO (abfd, in->l_lnno, ext);
  return LINESZ;
}
unsigned _bfd_XXi_swap_scnhdr_out ( bfd ,
void *  ,
void *   
)

Definition at line 859 of file peXXigen.c.

{
  struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
  SCNHDR *scnhdr_ext = (SCNHDR *) out;
  unsigned int ret = SCNHSZ;
  bfd_vma ps;
  bfd_vma ss;

  memcpy (scnhdr_ext->s_name, scnhdr_int->s_name, sizeof (scnhdr_int->s_name));

  PUT_SCNHDR_VADDR (abfd,
                  ((scnhdr_int->s_vaddr
                    - pe_data (abfd)->pe_opthdr.ImageBase)
                   & 0xffffffff),
                  scnhdr_ext->s_vaddr);

  /* NT wants the size data to be rounded up to the next
     NT_FILE_ALIGNMENT, but zero if it has no content (as in .bss,
     sometimes).  */
  if ((scnhdr_int->s_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA) != 0)
    {
      if (bfd_pe_executable_p (abfd))
       {
         ps = scnhdr_int->s_size;
         ss = 0;
       }
      else
       {
         ps = 0;
         ss = scnhdr_int->s_size;
       }
    }
  else
    {
      if (bfd_pe_executable_p (abfd))
       ps = scnhdr_int->s_paddr;
      else
       ps = 0;

      ss = scnhdr_int->s_size;
    }

  PUT_SCNHDR_SIZE (abfd, ss,
                 scnhdr_ext->s_size);

  /* s_paddr in PE is really the virtual size.  */
  PUT_SCNHDR_PADDR (abfd, ps, scnhdr_ext->s_paddr);

  PUT_SCNHDR_SCNPTR (abfd, scnhdr_int->s_scnptr,
                   scnhdr_ext->s_scnptr);
  PUT_SCNHDR_RELPTR (abfd, scnhdr_int->s_relptr,
                   scnhdr_ext->s_relptr);
  PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr,
                    scnhdr_ext->s_lnnoptr);

  {
    /* Extra flags must be set when dealing with PE.  All sections should also
       have the IMAGE_SCN_MEM_READ (0x40000000) flag set.  In addition, the
       .text section must have IMAGE_SCN_MEM_EXECUTE (0x20000000) and the data
       sections (.idata, .data, .bss, .CRT) must have IMAGE_SCN_MEM_WRITE set
       (this is especially important when dealing with the .idata section since
       the addresses for routines from .dlls must be overwritten).  If .reloc
       section data is ever generated, we must add IMAGE_SCN_MEM_DISCARDABLE
       (0x02000000).  Also, the resource data should also be read and
       writable.  */

    /* FIXME: Alignment is also encoded in this field, at least on PPC and 
       ARM-WINCE.  Although - how do we get the original alignment field
       back ?  */

    typedef struct
    {
      const char *   section_name;
      unsigned long  must_have;
    }
    pe_required_section_flags;
    
    pe_required_section_flags known_sections [] =
      {
       { ".arch",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_ALIGN_8BYTES },
       { ".bss",   IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
       { ".data",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
       { ".edata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
       { ".idata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
       { ".pdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
       { ".rdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
       { ".reloc", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_DISCARDABLE },
       { ".rsrc",  IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
       { ".text" , IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE },
       { ".tls",   IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE },
       { ".xdata", IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA },
       { NULL, 0}
      };

    pe_required_section_flags * p;

    /* We have defaulted to adding the IMAGE_SCN_MEM_WRITE flag, but now
       we know exactly what this specific section wants so we remove it
       and then allow the must_have field to add it back in if necessary.
       However, we don't remove IMAGE_SCN_MEM_WRITE flag from .text if the
       default WP_TEXT file flag has been cleared.  WP_TEXT may be cleared
       by ld --enable-auto-import (if auto-import is actually needed),
       by ld --omagic, or by obcopy --writable-text.  */

    for (p = known_sections; p->section_name; p++)
      if (strcmp (scnhdr_int->s_name, p->section_name) == 0)
       {
         if (strcmp (scnhdr_int->s_name, ".text")
             || (bfd_get_file_flags (abfd) & WP_TEXT))
           scnhdr_int->s_flags &= ~IMAGE_SCN_MEM_WRITE;
         scnhdr_int->s_flags |= p->must_have;
         break;
       }

    H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
  }

  if (coff_data (abfd)->link_info
      && ! coff_data (abfd)->link_info->relocatable
      && ! coff_data (abfd)->link_info->shared
      && strcmp (scnhdr_int->s_name, ".text") == 0)
    {
      /* By inference from looking at MS output, the 32 bit field
        which is the combination of the number_of_relocs and
        number_of_linenos is used for the line number count in
        executables.  A 16-bit field won't do for cc1.  The MS
        document says that the number of relocs is zero for
        executables, but the 17-th bit has been observed to be there.
        Overflow is not an issue: a 4G-line program will overflow a
        bunch of other fields long before this!  */
      H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);
      H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);
    }
  else
    {
      if (scnhdr_int->s_nlnno <= 0xffff)
       H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
      else
       {
         (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),
                             bfd_get_filename (abfd),
                             scnhdr_int->s_nlnno);
         bfd_set_error (bfd_error_file_truncated);
         H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);
         ret = 0;
       }

      /* Although we could encode 0xffff relocs here, we do not, to be
         consistent with other parts of bfd. Also it lets us warn, as
         we should never see 0xffff here w/o having the overflow flag
         set.  */
      if (scnhdr_int->s_nreloc < 0xffff)
       H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
      else
       {
         /* PE can deal with large #s of relocs, but not here.  */
         H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);
         scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;
         H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
       }
    }
  return ret;
}

Here is the call graph for this function:

void _bfd_XXi_swap_sym_in ( bfd ,
void *  ,
void *   
)

Definition at line 95 of file peXXigen.c.

{
  SYMENT *ext = (SYMENT *) ext1;
  struct internal_syment *in = (struct internal_syment *) in1;

  if (ext->e.e_name[0] == 0)
    {
      in->_n._n_n._n_zeroes = 0;
      in->_n._n_n._n_offset = H_GET_32 (abfd, ext->e.e.e_offset);
    }
  else
    memcpy (in->_n._n_name, ext->e.e_name, SYMNMLEN);

  in->n_value = H_GET_32 (abfd, ext->e_value);
  in->n_scnum = H_GET_16 (abfd, ext->e_scnum);

  if (sizeof (ext->e_type) == 2)
    in->n_type = H_GET_16 (abfd, ext->e_type);
  else
    in->n_type = H_GET_32 (abfd, ext->e_type);

  in->n_sclass = H_GET_8 (abfd, ext->e_sclass);
  in->n_numaux = H_GET_8 (abfd, ext->e_numaux);

#ifndef STRICT_PE_FORMAT
  /* This is for Gnu-created DLLs.  */

  /* The section symbols for the .idata$ sections have class 0x68
     (C_SECTION), which MS documentation indicates is a section
     symbol.  Unfortunately, the value field in the symbol is simply a
     copy of the .idata section's flags rather than something useful.
     When these symbols are encountered, change the value to 0 so that
     they will be handled somewhat correctly in the bfd code.  */
  if (in->n_sclass == C_SECTION)
    {
      in->n_value = 0x0;

      /* Create synthetic empty sections as needed.  DJ */
      if (in->n_scnum == 0)
       {
         asection *sec;

         for (sec = abfd->sections; sec; sec = sec->next)
           {
             if (strcmp (sec->name, in->n_name) == 0)
              {
                in->n_scnum = sec->target_index;
                break;
              }
           }
       }

      if (in->n_scnum == 0)
       {
         int unused_section_number = 0;
         asection *sec;
         char *name;
         flagword flags;

         for (sec = abfd->sections; sec; sec = sec->next)
           if (unused_section_number <= sec->target_index)
             unused_section_number = sec->target_index + 1;

         name = bfd_alloc (abfd, (bfd_size_type) strlen (in->n_name) + 10);
         if (name == NULL)
           return;
         strcpy (name, in->n_name);
         flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_DATA | SEC_LOAD;
         sec = bfd_make_section_anyway_with_flags (abfd, name, flags);

         sec->vma = 0;
         sec->lma = 0;
         sec->size = 0;
         sec->filepos = 0;
         sec->rel_filepos = 0;
         sec->reloc_count = 0;
         sec->line_filepos = 0;
         sec->lineno_count = 0;
         sec->userdata = NULL;
         sec->next = NULL;
         sec->alignment_power = 2;

         sec->target_index = unused_section_number;

         in->n_scnum = unused_section_number;
       }
      in->n_sclass = C_STAT;
    }
#endif

#ifdef coff_swap_sym_in_hook
  /* This won't work in peigen.c, but since it's for PPC PE, it's not
     worth fixing.  */
  coff_swap_sym_in_hook (abfd, ext1, in1);
#endif
}

Here is the call graph for this function:

unsigned _bfd_XXi_swap_sym_out ( bfd ,
void *  ,
void *   
)

Definition at line 193 of file peXXigen.c.

{
  struct internal_syment *in = (struct internal_syment *) inp;
  SYMENT *ext = (SYMENT *) extp;

  if (in->_n._n_name[0] == 0)
    {
      H_PUT_32 (abfd, 0, ext->e.e.e_zeroes);
      H_PUT_32 (abfd, in->_n._n_n._n_offset, ext->e.e.e_offset);
    }
  else
    memcpy (ext->e.e_name, in->_n._n_name, SYMNMLEN);

  H_PUT_32 (abfd, in->n_value, ext->e_value);
  H_PUT_16 (abfd, in->n_scnum, ext->e_scnum);

  if (sizeof (ext->e_type) == 2)
    H_PUT_16 (abfd, in->n_type, ext->e_type);
  else
    H_PUT_32 (abfd, in->n_type, ext->e_type);

  H_PUT_8 (abfd, in->n_sclass, ext->e_sclass);
  H_PUT_8 (abfd, in->n_numaux, ext->e_numaux);

  return SYMESZ;
}