Back to index

cell-binutils  2.17cvs20070401
Classes | Defines | Typedefs | Functions | Variables
dlltool.c File Reference
#include "bfd.h"
#include "libiberty.h"
#include "bucomm.h"
#include "getopt.h"
#include "demangle.h"
#include "dyn-string.h"
#include "dlltool.h"
#include "safe-ctype.h"
#include <time.h>
#include <sys/stat.h>
#include <stdarg.h>
#include <assert.h>

Go to the source code of this file.

Classes

struct  ifunct
struct  iheadt
struct  mac
struct  dlist
struct  export
struct  string_list
struct  sinfo

Defines

#define show_allnames   0
#define PAGE_SIZE   4096
#define PAGE_MASK   (-PAGE_SIZE)
#define WIFEXITED(w)   (((w) & 0377) == 0)
#define WIFSIGNALED(w)   (((w) & 0377) != 0177 && ((w) & ~0377) == 0)
#define WTERMSIG(w)   ((w) & 0177)
#define WEXITSTATUS(w)   (((w) >> 8) & 0377)
#define DRECTVE_SECTION_NAME   ".drectve"
#define PATHMAX   250
#define PREFIX_ALIAS_BASE   20000
#define TMP_ASM   dlltmp (&tmp_asm_buf, "%sc.s")
#define TMP_HEAD_S   dlltmp (&tmp_head_s_buf, "%sh.s")
#define TMP_HEAD_O   dlltmp (&tmp_head_o_buf, "%sh.o")
#define TMP_TAIL_S   dlltmp (&tmp_tail_s_buf, "%st.s")
#define TMP_TAIL_O   dlltmp (&tmp_tail_o_buf, "%st.o")
#define TMP_STUB   dlltmp (&tmp_stub_buf, "%ss")
#define MARM   0
#define M386   1
#define MPPC   2
#define MTHUMB   3
#define MARM_INTERWORK   4
#define MMCORE_BE   5
#define MMCORE_LE   6
#define MMCORE_ELF   7
#define MMCORE_ELF_LE   8
#define MARM_EPOC   9
#define MARM_WINCE   10
#define MX86   11
#define ASM_BYTE   mtable[machine].how_byte
#define ASM_SHORT   mtable[machine].how_short
#define ASM_LONG   mtable[machine].how_long
#define ASM_TEXT   mtable[machine].how_asciz
#define ASM_C   mtable[machine].how_comment
#define ASM_JUMP   mtable[machine].how_jump
#define ASM_GLOBAL   mtable[machine].how_global
#define ASM_SPACE   mtable[machine].how_space
#define ASM_ALIGN_SHORT   mtable[machine].how_align_short
#define ASM_RVA_BEFORE   rvabefore (machine)
#define ASM_RVA_AFTER   rvaafter (machine)
#define ASM_PREFIX(NAME)   asm_prefix (machine, (NAME))
#define ASM_ALIGN_LONG   mtable[machine].how_align_long
#define HOW_BFD_READ_TARGET   0 /* Always default. */
#define HOW_BFD_WRITE_TARGET   mtable[machine].how_bfd_target
#define HOW_BFD_ARCH   mtable[machine].how_bfd_arch
#define HOW_JTAB   mtable[machine].how_jtab
#define HOW_JTAB_SIZE   mtable[machine].how_jtab_size
#define HOW_JTAB_ROFF   mtable[machine].how_jtab_roff
#define ASM_SWITCHES   mtable[machine].how_default_as_switches
#define TEXT   0
#define DATA   1
#define BSS   2
#define IDATA7   3
#define IDATA5   4
#define IDATA4   5
#define IDATA6   6
#define NSECS   7
#define TEXT_SEC_FLAGS   (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY | SEC_HAS_CONTENTS)
#define DATA_SEC_FLAGS   (SEC_ALLOC | SEC_LOAD | SEC_DATA)
#define BSS_SEC_FLAGS   SEC_ALLOC
#define INIT_SEC_DATA(id, name, flags, align)   { id, name, flags, align, NULL, NULL, NULL, 0, NULL }
#define EXTRA   0
#define OPTION_EXPORT_ALL_SYMS   150
#define OPTION_NO_EXPORT_ALL_SYMS   (OPTION_EXPORT_ALL_SYMS + 1)
#define OPTION_EXCLUDE_SYMS   (OPTION_NO_EXPORT_ALL_SYMS + 1)
#define OPTION_NO_DEFAULT_EXCLUDES   (OPTION_EXCLUDE_SYMS + 1)
#define OPTION_ADD_STDCALL_UNDERSCORE   (OPTION_NO_DEFAULT_EXCLUDES + 1)

Typedefs

typedef struct ifunct ifunctype
typedef struct iheadt iheadtype
typedef struct dlist dlist_type
typedef struct export export_type

Functions

static char * look_for_prog (const char *, const char *, int)
static char * deduce_name (const char *)
static const char * rvaafter (int)
static const char * rvabefore (int)
static const char * asm_prefix (int, const char *)
static void process_def_file (const char *)
static void new_directive (char *)
static void append_import (const char *, const char *, int)
static void run (const char *, char *)
static void scan_drectve_symbols (bfd *)
static void scan_filtered_symbols (bfd *, void *, long, unsigned int)
static void add_excludes (const char *)
static bfd_boolean match_exclude (const char *)
static void set_default_excludes (void)
static long filter_symbols (bfd *, void *, long, unsigned int)
static void scan_all_symbols (bfd *)
static void scan_open_obj_file (bfd *)
static void scan_obj_file (const char *)
static void dump_def_info (FILE *)
static int sfunc (const void *, const void *)
static void flush_page (FILE *, long *, int, int)
static void gen_def_file (void)
static void generate_idata_ofile (FILE *)
static void assemble_file (const char *, const char *)
static void gen_exp_file (void)
static const char * xlate (const char *)
static char * make_label (const char *, const char *)
static char * make_imp_label (const char *, const char *)
static bfdmake_one_lib_file (export_type *, int)
static bfdmake_head (void)
static bfdmake_tail (void)
static void gen_lib_file (void)
static int pfunc (const void *, const void *)
static int nfunc (const void *, const void *)
static void remove_null_names (export_type **)
static void process_duplicates (export_type **)
static void fill_ordinals (export_type **)
static void mangle_defs (void)
static void usage (FILE *, int)
static void inform (const char *,...)
static char * dlltmp (char **buf, const char *fmt)
static void inform VPARAMS ((const char *message,...))
int yyerror (const char *err ATTRIBUTE_UNUSED)
void def_exports (const char *name, const char *internal_name, int ordinal, int noname, int constant, int data, int private)
static void set_dll_name_from_def (const char *name)
void def_name (const char *name, int base)
void def_library (const char *name, int base)
void def_description (const char *desc)
void def_heapsize (int reserve, int commit)
void def_stacksize (int reserve, int commit)
void def_import (const char *app_name, const char *module, const char *dllext, const char *entry, int ord_val)
void def_version (int major, int minor)
void def_section (const char *name, int attr)
void def_code (int attr)
void def_data (int attr)
int main (int, char **)

Variables

static iheadtypeimport_list = NULL
static char * as_name = NULL
static char * as_flags = ""
static char * tmp_prefix
static int no_idata4
static int no_idata5
static char * exp_name
static char * imp_name
static char * head_label
static char * imp_name_lab
static char * dll_name
static int add_indirect = 0
static int add_underscore = 0
static int add_stdcall_underscore = 0
static int dontdeltemps = 0
static bfd_boolean export_all_symbols
static bfd_boolean do_default_excludes = TRUE
static const char * default_excludes = "DllMain@12,DllEntryPoint@0,impure_ptr"
static bfd_boolean create_compat_implib
static char * def_file
char * program_name
static int machine
static int killat
static int add_stdcall_alias
static const char * ext_prefix_alias
static int verbose
static FILE * output_def
static FILE * base_file
char * tmp_asm_buf
char * tmp_head_s_buf
char * tmp_head_o_buf
char * tmp_tail_s_buf
char * tmp_tail_o_buf
char * tmp_stub_buf
static const unsigned char i386_jtab []
static const unsigned char arm_jtab []
static const unsigned char arm_interwork_jtab []
static const unsigned char thumb_jtab []
static const unsigned char mcore_be_jtab []
static const unsigned char mcore_le_jtab []
static const unsigned char ppc_jtab []
static struct mac []
static struct string_listexcludes
static char ** oav
static int d_nfuncs
static int d_named_nfuncs
static int d_low_ord
static int d_high_ord
static export_typed_exports
static export_type ** d_exports_lexically
static dlist_typed_list
static dlist_typea_list
static int d_nforwards = 0
static int d_is_dll
static int d_is_exe
static sinfo secdata [NSECS]
static struct option []

Class Documentation

struct ifunct

Definition at line 324 of file dlltool.c.

Collaboration diagram for ifunct:
Class Members
char * name
struct ifunct * next
int ord
struct iheadt

Definition at line 331 of file dlltool.c.

Collaboration diagram for iheadt:
Class Members
char * dllname
struct ifunct * funchead
struct ifunct * functail
struct iheadt * next
long nfuncs
struct mac

Definition at line 531 of file dlltool.c.

Class Members
const char * how_align_long
const char * how_align_short
const char * how_asciz
const char * how_bfd_target
const char * how_byte
const char * how_comment
const char * how_default_as_switches
const char * how_global
const char * how_jump
const char * how_long
const char * how_short
const char * how_space
const char * type
struct dlist

Definition at line 663 of file dlltool.c.

Collaboration diagram for dlist:
Class Members
struct dlist * next
char * text
struct export

Definition at line 670 of file dlltool.c.

Collaboration diagram for export:
Class Members
int constant
int data
int forward
int hint
const char * import_name
const char * internal_name
const char * name
struct export * next
int noname
int ordinal
int private
struct string_list

Definition at line 688 of file dlltool.c.

Collaboration diagram for string_list:
Class Members
struct string_list * next
char * string
struct sinfo

Definition at line 2073 of file dlltool.c.

Collaboration diagram for sinfo:
Class Members
int align
unsigned char * data
int flags
int id
const char * name
asection * sec
int size
asymbol * sym
asymbol ** sympp

Define Documentation

#define ASM_ALIGN_LONG   mtable[machine].how_align_long

Definition at line 871 of file dlltool.c.

#define ASM_ALIGN_SHORT   mtable[machine].how_align_short

Definition at line 867 of file dlltool.c.

#define ASM_BYTE   mtable[machine].how_byte

Definition at line 859 of file dlltool.c.

#define ASM_C   mtable[machine].how_comment

Definition at line 863 of file dlltool.c.

#define ASM_GLOBAL   mtable[machine].how_global

Definition at line 865 of file dlltool.c.

#define ASM_JUMP   mtable[machine].how_jump

Definition at line 864 of file dlltool.c.

#define ASM_LONG   mtable[machine].how_long

Definition at line 861 of file dlltool.c.

#define ASM_PREFIX (   NAME)    asm_prefix (machine, (NAME))

Definition at line 870 of file dlltool.c.

#define ASM_RVA_AFTER   rvaafter (machine)

Definition at line 869 of file dlltool.c.

Definition at line 868 of file dlltool.c.

#define ASM_SHORT   mtable[machine].how_short

Definition at line 860 of file dlltool.c.

#define ASM_SPACE   mtable[machine].how_space

Definition at line 866 of file dlltool.c.

#define ASM_SWITCHES   mtable[machine].how_default_as_switches

Definition at line 878 of file dlltool.c.

#define ASM_TEXT   mtable[machine].how_asciz

Definition at line 862 of file dlltool.c.

#define BSS   2

Definition at line 2090 of file dlltool.c.

#define BSS_SEC_FLAGS   SEC_ALLOC

Definition at line 2101 of file dlltool.c.

CODE data DATA bss ALLOC newvars BLOCK vectors BLOCK clink CLINK blksect DATA   1

Definition at line 2089 of file dlltool.c.

Definition at line 2100 of file dlltool.c.

#define DRECTVE_SECTION_NAME   ".drectve"

Definition at line 436 of file dlltool.c.

#define EXTRA   0
#define HOW_BFD_ARCH   mtable[machine].how_bfd_arch

Definition at line 874 of file dlltool.c.

#define HOW_BFD_READ_TARGET   0 /* Always default. */

Definition at line 872 of file dlltool.c.

#define HOW_BFD_WRITE_TARGET   mtable[machine].how_bfd_target

Definition at line 873 of file dlltool.c.

#define HOW_JTAB   mtable[machine].how_jtab

Definition at line 875 of file dlltool.c.

#define HOW_JTAB_ROFF   mtable[machine].how_jtab_roff

Definition at line 877 of file dlltool.c.

#define HOW_JTAB_SIZE   mtable[machine].how_jtab_size

Definition at line 876 of file dlltool.c.

#define IDATA4   5

Definition at line 2093 of file dlltool.c.

#define IDATA5   4

Definition at line 2092 of file dlltool.c.

#define IDATA6   6

Definition at line 2094 of file dlltool.c.

#define IDATA7   3

Definition at line 2091 of file dlltool.c.

#define INIT_SEC_DATA (   id,
  name,
  flags,
  align 
)    { id, name, flags, align, NULL, NULL, NULL, 0, NULL }

Definition at line 2103 of file dlltool.c.

#define M386   1
#define MARM   0
#define MARM_EPOC   9
#define MARM_INTERWORK   4
#define MARM_WINCE   10
#define MMCORE_BE   5
#define MMCORE_ELF   7
#define MMCORE_ELF_LE   8
#define MMCORE_LE   6
#define MPPC   2
#define MTHUMB   3
#define MX86   11
#define NSECS   7

Definition at line 2096 of file dlltool.c.

Definition at line 3179 of file dlltool.c.

Definition at line 3177 of file dlltool.c.

#define OPTION_EXPORT_ALL_SYMS   150

Definition at line 3175 of file dlltool.c.

Definition at line 3178 of file dlltool.c.

Definition at line 3176 of file dlltool.c.

#define PAGE_MASK   (-PAGE_SIZE)

Definition at line 245 of file dlltool.c.

#define PAGE_SIZE   4096

Definition at line 244 of file dlltool.c.

#define PATHMAX   250

Definition at line 440 of file dlltool.c.

#define PREFIX_ALIAS_BASE   20000

Definition at line 443 of file dlltool.c.

#define show_allnames   0

Definition at line 242 of file dlltool.c.

#define TEXT   0

Definition at line 2088 of file dlltool.c.

Definition at line 2098 of file dlltool.c.

#define TMP_ASM   dlltmp (&tmp_asm_buf, "%sc.s")

Definition at line 452 of file dlltool.c.

#define TMP_HEAD_O   dlltmp (&tmp_head_o_buf, "%sh.o")

Definition at line 454 of file dlltool.c.

#define TMP_HEAD_S   dlltmp (&tmp_head_s_buf, "%sh.s")

Definition at line 453 of file dlltool.c.

#define TMP_STUB   dlltmp (&tmp_stub_buf, "%ss")

Definition at line 457 of file dlltool.c.

#define TMP_TAIL_O   dlltmp (&tmp_tail_o_buf, "%st.o")

Definition at line 456 of file dlltool.c.

#define TMP_TAIL_S   dlltmp (&tmp_tail_s_buf, "%st.s")

Definition at line 455 of file dlltool.c.

#define WEXITSTATUS (   w)    (((w) >> 8) & 0377)

Definition at line 291 of file dlltool.c.

#define WIFEXITED (   w)    (((w) & 0377) == 0)

Definition at line 282 of file dlltool.c.

#define WIFSIGNALED (   w)    (((w) & 0377) != 0177 && ((w) & ~0377) == 0)

Definition at line 285 of file dlltool.c.

#define WTERMSIG (   w)    ((w) & 0177)

Definition at line 288 of file dlltool.c.


Typedef Documentation


Function Documentation

static void add_excludes ( const char *  new_excludes) [static]

Definition at line 1361 of file dlltool.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 string_list *new_exclude;

      new_exclude = ((struct string_list *)
                   xmalloc (sizeof (struct string_list)));
      new_exclude->string = (char *) xmalloc (strlen (exclude_string) + 2);
      /* Don't add a leading underscore for fastcall symbols.  */
      if (*exclude_string == '@')
       sprintf (new_exclude->string, "%s", exclude_string);
      else
       sprintf (new_exclude->string, "_%s", exclude_string);
      new_exclude->next = excludes;
      excludes = new_exclude;

      /* xgettext:c-format */
      inform (_("Excluding symbol: %s"), exclude_string);
    }

  free (local_copy);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void append_import ( const char *  symbol_name,
const char *  dll_name,
int  func_ordinal 
) [static]

Definition at line 1037 of file dlltool.c.

{
  iheadtype **pq;
  iheadtype *q;

  for (pq = &import_list; *pq != NULL; pq = &(*pq)->next)
    {
      if (strcmp ((*pq)->dllname, dll_name) == 0)
       {
         q = *pq;
         q->functail->next = xmalloc (sizeof (ifunctype));
         q->functail = q->functail->next;
         q->functail->ord  = func_ordinal;
         q->functail->name = xstrdup (symbol_name);
         q->functail->next = NULL;
         q->nfuncs++;
         return;
       }
    }

  q = xmalloc (sizeof (iheadtype));
  q->dllname = xstrdup (dll_name);
  q->nfuncs = 1;
  q->funchead = xmalloc (sizeof (ifunctype));
  q->functail = q->funchead;
  q->next = NULL;
  q->functail->name = xstrdup (symbol_name);
  q->functail->ord  = func_ordinal;
  q->functail->next = NULL;

  *pq = q;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static const char * asm_prefix ( int  machine,
const char *  name 
) [static]

Definition at line 829 of file dlltool.c.

{
  switch (machine)
    {
    case MARM:
    case MPPC:
    case MTHUMB:
    case MARM_INTERWORK:
    case MMCORE_BE:
    case MMCORE_LE:
    case MMCORE_ELF:
    case MMCORE_ELF_LE:
    case MARM_EPOC:
    case MARM_WINCE:
      break;
    case M386:
    case MX86:
      /* Symbol names starting with ? do not have a leading underscore. */
      if (name && *name == '?')
        break;
      else
        return "_";
    default:
      /* xgettext:c-format */
      fatal (_("Internal error: Unknown machine type: %d"), machine);
      break;
    }
  return "";
}

Here is the call graph for this function:

static void assemble_file ( const char *  source,
const char *  dest 
) [static]

Definition at line 1791 of file dlltool.c.

{
  char * cmd;

  cmd = (char *) alloca (strlen (ASM_SWITCHES) + strlen (as_flags)
                      + strlen (source) + strlen (dest) + 50);

  sprintf (cmd, "%s %s -o %s %s", ASM_SWITCHES, as_flags, dest, source);

  run (as_name, cmd);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char * deduce_name ( const char *  prog_name) [static]

Definition at line 3510 of file dlltool.c.

{
  char *cmd;
  char *dash, *slash, *cp;

  dash = NULL;
  slash = NULL;
  for (cp = program_name; *cp != '\0'; ++cp)
    {
      if (*cp == '-')
       dash = cp;
      if (
#if defined(__DJGPP__) || defined (__CYGWIN__) || defined(__WIN32__)
         *cp == ':' || *cp == '\\' ||
#endif
         *cp == '/')
       {
         slash = cp;
         dash = NULL;
       }
    }

  cmd = NULL;

  if (dash != NULL)
    {
      /* First, try looking for a prefixed PROG_NAME in the
         PROGRAM_NAME directory, with the same prefix as PROGRAM_NAME.  */
      cmd = look_for_prog (prog_name, program_name, dash - program_name + 1);
    }

  if (slash != NULL && cmd == NULL)
    {
      /* Next, try looking for a PROG_NAME in the same directory as
         that of this program.  */
      cmd = look_for_prog (prog_name, program_name, slash - program_name + 1);
    }

  if (cmd == NULL)
    {
      /* Just return PROG_NAME as is.  */
      cmd = xstrdup (prog_name);
    }

  return cmd;
}

Here is the call graph for this function:

void def_code ( int  attr)

Definition at line 1154 of file dlltool.c.

{

  def_section ("CODE", attr);
}

Here is the call graph for this function:

void def_data ( int  attr)

Definition at line 1161 of file dlltool.c.

{
  def_section ("DATA", attr);
}

Here is the call graph for this function:

void def_description ( const char *  desc)

Definition at line 994 of file dlltool.c.

{
  dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
  d->text = xstrdup (desc);
  d->next = d_list;
  d_list = d;
}

Here is the call graph for this function:

void def_exports ( const char *  name,
const char *  internal_name,
int  ordinal,
int  noname,
int  constant,
int  data,
int  private 
)

Definition at line 928 of file dlltool.c.

{
  struct export *p = (struct export *) xmalloc (sizeof (*p));

  p->name = name;
  p->internal_name = internal_name ? internal_name : name;
  p->import_name = name;
  p->ordinal = ordinal;
  p->constant = constant;
  p->noname = noname;
  p->private = private;
  p->data = data;
  p->next = d_exports;
  d_exports = p;
  d_nfuncs++;

  if ((internal_name != NULL)
      && (strchr (internal_name, '.') != NULL))
    p->forward = ++d_nforwards;
  else
    p->forward = 0; /* no forward */
}

Here is the call graph for this function:

Here is the caller graph for this function:

void def_heapsize ( int  reserve,
int  commit 
)

Definition at line 1012 of file dlltool.c.

{
  char b[200];
  if (commit > 0)
    sprintf (b, "-heap 0x%x,0x%x ", reserve, commit);
  else
    sprintf (b, "-heap 0x%x ", reserve);
  new_directive (xstrdup (b));
}

Here is the call graph for this function:

void def_import ( const char *  app_name,
const char *  module,
const char *  dllext,
const char *  entry,
int  ord_val 
)

Definition at line 1101 of file dlltool.c.

{
  const char *application_name;
  char *buf;

  if (entry != NULL)
    application_name = entry;
  else
    {
      if (app_name != NULL)
       application_name = app_name;
      else
       application_name = "";
    }

  if (dllext != NULL)
    {
      buf = (char *) alloca (strlen (module) + strlen (dllext) + 2);
      sprintf (buf, "%s.%s", module, dllext);
      module = buf;
    }

  append_import (application_name, module, ord_val);
}

Here is the call graph for this function:

void def_library ( const char *  name,
int  base 
)

Definition at line 979 of file dlltool.c.

{
  /* xgettext:c-format */
  inform (_("LIBRARY: %s base: %x"), name, base);

  if (d_is_exe)
    non_fatal (_("Can't have LIBRARY and NAME"));

  /* If --dllname not provided, use the one in the DEF file.  */
  if (! dll_name)
    set_dll_name_from_def (name);
  d_is_dll = 1;
}

Here is the call graph for this function:

void def_name ( const char *  name,
int  base 
)

Definition at line 963 of file dlltool.c.

{
  /* xgettext:c-format */
  inform (_("NAME: %s base: %x"), name, base);

  if (d_is_dll)
    non_fatal (_("Can't have LIBRARY and NAME"));

  /* If --dllname not provided, use the one in the DEF file.
     FIXME: Is this appropriate for executables?  */
  if (! dll_name)
    set_dll_name_from_def (name);
  d_is_exe = 1;
}

Here is the call graph for this function:

void def_section ( const char *  name,
int  attr 
)

Definition at line 1134 of file dlltool.c.

{
  char buf[200];
  char atts[5];
  char *d = atts;
  if (attr & 1)
    *d++ = 'R';

  if (attr & 2)
    *d++ = 'W';
  if (attr & 4)
    *d++ = 'X';
  if (attr & 8)
    *d++ = 'S';
  *d++ = 0;
  sprintf (buf, "-attr %s %s", name, atts);
  new_directive (xstrdup (buf));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void def_stacksize ( int  reserve,
int  commit 
)

Definition at line 1023 of file dlltool.c.

{
  char b[200];
  if (commit > 0)
    sprintf (b, "-stack 0x%x,0x%x ", reserve, commit);
  else
    sprintf (b, "-stack 0x%x ", reserve);
  new_directive (xstrdup (b));
}

Here is the call graph for this function:

void def_version ( int  major,
int  minor 
)

Definition at line 1128 of file dlltool.c.

{
  printf ("VERSION %d.%d\n", major, minor);
}

Here is the call graph for this function:

static char* dlltmp ( char **  buf,
const char *  fmt 
) [static]

Definition at line 752 of file dlltool.c.

{
  if (!*buf)
    {
      *buf = malloc (strlen (tmp_prefix) + 64);
      sprintf (*buf, fmt, tmp_prefix);
    }
  return *buf;
}

Here is the call graph for this function:

static void dump_def_info ( FILE *  f) [static]

Definition at line 1558 of file dlltool.c.

{
  int i;
  export_type *exp;
  fprintf (f, "%s ", ASM_C);
  for (i = 0; oav[i]; i++)
    fprintf (f, "%s ", oav[i]);
  fprintf (f, "\n");
  for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
    {
      fprintf (f, "%s  %d = %s %s @ %d %s%s%s%s\n",
              ASM_C,
              i,
              exp->name,
              exp->internal_name,
              exp->ordinal,
              exp->noname ? "NONAME " : "",
              exp->private ? "PRIVATE " : "",
              exp->constant ? "CONSTANT" : "",
              exp->data ? "DATA" : "");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void fill_ordinals ( export_type **  d_export_vec) [static]

Definition at line 3012 of file dlltool.c.

{
  int lowest = -1;
  int i;
  char *ptr;
  int size = 65536;

  qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);

  /* Fill in the unset ordinals with ones from our range.  */
  ptr = (char *) xmalloc (size);

  memset (ptr, 0, size);

  /* Mark in our large vector all the numbers that are taken.  */
  for (i = 0; i < d_nfuncs; i++)
    {
      if (d_export_vec[i]->ordinal != -1)
       {
         ptr[d_export_vec[i]->ordinal] = 1;

         if (lowest == -1 || d_export_vec[i]->ordinal < lowest)
           lowest = d_export_vec[i]->ordinal;
       }
    }

  /* Start at 1 for compatibility with MS toolchain.  */
  if (lowest == -1)
    lowest = 1;

  /* Now fill in ordinals where the user wants us to choose.  */
  for (i = 0; i < d_nfuncs; i++)
    {
      if (d_export_vec[i]->ordinal == -1)
       {
         int j;

         /* First try within or after any user supplied range.  */
         for (j = lowest; j < size; j++)
           if (ptr[j] == 0)
             {
              ptr[j] = 1;
              d_export_vec[i]->ordinal = j;
              goto done;
             }

         /* Then try before the range.  */
         for (j = lowest; j >0; j--)
           if (ptr[j] == 0)
             {
              ptr[j] = 1;
              d_export_vec[i]->ordinal = j;
              goto done;
             }
       done:;
       }
    }

  free (ptr);

  /* And resort.  */
  qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);

  /* Work out the lowest and highest ordinal numbers.  */
  if (d_nfuncs)
    {
      if (d_export_vec[0])
       d_low_ord = d_export_vec[0]->ordinal;
      if (d_export_vec[d_nfuncs-1])
       d_high_ord = d_export_vec[d_nfuncs-1]->ordinal;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static long filter_symbols ( bfd abfd,
void *  minisyms,
long  symcount,
unsigned int  size 
) [static]

Definition at line 1415 of file dlltool.c.

{
  bfd_byte *from, *fromend, *to;
  asymbol *store;

  store = bfd_make_empty_symbol (abfd);
  if (store == NULL)
    bfd_fatal (bfd_get_filename (abfd));

  from = (bfd_byte *) minisyms;
  fromend = from + symcount * size;
  to = (bfd_byte *) minisyms;

  for (; from < fromend; from += size)
    {
      int keep = 0;
      asymbol *sym;

      sym = bfd_minisymbol_to_symbol (abfd, FALSE, (const void *) from, store);
      if (sym == NULL)
       bfd_fatal (bfd_get_filename (abfd));

      /* Check for external and defined only symbols.  */
      keep = (((sym->flags & BSF_GLOBAL) != 0
              || (sym->flags & BSF_WEAK) != 0
              || bfd_is_com_section (sym->section))
             && ! bfd_is_und_section (sym->section));

      keep = keep && ! match_exclude (sym->name);

      if (keep)
       {
         memcpy (to, from, size);
         to += size;
       }
    }

  return (to - (bfd_byte *) minisyms) / size;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void flush_page ( FILE *  f,
long need,
int  page_addr,
int  on_page 
) [static]

Definition at line 1590 of file dlltool.c.

{
  int i;

  /* Flush this page.  */
  fprintf (f, "\t%s\t0x%08x\t%s Starting RVA for chunk\n",
          ASM_LONG,
          page_addr,
          ASM_C);
  fprintf (f, "\t%s\t0x%x\t%s Size of block\n",
          ASM_LONG,
          (on_page * 2) + (on_page & 1) * 2 + 8,
          ASM_C);

  for (i = 0; i < on_page; i++)
    {
      long needed = need[i];

      if (needed)
       needed = ((needed - page_addr) | 0x3000) & 0xffff;

      fprintf (f, "\t%s\t0x%lx\n", ASM_SHORT, needed);
    }

  /* And padding */
  if (on_page & 1)
    fprintf (f, "\t%s\t0x%x\n", ASM_SHORT, 0 | 0x0000);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void gen_def_file ( void  ) [static]

Definition at line 1620 of file dlltool.c.

{
  int i;
  export_type *exp;

  inform (_("Adding exports to output file"));

  fprintf (output_def, ";");
  for (i = 0; oav[i]; i++)
    fprintf (output_def, " %s", oav[i]);

  fprintf (output_def, "\nEXPORTS\n");

  for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
    {
      char *quote = strchr (exp->name, '.') ? "\"" : "";
      char *res = cplus_demangle (exp->internal_name, DMGL_ANSI | DMGL_PARAMS);

      if (res)
       {
         fprintf (output_def,";\t%s\n", res);
         free (res);
       }

      if (strcmp (exp->name, exp->internal_name) == 0)
       {
         fprintf (output_def, "\t%s%s%s @ %d%s%s%s\n",
                 quote,
                 exp->name,
                 quote,
                 exp->ordinal,
                 exp->noname ? " NONAME" : "",
                 exp->private ? "PRIVATE " : "",
                 exp->data ? " DATA" : "");
       }
      else
       {
         char * quote1 = strchr (exp->internal_name, '.') ? "\"" : "";
         /* char *alias =  */
         fprintf (output_def, "\t%s%s%s = %s%s%s @ %d%s%s%s\n",
                 quote,
                 exp->name,
                 quote,
                 quote1,
                 exp->internal_name,
                 quote1,
                 exp->ordinal,
                 exp->noname ? " NONAME" : "",
                 exp->private ? "PRIVATE " : "",
                 exp->data ? " DATA" : "");
       }
    }

  inform (_("Added exports to output file"));
}

Here is the call graph for this function:

static void gen_exp_file ( void  ) [static]

Definition at line 1804 of file dlltool.c.

{
  FILE *f;
  int i;
  export_type *exp;
  dlist_type *dl;

  /* xgettext:c-format */
  inform (_("Generating export file: %s"), exp_name);

  f = fopen (TMP_ASM, FOPEN_WT);
  if (!f)
    /* xgettext:c-format */
    fatal (_("Unable to open temporary assembler file: %s"), TMP_ASM);

  /* xgettext:c-format */
  inform (_("Opened temporary file: %s"), TMP_ASM);

  dump_def_info (f);

  if (d_exports)
    {
      fprintf (f, "\t.section      .edata\n\n");
      fprintf (f, "\t%s     0      %s Allways 0\n", ASM_LONG, ASM_C);
      fprintf (f, "\t%s     0x%lx  %s Time and date\n", ASM_LONG, (long) time(0),
              ASM_C);
      fprintf (f, "\t%s     0      %s Major and Minor version\n", ASM_LONG, ASM_C);
      fprintf (f, "\t%sname%s      %s Ptr to name of dll\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
      fprintf (f, "\t%s     %d     %s Starting ordinal of exports\n", ASM_LONG, d_low_ord, ASM_C);


      fprintf (f, "\t%s     %d     %s Number of functions\n", ASM_LONG, d_high_ord - d_low_ord + 1, ASM_C);
      fprintf(f,"\t%s named funcs %d, low ord %d, high ord %d\n",
             ASM_C,
             d_named_nfuncs, d_low_ord, d_high_ord);
      fprintf (f, "\t%s     %d     %s Number of names\n", ASM_LONG,
              show_allnames ? d_high_ord - d_low_ord + 1 : d_named_nfuncs, ASM_C);
      fprintf (f, "\t%safuncs%s  %s Address of functions\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);

      fprintf (f, "\t%sanames%s    %s Address of Name Pointer Table\n",
              ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);

      fprintf (f, "\t%sanords%s    %s Address of ordinals\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);

      fprintf (f, "name:    %s     \"%s\"\n", ASM_TEXT, dll_name);


      fprintf(f,"%s Export address Table\n", ASM_C);
      fprintf(f,"\t%s\n", ASM_ALIGN_LONG);
      fprintf (f, "afuncs:\n");
      i = d_low_ord;

      for (exp = d_exports; exp; exp = exp->next)
       {
         if (exp->ordinal != i)
           {
             while (i < exp->ordinal)
              {
                fprintf(f,"\t%s\t0\n", ASM_LONG);
                i++;
              }
           }

         if (exp->forward == 0)
           {
             if (exp->internal_name[0] == '@')
              fprintf (f, "\t%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
                      exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
             else
              fprintf (f, "\t%s%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
                      ASM_PREFIX (exp->internal_name),
                      exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
           }
         else
           fprintf (f, "\t%sf%d%s\t%s %d\n", ASM_RVA_BEFORE,
                   exp->forward, ASM_RVA_AFTER, ASM_C, exp->ordinal);
         i++;
       }

      fprintf (f,"%s Export Name Pointer Table\n", ASM_C);
      fprintf (f, "anames:\n");

      for (i = 0; (exp = d_exports_lexically[i]); i++)
       {
         if (!exp->noname || show_allnames)
           fprintf (f, "\t%sn%d%s\n",
                   ASM_RVA_BEFORE, exp->ordinal, ASM_RVA_AFTER);
       }

      fprintf (f,"%s Export Oridinal Table\n", ASM_C);
      fprintf (f, "anords:\n");
      for (i = 0; (exp = d_exports_lexically[i]); i++)
       {
         if (!exp->noname || show_allnames)
           fprintf (f, "\t%s       %d\n", ASM_SHORT, exp->ordinal - d_low_ord);
       }

      fprintf(f,"%s Export Name Table\n", ASM_C);
      for (i = 0; (exp = d_exports_lexically[i]); i++)
       {
         if (!exp->noname || show_allnames)
           fprintf (f, "n%d:       %s     \"%s\"\n",
                   exp->ordinal, ASM_TEXT, xlate (exp->name));
         if (exp->forward != 0)
           fprintf (f, "f%d:       %s     \"%s\"\n",
                   exp->forward, ASM_TEXT, exp->internal_name);
       }

      if (a_list)
       {
         fprintf (f, "\t.section %s\n", DRECTVE_SECTION_NAME);
         for (dl = a_list; dl; dl = dl->next)
           {
             fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, dl->text);
           }
       }

      if (d_list)
       {
         fprintf (f, "\t.section .rdata\n");
         for (dl = d_list; dl; dl = dl->next)
           {
             char *p;
             int l;

             /* We don't output as ascii because there can
                be quote characters in the string.  */
             l = 0;
             for (p = dl->text; *p; p++)
              {
                if (l == 0)
                  fprintf (f, "\t%s\t", ASM_BYTE);
                else
                  fprintf (f, ",");
                fprintf (f, "%d", *p);
                if (p[1] == 0)
                  {
                    fprintf (f, ",0\n");
                    break;
                  }
                if (++l == 10)
                  {
                    fprintf (f, "\n");
                    l = 0;
                  }
              }
           }
       }
    }


  /* Add to the output file a way of getting to the exported names
     without using the import library.  */
  if (add_indirect)
    {
      fprintf (f, "\t.section\t.rdata\n");
      for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
       if (!exp->noname || show_allnames)
         {
           /* We use a single underscore for MS compatibility, and a
               double underscore for backward compatibility with old
               cygwin releases.  */
           if (create_compat_implib)
             fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name);
           fprintf (f, "\t%s\t_imp__%s\n", ASM_GLOBAL, exp->name);
           if (create_compat_implib)
             fprintf (f, "__imp_%s:\n", exp->name);
           fprintf (f, "_imp__%s:\n", exp->name);
           fprintf (f, "\t%s\t%s\n", ASM_LONG, exp->name);
         }
    }

  /* Dump the reloc section if a base file is provided.  */
  if (base_file)
    {
      int addr;
      long need[PAGE_SIZE];
      long page_addr;
      int numbytes;
      int num_entries;
      long *copy;
      int j;
      int on_page;
      fprintf (f, "\t.section\t.init\n");
      fprintf (f, "lab:\n");

      fseek (base_file, 0, SEEK_END);
      numbytes = ftell (base_file);
      fseek (base_file, 0, SEEK_SET);
      copy = xmalloc (numbytes);
      fread (copy, 1, numbytes, base_file);
      num_entries = numbytes / sizeof (long);


      fprintf (f, "\t.section\t.reloc\n");
      if (num_entries)
       {
         int src;
         int dst = 0;
         int last = -1;
         qsort (copy, num_entries, sizeof (long), sfunc);
         /* Delete duplicates */
         for (src = 0; src < num_entries; src++)
           {
             if (last != copy[src])
              last = copy[dst++] = copy[src];
           }
         num_entries = dst;
         addr = copy[0];
         page_addr = addr & PAGE_MASK;           /* work out the page addr */
         on_page = 0;
         for (j = 0; j < num_entries; j++)
           {
             addr = copy[j];
             if ((addr & PAGE_MASK) != page_addr)
              {
                flush_page (f, need, page_addr, on_page);
                on_page = 0;
                page_addr = addr & PAGE_MASK;
              }
             need[on_page++] = addr;
           }
         flush_page (f, need, page_addr, on_page);

/*       fprintf (f, "\t%s\t0,0\t%s End\n", ASM_LONG, ASM_C);*/
       }
    }

  generate_idata_ofile (f);

  fclose (f);

  /* Assemble the file.  */
  assemble_file (TMP_ASM, exp_name);

  if (dontdeltemps == 0)
    unlink (TMP_ASM);

  inform (_("Generated exports file"));
}

Here is the call graph for this function:

static void gen_lib_file ( void  ) [static]

Definition at line 2793 of file dlltool.c.

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

  unlink (imp_name);

  outarch = bfd_openw (imp_name, HOW_BFD_WRITE_TARGET);

  if (!outarch)
    /* xgettext:c-format */
    fatal (_("Can't open .lib file: %s"), imp_name);

  /* xgettext:c-format */
  inform (_("Creating library file: %s"), imp_name);

  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 ();
  ar_tail = make_tail();

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

  for (i = 0; (exp = d_exports_lexically[i]); i++)
    {
      bfd *n;
      /* Don't add PRIVATE entries to import lib.  */
      if (exp->private)
       continue;
      n = make_one_lib_file (exp, i);
      n->next = head;
      head = n;
      if (ext_prefix_alias)
       {
         export_type alias_exp;

         assert (i < PREFIX_ALIAS_BASE);
         alias_exp.name = make_imp_label (ext_prefix_alias, exp->name);
         alias_exp.internal_name = exp->internal_name;
         alias_exp.import_name = exp->name;
         alias_exp.ordinal = exp->ordinal;
         alias_exp.constant = exp->constant;
         alias_exp.noname = exp->noname;
         alias_exp.private = exp->private;
         alias_exp.data = exp->data;
         alias_exp.hint = exp->hint;
         alias_exp.forward = exp->forward;
         alias_exp.next = exp->next;
         n = make_one_lib_file (&alias_exp, i + PREFIX_ALIAS_BASE);
         n->next = head;
         head = n;
       }
    }

  /* 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))
    bfd_fatal ("bfd_set_archive_head");

  if (! bfd_close (outarch))
    bfd_fatal (imp_name);

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

  /* Delete all the temp files.  */
  if (dontdeltemps == 0)
    {
      unlink (TMP_HEAD_O);
      unlink (TMP_HEAD_S);
      unlink (TMP_TAIL_O);
      unlink (TMP_TAIL_S);
    }

  if (dontdeltemps < 2)
    {
      char *name;

      name = (char *) alloca (strlen (TMP_STUB) + 10);
      for (i = 0; (exp = d_exports_lexically[i]); i++)
       {
         /* Don't delete non-existent stubs for PRIVATE entries.  */
          if (exp->private)
           continue;
         sprintf (name, "%s%05d.o", TMP_STUB, i);
         if (unlink (name) < 0)
           /* xgettext:c-format */
           non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
         if (ext_prefix_alias)
           {
             sprintf (name, "%s%05d.o", TMP_STUB, i + PREFIX_ALIAS_BASE);
             if (unlink (name) < 0)
              /* xgettext:c-format */
              non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
           }
       }
    }

  inform (_("Created lib file"));
}

Here is the call graph for this function:

static void generate_idata_ofile ( FILE *  filvar) [static]

Definition at line 1681 of file dlltool.c.

{
  iheadtype *headptr;
  ifunctype *funcptr;
  int        headindex;
  int        funcindex;
  int       nheads;

  if (import_list == NULL)
    return;

  fprintf (filvar, "%s Import data sections\n", ASM_C);
  fprintf (filvar, "\n\t.section\t.idata$2\n");
  fprintf (filvar, "\t%s\tdoi_idata\n", ASM_GLOBAL);
  fprintf (filvar, "doi_idata:\n");

  nheads = 0;
  for (headptr = import_list; headptr != NULL; headptr = headptr->next)
    {
      fprintf (filvar, "\t%slistone%d%s\t%s %s\n",
              ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER,
              ASM_C, headptr->dllname);
      fprintf (filvar, "\t%s\t0\n", ASM_LONG);
      fprintf (filvar, "\t%s\t0\n", ASM_LONG);
      fprintf (filvar, "\t%sdllname%d%s\n",
              ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
      fprintf (filvar, "\t%slisttwo%d%s\n\n",
              ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
      nheads++;
    }

  fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL record at */
  fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* end of idata$2 */
  fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* section        */
  fprintf (filvar, "\t%s\t0\n", ASM_LONG);
  fprintf (filvar, "\t%s\t0\n", ASM_LONG);

  fprintf (filvar, "\n\t.section\t.idata$4\n");
  headindex = 0;
  for (headptr = import_list; headptr != NULL; headptr = headptr->next)
    {
      fprintf (filvar, "listone%d:\n", headindex);
      for (funcindex = 0; funcindex < headptr->nfuncs; funcindex++)
#ifdef DLLTOOL_MX86_64
       fprintf (filvar, "\t%sfuncptr%d_%d%s\n%s\t0\n",
               ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER,ASM_LONG);
#else
       fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
               ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
#endif
#ifdef DLLTOOL_MX86_64
      fprintf (filvar, "\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG); /* NULL terminating list.  */
#else
      fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list.  */
#endif
      headindex++;
    }

  fprintf (filvar, "\n\t.section\t.idata$5\n");
  headindex = 0;
  for (headptr = import_list; headptr != NULL; headptr = headptr->next)
    {
      fprintf (filvar, "listtwo%d:\n", headindex);
      for (funcindex = 0; funcindex < headptr->nfuncs; funcindex++)
#ifdef DLLTOOL_MX86_64
       fprintf (filvar, "\t%sfuncptr%d_%d%s\n%s\t0\n",
               ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER,ASM_LONG);
#else
       fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
               ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
#endif
#ifdef DLLTOOL_MX86_64
      fprintf (filvar, "\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG); /* NULL terminating list.  */
#else
      fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list.  */
#endif
      headindex++;
    }

  fprintf (filvar, "\n\t.section\t.idata$6\n");
  headindex = 0;
  for (headptr = import_list; headptr != NULL; headptr = headptr->next)
    {
      funcindex = 0;
      for (funcptr = headptr->funchead; funcptr != NULL;
          funcptr = funcptr->next)
       {
         fprintf (filvar,"funcptr%d_%d:\n", headindex, funcindex);
         fprintf (filvar,"\t%s\t%d\n", ASM_SHORT,
                 ((funcptr->ord) & 0xFFFF));
         fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, funcptr->name);
         fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
         funcindex++;
       }
      headindex++;
    }

  fprintf (filvar, "\n\t.section\t.idata$7\n");
  headindex = 0;
  for (headptr = import_list; headptr != NULL; headptr = headptr->next)
    {
      fprintf (filvar,"dllname%d:\n", headindex);
      fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, headptr->dllname);
      fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
      headindex++;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void inform ( const char *  ,
  ... 
) [static]

Definition at line 733 of file dlltool.c.

{
  static char alpha[26] = "abcdefghijklmnopqrstuvwxyz";
  static char buf[32];
  char *p;
  strcpy (buf, start);
  p = strchr (buf, '\0');
  do
    *p++ = alpha[code % sizeof (alpha)];
  while ((code /= sizeof (alpha)) != 0);
  *p = '\0';
  return buf;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char * look_for_prog ( const char *  prog_name,
const char *  prefix,
int  end_prefix 
) [static]

Definition at line 3444 of file dlltool.c.

{
  struct stat s;
  char *cmd;

  cmd = xmalloc (strlen (prefix)
               + strlen (prog_name)
#ifdef HAVE_EXECUTABLE_SUFFIX
               + strlen (EXECUTABLE_SUFFIX)
#endif
               + 10);
  strcpy (cmd, prefix);

  sprintf (cmd + end_prefix, "%s", prog_name);

  if (strchr (cmd, '/') != NULL)
    {
      int found;

      found = (stat (cmd, &s) == 0
#ifdef HAVE_EXECUTABLE_SUFFIX
              || stat (strcat (cmd, EXECUTABLE_SUFFIX), &s) == 0
#endif
              );

      if (! found)
       {
         /* xgettext:c-format */
         inform (_("Tried file: %s"), cmd);
         free (cmd);
         return NULL;
       }
    }

  /* xgettext:c-format */
  inform (_("Using file: %s"), cmd);

  return cmd;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int main ( int  ac,
char **  av 
)
static bfd * make_head ( void  ) [static]

Definition at line 2665 of file dlltool.c.

{
  FILE *f = fopen (TMP_HEAD_S, FOPEN_WT);

  if (f == NULL)
    {
      fatal (_("failed to open temporary head file: %s"), TMP_HEAD_S);
      return NULL;
    }

  fprintf (f, "%s IMAGE_IMPORT_DESCRIPTOR\n", ASM_C);
  fprintf (f, "\t.section   .idata$2\n");

  fprintf(f,"\t%s\t%s\n", ASM_GLOBAL,head_label);

  fprintf (f, "%s:\n", head_label);

  fprintf (f, "\t%shname%s\t%sPtr to image import by name list\n",
          ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);

  fprintf (f, "\t%sthis should be the timestamp, but NT sometimes\n", ASM_C);
  fprintf (f, "\t%sdoesn't load DLLs when this is set.\n", ASM_C);
  fprintf (f, "\t%s\t0\t%s loaded time\n", ASM_LONG, ASM_C);
  fprintf (f, "\t%s\t0\t%s Forwarder chain\n", ASM_LONG, ASM_C);
  fprintf (f, "\t%s__%s_iname%s\t%s imported dll's name\n",
          ASM_RVA_BEFORE,
          imp_name_lab,
          ASM_RVA_AFTER,
          ASM_C);
  fprintf (f, "\t%sfthunk%s\t%s pointer to firstthunk\n",
          ASM_RVA_BEFORE,
          ASM_RVA_AFTER, ASM_C);

  fprintf (f, "%sStuff for compatibility\n", ASM_C);

  if (!no_idata5)
    {
      fprintf (f, "\t.section\t.idata$5\n");
#ifdef DLLTOOL_MX86_64
      fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG); /* NULL terminating list.  */
#else
      fprintf (f,"\t%s\t0\n", ASM_LONG); /* NULL terminating list.  */
#endif
      fprintf (f, "fthunk:\n");
    }

  if (!no_idata4)
    {
      fprintf (f, "\t.section\t.idata$4\n");
      fprintf (f, "\t%s\t0\n", ASM_LONG);
      fprintf (f, "\t.section      .idata$4\n");
      fprintf (f, "hname:\n");
    }

  fclose (f);

  assemble_file (TMP_HEAD_S, TMP_HEAD_O);

  return bfd_openr (TMP_HEAD_O, HOW_BFD_READ_TARGET);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char * make_imp_label ( const char *  prefix,
const char *  name 
) [static]

Definition at line 2197 of file dlltool.c.

{
  int len;
  char *copy;

  if (name[0] == '@')
    {
      len = strlen (prefix) + strlen (name);
      copy = xmalloc (len + 1);
      strcpy (copy, prefix);
      strcat (copy, name);
    }
  else
    {
      len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name);
      copy = xmalloc (len + 1);
      strcpy (copy, prefix);
      strcat (copy, ASM_PREFIX (name));
      strcat (copy, name);
    }
  return copy;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char * make_label ( const char *  prefix,
const char *  name 
) [static]

Definition at line 2185 of file dlltool.c.

{
  int len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name);
  char *copy = xmalloc (len + 1);

  strcpy (copy, ASM_PREFIX (name));
  strcat (copy, prefix);
  strcat (copy, name);
  return copy;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd * make_one_lib_file ( export_type exp,
int  i 
) [static]

Definition at line 2221 of file dlltool.c.

{
  bfd *      abfd;
  asymbol *  exp_label;
  asymbol *  iname = 0;
  asymbol *  iname2;
  asymbol *  iname_lab;
  asymbol ** iname_lab_pp;
  asymbol ** iname_pp;
#ifdef DLLTOOL_PPC
  asymbol ** fn_pp;
  asymbol ** toc_pp;
#define EXTRA  2
#endif
#ifndef EXTRA
#define EXTRA    0
#endif
  asymbol *  ptrs[NSECS + 4 + EXTRA + 1];
  flagword   applicable;
  char *     outname = xmalloc (strlen (TMP_STUB) + 10);
  int        oidx = 0;


  sprintf (outname, "%s%05d.o", TMP_STUB, i);

  abfd = bfd_openw (outname, HOW_BFD_WRITE_TARGET);

  if (!abfd)
    /* xgettext:c-format */
    fatal (_("bfd_open failed open stub file: %s"), outname);

  /* xgettext:c-format */
  inform (_("Creating stub file: %s"), outname);

  bfd_set_format (abfd, bfd_object);
  bfd_set_arch_mach (abfd, HOW_BFD_ARCH, 0);

#ifdef DLLTOOL_ARM
  if (machine == MARM_INTERWORK || machine == MTHUMB)
    bfd_set_private_flags (abfd, F_INTERWORK);
#endif

  applicable = bfd_applicable_section_flags (abfd);

  /* First make symbols for the sections.  */
  for (i = 0; i < NSECS; i++)
    {
      sinfo *si = secdata + i;

      if (si->id != i)
       abort();
      si->sec = bfd_make_section_old_way (abfd, si->name);
      bfd_set_section_flags (abfd,
                          si->sec,
                          si->flags & applicable);

      bfd_set_section_alignment(abfd, si->sec, si->align);
      si->sec->output_section = si->sec;
      si->sym = bfd_make_empty_symbol(abfd);
      si->sym->name = si->sec->name;
      si->sym->section = si->sec;
      si->sym->flags = BSF_LOCAL;
      si->sym->value = 0;
      ptrs[oidx] = si->sym;
      si->sympp = ptrs + oidx;
      si->size = 0;
      si->data = NULL;

      oidx++;
    }

  if (! exp->data)
    {
      exp_label = bfd_make_empty_symbol (abfd);
      exp_label->name = make_imp_label ("", exp->name);

      /* On PowerPC, the function name points to a descriptor in
        the rdata section, the first element of which is a
        pointer to the code (..function_name), and the second
        points to the .toc.  */
#ifdef DLLTOOL_PPC
      if (machine == MPPC)
       exp_label->section = secdata[RDATA].sec;
      else
#endif
       exp_label->section = secdata[TEXT].sec;

      exp_label->flags = BSF_GLOBAL;
      exp_label->value = 0;

#ifdef DLLTOOL_ARM
      if (machine == MTHUMB)
       bfd_coff_set_symbol_class (abfd, exp_label, C_THUMBEXTFUNC);
#endif
      ptrs[oidx++] = exp_label;
    }

  /* Generate imp symbols with one underscore for Microsoft
     compatibility, and with two underscores for backward
     compatibility with old versions of cygwin.  */
  if (create_compat_implib)
    {
      iname = bfd_make_empty_symbol (abfd);
      iname->name = make_imp_label ("___imp", exp->name);
      iname->section = secdata[IDATA5].sec;
      iname->flags = BSF_GLOBAL;
      iname->value = 0;
    }

  iname2 = bfd_make_empty_symbol (abfd);
  iname2->name = make_imp_label ("__imp_", exp->name);
  iname2->section = secdata[IDATA5].sec;
  iname2->flags = BSF_GLOBAL;
  iname2->value = 0;

  iname_lab = bfd_make_empty_symbol (abfd);

  iname_lab->name = head_label;
  iname_lab->section = (asection *) &bfd_und_section;
  iname_lab->flags = 0;
  iname_lab->value = 0;

  iname_pp = ptrs + oidx;
  if (create_compat_implib)
    ptrs[oidx++] = iname;
  ptrs[oidx++] = iname2;

  iname_lab_pp = ptrs + oidx;
  ptrs[oidx++] = iname_lab;

#ifdef DLLTOOL_PPC
  /* The symbol referring to the code (.text).  */
  {
    asymbol *function_name;

    function_name = bfd_make_empty_symbol(abfd);
    function_name->name = make_label ("..", exp->name);
    function_name->section = secdata[TEXT].sec;
    function_name->flags = BSF_GLOBAL;
    function_name->value = 0;

    fn_pp = ptrs + oidx;
    ptrs[oidx++] = function_name;
  }

  /* The .toc symbol.  */
  {
    asymbol *toc_symbol;

    toc_symbol = bfd_make_empty_symbol (abfd);
    toc_symbol->name = make_label (".", "toc");
    toc_symbol->section = (asection *)&bfd_und_section;
    toc_symbol->flags = BSF_GLOBAL;
    toc_symbol->value = 0;

    toc_pp = ptrs + oidx;
    ptrs[oidx++] = toc_symbol;
  }
#endif

  ptrs[oidx] = 0;

  for (i = 0; i < NSECS; i++)
    {
      sinfo *si = secdata + i;
      asection *sec = si->sec;
      arelent *rel;
      arelent **rpp;

      switch (i)
       {
       case TEXT:
         if (! exp->data)
           {
             si->size = HOW_JTAB_SIZE;
             si->data = xmalloc (HOW_JTAB_SIZE);
             memcpy (si->data, HOW_JTAB, HOW_JTAB_SIZE);

             /* Add the reloc into idata$5.  */
             rel = xmalloc (sizeof (arelent));

             rpp = xmalloc (sizeof (arelent *) * 2);
             rpp[0] = rel;
             rpp[1] = 0;

             rel->address = HOW_JTAB_ROFF;
             rel->addend = 0;

             if (machine == MPPC)
              {
                rel->howto = bfd_reloc_type_lookup (abfd,
                                                BFD_RELOC_16_GOTOFF);
                rel->sym_ptr_ptr = iname_pp;
              }
             else if (machine == MX86)
              {
                rel->howto = bfd_reloc_type_lookup (abfd,
                                                BFD_RELOC_32_PCREL);
                rel->sym_ptr_ptr = iname_pp;
              }
             else
              {
                rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
                rel->sym_ptr_ptr = secdata[IDATA5].sympp;
              }
             sec->orelocation = rpp;
             sec->reloc_count = 1;
           }
         break;
       case IDATA4:
       case IDATA5:
         /* An idata$4 or idata$5 is one word long, and has an
            rva to idata$6.  */

#ifdef DLLTOOL_MX86_64
         si->data = xmalloc (8);
         si->size = 8;

         if (exp->noname)
           {
             si->data[0] = exp->ordinal ;
             si->data[1] = exp->ordinal >> 8;
             si->data[2] = exp->ordinal >> 16;
             si->data[3] = exp->ordinal >> 24;
             si->data[4] = 0;
             si->data[5] = 0;
             si->data[6] = 0;
             si->data[7] = 0x80;
           }
         else
           {
             sec->reloc_count = 1;
             memset (si->data, 0, si->size);
             rel = xmalloc (sizeof (arelent));
             rpp = xmalloc (sizeof (arelent *) * 2);
             rpp[0] = rel;
             rpp[1] = 0;
             rel->address = 0;
             rel->addend = 0;
             rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
             rel->sym_ptr_ptr = secdata[IDATA6].sympp;
             sec->orelocation = rpp;
           }
#else
         si->data = xmalloc (4);
         si->size = 4;

         if (exp->noname)
           {
             si->data[0] = exp->ordinal ;
             si->data[1] = exp->ordinal >> 8;
             si->data[2] = exp->ordinal >> 16;
             si->data[3] = 0x80;
           }
         else
           {
             sec->reloc_count = 1;
             memset (si->data, 0, si->size);
             rel = xmalloc (sizeof (arelent));
             rpp = xmalloc (sizeof (arelent *) * 2);
             rpp[0] = rel;
             rpp[1] = 0;
             rel->address = 0;
             rel->addend = 0;
             rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
             rel->sym_ptr_ptr = secdata[IDATA6].sympp;
             sec->orelocation = rpp;
           }
#endif
         break;

       case IDATA6:
         if (!exp->noname)
           {
             /* This used to add 1 to exp->hint.  I don't know
               why it did that, and it does not match what I see
               in programs compiled with the MS tools.  */
             int idx = exp->hint;
             si->size = strlen (xlate (exp->import_name)) + 3;
             si->data = xmalloc (si->size);
             si->data[0] = idx & 0xff;
             si->data[1] = idx >> 8;
             strcpy ((char *) si->data + 2, xlate (exp->import_name));
           }
         break;
       case IDATA7:
         si->size = 4;
         si->data = xmalloc (4);
         memset (si->data, 0, si->size);
         rel = xmalloc (sizeof (arelent));
         rpp = xmalloc (sizeof (arelent *) * 2);
         rpp[0] = rel;
         rel->address = 0;
         rel->addend = 0;
         rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
         rel->sym_ptr_ptr = iname_lab_pp;
         sec->orelocation = rpp;
         sec->reloc_count = 1;
         break;

#ifdef DLLTOOL_PPC
       case PDATA:
         {
           /* The .pdata section is 5 words long.
              Think of it as:
              struct
              {
              bfd_vma BeginAddress,     [0x00]
              EndAddress,       [0x04]
              ExceptionHandler, [0x08]
              HandlerData,      [0x0c]
              PrologEndAddress; [0x10]
              };  */

           /* So this pdata section setups up this as a glue linkage to
              a dll routine. There are a number of house keeping things
              we need to do:

              1. In the name of glue trickery, the ADDR32 relocs for 0,
              4, and 0x10 are set to point to the same place:
              "..function_name".
              2. There is one more reloc needed in the pdata section.
              The actual glue instruction to restore the toc on
              return is saved as the offset in an IMGLUE reloc.
              So we need a total of four relocs for this section.

              3. Lastly, the HandlerData field is set to 0x03, to indicate
              that this is a glue routine.  */
           arelent *imglue, *ba_rel, *ea_rel, *pea_rel;

           /* Alignment must be set to 2**2 or you get extra stuff.  */
           bfd_set_section_alignment(abfd, sec, 2);

           si->size = 4 * 5;
           si->data = xmalloc (si->size);
           memset (si->data, 0, si->size);
           rpp = xmalloc (sizeof (arelent *) * 5);
           rpp[0] = imglue  = xmalloc (sizeof (arelent));
           rpp[1] = ba_rel  = xmalloc (sizeof (arelent));
           rpp[2] = ea_rel  = xmalloc (sizeof (arelent));
           rpp[3] = pea_rel = xmalloc (sizeof (arelent));
           rpp[4] = 0;

           /* Stick the toc reload instruction in the glue reloc.  */
           bfd_put_32(abfd, ppc_glue_insn, (char *) &imglue->address);

           imglue->addend = 0;
           imglue->howto = bfd_reloc_type_lookup (abfd,
                                             BFD_RELOC_32_GOTOFF);
           imglue->sym_ptr_ptr = fn_pp;

           ba_rel->address = 0;
           ba_rel->addend = 0;
           ba_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
           ba_rel->sym_ptr_ptr = fn_pp;

           bfd_put_32 (abfd, 0x18, si->data + 0x04);
           ea_rel->address = 4;
           ea_rel->addend = 0;
           ea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
           ea_rel->sym_ptr_ptr = fn_pp;

           /* Mark it as glue.  */
           bfd_put_32 (abfd, 0x03, si->data + 0x0c);

           /* Mark the prolog end address.  */
           bfd_put_32 (abfd, 0x0D, si->data + 0x10);
           pea_rel->address = 0x10;
           pea_rel->addend = 0;
           pea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
           pea_rel->sym_ptr_ptr = fn_pp;

           sec->orelocation = rpp;
           sec->reloc_count = 4;
           break;
         }
       case RDATA:
         /* Each external function in a PowerPC PE file has a two word
            descriptor consisting of:
            1. The address of the code.
            2. The address of the appropriate .toc
            We use relocs to build this.  */
         si->size = 8;
         si->data = xmalloc (8);
         memset (si->data, 0, si->size);

         rpp = xmalloc (sizeof (arelent *) * 3);
         rpp[0] = rel = xmalloc (sizeof (arelent));
         rpp[1] = xmalloc (sizeof (arelent));
         rpp[2] = 0;

         rel->address = 0;
         rel->addend = 0;
         rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
         rel->sym_ptr_ptr = fn_pp;

         rel = rpp[1];

         rel->address = 4;
         rel->addend = 0;
         rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
         rel->sym_ptr_ptr = toc_pp;

         sec->orelocation = rpp;
         sec->reloc_count = 2;
         break;
#endif /* DLLTOOL_PPC */
       }
    }

  {
    bfd_vma vma = 0;
    /* Size up all the sections.  */
    for (i = 0; i < NSECS; i++)
      {
       sinfo *si = secdata + i;

       bfd_set_section_size (abfd, si->sec, si->size);
       bfd_set_section_vma (abfd, si->sec, vma);
      }
  }
  /* Write them out.  */
  for (i = 0; i < NSECS; i++)
    {
      sinfo *si = secdata + i;

      if (i == IDATA5 && no_idata5)
       continue;

      if (i == IDATA4 && no_idata4)
       continue;

      bfd_set_section_contents (abfd, si->sec,
                            si->data, 0,
                            si->size);
    }

  bfd_set_symtab (abfd, ptrs, oidx);
  bfd_close (abfd);
  abfd = bfd_openr (outname, HOW_BFD_READ_TARGET);
  return abfd;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd * make_tail ( void  ) [static]

Definition at line 2727 of file dlltool.c.

{
  FILE *f = fopen (TMP_TAIL_S, FOPEN_WT);

  if (f == NULL)
    {
      fatal (_("failed to open temporary tail file: %s"), TMP_TAIL_S);
      return NULL;
    }

  if (!no_idata4)
    {
      fprintf (f, "\t.section      .idata$4\n");
#ifdef DLLTOOL_MX86_64
      fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG); /* NULL terminating list.  */
#else
      fprintf (f,"\t%s\t0\n", ASM_LONG); /* NULL terminating list.  */
#endif
    }

  if (!no_idata5)
    {
      fprintf (f, "\t.section      .idata$5\n");
#ifdef DLLTOOL_MX86_64
      fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG); /* NULL terminating list.  */
#else
      fprintf (f,"\t%s\t0\n", ASM_LONG); /* NULL terminating list.  */
#endif
    }

#ifdef DLLTOOL_PPC
  /* Normally, we need to see a null descriptor built in idata$3 to
     act as the terminator for the list. The ideal way, I suppose,
     would be to mark this section as a comdat type 2 section, so
     only one would appear in the final .exe (if our linker supported
     comdat, that is) or cause it to be inserted by something else (say
     crt0).  */

  fprintf (f, "\t.section   .idata$3\n");
  fprintf (f, "\t%s\t0\n", ASM_LONG);
  fprintf (f, "\t%s\t0\n", ASM_LONG);
  fprintf (f, "\t%s\t0\n", ASM_LONG);
  fprintf (f, "\t%s\t0\n", ASM_LONG);
  fprintf (f, "\t%s\t0\n", ASM_LONG);
#endif

#ifdef DLLTOOL_PPC
  /* Other PowerPC NT compilers use idata$6 for the dllname, so I
     do too. Original, huh?  */
  fprintf (f, "\t.section   .idata$6\n");
#else
  fprintf (f, "\t.section   .idata$7\n");
#endif

  fprintf (f, "\t%s\t__%s_iname\n", ASM_GLOBAL, imp_name_lab);
  fprintf (f, "__%s_iname:\t%s\t\"%s\"\n",
          imp_name_lab, ASM_TEXT, dll_name);

  fclose (f);

  assemble_file (TMP_TAIL_S, TMP_TAIL_O);

  return bfd_openr (TMP_TAIL_O, HOW_BFD_READ_TARGET);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void mangle_defs ( void  ) [static]

Definition at line 3086 of file dlltool.c.

{
  /* First work out the minimum ordinal chosen.  */
  export_type *exp;

  int i;
  int hint = 0;
  export_type **d_export_vec = xmalloc (sizeof (export_type *) * d_nfuncs);

  inform (_("Processing definitions"));

  for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
    d_export_vec[i] = exp;

  process_duplicates (d_export_vec);
  fill_ordinals (d_export_vec);

  /* Put back the list in the new order.  */
  d_exports = 0;
  for (i = d_nfuncs - 1; i >= 0; i--)
    {
      d_export_vec[i]->next = d_exports;
      d_exports = d_export_vec[i];
    }

  /* Build list in alpha order.  */
  d_exports_lexically = (export_type **)
    xmalloc (sizeof (export_type *) * (d_nfuncs + 1));

  for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
    d_exports_lexically[i] = exp;

  d_exports_lexically[i] = 0;

  qsort (d_exports_lexically, i, sizeof (export_type *), nfunc);

  /* Fill exp entries with their hint values.  */
  for (i = 0; i < d_nfuncs; i++)
    if (!d_exports_lexically[i]->noname || show_allnames)
      d_exports_lexically[i]->hint = hint++;

  inform (_("Processed definitions"));
}

Here is the call graph for this function:

static bfd_boolean match_exclude ( const char *  string) [static]

Definition at line 1394 of file dlltool.c.

{
  struct string_list *excl_item;

  for (excl_item = excludes; excl_item; excl_item = excl_item->next)
    if (strcmp (string, excl_item->string) == 0)
      return TRUE;
  return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void new_directive ( char *  dir) [static]

Definition at line 1003 of file dlltool.c.

{
  dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
  d->text = xstrdup (dir);
  d->next = a_list;
  a_list = d;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int nfunc ( const void *  a,
const void *  b 
) [static]

Definition at line 2928 of file dlltool.c.

{
  export_type *ap = *(export_type **) a;
  export_type *bp = *(export_type **) b;
  const char *an = ap->name;
  const char *bn = bp->name;

  if (killat)
    {
      an = (an[0] == '@') ? an + 1 : an;
      bn = (bn[0] == '@') ? bn + 1 : bn;
    }

  return (strcmp (an, bn));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int pfunc ( const void *  a,
const void *  b 
) [static]

Definition at line 2912 of file dlltool.c.

{
  export_type *ap = *(export_type **) a;
  export_type *bp = *(export_type **) b;
  if (ap->ordinal == bp->ordinal)
    return 0;

  /* Unset ordinals go to the bottom.  */
  if (ap->ordinal == -1)
    return 1;
  if (bp->ordinal == -1)
    return -1;
  return (ap->ordinal - bp->ordinal);
}

Here is the caller graph for this function:

static void process_def_file ( const char *  name) [static]

Definition at line 883 of file dlltool.c.

{
  FILE *f = fopen (name, FOPEN_RT);

  if (!f)
    /* xgettext:c-format */
    fatal (_("Can't open def file: %s"), name);

  yyin = f;

  /* xgettext:c-format */
  inform (_("Processing def file: %s"), name);

  yyparse ();

  inform (_("Processed def file"));
}

Here is the call graph for this function:

static void process_duplicates ( export_type **  d_export_vec) [static]

Definition at line 2962 of file dlltool.c.

{
  int more = 1;
  int i;

  while (more)
    {
      more = 0;
      /* Remove duplicates.  */
      qsort (d_export_vec, d_nfuncs, sizeof (export_type *), nfunc);

      for (i = 0; i < d_nfuncs - 1; i++)
       {
         if (strcmp (d_export_vec[i]->name,
                    d_export_vec[i + 1]->name) == 0)
           {
             export_type *a = d_export_vec[i];
             export_type *b = d_export_vec[i + 1];

             more = 1;

             /* xgettext:c-format */
             inform (_("Warning, ignoring duplicate EXPORT %s %d,%d"),
                    a->name, a->ordinal, b->ordinal);

             if (a->ordinal != -1
                && b->ordinal != -1)
              /* xgettext:c-format */
              fatal (_("Error, duplicate EXPORT with oridinals: %s"),
                    a->name);

             /* Merge attributes.  */
             b->ordinal = a->ordinal > 0 ? a->ordinal : b->ordinal;
             b->constant |= a->constant;
             b->noname |= a->noname;
             b->data |= a->data;
             d_export_vec[i] = 0;
           }

         remove_null_names (d_export_vec);
       }
    }

  /* Count the names.  */
  for (i = 0; i < d_nfuncs; i++)
    if (!d_export_vec[i]->noname)
      d_named_nfuncs++;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void remove_null_names ( export_type **  ptr) [static]

Definition at line 2945 of file dlltool.c.

{
  int src;
  int dst;

  for (dst = src = 0; src < d_nfuncs; src++)
    {
      if (ptr[src])
       {
         ptr[dst] = ptr[src];
         dst++;
       }
    }
  d_nfuncs = dst;
}

Here is the caller graph for this function:

static void run ( const char *  what,
char *  args 
) [static]

Definition at line 1169 of file dlltool.c.

{
  char *s;
  int pid, wait_status;
  int i;
  const char **argv;
  char *errmsg_fmt, *errmsg_arg;
  char *temp_base = choose_temp_base ();

  inform ("run: %s %s", what, args);

  /* Count the args */
  i = 0;
  for (s = args; *s; s++)
    if (*s == ' ')
      i++;
  i++;
  argv = alloca (sizeof (char *) * (i + 3));
  i = 0;
  argv[i++] = what;
  s = args;
  while (1)
    {
      while (*s == ' ')
       ++s;
      argv[i++] = s;
      while (*s != ' ' && *s != 0)
       s++;
      if (*s == 0)
       break;
      *s++ = 0;
    }
  argv[i++] = NULL;

  pid = pexecute (argv[0], (char * const *) argv, program_name, temp_base,
                &errmsg_fmt, &errmsg_arg, PEXECUTE_ONE | PEXECUTE_SEARCH);

  if (pid == -1)
    {
      inform (strerror (errno));

      fatal (errmsg_fmt, errmsg_arg);
    }

  pid = pwait (pid, & wait_status, 0);

  if (pid == -1)
    {
      /* xgettext:c-format */
      fatal (_("wait: %s"), strerror (errno));
    }
  else if (WIFSIGNALED (wait_status))
    {
      /* xgettext:c-format */
      fatal (_("subprocess got fatal signal %d"), WTERMSIG (wait_status));
    }
  else if (WIFEXITED (wait_status))
    {
      if (WEXITSTATUS (wait_status) != 0)
       /* xgettext:c-format */
       non_fatal (_("%s exited with status %d"),
                 what, WEXITSTATUS (wait_status));
    }
  else
    abort ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static const char * rvaafter ( int  machine) [static]

Definition at line 777 of file dlltool.c.

{
  switch (machine)
    {
    case MARM:
    case M386:
    case MX86:
    case MPPC:
    case MTHUMB:
    case MARM_INTERWORK:
    case MMCORE_BE:
    case MMCORE_LE:
    case MMCORE_ELF:
    case MMCORE_ELF_LE:
    case MARM_EPOC:
    case MARM_WINCE:
      break;
    default:
      /* xgettext:c-format */
      fatal (_("Internal error: Unknown machine type: %d"), machine);
      break;
    }
  return "";
}

Here is the call graph for this function:

static const char * rvabefore ( int  machine) [static]

Definition at line 803 of file dlltool.c.

{
  switch (machine)
    {
    case MARM:
    case M386:
    case MX86:
    case MPPC:
    case MTHUMB:
    case MARM_INTERWORK:
    case MMCORE_BE:
    case MMCORE_LE:
    case MMCORE_ELF:
    case MMCORE_ELF_LE:
    case MARM_EPOC:
    case MARM_WINCE:
      return ".rva\t";
    default:
      /* xgettext:c-format */
      fatal (_("Internal error: Unknown machine type: %d"), machine);
      break;
    }
  return "";
}

Here is the call graph for this function:

static void scan_all_symbols ( bfd abfd) [static]

Definition at line 1459 of file dlltool.c.

{
  long symcount;
  void *minisyms;
  unsigned int size;

  /* Ignore bfds with an import descriptor table.  We assume that any
     such BFD contains symbols which are exported from another DLL,
     and we don't want to reexport them from here.  */
  if (bfd_get_section_by_name (abfd, ".idata$4"))
    return;

  if (! (bfd_get_file_flags (abfd) & HAS_SYMS))
    {
      /* xgettext:c-format */
      non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
      return;
    }

  symcount = bfd_read_minisymbols (abfd, FALSE, &minisyms, &size);
  if (symcount < 0)
    bfd_fatal (bfd_get_filename (abfd));

  if (symcount == 0)
    {
      /* xgettext:c-format */
      non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
      return;
    }

  /* Discard the symbols we don't want to export.  It's OK to do this
     in place; we'll free the storage anyway.  */

  symcount = filter_symbols (abfd, minisyms, symcount, size);
  scan_filtered_symbols (abfd, minisyms, symcount, size);

  free (minisyms);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void scan_drectve_symbols ( bfd abfd) [static]

Definition at line 1240 of file dlltool.c.

{
  asection * s;
  int        size;
  char *     buf;
  char *     p;
  char *     e;

  /* Look for .drectve's */
  s = bfd_get_section_by_name (abfd, DRECTVE_SECTION_NAME);

  if (s == NULL)
    return;

  size = bfd_get_section_size (s);
  buf  = xmalloc (size);

  bfd_get_section_contents (abfd, s, buf, 0, size);

  /* xgettext:c-format */
  inform (_("Sucking in info from %s section in %s"),
         DRECTVE_SECTION_NAME, bfd_get_filename (abfd));

  /* Search for -export: strings. The exported symbols can optionally
     have type tags (eg., -export:foo,data), so handle those as well.
     Currently only data tag is supported.  */
  p = buf;
  e = buf + size;
  while (p < e)
    {
      if (p[0] == '-'
         && CONST_STRNEQ (p, "-export:"))
       {
         char * name;
         char * c;
         flagword flags = BSF_FUNCTION;

         p += 8;
         name = p;
         while (p < e && *p != ',' && *p != ' ' && *p != '-')
           p++;
         c = xmalloc (p - name + 1);
         memcpy (c, name, p - name);
         c[p - name] = 0;
         if (p < e && *p == ',')       /* found type tag.  */
           {
             char *tag_start = ++p;
             while (p < e && *p != ' ' && *p != '-')
              p++;
             if (CONST_STRNEQ (tag_start, "data"))
              flags &= ~BSF_FUNCTION;
           }

         /* FIXME: The 5th arg is for the `constant' field.
            What should it be?  Not that it matters since it's not
            currently useful.  */
         def_exports (c, 0, -1, 0, 0, ! (flags & BSF_FUNCTION), 0);

         if (add_stdcall_alias && strchr (c, '@'))
           {
             int lead_at = (*c == '@') ;
             char *exported_name = xstrdup (c + lead_at);
             char *atsym = strchr (exported_name, '@');
             *atsym = '\0';
             /* Note: stdcall alias symbols can never be data.  */
             def_exports (exported_name, xstrdup (c), -1, 0, 0, 0, 0);
           }
       }
      else
       p++;
    }
  free (buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void scan_filtered_symbols ( bfd abfd,
void *  minisyms,
long  symcount,
unsigned int  size 
) [static]

Definition at line 1318 of file dlltool.c.

{
  asymbol *store;
  bfd_byte *from, *fromend;

  store = bfd_make_empty_symbol (abfd);
  if (store == NULL)
    bfd_fatal (bfd_get_filename (abfd));

  from = (bfd_byte *) minisyms;
  fromend = from + symcount * size;
  for (; from < fromend; from += size)
    {
      asymbol *sym;
      const char *symbol_name;

      sym = bfd_minisymbol_to_symbol (abfd, FALSE, from, store);
      if (sym == NULL)
       bfd_fatal (bfd_get_filename (abfd));

      symbol_name = bfd_asymbol_name (sym);
      if (bfd_get_symbol_leading_char (abfd) == symbol_name[0])
       ++symbol_name;

      def_exports (xstrdup (symbol_name) , 0, -1, 0, 0,
                 ! (sym->flags & BSF_FUNCTION), 0);

      if (add_stdcall_alias && strchr (symbol_name, '@'))
        {
         int lead_at = (*symbol_name == '@');
         char *exported_name = xstrdup (symbol_name + lead_at);
         char *atsym = strchr (exported_name, '@');
         *atsym = '\0';
         /* Note: stdcall alias symbols can never be data.  */
         def_exports (exported_name, xstrdup (symbol_name), -1, 0, 0, 0, 0);
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void scan_obj_file ( const char *  filename) [static]

Definition at line 1515 of file dlltool.c.

{
  bfd * f = bfd_openr (filename, 0);

  if (!f)
    /* xgettext:c-format */
    fatal (_("Unable to open object file: %s"), filename);

  /* xgettext:c-format */
  inform (_("Scanning object file %s"), filename);

  if (bfd_check_format (f, bfd_archive))
    {
      bfd *arfile = bfd_openr_next_archived_file (f, 0);
      while (arfile)
       {
         if (bfd_check_format (arfile, bfd_object))
           scan_open_obj_file (arfile);
         bfd_close (arfile);
         arfile = bfd_openr_next_archived_file (f, arfile);
       }

#ifdef DLLTOOL_MCORE_ELF
      if (mcore_elf_out_file)
       inform (_("Cannot produce mcore-elf dll from archive file: %s"), filename);
#endif
    }
  else if (bfd_check_format (f, bfd_object))
    {
      scan_open_obj_file (f);

#ifdef DLLTOOL_MCORE_ELF
      if (mcore_elf_out_file)
       mcore_elf_cache_filename ((char *) filename);
#endif
    }

  bfd_close (f);
}

Here is the call graph for this function:

static void scan_open_obj_file ( bfd abfd) [static]

Definition at line 1501 of file dlltool.c.

{
  if (export_all_symbols)
    scan_all_symbols (abfd);
  else
    scan_drectve_symbols (abfd);

  /* FIXME: we ought to read in and block out the base relocations.  */

  /* xgettext:c-format */
  inform (_("Done reading %s"), bfd_get_filename (abfd));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void set_default_excludes ( void  ) [static]

Definition at line 1407 of file dlltool.c.

Here is the call graph for this function:

static void set_dll_name_from_def ( const char *  name) [static]

Definition at line 953 of file dlltool.c.

{
  const char* image_basename = lbasename (name);
  if (image_basename != name)
    non_fatal (_("%s: Path components stripped from image name, '%s'."),
             def_file, name);
  dll_name = xstrdup (image_basename);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int sfunc ( const void *  a,
const void *  b 
) [static]

Definition at line 1584 of file dlltool.c.

{
  return *(const long *) a - *(const long *) b;
}

Here is the caller graph for this function:

static void usage ( FILE *  file,
int  status 
) [static]

Definition at line 3131 of file dlltool.c.

{
  /* xgetext:c-format */
  fprintf (file, _("Usage %s <option(s)> <object-file(s)>\n"), program_name);
  /* xgetext:c-format */
  fprintf (file, _("   -m --machine <machine>    Create as DLL for <machine>.  [default: %s]\n"), mname);
  fprintf (file, _("        possible <machine>: arm[_interwork], i386, mcore[-elf]{-le|-be}, ppc, thumb\n"));
  fprintf (file, _("   -e --output-exp <outname> Generate an export file.\n"));
  fprintf (file, _("   -l --output-lib <outname> Generate an interface library.\n"));
  fprintf (file, _("   -a --add-indirect         Add dll indirects to export file.\n"));
  fprintf (file, _("   -D --dllname <name>       Name of input dll to put into interface lib.\n"));
  fprintf (file, _("   -d --input-def <deffile>  Name of .def file to be read in.\n"));
  fprintf (file, _("   -z --output-def <deffile> Name of .def file to be created.\n"));
  fprintf (file, _("      --export-all-symbols   Export all symbols to .def\n"));
  fprintf (file, _("      --no-export-all-symbols  Only export listed symbols\n"));
  fprintf (file, _("      --exclude-symbols <list> Don't export <list>\n"));
  fprintf (file, _("      --no-default-excludes  Clear default exclude symbols\n"));
  fprintf (file, _("   -b --base-file <basefile> Read linker generated base file.\n"));
  fprintf (file, _("   -x --no-idata4            Don't generate idata$4 section.\n"));
  fprintf (file, _("   -c --no-idata5            Don't generate idata$5 section.\n"));
  fprintf (file, _("   -U --add-underscore       Add underscores to all symbols in interface library.\n"));
  fprintf (file, _("      --add-stdcall-underscore Add underscores to stdcall symbols in interface library.\n"));
  fprintf (file, _("   -k --kill-at              Kill @<n> from exported names.\n"));
  fprintf (file, _("   -A --add-stdcall-alias    Add aliases without @<n>.\n"));
  fprintf (file, _("   -p --ext-prefix-alias <prefix> Add aliases with <prefix>.\n"));
  fprintf (file, _("   -S --as <name>            Use <name> for assembler.\n"));
  fprintf (file, _("   -f --as-flags <flags>     Pass <flags> to the assembler.\n"));
  fprintf (file, _("   -C --compat-implib        Create backward compatible import library.\n"));
  fprintf (file, _("   -n --no-delete            Keep temp files (repeat for extra preservation).\n"));
  fprintf (file, _("   -t --temp-prefix <prefix> Use <prefix> to construct temp file names.\n"));
  fprintf (file, _("   -v --verbose              Be verbose.\n"));
  fprintf (file, _("   -V --version              Display the program version.\n"));
  fprintf (file, _("   -h --help                 Display this information.\n"));
  fprintf (file, _("   @<file>                   Read options from <file>.\n"));
#ifdef DLLTOOL_MCORE_ELF
  fprintf (file, _("   -M --mcore-elf <outname>  Process mcore-elf object files into <outname>.\n"));
  fprintf (file, _("   -L --linker <name>        Use <name> as the linker.\n"));
  fprintf (file, _("   -F --linker-flags <flags> Pass <flags> to the linker.\n"));
#endif
  if (REPORT_BUGS_TO[0] && status == 0)
    fprintf (file, _("Report bugs to %s\n"), REPORT_BUGS_TO);
  exit (status);
}

Here is the call graph for this function:

static void inform VPARAMS ( (const char *message,...)  ) [static]

Definition at line 763 of file dlltool.c.

{
  VA_OPEN (args, message);
  VA_FIXEDARG (args, const char *, message);

  if (!verbose)
    return;

  report (message, args);

  VA_CLOSE (args);
}

Here is the call graph for this function:

static const char * xlate ( const char *  name) [static]

Definition at line 2046 of file dlltool.c.

{
  int lead_at = (*name == '@');

  if (!lead_at && (add_underscore
                 || (add_stdcall_underscore
                     && strchr (name, '@'))))
    {
      char *copy = xmalloc (strlen (name) + 2);

      copy[0] = '_';
      strcpy (copy + 1, name);
      name = copy;
    }

  if (killat)
    {
      char *p;

      name += lead_at;
      p = strchr (name, '@');
      if (p)
       *p = 0;
    }
  return name;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int yyerror ( const char *err  ATTRIBUTE_UNUSED)

Definition at line 919 of file dlltool.c.

{
  /* xgettext:c-format */
  non_fatal (_("Syntax error in def file %s:%d"), def_file, linenumber);

  return 0;
}

Here is the call graph for this function:


Variable Documentation

dlist_type* a_list [static]

Definition at line 912 of file dlltool.c.

int add_indirect = 0 [static]

Definition at line 358 of file dlltool.c.

Definition at line 384 of file dlltool.c.

Definition at line 360 of file dlltool.c.

int add_underscore = 0 [static]

Definition at line 359 of file dlltool.c.

Initial value:
{
  0x04, 0xc0, 0x9f, 0xe5,   
  0x00, 0xc0, 0x9c, 0xe5,   
  0x1c, 0xff, 0x2f, 0xe1,   
  0,    0,    0,    0
}

Definition at line 472 of file dlltool.c.

const unsigned char arm_jtab[] [static]
Initial value:
{
  0x00, 0xc0, 0x9f, 0xe5,   
  0x00, 0xf0, 0x9c, 0xe5,   
  0,    0,    0,    0
}

Definition at line 465 of file dlltool.c.

char* as_flags = "" [static]

Definition at line 346 of file dlltool.c.

char* as_name = NULL [static]

Definition at line 345 of file dlltool.c.

FILE* base_file [static]

Definition at line 388 of file dlltool.c.

Definition at line 376 of file dlltool.c.

Definition at line 909 of file dlltool.c.

Definition at line 910 of file dlltool.c.

int d_high_ord [static]

Definition at line 908 of file dlltool.c.

int d_is_dll [static]

Definition at line 915 of file dlltool.c.

int d_is_exe [static]

Definition at line 916 of file dlltool.c.

dlist_type* d_list [static]

Definition at line 911 of file dlltool.c.

int d_low_ord [static]

Definition at line 907 of file dlltool.c.

int d_named_nfuncs [static]

Definition at line 906 of file dlltool.c.

int d_nforwards = 0 [static]

Definition at line 913 of file dlltool.c.

int d_nfuncs [static]

Definition at line 905 of file dlltool.c.

char* def_file [static]

Definition at line 378 of file dlltool.c.

const char* default_excludes = "DllMain@12,DllEntryPoint@0,impure_ptr" [static]

Definition at line 372 of file dlltool.c.

char* dll_name [static]

Definition at line 356 of file dlltool.c.

Definition at line 369 of file dlltool.c.

int dontdeltemps = 0 [static]

Definition at line 361 of file dlltool.c.

Definition at line 694 of file dlltool.c.

char* exp_name [static]

Definition at line 352 of file dlltool.c.

Definition at line 365 of file dlltool.c.

const char* ext_prefix_alias [static]

Definition at line 385 of file dlltool.c.

char* head_label [static]

Definition at line 354 of file dlltool.c.

const unsigned char i386_jtab[] [static]
Initial value:
{
  0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
}

Definition at line 460 of file dlltool.c.

char* imp_name [static]

Definition at line 353 of file dlltool.c.

char* imp_name_lab [static]

Definition at line 355 of file dlltool.c.

iheadtype* import_list = NULL [static]

Definition at line 343 of file dlltool.c.

int killat [static]

Definition at line 383 of file dlltool.c.

struct mac[] [static]

Definition at line 553 of file dlltool.c.

int machine [static]

Definition at line 382 of file dlltool.c.

const unsigned char mcore_be_jtab[] [static]
Initial value:
{
  0x71, 0x02,            
  0x81, 0x01,            
  0x00, 0xC1,            
  0x12, 0x00,            
  0x00, 0x00, 0x00, 0x00 
}

Definition at line 491 of file dlltool.c.

const unsigned char mcore_le_jtab[] [static]
Initial value:
{
  0x02, 0x71,            
  0x01, 0x81,            
  0xC1, 0x00,            
  0x00, 0x12,            
  0x00, 0x00, 0x00, 0x00 
}

Definition at line 500 of file dlltool.c.

int no_idata4 [static]

Definition at line 350 of file dlltool.c.

int no_idata5 [static]

Definition at line 351 of file dlltool.c.

char** oav [static]

Definition at line 880 of file dlltool.c.

struct option[] [static]

Definition at line 3181 of file dlltool.c.

FILE* output_def [static]

Definition at line 387 of file dlltool.c.

const unsigned char ppc_jtab[] [static]
Initial value:
{
  0x00, 0x00, 0x62, 0x81, 
                          
  0x00, 0x00, 0x8B, 0x81, 
  0x04, 0x00, 0x41, 0x90, 
  0xA6, 0x03, 0x89, 0x7D, 
  0x04, 0x00, 0x4B, 0x80, 
  0x20, 0x04, 0x80, 0x4E  
}

Definition at line 514 of file dlltool.c.

char* program_name

Definition at line 49 of file bucomm.c.

sinfo secdata[NSECS] [static]
Initial value:

Definition at line 2105 of file dlltool.c.

const unsigned char thumb_jtab[] [static]
Initial value:
{
  0x40, 0xb4,           
  0x02, 0x4e,           
  0x36, 0x68,           
  0xb4, 0x46,           
  0x40, 0xbc,           
  0x60, 0x47,           
  0,    0,    0,    0
}

Definition at line 480 of file dlltool.c.

char* tmp_asm_buf

Definition at line 445 of file dlltool.c.

Definition at line 447 of file dlltool.c.

Definition at line 446 of file dlltool.c.

char* tmp_prefix [static]

Definition at line 348 of file dlltool.c.

char* tmp_stub_buf

Definition at line 450 of file dlltool.c.

Definition at line 449 of file dlltool.c.

Definition at line 448 of file dlltool.c.

int verbose [static]

Definition at line 386 of file dlltool.c.