Back to index

cell-binutils  2.17cvs20070401
Functions | Variables
pe-dll.h File Reference
#include "bfd.h"
#include "sysdep.h"
#include "bfdlink.h"
#include "deffile.h"
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

void pe_dll_id_target (const char *)
void pe_dll_add_excludes (const char *, const int)
void pe_dll_generate_def_file (const char *)
void pe_dll_generate_implib (def_file *, const char *)
void pe_process_import_defs (bfd *, struct bfd_link_info *)
bfd_boolean pe_implied_import_dll (const char *)
void pe_dll_build_sections (bfd *, struct bfd_link_info *)
void pe_exe_build_sections (bfd *, struct bfd_link_info *)
void pe_dll_fill_sections (bfd *, struct bfd_link_info *)
void pe_exe_fill_sections (bfd *, struct bfd_link_info *)
void pe_walk_relocs_of_symbol (struct bfd_link_info *, const char *, int(*)(arelent *, asection *))
void pe_create_import_fixup (arelent *rel, asection *, int)
bfd_boolean pe_bfd_is_dll (bfd *)

Variables

def_filepe_def_file
int pe_dll_export_everything
int pe_dll_do_default_excludes
int pe_dll_kill_ats
int pe_dll_stdcall_aliases
int pe_dll_warn_dup_exports
int pe_dll_compat_implib
int pe_dll_extra_pe_debug

Function Documentation

Definition at line 2859 of file pe-dll.c.

{
  return (bfd_get_format (abfd) == bfd_object
          && obj_pe (abfd)
          && pe_data (abfd)->dll);
}
void pe_create_import_fixup ( arelent rel,
asection ,
int   
)

Definition at line 2313 of file pe-dll.c.

{
  char buf[300];
  struct bfd_symbol *sym = *rel->sym_ptr_ptr;
  struct bfd_link_hash_entry *name_thunk_sym;
  const char *name = sym->name;
  char *fixup_name = make_import_fixup_mark (rel);
  bfd *b;

  sprintf (buf, U ("_nm_thnk_%s"), name);

  name_thunk_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);

  if (!name_thunk_sym || name_thunk_sym->type != bfd_link_hash_defined)
    {
      bfd *b = make_singleton_name_thunk (name, output_bfd);
      add_bfd_to_link (b, b->filename, &link_info);

      /* If we ever use autoimport, we have to cast text section writable.  */
      config.text_read_only = FALSE;
      output_bfd->flags &= ~WP_TEXT;   
    }

  if (addend == 0 || link_info.pei386_runtime_pseudo_reloc)
    {
      extern char * pe_data_import_dll;
      char * dll_symname = pe_data_import_dll ? pe_data_import_dll : "unknown";

      b = make_import_fixup_entry (name, fixup_name, dll_symname, output_bfd);
      add_bfd_to_link (b, b->filename, &link_info);
    }

  if (addend != 0)
    {
      if (link_info.pei386_runtime_pseudo_reloc)
       {
         if (pe_dll_extra_pe_debug)
           printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
                 fixup_name, addend);
         b = make_runtime_pseudo_reloc (name, fixup_name, addend, output_bfd);
         add_bfd_to_link (b, b->filename, &link_info);

         if (runtime_pseudo_relocs_created == 0)
           {
             b = pe_create_runtime_relocator_reference (output_bfd);
             add_bfd_to_link (b, b->filename, &link_info);
           }
         runtime_pseudo_relocs_created++;
       }
      else
       {
         einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
               s->owner, s, rel->address, sym->name);
         einfo ("%X");
       }
    }
}

Here is the call graph for this function:

void pe_dll_add_excludes ( const char *  ,
const int   
)

Definition at line 427 of file pe-dll.c.

{
  char *local_copy;
  char *exclude_string;

  local_copy = xstrdup (new_excludes);

  exclude_string = strtok (local_copy, ",:");
  for (; exclude_string; exclude_string = strtok (NULL, ",:"))
    {
      struct exclude_list_struct *new_exclude;

      new_exclude = xmalloc (sizeof (struct exclude_list_struct));
      new_exclude->string = xmalloc (strlen (exclude_string) + 1);
      strcpy (new_exclude->string, exclude_string);
      new_exclude->type = type;
      new_exclude->next = excludes;
      excludes = new_exclude;
    }

  free (local_copy);
}

Here is the call graph for this function:

Definition at line 2784 of file pe-dll.c.

Here is the call graph for this function:

Definition at line 2804 of file pe-dll.c.

{
  pe_dll_id_target (bfd_get_target (abfd));
  image_base = pe_data (abfd)->pe_opthdr.ImageBase;

  generate_reloc (abfd, info);
  if (reloc_sz > 0)
    {
      bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);

      /* Resize the sections.  */
      lang_reset_memory_regions ();
      lang_size_sections (NULL, TRUE);

      /* Redo special stuff.  */
      ldemul_after_allocation ();

      /* Do the assignments again.  */
      lang_do_assignments ();
    }

  fill_edata (abfd, info);

  if (info->shared && !info->pie)
    pe_data (abfd)->dll = 1;

  edata_s->contents = edata_d;
  reloc_s->contents = reloc_d;
}

Here is the call graph for this function:

void pe_dll_generate_def_file ( const char *  )

Definition at line 1418 of file pe-dll.c.

{
  int i;
  FILE *out = fopen (pe_out_def_filename, "w");

  if (out == NULL)
    /* xgettext:c-format */
    einfo (_("%s: Can't open output def file %s\n"),
          program_name, pe_out_def_filename);

  if (pe_def_file)
    {
      if (pe_def_file->name)
       {
         if (pe_def_file->is_dll)
           fprintf (out, "LIBRARY ");
         else
           fprintf (out, "NAME ");

         quoteput (pe_def_file->name, out, 1);

         if (pe_data (output_bfd)->pe_opthdr.ImageBase)
           fprintf (out, " BASE=0x%lx",
                   (unsigned long) pe_data (output_bfd)->pe_opthdr.ImageBase);
         fprintf (out, "\n");
       }

      if (pe_def_file->description)
       {
         fprintf (out, "DESCRIPTION ");
         quoteput (pe_def_file->description, out, 1);
         fprintf (out, "\n");
       }

      if (pe_def_file->version_minor != -1)
       fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major,
               pe_def_file->version_minor);
      else if (pe_def_file->version_major != -1)
       fprintf (out, "VERSION %d\n", pe_def_file->version_major);

      if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1)
       fprintf (out, "\n");

      if (pe_def_file->stack_commit != -1)
       fprintf (out, "STACKSIZE 0x%x,0x%x\n",
               pe_def_file->stack_reserve, pe_def_file->stack_commit);
      else if (pe_def_file->stack_reserve != -1)
       fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve);

      if (pe_def_file->heap_commit != -1)
       fprintf (out, "HEAPSIZE 0x%x,0x%x\n",
               pe_def_file->heap_reserve, pe_def_file->heap_commit);
      else if (pe_def_file->heap_reserve != -1)
       fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve);

      if (pe_def_file->num_section_defs > 0)
       {
         fprintf (out, "\nSECTIONS\n\n");

         for (i = 0; i < pe_def_file->num_section_defs; i++)
           {
             fprintf (out, "    ");
             quoteput (pe_def_file->section_defs[i].name, out, 0);

             if (pe_def_file->section_defs[i].class)
              {
                fprintf (out, " CLASS ");
                quoteput (pe_def_file->section_defs[i].class, out, 0);
              }

             if (pe_def_file->section_defs[i].flag_read)
              fprintf (out, " READ");

             if (pe_def_file->section_defs[i].flag_write)
              fprintf (out, " WRITE");

             if (pe_def_file->section_defs[i].flag_execute)
              fprintf (out, " EXECUTE");

             if (pe_def_file->section_defs[i].flag_shared)
              fprintf (out, " SHARED");

             fprintf (out, "\n");
           }
       }

      if (pe_def_file->num_exports > 0)
       {
         fprintf (out, "EXPORTS\n");

         for (i = 0; i < pe_def_file->num_exports; i++)
           {
             def_file_export *e = pe_def_file->exports + i;
             fprintf (out, "    ");
             quoteput (e->name, out, 0);

             if (e->internal_name && strcmp (e->internal_name, e->name))
              {
                fprintf (out, " = ");
                quoteput (e->internal_name, out, 0);
              }

             if (e->ordinal != -1)
              fprintf (out, " @%d", e->ordinal);

             if (e->flag_private)
              fprintf (out, " PRIVATE");

             if (e->flag_constant)
              fprintf (out, " CONSTANT");

             if (e->flag_noname)
              fprintf (out, " NONAME");

             if (e->flag_data)
              fprintf (out, " DATA");

             fprintf (out, "\n");
           }
       }

      if (pe_def_file->num_imports > 0)
       {
         fprintf (out, "\nIMPORTS\n\n");

         for (i = 0; i < pe_def_file->num_imports; i++)
           {
             def_file_import *im = pe_def_file->imports + i;
             fprintf (out, "    ");

             if (im->internal_name
                && (!im->name || strcmp (im->internal_name, im->name)))
              {
                quoteput (im->internal_name, out, 0);
                fprintf (out, " = ");
              }

             quoteput (im->module->name, out, 0);
             fprintf (out, ".");

             if (im->name)
              quoteput (im->name, out, 0);
             else
              fprintf (out, "%d", im->ordinal);

             fprintf (out, "\n");
           }
       }
    }
  else
    fprintf (out, _("; no contents available\n"));

  if (fclose (out) == EOF)
    /* xgettext:c-format */
    einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename);
}

Here is the call graph for this function:

void pe_dll_generate_implib ( def_file ,
const char *   
)

Definition at line 2373 of file pe-dll.c.

{
  int i;
  bfd *ar_head;
  bfd *ar_tail;
  bfd *outarch;
  bfd *head = 0;

  dll_filename = (def->name) ? def->name : dll_name;
  dll_symname = xstrdup (dll_filename);
  for (i = 0; dll_symname[i]; i++)
    if (!ISALNUM (dll_symname[i]))
      dll_symname[i] = '_';

  unlink_if_ordinary (impfilename);

  outarch = bfd_openw (impfilename, 0);

  if (!outarch)
    {
      /* xgettext:c-format */
      einfo (_("%XCan't open .lib file: %s\n"), impfilename);
      return;
    }

  /* xgettext:c-format */
  info_msg (_("Creating library file: %s\n"), impfilename);
 
  bfd_set_format (outarch, bfd_archive);
  outarch->has_armap = 1;

  /* Work out a reasonable size of things to put onto one line.  */
  ar_head = make_head (outarch);

  for (i = 0; i < def->num_exports; i++)
    {
      /* The import library doesn't know about the internal name.  */
      char *internal = def->exports[i].internal_name;
      bfd *n;

      /* Don't add PRIVATE entries to import lib.  */   
      if (pe_def_file->exports[i].flag_private)
       continue;
      def->exports[i].internal_name = def->exports[i].name;
      n = make_one (def->exports + i, outarch,
                  ! (def->exports + i)->flag_data);
      n->next = head;
      head = n;
      def->exports[i].internal_name = internal;
    }

  ar_tail = make_tail (outarch);

  if (ar_head == NULL || ar_tail == NULL)
    return;

  /* Now stick them all into the archive.  */
  ar_head->next = head;
  ar_tail->next = ar_head;
  head = ar_tail;

  if (! bfd_set_archive_head (outarch, head))
    einfo ("%Xbfd_set_archive_head: %E\n");

  if (! bfd_close (outarch))
    einfo ("%Xbfd_close %s: %E\n", impfilename);

  while (head != NULL)
    {
      bfd *n = head->next;
      bfd_close (head);
      head = n;
    }
}

Here is the call graph for this function:

void pe_dll_id_target ( const char *  )

Definition at line 356 of file pe-dll.c.

{
  int i;

  for (i = 0; pe_detail_list[i].target_name; i++)
    if (strcmp (pe_detail_list[i].target_name, target) == 0
       || strcmp (pe_detail_list[i].object_target, target) == 0)
      {
       pe_details = pe_detail_list + i;
       return;
      }
  einfo (_("%XUnsupported PEI architecture: %s\n"), target);
  exit (1);
}

Here is the call graph for this function:

Definition at line 2835 of file pe-dll.c.

{
  pe_dll_id_target (bfd_get_target (abfd));
  image_base = pe_data (abfd)->pe_opthdr.ImageBase;

  generate_reloc (abfd, info);
  if (reloc_sz > 0)
    {
      bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);

      /* Resize the sections.  */
      lang_reset_memory_regions ();
      lang_size_sections (NULL, TRUE);

      /* Redo special stuff.  */
      ldemul_after_allocation ();

      /* Do the assignments again.  */
      lang_do_assignments ();
    }
  reloc_s->contents = reloc_d;
}

Here is the call graph for this function:

Definition at line 2590 of file pe-dll.c.

{
  bfd *dll;
  unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
  unsigned long export_rva, export_size, nsections, secptr, expptr;
  unsigned long exp_funcbase;
  unsigned char *expdata;
  char *erva;
  unsigned long name_rvas, ordinals, nexp, ordbase;
  const char *dll_name;
  /* Initialization with start > end guarantees that is_data
     will not be set by mistake, and avoids compiler warning.  */
  unsigned long data_start = 1;
  unsigned long data_end = 0;
  unsigned long rdata_start = 1;
  unsigned long rdata_end = 0;
  unsigned long bss_start = 1;
  unsigned long bss_end = 0;

  /* No, I can't use bfd here.  kernel32.dll puts its export table in
     the middle of the .rdata section.  */
  dll = bfd_openr (filename, pe_details->target_name);
  if (!dll)
    {
      einfo ("%Xopen %s: %E\n", filename);
      return FALSE;
    }

  /* PEI dlls seem to be bfd_objects.  */
  if (!bfd_check_format (dll, bfd_object))
    {
      einfo ("%X%s: this doesn't appear to be a DLL\n", filename);
      return FALSE;
    }

  /* Get pe_header, optional header and numbers of export entries.  */
  pe_header_offset = pe_get32 (dll, 0x3c);
  opthdr_ofs = pe_header_offset + 4 + 20;
#ifdef pe_use_x86_64
  num_entries = pe_get32 (dll, opthdr_ofs + 92 + 4 * 4); /*  & NumberOfRvaAndSizes.  */
#else
  num_entries = pe_get32 (dll, opthdr_ofs + 92);
#endif

  if (num_entries < 1) /* No exports.  */
    return FALSE;

#ifdef pe_use_x86_64
  export_rva  = pe_get32 (dll, opthdr_ofs + 96 + 4 * 4);
  export_size = pe_get32 (dll, opthdr_ofs + 100 + 4 * 4);
#else
  export_rva = pe_get32 (dll, opthdr_ofs + 96);
  export_size = pe_get32 (dll, opthdr_ofs + 100);
#endif
  
  nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
  secptr = (pe_header_offset + 4 + 20 +
           pe_get16 (dll, pe_header_offset + 4 + 16));
  expptr = 0;

  /* Get the rva and size of the export section.  */
  for (i = 0; i < nsections; i++)
    {
      char sname[8];
      unsigned long secptr1 = secptr + 40 * i;
      unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
      unsigned long vsize = pe_get32 (dll, secptr1 + 16);
      unsigned long fptr = pe_get32 (dll, secptr1 + 20);

      bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
      bfd_bread (sname, (bfd_size_type) 8, dll);

      if (vaddr <= export_rva && vaddr + vsize > export_rva)
       {
         expptr = fptr + (export_rva - vaddr);
         if (export_rva + export_size > vaddr + vsize)
           export_size = vsize - (export_rva - vaddr);
         break;
       }
    }

  /* Scan sections and store the base and size of the
     data and bss segments in data/base_start/end.  */
  for (i = 0; i < nsections; i++)
    {
      unsigned long secptr1 = secptr + 40 * i;
      unsigned long vsize = pe_get32 (dll, secptr1 + 8);
      unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
      unsigned long flags = pe_get32 (dll, secptr1 + 36);
      char sec_name[9];

      sec_name[8] = '\0';
      bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET);
      bfd_bread (sec_name, (bfd_size_type) 8, dll);

      if (strcmp(sec_name,".data") == 0)
       {
         data_start = vaddr;
         data_end = vaddr + vsize;

         if (pe_dll_extra_pe_debug)
           printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
                  __FUNCTION__, sec_name, vaddr, vaddr + vsize, flags);
       }
      else if (strcmp(sec_name,".rdata") == 0)
       {
         rdata_start = vaddr;
         rdata_end = vaddr + vsize;

         if (pe_dll_extra_pe_debug)
           printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
                  __FUNCTION__, sec_name, vaddr, vaddr + vsize, flags);
       }
      else if (strcmp (sec_name,".bss") == 0)
       {
         bss_start = vaddr;
         bss_end = vaddr + vsize;

         if (pe_dll_extra_pe_debug)
           printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
                  __FUNCTION__, sec_name, vaddr, vaddr + vsize, flags);
       }
    }

  expdata = xmalloc (export_size);
  bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
  bfd_bread (expdata, (bfd_size_type) export_size, dll);
  erva = (char *) expdata - export_rva;

  if (pe_def_file == 0)
    pe_def_file = def_file_empty ();

  nexp = pe_as32 (expdata + 24);
  name_rvas = pe_as32 (expdata + 32);
  ordinals = pe_as32 (expdata + 36);
  ordbase = pe_as32 (expdata + 16);
  exp_funcbase = pe_as32 (expdata + 28);

  /* Use internal dll name instead of filename
     to enable symbolic dll linking.  */
  dll_name = erva + pe_as32 (expdata + 12);

  /* Check to see if the dll has already been added to
     the definition list and if so return without error.
     This avoids multiple symbol definitions.  */
  if (def_get_module (pe_def_file, dll_name))
    {
      if (pe_dll_extra_pe_debug)
       printf ("%s is already loaded\n", dll_name);
      return TRUE;
    }

  /* Iterate through the list of symbols.  */
  for (i = 0; i < nexp; i++)
    {
      /* Pointer to the names vector.  */
      unsigned long name_rva = pe_as32 (erva + name_rvas + i * 4);
      def_file_import *imp;
      /* Pointer to the function address vector.  */
      unsigned long func_rva = pe_as32 (erva + exp_funcbase + i * 4);
      int is_data = 0;

      /* Skip unwanted symbols, which are
        exported in buggy auto-import releases.  */
      if (! CONST_STRNEQ (erva + name_rva, "_nm_"))
       {
         /* is_data is true if the address is in the data, rdata or bss
            segment.  */
         is_data =
           (func_rva >= data_start && func_rva < data_end)
           || (func_rva >= rdata_start && func_rva < rdata_end)
           || (func_rva >= bss_start && func_rva < bss_end);

         imp = def_file_add_import (pe_def_file, erva + name_rva,
                                 dll_name, i, 0);
         /* Mark symbol type.  */
         imp->data = is_data;

         if (pe_dll_extra_pe_debug)
           printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
                  __FUNCTION__, dll_name, erva + name_rva,
                  func_rva, is_data ? "(data)" : "");
       }
    }

  return TRUE;
}

Here is the call graph for this function:

Definition at line 2464 of file pe-dll.c.

{
  def_file_module *module;

  pe_dll_id_target (bfd_get_target (output_bfd));

  if (!pe_def_file)
    return;

  for (module = pe_def_file->modules; module; module = module->next)
    {
      int i, do_this_dll;

      dll_filename = module->name;
      dll_symname = xstrdup (module->name);
      for (i = 0; dll_symname[i]; i++)
       if (!ISALNUM (dll_symname[i]))
         dll_symname[i] = '_';

      do_this_dll = 0;

      for (i = 0; i < pe_def_file->num_imports; i++)
       if (pe_def_file->imports[i].module == module)
         {
           def_file_export exp;
           struct bfd_link_hash_entry *blhe;
           int lead_at = (*pe_def_file->imports[i].internal_name == '@');
           /* See if we need this import.  */
           size_t len = strlen (pe_def_file->imports[i].internal_name);
           char *name = xmalloc (len + 2 + 6);
           bfd_boolean include_jmp_stub = FALSE;

           if (lead_at)
             sprintf (name, "%s",
                     pe_def_file->imports[i].internal_name);
           else
             sprintf (name, "%s%s",U (""),
                     pe_def_file->imports[i].internal_name);

           blhe = bfd_link_hash_lookup (link_info->hash, name,
                                    FALSE, FALSE, FALSE);

           /* Include the jump stub for <sym> only if the <sym>
              is undefined.  */
           if (!blhe || (blhe && blhe->type != bfd_link_hash_undefined))
             {
              if (lead_at)
                sprintf (name, "%s%s", "__imp_", 
                        pe_def_file->imports[i].internal_name);
              else
                sprintf (name, "%s%s%s", "__imp_", U (""),
                        pe_def_file->imports[i].internal_name);

              blhe = bfd_link_hash_lookup (link_info->hash, name,
                                        FALSE, FALSE, FALSE);
             }
           else
             include_jmp_stub = TRUE;

           free (name);

           if (blhe && blhe->type == bfd_link_hash_undefined)
             {
              bfd *one;
              /* We do.  */
              if (!do_this_dll)
                {
                  bfd *ar_head = make_head (output_bfd);
                  add_bfd_to_link (ar_head, ar_head->filename, link_info);
                  do_this_dll = 1;
                }
              exp.internal_name = pe_def_file->imports[i].internal_name;
              exp.name = pe_def_file->imports[i].name;
              exp.ordinal = pe_def_file->imports[i].ordinal;
              exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
              exp.flag_private = 0;
              exp.flag_constant = 0;
              exp.flag_data = pe_def_file->imports[i].data;
              exp.flag_noname = exp.name ? 0 : 1;
              one = make_one (&exp, output_bfd, (! exp.flag_data) && include_jmp_stub);
              add_bfd_to_link (one, one->filename, link_info);
             }
         }
      if (do_this_dll)
       {
         bfd *ar_tail = make_tail (output_bfd);
         add_bfd_to_link (ar_tail, ar_tail->filename, link_info);
       }

      free (dll_symname);
    }
}

Here is the call graph for this function:

void pe_walk_relocs_of_symbol ( struct bfd_link_info ,
const char *  ,
int(*)(arelent *, asection *)   
)

Definition at line 1119 of file pe-dll.c.

{
  bfd *b;
  asection *s;

  for (b = info->input_bfds; b; b = b->link_next)
    {
      asymbol **symbols;
      int nsyms, symsize;

      symsize = bfd_get_symtab_upper_bound (b);
      symbols = xmalloc (symsize);
      nsyms   = bfd_canonicalize_symtab (b, symbols);

      for (s = b->sections; s; s = s->next)
       {
         arelent **relocs;
         int relsize, nrelocs, i;
         int flags = bfd_get_section_flags (b, s);

         /* Skip discarded linkonce sections.  */
         if (flags & SEC_LINK_ONCE
             && s->output_section == bfd_abs_section_ptr)
           continue;

         current_sec = s;

         relsize = bfd_get_reloc_upper_bound (b, s);
         relocs = xmalloc (relsize);
         nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);

         for (i = 0; i < nrelocs; i++)
           {
             struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;

             if (!strcmp (name, sym->name))
              cb (relocs[i], s);
           }

         free (relocs);

         /* Warning: the allocated symbols are remembered in BFD and reused
            later, so don't free them! */
         /* free (symbols); */
       }
    }
}

Here is the call graph for this function:


Variable Documentation

Definition at line 151 of file pe-dll.c.

Definition at line 157 of file pe-dll.c.

Definition at line 153 of file pe-dll.c.

Definition at line 152 of file pe-dll.c.

Definition at line 158 of file pe-dll.c.

Definition at line 154 of file pe-dll.c.

Definition at line 155 of file pe-dll.c.

Definition at line 156 of file pe-dll.c.