contrib/binutils/binutils/dlltool.c

   1 /* dlltool.c -- tool to generate stuff for PE style DLLs
   2    Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GNU Binutils.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  20    02111-1307, USA.  */
  21
  22
  23 /* This program allows you to build the files necessary to create
  24    DLLs to run on a system which understands PE format image files.
  25    (eg, Windows NT)
  26
  27    See "Peering Inside the PE: A Tour of the Win32 Portable Executable
  28    File Format", MSJ 1994, Volume 9 for more information.
  29    Also see "Microsoft Portable Executable and Common Object File Format,
  30    Specification 4.1" for more information.
  31
  32    A DLL contains an export table which contains the information
  33    which the runtime loader needs to tie up references from a
  34    referencing program.
  35
  36    The export table is generated by this program by reading
  37    in a .DEF file or scanning the .a and .o files which will be in the
  38    DLL.  A .o file can contain information in special  ".drectve" sections
  39    with export information.
  40
  41    A DEF file contains any number of the following commands:
  42
  43
  44    NAME <name> [ , <base> ]
  45    The result is going to be <name>.EXE
  46
  47    LIBRARY <name> [ , <base> ]
  48    The result is going to be <name>.DLL
  49
  50    EXPORTS  ( (  ( <name1> [ = <name2> ] )
  51                | ( <name1> = <module-name> . <external-name>))
  52             [ @ <integer> ] [ NONAME ] [CONSTANT] [DATA] [PRIVATE] ) *
  53    Declares name1 as an exported symbol from the
  54    DLL, with optional ordinal number <integer>.
  55    Or declares name1 as an alias (forward) of the function <external-name>
  56    in the DLL <module-name>.
  57
  58    IMPORTS  (  (   <internal-name> =   <module-name> . <integer> )
  59              | ( [ <internal-name> = ] <module-name> . <external-name> )) *
  60    Declares that <external-name> or the exported function whoes ordinal number
  61    is <integer> is to be imported from the file <module-name>.  If
  62    <internal-name> is specified then this is the name that the imported
  63    function will be refereed to in the body of the DLL.
  64
  65    DESCRIPTION <string>
  66    Puts <string> into output .exp file in the .rdata section
  67
  68    [STACKSIZE|HEAPSIZE] <number-reserve> [ , <number-commit> ]
  69    Generates --stack|--heap <number-reserve>,<number-commit>
  70    in the output .drectve section.  The linker will
  71    see this and act upon it.
  72
  73    [CODE|DATA] <attr>+
  74    SECTIONS ( <sectionname> <attr>+ )*
  75    <attr> = READ | WRITE | EXECUTE | SHARED
  76    Generates --attr <sectionname> <attr> in the output
  77    .drectve section.  The linker will see this and act
  78    upon it.
  79
  80
  81    A -export:<name> in a .drectve section in an input .o or .a
  82    file to this program is equivalent to a EXPORTS <name>
  83    in a .DEF file.
  84
  85
  86
  87    The program generates output files with the prefix supplied
  88    on the command line, or in the def file, or taken from the first
  89    supplied argument.
  90
  91    The .exp.s file contains the information necessary to export
  92    the routines in the DLL.  The .lib.s file contains the information
  93    necessary to use the DLL's routines from a referencing program.
  94
  95
  96
  97    Example:
  98
  99  file1.c:
 100    asm (".section .drectve");
 101    asm (".ascii \"-export:adef\"");
 102
 103    void adef (char * s)
 104    {
 105      printf ("hello from the dll %s\n", s);
 106    }
 107
 108    void bdef (char * s)
 109    {
 110      printf ("hello from the dll and the other entry point %s\n", s);
 111    }
 112
 113  file2.c:
 114    asm (".section .drectve");
 115    asm (".ascii \"-export:cdef\"");
 116    asm (".ascii \"-export:ddef\"");
 117
 118    void cdef (char * s)
 119    {
 120      printf ("hello from the dll %s\n", s);
 121    }
 122
 123    void ddef (char * s)
 124    {
 125      printf ("hello from the dll and the other entry point %s\n", s);
 126    }
 127
 128    int printf (void)
 129    {
 130      return 9;
 131    }
 132
 133  themain.c:
 134    int main (void)
 135    {
 136      cdef ();
 137      return 0;
 138    }
 139
 140  thedll.def
 141
 142    LIBRARY thedll
 143    HEAPSIZE 0x40000, 0x2000
 144    EXPORTS bdef @ 20
 145            cdef @ 30 NONAME
 146
 147    SECTIONS donkey READ WRITE
 148    aardvark EXECUTE
 149
 150  # Compile up the parts of the dll and the program
 151
 152    gcc -c file1.c file2.c themain.c
 153
 154  # Optional: put the dll objects into a library
 155  # (you don't have to, you could name all the object
 156  # files on the dlltool line)
 157
 158    ar  qcv thedll.in file1.o file2.o
 159    ranlib thedll.in
 160
 161  # Run this tool over the DLL's .def file and generate an exports
 162  # file (thedll.o) and an imports file (thedll.a).
 163  # (You may have to use -S to tell dlltool where to find the assembler).
 164
 165    dlltool --def thedll.def --output-exp thedll.o --output-lib thedll.a
 166
 167  # Build the dll with the library and the export table
 168
 169    ld -o thedll.dll thedll.o thedll.in
 170
 171  # Link the executable with the import library
 172
 173    gcc -o themain.exe themain.o thedll.a
 174
 175  This example can be extended if relocations are needed in the DLL:
 176
 177  # Compile up the parts of the dll and the program
 178
 179    gcc -c file1.c file2.c themain.c
 180
 181  # Run this tool over the DLL's .def file and generate an imports file.
 182
 183    dlltool --def thedll.def --output-lib thedll.lib
 184
 185  # Link the executable with the import library and generate a base file
 186  # at the same time
 187
 188    gcc -o themain.exe themain.o thedll.lib -Wl,--base-file -Wl,themain.base
 189
 190  # Run this tool over the DLL's .def file and generate an exports file
 191  # which includes the relocations from the base file.
 192
 193    dlltool --def thedll.def --base-file themain.base --output-exp thedll.exp
 194
 195  # Build the dll with file1.o, file2.o and the export table
 196
 197    ld -o thedll.dll thedll.exp file1.o file2.o  */
 198
 199 /* .idata section description
 200
 201    The .idata section is the import table.  It is a collection of several
 202    subsections used to keep the pieces for each dll together: .idata$[234567].
 203    IE: Each dll's .idata$2's are catenated together, each .idata$3's, etc.
 204
 205    .idata$2 = Import Directory Table
 206    = array of IMAGE_IMPORT_DESCRIPTOR's.
 207
 208         DWORD   Import Lookup Table;  - pointer to .idata$4
 209         DWORD   TimeDateStamp;        - currently always 0
 210         DWORD   ForwarderChain;       - currently always 0
 211         DWORD   Name;                 - pointer to dll's name
 212         PIMAGE_THUNK_DATA FirstThunk; - pointer to .idata$5
 213
 214    .idata$3 = null terminating entry for .idata$2.
 215
 216    .idata$4 = Import Lookup Table
 217    = array of array of pointers to hint name table.
 218    There is one for each dll being imported from, and each dll's set is
 219    terminated by a trailing NULL.
 220
 221    .idata$5 = Import Address Table
 222    = array of array of pointers to hint name table.
 223    There is one for each dll being imported from, and each dll's set is
 224    terminated by a trailing NULL.
 225    Initially, this table is identical to the Import Lookup Table.  However,
 226    at load time, the loader overwrites the entries with the address of the
 227    function.
 228
 229    .idata$6 = Hint Name Table
 230    = Array of { short, asciz } entries, one for each imported function.
 231    The `short' is the function's ordinal number.
 232
 233    .idata$7 = dll name (eg: "kernel32.dll"). (.idata$6 for ppc).  */
 234
 235 /* AIX requires this to be the first thing in the file.  */
 236 #ifndef __GNUC__
 237 # ifdef _AIX
 238  #pragma alloca
 239 #endif
 240 #endif
 241
 242 #define show_allnames 0
 243
 244 #define PAGE_SIZE 4096
 245 #define PAGE_MASK (-PAGE_SIZE)
 246 #include "bfd.h"
 247 #include "libiberty.h"
 248 #include "bucomm.h"
 249 #include "getopt.h"
 250 #include "demangle.h"
 251 #include "dyn-string.h"
 252 #include "dlltool.h"
 253 #include "safe-ctype.h"
 254
 255 #include <time.h>
 256 #include <sys/stat.h>
 257
 258 #ifdef ANSI_PROTOTYPES
 259 #include <stdarg.h>
 260 #else
 261 #include <varargs.h>
 262 #endif
 263
 264 #ifdef DLLTOOL_ARM
 265 #include "coff/arm.h"
 266 #include "coff/internal.h"
 267 #endif
 268
 269 /* Forward references.  */
 270 static char *look_for_prog (const char *, const char *, int);
 271 static char *deduce_name (const char *);
 272
 273 #ifdef DLLTOOL_MCORE_ELF
 274 static void mcore_elf_cache_filename (char *);
 275 static void mcore_elf_gen_out_file (void);
 276 #endif
 277
 278 #ifdef HAVE_SYS_WAIT_H
 279 #include <sys/wait.h>
 280 #else /* ! HAVE_SYS_WAIT_H */
 281 #if ! defined (_WIN32) || defined (__CYGWIN32__)
 282 #ifndef WIFEXITED
 283 #define WIFEXITED(w)    (((w) & 0377) == 0)
 284 #endif
 285 #ifndef WIFSIGNALED
 286 #define WIFSIGNALED(w)  (((w) & 0377) != 0177 && ((w) & ~0377) == 0)
 287 #endif
 288 #ifndef WTERMSIG
 289 #define WTERMSIG(w)     ((w) & 0177)
 290 #endif
 291 #ifndef WEXITSTATUS
 292 #define WEXITSTATUS(w)  (((w) >> 8) & 0377)
 293 #endif
 294 #else /* defined (_WIN32) && ! defined (__CYGWIN32__) */
 295 #ifndef WIFEXITED
 296 #define WIFEXITED(w)    (((w) & 0xff) == 0)
 297 #endif
 298 #ifndef WIFSIGNALED
 299 #define WIFSIGNALED(w)  (((w) & 0xff) != 0 && ((w) & 0xff) != 0x7f)
 300 #endif
 301 #ifndef WTERMSIG
 302 #define WTERMSIG(w)     ((w) & 0x7f)
 303 #endif
 304 #ifndef WEXITSTATUS
 305 #define WEXITSTATUS(w)  (((w) & 0xff00) >> 8)
 306 #endif
 307 #endif /* defined (_WIN32) && ! defined (__CYGWIN32__) */
 308 #endif /* ! HAVE_SYS_WAIT_H */
 309
 310 /* ifunc and ihead data structures: ttk@cygnus.com 1997
 311
 312    When IMPORT declarations are encountered in a .def file the
 313    function import information is stored in a structure referenced by
 314    the global variable IMPORT_LIST.  The structure is a linked list
 315    containing the names of the dll files each function is imported
 316    from and a linked list of functions being imported from that dll
 317    file.  This roughly parallels the structure of the .idata section
 318    in the PE object file.
 319
 320    The contents of .def file are interpreted from within the
 321    process_def_file function.  Every time an IMPORT declaration is
 322    encountered, it is broken up into its component parts and passed to
 323    def_import.  IMPORT_LIST is initialized to NULL in function main.  */
 324
 325 typedef struct ifunct
 326 {
 327   char *         name;   /* Name of function being imported.  */
 328   int            ord;    /* Two-byte ordinal value associated with function.  */
 329   struct ifunct *next;
 330 } ifunctype;
 331
 332 typedef struct iheadt
 333 {
 334   char          *dllname;  /* Name of dll file imported from.  */
 335   long           nfuncs;   /* Number of functions in list.  */
 336   struct ifunct *funchead; /* First function in list.  */
 337   struct ifunct *functail; /* Last  function in list.  */
 338   struct iheadt *next;     /* Next dll file in list.  */
 339 } iheadtype;
 340
 341 /* Structure containing all import information as defined in .def file
 342    (qv "ihead structure").  */
 343
 344 static iheadtype *import_list = NULL;
 345
 346 static char *as_name = NULL;
 347 static char * as_flags = "";
 348
 349 static char *tmp_prefix;
 350
 351 static int no_idata4;
 352 static int no_idata5;
 353 static char *exp_name;
 354 static char *imp_name;
 355 static char *head_label;
 356 static char *imp_name_lab;
 357 static char *dll_name;
 358
 359 static int add_indirect = 0;
 360 static int add_underscore = 0;
 361 static int dontdeltemps = 0;
 362
 363 /* TRUE if we should export all symbols.  Otherwise, we only export
 364    symbols listed in .drectve sections or in the def file.  */
 365 static bfd_boolean export_all_symbols;
 366
 367 /* TRUE if we should exclude the symbols in DEFAULT_EXCLUDES when
 368    exporting all symbols.  */
 369 static bfd_boolean do_default_excludes = TRUE;
 370
 371 /* Default symbols to exclude when exporting all the symbols.  */
 372 static const char *default_excludes = "DllMain@12,DllEntryPoint@0,impure_ptr";
 373
 374 /* TRUE if we should add __imp_<SYMBOL> to import libraries for backward
 375    compatibility to old Cygwin releases.  */
 376 static bfd_boolean create_compat_implib;
 377
 378 static char *def_file;
 379
 380 extern char * program_name;
 381
 382 static int machine;
 383 static int killat;
 384 static int add_stdcall_alias;
 385 static int verbose;
 386 static FILE *output_def;
 387 static FILE *base_file;
 388
 389 #ifdef DLLTOOL_ARM
 390 #ifdef DLLTOOL_ARM_EPOC
 391 static const char *mname = "arm-epoc";
 392 #else
 393 static const char *mname = "arm";
 394 #endif
 395 #endif
 396
 397 #ifdef DLLTOOL_I386
 398 static const char *mname = "i386";
 399 #endif
 400
 401 #ifdef DLLTOOL_PPC
 402 static const char *mname = "ppc";
 403 #endif
 404
 405 #ifdef DLLTOOL_SH
 406 static const char *mname = "sh";
 407 #endif
 408
 409 #ifdef DLLTOOL_MIPS
 410 static const char *mname = "mips";
 411 #endif
 412
 413 #ifdef DLLTOOL_MCORE
 414 static const char * mname = "mcore-le";
 415 #endif
 416
 417 #ifdef DLLTOOL_MCORE_ELF
 418 static const char * mname = "mcore-elf";
 419 static char * mcore_elf_out_file = NULL;
 420 static char * mcore_elf_linker   = NULL;
 421 static char * mcore_elf_linker_flags = NULL;
 422
 423 #define DRECTVE_SECTION_NAME ((machine == MMCORE_ELF || machine == MMCORE_ELF_LE) ? ".exports" : ".drectve")
 424 #endif
 425
 426 #ifndef DRECTVE_SECTION_NAME
 427 #define DRECTVE_SECTION_NAME ".drectve"
 428 #endif
 429
 430 #define PATHMAX 250             /* What's the right name for this ?  */
 431
 432 char *tmp_asm_buf;
 433 char *tmp_head_s_buf;
 434 char *tmp_head_o_buf;
 435 char *tmp_tail_s_buf;
 436 char *tmp_tail_o_buf;
 437 char *tmp_stub_buf;
 438
 439 #define TMP_ASM         dlltmp (&tmp_asm_buf, "%sc.s")
 440 #define TMP_HEAD_S      dlltmp (&tmp_head_s_buf, "%sh.s")
 441 #define TMP_HEAD_O      dlltmp (&tmp_head_o_buf, "%sh.o")
 442 #define TMP_TAIL_S      dlltmp (&tmp_tail_s_buf, "%st.s")
 443 #define TMP_TAIL_O      dlltmp (&tmp_tail_o_buf, "%st.o")
 444 #define TMP_STUB        dlltmp (&tmp_stub_buf, "%ss")
 445
 446 /* This bit of assembly does jmp * ....  */
 447 static const unsigned char i386_jtab[] =
 448 {
 449   0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
 450 };
 451
 452 static const unsigned char arm_jtab[] =
 453 {
 454   0x00, 0xc0, 0x9f, 0xe5,       /* ldr  ip, [pc] */
 455   0x00, 0xf0, 0x9c, 0xe5,       /* ldr  pc, [ip] */
 456   0,    0,    0,    0
 457 };
 458
 459 static const unsigned char arm_interwork_jtab[] =
 460 {
 461   0x04, 0xc0, 0x9f, 0xe5,       /* ldr  ip, [pc] */
 462   0x00, 0xc0, 0x9c, 0xe5,       /* ldr  ip, [ip] */
 463   0x1c, 0xff, 0x2f, 0xe1,       /* bx   ip       */
 464   0,    0,    0,    0
 465 };
 466
 467 static const unsigned char thumb_jtab[] =
 468 {
 469   0x40, 0xb4,           /* push {r6}         */
 470   0x02, 0x4e,           /* ldr  r6, [pc, #8] */
 471   0x36, 0x68,           /* ldr  r6, [r6]     */
 472   0xb4, 0x46,           /* mov  ip, r6       */
 473   0x40, 0xbc,           /* pop  {r6}         */
 474   0x60, 0x47,           /* bx   ip           */
 475   0,    0,    0,    0
 476 };
 477
 478 static const unsigned char mcore_be_jtab[] =
 479 {
 480   0x71, 0x02,            /* lrw r1,2       */
 481   0x81, 0x01,            /* ld.w r1,(r1,0) */
 482   0x00, 0xC1,            /* jmp r1         */
 483   0x12, 0x00,            /* nop            */
 484   0x00, 0x00, 0x00, 0x00 /* <address>      */
 485 };
 486
 487 static const unsigned char mcore_le_jtab[] =
 488 {
 489   0x02, 0x71,            /* lrw r1,2       */
 490   0x01, 0x81,            /* ld.w r1,(r1,0) */
 491   0xC1, 0x00,            /* jmp r1         */
 492   0x00, 0x12,            /* nop            */
 493   0x00, 0x00, 0x00, 0x00 /* <address>      */
 494 };
 495
 496 /* This is the glue sequence for PowerPC PE. There is a
 497    tocrel16-tocdefn reloc against the first instruction.
 498    We also need a IMGLUE reloc against the glue function
 499    to restore the toc saved by the third instruction in
 500    the glue.  */
 501 static const unsigned char ppc_jtab[] =
 502 {
 503   0x00, 0x00, 0x62, 0x81, /* lwz r11,0(r2)               */
 504                           /*   Reloc TOCREL16 __imp_xxx  */
 505   0x00, 0x00, 0x8B, 0x81, /* lwz r12,0(r11)              */
 506   0x04, 0x00, 0x41, 0x90, /* stw r2,4(r1)                */
 507   0xA6, 0x03, 0x89, 0x7D, /* mtctr r12                   */
 508   0x04, 0x00, 0x4B, 0x80, /* lwz r2,4(r11)               */
 509   0x20, 0x04, 0x80, 0x4E  /* bctr                        */
 510 };
 511
 512 #ifdef DLLTOOL_PPC
 513 /* The glue instruction, picks up the toc from the stw in
 514    the above code: "lwz r2,4(r1)".  */
 515 static bfd_vma ppc_glue_insn = 0x80410004;
 516 #endif
 517
 518 struct mac
 519   {
 520     const char *type;
 521     const char *how_byte;
 522     const char *how_short;
 523     const char *how_long;
 524     const char *how_asciz;
 525     const char *how_comment;
 526     const char *how_jump;
 527     const char *how_global;
 528     const char *how_space;
 529     const char *how_align_short;
 530     const char *how_align_long;
 531     const char *how_default_as_switches;
 532     const char *how_bfd_target;
 533     enum bfd_architecture how_bfd_arch;
 534     const unsigned char *how_jtab;
 535     int how_jtab_size; /* Size of the jtab entry.  */
 536     int how_jtab_roff; /* Offset into it for the ind 32 reloc into idata 5.  */
 537   };
 538
 539 static const struct mac
 540 mtable[] =
 541 {
 542   {
 543 #define MARM 0
 544     "arm", ".byte", ".short", ".long", ".asciz", "@",
 545     "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
 546     ".global", ".space", ".align\t2",".align\t4", "-mapcs-32",
 547     "pe-arm-little", bfd_arch_arm,
 548     arm_jtab, sizeof (arm_jtab), 8
 549   }
 550   ,
 551   {
 552 #define M386 1
 553     "i386", ".byte", ".short", ".long", ".asciz", "#",
 554     "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
 555     "pe-i386",bfd_arch_i386,
 556     i386_jtab, sizeof (i386_jtab), 2
 557   }
 558   ,
 559   {
 560 #define MPPC 2
 561     "ppc", ".byte", ".short", ".long", ".asciz", "#",
 562     "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
 563     "pe-powerpcle",bfd_arch_powerpc,
 564     ppc_jtab, sizeof (ppc_jtab), 0
 565   }
 566   ,
 567   {
 568 #define MTHUMB 3
 569     "thumb", ".byte", ".short", ".long", ".asciz", "@",
 570     "push\t{r6}\n\tldr\tr6, [pc, #8]\n\tldr\tr6, [r6]\n\tmov\tip, r6\n\tpop\t{r6}\n\tbx\tip",
 571     ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
 572     "pe-arm-little", bfd_arch_arm,
 573     thumb_jtab, sizeof (thumb_jtab), 12
 574   }
 575   ,
 576 #define MARM_INTERWORK 4
 577   {
 578     "arm_interwork", ".byte", ".short", ".long", ".asciz", "@",
 579     "ldr\tip,[pc]\n\tldr\tip,[ip]\n\tbx\tip\n\t.long",
 580     ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
 581     "pe-arm-little", bfd_arch_arm,
 582     arm_interwork_jtab, sizeof (arm_interwork_jtab), 12
 583   }
 584   ,
 585   {
 586 #define MMCORE_BE 5
 587     "mcore-be", ".byte", ".short", ".long", ".asciz", "//",
 588     "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
 589     ".global", ".space", ".align\t2",".align\t4", "",
 590     "pe-mcore-big", bfd_arch_mcore,
 591     mcore_be_jtab, sizeof (mcore_be_jtab), 8
 592   }
 593   ,
 594   {
 595 #define MMCORE_LE 6
 596     "mcore-le", ".byte", ".short", ".long", ".asciz", "//",
 597     "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
 598     ".global", ".space", ".align\t2",".align\t4", "-EL",
 599     "pe-mcore-little", bfd_arch_mcore,
 600     mcore_le_jtab, sizeof (mcore_le_jtab), 8
 601   }
 602   ,
 603   {
 604 #define MMCORE_ELF 7
 605     "mcore-elf-be", ".byte", ".short", ".long", ".asciz", "//",
 606     "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
 607     ".global", ".space", ".align\t2",".align\t4", "",
 608     "elf32-mcore-big", bfd_arch_mcore,
 609     mcore_be_jtab, sizeof (mcore_be_jtab), 8
 610   }
 611   ,
 612   {
 613 #define MMCORE_ELF_LE 8
 614     "mcore-elf-le", ".byte", ".short", ".long", ".asciz", "//",
 615     "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
 616     ".global", ".space", ".align\t2",".align\t4", "-EL",
 617     "elf32-mcore-little", bfd_arch_mcore,
 618     mcore_le_jtab, sizeof (mcore_le_jtab), 8
 619   }
 620   ,
 621   {
 622 #define MARM_EPOC 9
 623     "arm-epoc", ".byte", ".short", ".long", ".asciz", "@",
 624     "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
 625     ".global", ".space", ".align\t2",".align\t4", "",
 626     "epoc-pe-arm-little", bfd_arch_arm,
 627     arm_jtab, sizeof (arm_jtab), 8
 628   }
 629   ,
 630   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
 631 };
 632
 633 typedef struct dlist
 634 {
 635   char *text;
 636   struct dlist *next;
 637 }
 638 dlist_type;
 639
 640 typedef struct export
 641   {
 642     const char *name;
 643     const char *internal_name;
 644     int ordinal;
 645     int constant;
 646     int noname;         /* Don't put name in image file.  */
 647     int private;        /* Don't put reference in import lib.  */
 648     int data;
 649     int hint;
 650     int forward;        /* Number of forward label, 0 means no forward.  */
 651     struct export *next;
 652   }
 653 export_type;
 654
 655 /* A list of symbols which we should not export.  */
 656
 657 struct string_list
 658 {
 659   struct string_list *next;
 660   char *string;
 661 };
 662
 663 static struct string_list *excludes;
 664
 665 static const char *rvaafter (int);
 666 static const char *rvabefore (int);
 667 static const char *asm_prefix (int);
 668 static void process_def_file (const char *);
 669 static void new_directive (char *);
 670 static void append_import (const char *, const char *, int);
 671 static void run (const char *, char *);
 672 static void scan_drectve_symbols (bfd *);
 673 static void scan_filtered_symbols (bfd *, void *, long, unsigned int);
 674 static void add_excludes (const char *);
 675 static bfd_boolean match_exclude (const char *);
 676 static void set_default_excludes (void);
 677 static long filter_symbols (bfd *, void *, long, unsigned int);
 678 static void scan_all_symbols (bfd *);
 679 static void scan_open_obj_file (bfd *);
 680 static void scan_obj_file (const char *);
 681 static void dump_def_info (FILE *);
 682 static int sfunc (const void *, const void *);
 683 static void flush_page (FILE *, long *, int, int);
 684 static void gen_def_file (void);
 685 static void generate_idata_ofile (FILE *);
 686 static void assemble_file (const char *, const char *);
 687 static void gen_exp_file (void);
 688 static const char *xlate (const char *);
 689 #if 0
 690 static void dump_iat (FILE *, export_type *);
 691 #endif
 692 static char *make_label (const char *, const char *);
 693 static char *make_imp_label (const char *, const char *);
 694 static bfd *make_one_lib_file (export_type *, int);
 695 static bfd *make_head (void);
 696 static bfd *make_tail (void);
 697 static void gen_lib_file (void);
 698 static int pfunc (const void *, const void *);
 699 static int nfunc (const void *, const void *);
 700 static void remove_null_names (export_type **);
 701 static void dtab (export_type **);
 702 static void process_duplicates (export_type **);
 703 static void fill_ordinals (export_type **);
 704 static int alphafunc (const void *, const void *);
 705 static void mangle_defs (void);
 706 static void usage (FILE *, int);
 707 static void inform (const char *, ...);
 708
 709 static char *
 710 prefix_encode (char *start, unsigned code)
 711 {
 712   static char alpha[26] = "abcdefghijklmnopqrstuvwxyz";
 713   static char buf[32];
 714   char *p;
 715   strcpy (buf, start);
 716   p = strchr (buf, '\0');
 717   do
 718     *p++ = alpha[code % sizeof (alpha)];
 719   while ((code /= sizeof (alpha)) != 0);
 720   *p = '\0';
 721   return buf;
 722 }
 723
 724 static char *
 725 dlltmp (char **buf, const char *fmt)
 726 {
 727   if (!*buf)
 728     {
 729       *buf = malloc (strlen (tmp_prefix) + 64);
 730       sprintf (*buf, fmt, tmp_prefix);
 731     }
 732   return *buf;
 733 }
 734
 735 static void
 736 inform VPARAMS ((const char * message, ...))
 737 {
 738   VA_OPEN (args, message);
 739   VA_FIXEDARG (args, const char *, message);
 740
 741   if (!verbose)
 742     return;
 743
 744   report (message, args);
 745
 746   VA_CLOSE (args);
 747 }
 748
 749 static const char *
 750 rvaafter (int machine)
 751 {
 752   switch (machine)
 753     {
 754     case MARM:
 755     case M386:
 756     case MPPC:
 757     case MTHUMB:
 758     case MARM_INTERWORK:
 759     case MMCORE_BE:
 760     case MMCORE_LE:
 761     case MMCORE_ELF:
 762     case MMCORE_ELF_LE:
 763     case MARM_EPOC:
 764       break;
 765     default:
 766       /* xgettext:c-format */
 767       fatal (_("Internal error: Unknown machine type: %d"), machine);
 768       break;
 769     }
 770   return "";
 771 }
 772
 773 static const char *
 774 rvabefore (int machine)
 775 {
 776   switch (machine)
 777     {
 778     case MARM:
 779     case M386:
 780     case MPPC:
 781     case MTHUMB:
 782     case MARM_INTERWORK:
 783     case MMCORE_BE:
 784     case MMCORE_LE:
 785     case MMCORE_ELF:
 786     case MMCORE_ELF_LE:
 787     case MARM_EPOC:
 788       return ".rva\t";
 789     default:
 790       /* xgettext:c-format */
 791       fatal (_("Internal error: Unknown machine type: %d"), machine);
 792       break;
 793     }
 794   return "";
 795 }
 796
 797 static const char *
 798 asm_prefix (int machine)
 799 {
 800   switch (machine)
 801     {
 802     case MARM:
 803     case MPPC:
 804     case MTHUMB:
 805     case MARM_INTERWORK:
 806     case MMCORE_BE:
 807     case MMCORE_LE:
 808     case MMCORE_ELF:
 809     case MMCORE_ELF_LE:
 810     case MARM_EPOC:
 811       break;
 812     case M386:
 813       return "_";
 814     default:
 815       /* xgettext:c-format */
 816       fatal (_("Internal error: Unknown machine type: %d"), machine);
 817       break;
 818     }
 819   return "";
 820 }
 821
 822 #define ASM_BYTE        mtable[machine].how_byte
 823 #define ASM_SHORT       mtable[machine].how_short
 824 #define ASM_LONG        mtable[machine].how_long
 825 #define ASM_TEXT        mtable[machine].how_asciz
 826 #define ASM_C           mtable[machine].how_comment
 827 #define ASM_JUMP        mtable[machine].how_jump
 828 #define ASM_GLOBAL      mtable[machine].how_global
 829 #define ASM_SPACE       mtable[machine].how_space
 830 #define ASM_ALIGN_SHORT mtable[machine].how_align_short
 831 #define ASM_RVA_BEFORE  rvabefore(machine)
 832 #define ASM_RVA_AFTER   rvaafter(machine)
 833 #define ASM_PREFIX      asm_prefix(machine)
 834 #define ASM_ALIGN_LONG  mtable[machine].how_align_long
 835 #define HOW_BFD_READ_TARGET  0  /* always default*/
 836 #define HOW_BFD_WRITE_TARGET mtable[machine].how_bfd_target
 837 #define HOW_BFD_ARCH    mtable[machine].how_bfd_arch
 838 #define HOW_JTAB        mtable[machine].how_jtab
 839 #define HOW_JTAB_SIZE   mtable[machine].how_jtab_size
 840 #define HOW_JTAB_ROFF   mtable[machine].how_jtab_roff
 841 #define ASM_SWITCHES    mtable[machine].how_default_as_switches
 842
 843 static char **oav;
 844
 845 static void
 846 process_def_file (const char *name)
 847 {
 848   FILE *f = fopen (name, FOPEN_RT);
 849
 850   if (!f)
 851     /* xgettext:c-format */
 852     fatal (_("Can't open def file: %s"), name);
 853
 854   yyin = f;
 855
 856   /* xgettext:c-format */
 857   inform (_("Processing def file: %s"), name);
 858
 859   yyparse ();
 860
 861   inform (_("Processed def file"));
 862 }
 863
 864 /**********************************************************************/
 865
 866 /* Communications with the parser.  */
 867
 868 static const char *d_name;      /* Arg to NAME or LIBRARY.  */
 869 static int d_nfuncs;            /* Number of functions exported.  */
 870 static int d_named_nfuncs;      /* Number of named functions exported.  */
 871 static int d_low_ord;           /* Lowest ordinal index.  */
 872 static int d_high_ord;          /* Highest ordinal index.  */
 873 static export_type *d_exports;  /* List of exported functions.  */
 874 static export_type **d_exports_lexically;  /* Vector of exported functions in alpha order.  */
 875 static dlist_type *d_list;      /* Descriptions.  */
 876 static dlist_type *a_list;      /* Stuff to go in directives.  */
 877 static int d_nforwards = 0;     /* Number of forwarded exports.  */
 878
 879 static int d_is_dll;
 880 static int d_is_exe;
 881
 882 int
 883 yyerror (const char * err ATTRIBUTE_UNUSED)
 884 {
 885   /* xgettext:c-format */
 886   non_fatal (_("Syntax error in def file %s:%d"), def_file, linenumber);
 887
 888   return 0;
 889 }
 890
 891 void
 892 def_exports (const char *name, const char *internal_name, int ordinal,
 893              int noname, int constant, int data, int private)
 894 {
 895   struct export *p = (struct export *) xmalloc (sizeof (*p));
 896
 897   p->name = name;
 898   p->internal_name = internal_name ? internal_name : name;
 899   p->ordinal = ordinal;
 900   p->constant = constant;
 901   p->noname = noname;
 902   p->private = private;
 903   p->data = data;
 904   p->next = d_exports;
 905   d_exports = p;
 906   d_nfuncs++;
 907
 908   if ((internal_name != NULL)
 909       && (strchr (internal_name, '.') != NULL))
 910     p->forward = ++d_nforwards;
 911   else
 912     p->forward = 0; /* no forward */
 913 }
 914
 915 void
 916 def_name (const char *name, int base)
 917 {
 918   /* xgettext:c-format */
 919   inform (_("NAME: %s base: %x"), name, base);
 920
 921   if (d_is_dll)
 922     non_fatal (_("Can't have LIBRARY and NAME"));
 923
 924   d_name = name;
 925   /* If --dllname not provided, use the one in the DEF file.
 926      FIXME: Is this appropriate for executables?  */
 927   if (! dll_name)
 928     dll_name = xstrdup (name);
 929   d_is_exe = 1;
 930 }
 931
 932 void
 933 def_library (const char *name, int base)
 934 {
 935   /* xgettext:c-format */
 936   inform (_("LIBRARY: %s base: %x"), name, base);
 937
 938   if (d_is_exe)
 939     non_fatal (_("Can't have LIBRARY and NAME"));
 940
 941   d_name = name;
 942   /* If --dllname not provided, use the one in the DEF file.  */
 943   if (! dll_name)
 944     dll_name = xstrdup (name);
 945   d_is_dll = 1;
 946 }
 947
 948 void
 949 def_description (const char *desc)
 950 {
 951   dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
 952   d->text = xstrdup (desc);
 953   d->next = d_list;
 954   d_list = d;
 955 }
 956
 957 static void
 958 new_directive (char *dir)
 959 {
 960   dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
 961   d->text = xstrdup (dir);
 962   d->next = a_list;
 963   a_list = d;
 964 }
 965
 966 void
 967 def_heapsize (int reserve, int commit)
 968 {
 969   char b[200];
 970   if (commit > 0)
 971     sprintf (b, "-heap 0x%x,0x%x ", reserve, commit);
 972   else
 973     sprintf (b, "-heap 0x%x ", reserve);
 974   new_directive (xstrdup (b));
 975 }
 976
 977 void
 978 def_stacksize (int reserve, int commit)
 979 {
 980   char b[200];
 981   if (commit > 0)
 982     sprintf (b, "-stack 0x%x,0x%x ", reserve, commit);
 983   else
 984     sprintf (b, "-stack 0x%x ", reserve);
 985   new_directive (xstrdup (b));
 986 }
 987
 988 /* append_import simply adds the given import definition to the global
 989    import_list.  It is used by def_import.  */
 990
 991 static void
 992 append_import (const char *symbol_name, const char *dll_name, int func_ordinal)
 993 {
 994   iheadtype **pq;
 995   iheadtype *q;
 996
 997   for (pq = &import_list; *pq != NULL; pq = &(*pq)->next)
 998     {
 999       if (strcmp ((*pq)->dllname, dll_name) == 0)
1000         {
1001           q = *pq;
1002           q->functail->next = xmalloc (sizeof (ifunctype));
1003           q->functail = q->functail->next;
1004           q->functail->ord  = func_ordinal;
1005           q->functail->name = xstrdup (symbol_name);
1006           q->functail->next = NULL;
1007           q->nfuncs++;
1008           return;
1009         }
1010     }
1011
1012   q = xmalloc (sizeof (iheadtype));
1013   q->dllname = xstrdup (dll_name);
1014   q->nfuncs = 1;
1015   q->funchead = xmalloc (sizeof (ifunctype));
1016   q->functail = q->funchead;
1017   q->next = NULL;
1018   q->functail->name = xstrdup (symbol_name);
1019   q->functail->ord  = func_ordinal;
1020   q->functail->next = NULL;
1021
1022   *pq = q;
1023 }
1024
1025 /* def_import is called from within defparse.y when an IMPORT
1026    declaration is encountered.  Depending on the form of the
1027    declaration, the module name may or may not need ".dll" to be
1028    appended to it, the name of the function may be stored in internal
1029    or entry, and there may or may not be an ordinal value associated
1030    with it.  */
1031
1032 /* A note regarding the parse modes:
1033    In defparse.y we have to accept import declarations which follow
1034    any one of the following forms:
1035      <func_name_in_app> = <dll_name>.<func_name_in_dll>
1036      <func_name_in_app> = <dll_name>.<number>
1037      <dll_name>.<func_name_in_dll>
1038      <dll_name>.<number>
1039    Furthermore, the dll's name may or may not end with ".dll", which
1040    complicates the parsing a little.  Normally the dll's name is
1041    passed to def_import() in the "module" parameter, but when it ends
1042    with ".dll" it gets passed in "module" sans ".dll" and that needs
1043    to be reappended.
1044
1045   def_import gets five parameters:
1046   APP_NAME - the name of the function in the application, if
1047              present, or NULL if not present.
1048   MODULE   - the name of the dll, possibly sans extension (ie, '.dll').
1049   DLLEXT   - the extension of the dll, if present, NULL if not present.
1050   ENTRY    - the name of the function in the dll, if present, or NULL.
1051   ORD_VAL  - the numerical tag of the function in the dll, if present,
1052              or NULL.  Exactly one of <entry> or <ord_val> must be
1053              present (i.e., not NULL).  */
1054
1055 void
1056 def_import (const char *app_name, const char *module, const char *dllext,
1057             const char *entry, int ord_val)
1058 {
1059   const char *application_name;
1060   char *buf;
1061
1062   if (entry != NULL)
1063     application_name = entry;
1064   else
1065     {
1066       if (app_name != NULL)
1067         application_name = app_name;
1068       else
1069         application_name = "";
1070     }
1071
1072   if (dllext != NULL)
1073     {
1074       buf = (char *) alloca (strlen (module) + strlen (dllext) + 2);
1075       sprintf (buf, "%s.%s", module, dllext);
1076       module = buf;
1077     }
1078
1079   append_import (application_name, module, ord_val);
1080 }
1081
1082 void
1083 def_version (int major, int minor)
1084 {
1085   printf ("VERSION %d.%d\n", major, minor);
1086 }
1087
1088 void
1089 def_section (const char *name, int attr)
1090 {
1091   char buf[200];
1092   char atts[5];
1093   char *d = atts;
1094   if (attr & 1)
1095     *d++ = 'R';
1096
1097   if (attr & 2)
1098     *d++ = 'W';
1099   if (attr & 4)
1100     *d++ = 'X';
1101   if (attr & 8)
1102     *d++ = 'S';
1103   *d++ = 0;
1104   sprintf (buf, "-attr %s %s", name, atts);
1105   new_directive (xstrdup (buf));
1106 }
1107
1108 void
1109 def_code (int attr)
1110 {
1111
1112   def_section ("CODE", attr);
1113 }
1114
1115 void
1116 def_data (int attr)
1117 {
1118   def_section ("DATA", attr);
1119 }
1120
1121 /**********************************************************************/
1122
1123 static void
1124 run (const char *what, char *args)
1125 {
1126   char *s;
1127   int pid, wait_status;
1128   int i;
1129   const char **argv;
1130   char *errmsg_fmt, *errmsg_arg;
1131   char *temp_base = choose_temp_base ();
1132
1133   inform ("run: %s %s", what, args);
1134
1135   /* Count the args */
1136   i = 0;
1137   for (s = args; *s; s++)
1138     if (*s == ' ')
1139       i++;
1140   i++;
1141   argv = alloca (sizeof (char *) * (i + 3));
1142   i = 0;
1143   argv[i++] = what;
1144   s = args;
1145   while (1)
1146     {
1147       while (*s == ' ')
1148         ++s;
1149       argv[i++] = s;
1150       while (*s != ' ' && *s != 0)
1151         s++;
1152       if (*s == 0)
1153         break;
1154       *s++ = 0;
1155     }
1156   argv[i++] = NULL;
1157
1158   pid = pexecute (argv[0], (char * const *) argv, program_name, temp_base,
1159                   &errmsg_fmt, &errmsg_arg, PEXECUTE_ONE | PEXECUTE_SEARCH);
1160
1161   if (pid == -1)
1162     {
1163       inform (strerror (errno));
1164
1165       fatal (errmsg_fmt, errmsg_arg);
1166     }
1167
1168   pid = pwait (pid, & wait_status, 0);
1169
1170   if (pid == -1)
1171     {
1172       /* xgettext:c-format */
1173       fatal (_("wait: %s"), strerror (errno));
1174     }
1175   else if (WIFSIGNALED (wait_status))
1176     {
1177       /* xgettext:c-format */
1178       fatal (_("subprocess got fatal signal %d"), WTERMSIG (wait_status));
1179     }
1180   else if (WIFEXITED (wait_status))
1181     {
1182       if (WEXITSTATUS (wait_status) != 0)
1183         /* xgettext:c-format */
1184         non_fatal (_("%s exited with status %d"),
1185                    what, WEXITSTATUS (wait_status));
1186     }
1187   else
1188     abort ();
1189 }
1190
1191 /* Look for a list of symbols to export in the .drectve section of
1192    ABFD.  Pass each one to def_exports.  */
1193
1194 static void
1195 scan_drectve_symbols (bfd *abfd)
1196 {
1197   asection * s;
1198   int        size;
1199   char *     buf;
1200   char *     p;
1201   char *     e;
1202
1203   /* Look for .drectve's */
1204   s = bfd_get_section_by_name (abfd, DRECTVE_SECTION_NAME);
1205
1206   if (s == NULL)
1207     return;
1208
1209   size = bfd_get_section_size_before_reloc (s);
1210   buf  = xmalloc (size);
1211
1212   bfd_get_section_contents (abfd, s, buf, 0, size);
1213
1214   /* xgettext:c-format */
1215   inform (_("Sucking in info from %s section in %s"),
1216           DRECTVE_SECTION_NAME, bfd_get_filename (abfd));
1217
1218   /* Search for -export: strings. The exported symbols can optionally
1219      have type tags (eg., -export:foo,data), so handle those as well.
1220      Currently only data tag is supported.  */
1221   p = buf;
1222   e = buf + size;
1223   while (p < e)
1224     {
1225       if (p[0] == '-'
1226           && strncmp (p, "-export:", 8) == 0)
1227         {
1228           char * name;
1229           char * c;
1230           flagword flags = BSF_FUNCTION;
1231
1232           p += 8;
1233           name = p;
1234           while (p < e && *p != ',' && *p != ' ' && *p != '-')
1235             p++;
1236           c = xmalloc (p - name + 1);
1237           memcpy (c, name, p - name);
1238           c[p - name] = 0;
1239           if (p < e && *p == ',')       /* found type tag.  */
1240             {
1241               char *tag_start = ++p;
1242               while (p < e && *p != ' ' && *p != '-')
1243                 p++;
1244               if (strncmp (tag_start, "data", 4) == 0)
1245                 flags &= ~BSF_FUNCTION;
1246             }
1247
1248           /* FIXME: The 5th arg is for the `constant' field.
1249              What should it be?  Not that it matters since it's not
1250              currently useful.  */
1251           def_exports (c, 0, -1, 0, 0, ! (flags & BSF_FUNCTION), 0);
1252
1253           if (add_stdcall_alias && strchr (c, '@'))
1254             {
1255               int lead_at = (*c == '@') ;
1256               char *exported_name = xstrdup (c + lead_at);
1257               char *atsym = strchr (exported_name, '@');
1258               *atsym = '\0';
1259               /* Note: stdcall alias symbols can never be data.  */
1260               def_exports (exported_name, xstrdup (c), -1, 0, 0, 0, 0);
1261             }
1262         }
1263       else
1264         p++;
1265     }
1266   free (buf);
1267 }
1268
1269 /* Look through the symbols in MINISYMS, and add each one to list of
1270    symbols to export.  */
1271
1272 static void
1273 scan_filtered_symbols (bfd *abfd, void *minisyms, long symcount,
1274                        unsigned int size)
1275 {
1276   asymbol *store;
1277   bfd_byte *from, *fromend;
1278
1279   store = bfd_make_empty_symbol (abfd);
1280   if (store == NULL)
1281     bfd_fatal (bfd_get_filename (abfd));
1282
1283   from = (bfd_byte *) minisyms;
1284   fromend = from + symcount * size;
1285   for (; from < fromend; from += size)
1286     {
1287       asymbol *sym;
1288       const char *symbol_name;
1289
1290       sym = bfd_minisymbol_to_symbol (abfd, FALSE, from, store);
1291       if (sym == NULL)
1292         bfd_fatal (bfd_get_filename (abfd));
1293
1294       symbol_name = bfd_asymbol_name (sym);
1295       if (bfd_get_symbol_leading_char (abfd) == symbol_name[0])
1296         ++symbol_name;
1297
1298       def_exports (xstrdup (symbol_name) , 0, -1, 0, 0,
1299                    ! (sym->flags & BSF_FUNCTION), 0);
1300
1301       if (add_stdcall_alias && strchr (symbol_name, '@'))
1302         {
1303           int lead_at = (*symbol_name == '@');
1304           char *exported_name = xstrdup (symbol_name + lead_at);
1305           char *atsym = strchr (exported_name, '@');
1306           *atsym = '\0';
1307           /* Note: stdcall alias symbols can never be data.  */
1308           def_exports (exported_name, xstrdup (symbol_name), -1, 0, 0, 0, 0);
1309         }
1310     }
1311 }
1312
1313 /* Add a list of symbols to exclude.  */
1314
1315 static void
1316 add_excludes (const char *new_excludes)
1317 {
1318   char *local_copy;
1319   char *exclude_string;
1320
1321   local_copy = xstrdup (new_excludes);
1322
1323   exclude_string = strtok (local_copy, ",:");
1324   for (; exclude_string; exclude_string = strtok (NULL, ",:"))
1325     {
1326       struct string_list *new_exclude;
1327
1328       new_exclude = ((struct string_list *)
1329                      xmalloc (sizeof (struct string_list)));
1330       new_exclude->string = (char *) xmalloc (strlen (exclude_string) + 2);
1331       /* Don't add a leading underscore for fastcall symbols.  */
1332       if (*exclude_string == '@')
1333         sprintf (new_exclude->string, "%s", exclude_string);
1334       else
1335         sprintf (new_exclude->string, "_%s", exclude_string);
1336       new_exclude->next = excludes;
1337       excludes = new_exclude;
1338
1339       /* xgettext:c-format */
1340       inform (_("Excluding symbol: %s"), exclude_string);
1341     }
1342
1343   free (local_copy);
1344 }
1345
1346 /* See if STRING is on the list of symbols to exclude.  */
1347
1348 static bfd_boolean
1349 match_exclude (const char *string)
1350 {
1351   struct string_list *excl_item;
1352
1353   for (excl_item = excludes; excl_item; excl_item = excl_item->next)
1354     if (strcmp (string, excl_item->string) == 0)
1355       return TRUE;
1356   return FALSE;
1357 }
1358
1359 /* Add the default list of symbols to exclude.  */
1360
1361 static void
1362 set_default_excludes (void)
1363 {
1364   add_excludes (default_excludes);
1365 }
1366
1367 /* Choose which symbols to export.  */
1368
1369 static long
1370 filter_symbols (bfd *abfd, void *minisyms, long symcount, unsigned int size)
1371 {
1372   bfd_byte *from, *fromend, *to;
1373   asymbol *store;
1374
1375   store = bfd_make_empty_symbol (abfd);
1376   if (store == NULL)
1377     bfd_fatal (bfd_get_filename (abfd));
1378
1379   from = (bfd_byte *) minisyms;
1380   fromend = from + symcount * size;
1381   to = (bfd_byte *) minisyms;
1382
1383   for (; from < fromend; from += size)
1384     {
1385       int keep = 0;
1386       asymbol *sym;
1387
1388       sym = bfd_minisymbol_to_symbol (abfd, FALSE, (const void *) from, store);
1389       if (sym == NULL)
1390         bfd_fatal (bfd_get_filename (abfd));
1391
1392       /* Check for external and defined only symbols.  */
1393       keep = (((sym->flags & BSF_GLOBAL) != 0
1394                || (sym->flags & BSF_WEAK) != 0
1395                || bfd_is_com_section (sym->section))
1396               && ! bfd_is_und_section (sym->section));
1397
1398       keep = keep && ! match_exclude (sym->name);
1399
1400       if (keep)
1401         {
1402           memcpy (to, from, size);
1403           to += size;
1404         }
1405     }
1406
1407   return (to - (bfd_byte *) minisyms) / size;
1408 }
1409
1410 /* Export all symbols in ABFD, except for ones we were told not to
1411    export.  */
1412
1413 static void
1414 scan_all_symbols (bfd *abfd)
1415 {
1416   long symcount;
1417   void *minisyms;
1418   unsigned int size;
1419
1420   /* Ignore bfds with an import descriptor table.  We assume that any
1421      such BFD contains symbols which are exported from another DLL,
1422      and we don't want to reexport them from here.  */
1423   if (bfd_get_section_by_name (abfd, ".idata$4"))
1424     return;
1425
1426   if (! (bfd_get_file_flags (abfd) & HAS_SYMS))
1427     {
1428       /* xgettext:c-format */
1429       non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1430       return;
1431     }
1432
1433   symcount = bfd_read_minisymbols (abfd, FALSE, &minisyms, &size);
1434   if (symcount < 0)
1435     bfd_fatal (bfd_get_filename (abfd));
1436
1437   if (symcount == 0)
1438     {
1439       /* xgettext:c-format */
1440       non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1441       return;
1442     }
1443
1444   /* Discard the symbols we don't want to export.  It's OK to do this
1445      in place; we'll free the storage anyway.  */
1446
1447   symcount = filter_symbols (abfd, minisyms, symcount, size);
1448   scan_filtered_symbols (abfd, minisyms, symcount, size);
1449
1450   free (minisyms);
1451 }
1452
1453 /* Look at the object file to decide which symbols to export.  */
1454
1455 static void
1456 scan_open_obj_file (bfd *abfd)
1457 {
1458   if (export_all_symbols)
1459     scan_all_symbols (abfd);
1460   else
1461     scan_drectve_symbols (abfd);
1462
1463   /* FIXME: we ought to read in and block out the base relocations.  */
1464
1465   /* xgettext:c-format */
1466   inform (_("Done reading %s"), bfd_get_filename (abfd));
1467 }
1468
1469 static void
1470 scan_obj_file (const char *filename)
1471 {
1472   bfd * f = bfd_openr (filename, 0);
1473
1474   if (!f)
1475     /* xgettext:c-format */
1476     fatal (_("Unable to open object file: %s"), filename);
1477
1478   /* xgettext:c-format */
1479   inform (_("Scanning object file %s"), filename);
1480
1481   if (bfd_check_format (f, bfd_archive))
1482     {
1483       bfd *arfile = bfd_openr_next_archived_file (f, 0);
1484       while (arfile)
1485         {
1486           if (bfd_check_format (arfile, bfd_object))
1487             scan_open_obj_file (arfile);
1488           bfd_close (arfile);
1489           arfile = bfd_openr_next_archived_file (f, arfile);
1490         }
1491
1492 #ifdef DLLTOOL_MCORE_ELF
1493       if (mcore_elf_out_file)
1494         inform (_("Cannot produce mcore-elf dll from archive file: %s"), filename);
1495 #endif
1496     }
1497   else if (bfd_check_format (f, bfd_object))
1498     {
1499       scan_open_obj_file (f);
1500
1501 #ifdef DLLTOOL_MCORE_ELF
1502       if (mcore_elf_out_file)
1503         mcore_elf_cache_filename ((char *) filename);
1504 #endif
1505     }
1506
1507   bfd_close (f);
1508 }
1509
1510 /**********************************************************************/
1511
1512 static void
1513 dump_def_info (FILE *f)
1514 {
1515   int i;
1516   export_type *exp;
1517   fprintf (f, "%s ", ASM_C);
1518   for (i = 0; oav[i]; i++)
1519     fprintf (f, "%s ", oav[i]);
1520   fprintf (f, "\n");
1521   for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1522     {
1523       fprintf (f, "%s  %d = %s %s @ %d %s%s%s%s\n",
1524                ASM_C,
1525                i,
1526                exp->name,
1527                exp->internal_name,
1528                exp->ordinal,
1529                exp->noname ? "NONAME " : "",
1530                exp->private ? "PRIVATE " : "",
1531                exp->constant ? "CONSTANT" : "",
1532                exp->data ? "DATA" : "");
1533     }
1534 }
1535
1536 /* Generate the .exp file.  */
1537
1538 static int
1539 sfunc (const void *a, const void *b)
1540 {
1541   return *(const long *) a - *(const long *) b;
1542 }
1543
1544 static void
1545 flush_page (FILE *f, long *need, int page_addr, int on_page)
1546 {
1547   int i;
1548
1549   /* Flush this page.  */
1550   fprintf (f, "\t%s\t0x%08x\t%s Starting RVA for chunk\n",
1551            ASM_LONG,
1552            page_addr,
1553            ASM_C);
1554   fprintf (f, "\t%s\t0x%x\t%s Size of block\n",
1555            ASM_LONG,
1556            (on_page * 2) + (on_page & 1) * 2 + 8,
1557            ASM_C);
1558
1559   for (i = 0; i < on_page; i++)
1560     {
1561       long needed = need[i];
1562
1563       if (needed)
1564         needed = ((needed - page_addr) | 0x3000) & 0xffff;
1565
1566       fprintf (f, "\t%s\t0x%lx\n", ASM_SHORT, needed);
1567     }
1568
1569   /* And padding */
1570   if (on_page & 1)
1571     fprintf (f, "\t%s\t0x%x\n", ASM_SHORT, 0 | 0x0000);
1572 }
1573
1574 static void
1575 gen_def_file (void)
1576 {
1577   int i;
1578   export_type *exp;
1579
1580   inform (_("Adding exports to output file"));
1581
1582   fprintf (output_def, ";");
1583   for (i = 0; oav[i]; i++)
1584     fprintf (output_def, " %s", oav[i]);
1585
1586   fprintf (output_def, "\nEXPORTS\n");
1587
1588   for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1589     {
1590       char *quote = strchr (exp->name, '.') ? "\"" : "";
1591       char *res = cplus_demangle (exp->internal_name, DMGL_ANSI | DMGL_PARAMS);
1592
1593       if (res)
1594         {
1595           fprintf (output_def,";\t%s\n", res);
1596           free (res);
1597         }
1598
1599       if (strcmp (exp->name, exp->internal_name) == 0)
1600         {
1601           fprintf (output_def, "\t%s%s%s @ %d%s%s%s\n",
1602                    quote,
1603                    exp->name,
1604                    quote,
1605                    exp->ordinal,
1606                    exp->noname ? " NONAME" : "",
1607                    exp->private ? "PRIVATE " : "",
1608                    exp->data ? " DATA" : "");
1609         }
1610       else
1611         {
1612           char * quote1 = strchr (exp->internal_name, '.') ? "\"" : "";
1613           /* char *alias =  */
1614           fprintf (output_def, "\t%s%s%s = %s%s%s @ %d%s%s%s\n",
1615                    quote,
1616                    exp->name,
1617                    quote,
1618                    quote1,
1619                    exp->internal_name,
1620                    quote1,
1621                    exp->ordinal,
1622                    exp->noname ? " NONAME" : "",
1623                    exp->private ? "PRIVATE " : "",
1624                    exp->data ? " DATA" : "");
1625         }
1626     }
1627
1628   inform (_("Added exports to output file"));
1629 }
1630
1631 /* generate_idata_ofile generates the portable assembly source code
1632    for the idata sections.  It appends the source code to the end of
1633    the file.  */
1634
1635 static void
1636 generate_idata_ofile (FILE *filvar)
1637 {
1638   iheadtype *headptr;
1639   ifunctype *funcptr;
1640   int        headindex;
1641   int        funcindex;
1642   int        nheads;
1643
1644   if (import_list == NULL)
1645     return;
1646
1647   fprintf (filvar, "%s Import data sections\n", ASM_C);
1648   fprintf (filvar, "\n\t.section\t.idata$2\n");
1649   fprintf (filvar, "\t%s\tdoi_idata\n", ASM_GLOBAL);
1650   fprintf (filvar, "doi_idata:\n");
1651
1652   nheads = 0;
1653   for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1654     {
1655       fprintf (filvar, "\t%slistone%d%s\t%s %s\n",
1656                ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER,
1657                ASM_C, headptr->dllname);
1658       fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1659       fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1660       fprintf (filvar, "\t%sdllname%d%s\n",
1661                ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1662       fprintf (filvar, "\t%slisttwo%d%s\n\n",
1663                ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1664       nheads++;
1665     }
1666
1667   fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL record at */
1668   fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* end of idata$2 */
1669   fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* section        */
1670   fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1671   fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1672
1673   fprintf (filvar, "\n\t.section\t.idata$4\n");
1674   headindex = 0;
1675   for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1676     {
1677       fprintf (filvar, "listone%d:\n", headindex);
1678       for ( funcindex = 0; funcindex < headptr->nfuncs; funcindex++ )
1679         fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1680                  ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1681       fprintf (filvar,"\t%s\t0\n", ASM_LONG); /* NULL terminating list */
1682       headindex++;
1683     }
1684
1685   fprintf (filvar, "\n\t.section\t.idata$5\n");
1686   headindex = 0;
1687   for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1688     {
1689       fprintf (filvar, "listtwo%d:\n", headindex);
1690       for ( funcindex = 0; funcindex < headptr->nfuncs; funcindex++ )
1691         fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1692                  ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1693       fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list */
1694       headindex++;
1695     }
1696
1697   fprintf (filvar, "\n\t.section\t.idata$6\n");
1698   headindex = 0;
1699   for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1700     {
1701       funcindex = 0;
1702       for (funcptr = headptr->funchead; funcptr != NULL;
1703            funcptr = funcptr->next)
1704         {
1705           fprintf (filvar,"funcptr%d_%d:\n", headindex, funcindex);
1706           fprintf (filvar,"\t%s\t%d\n", ASM_SHORT,
1707                    ((funcptr->ord) & 0xFFFF));
1708           fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, funcptr->name);
1709           fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1710           funcindex++;
1711         }
1712       headindex++;
1713     }
1714
1715   fprintf (filvar, "\n\t.section\t.idata$7\n");
1716   headindex = 0;
1717   for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1718     {
1719       fprintf (filvar,"dllname%d:\n", headindex);
1720       fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, headptr->dllname);
1721       fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1722       headindex++;
1723     }
1724 }
1725
1726 /* Assemble the specified file.  */
1727 static void
1728 assemble_file (const char * source, const char * dest)
1729 {
1730   char * cmd;
1731
1732   cmd = (char *) alloca (strlen (ASM_SWITCHES) + strlen (as_flags)
1733                          + strlen (source) + strlen (dest) + 50);
1734
1735   sprintf (cmd, "%s %s -o %s %s", ASM_SWITCHES, as_flags, dest, source);
1736
1737   run (as_name, cmd);
1738 }
1739
1740 static void
1741 gen_exp_file (void)
1742 {
1743   FILE *f;
1744   int i;
1745   export_type *exp;
1746   dlist_type *dl;
1747
1748   /* xgettext:c-format */
1749   inform (_("Generating export file: %s"), exp_name);
1750
1751   f = fopen (TMP_ASM, FOPEN_WT);
1752   if (!f)
1753     /* xgettext:c-format */
1754     fatal (_("Unable to open temporary assembler file: %s"), TMP_ASM);
1755
1756   /* xgettext:c-format */
1757   inform (_("Opened temporary file: %s"), TMP_ASM);
1758
1759   dump_def_info (f);
1760
1761   if (d_exports)
1762     {
1763       fprintf (f, "\t.section   .edata\n\n");
1764       fprintf (f, "\t%s 0       %s Allways 0\n", ASM_LONG, ASM_C);
1765       fprintf (f, "\t%s 0x%lx   %s Time and date\n", ASM_LONG, (long) time(0),
1766                ASM_C);
1767       fprintf (f, "\t%s 0       %s Major and Minor version\n", ASM_LONG, ASM_C);
1768       fprintf (f, "\t%sname%s   %s Ptr to name of dll\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1769       fprintf (f, "\t%s %d      %s Starting ordinal of exports\n", ASM_LONG, d_low_ord, ASM_C);
1770
1771
1772       fprintf (f, "\t%s %d      %s Number of functions\n", ASM_LONG, d_high_ord - d_low_ord + 1, ASM_C);
1773       fprintf(f,"\t%s named funcs %d, low ord %d, high ord %d\n",
1774               ASM_C,
1775               d_named_nfuncs, d_low_ord, d_high_ord);
1776       fprintf (f, "\t%s %d      %s Number of names\n", ASM_LONG,
1777                show_allnames ? d_high_ord - d_low_ord + 1 : d_named_nfuncs, ASM_C);
1778       fprintf (f, "\t%safuncs%s  %s Address of functions\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1779
1780       fprintf (f, "\t%sanames%s %s Address of Name Pointer Table\n",
1781                ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1782
1783       fprintf (f, "\t%sanords%s %s Address of ordinals\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1784
1785       fprintf (f, "name:        %s      \"%s\"\n", ASM_TEXT, dll_name);
1786
1787
1788       fprintf(f,"%s Export address Table\n", ASM_C);
1789       fprintf(f,"\t%s\n", ASM_ALIGN_LONG);
1790       fprintf (f, "afuncs:\n");
1791       i = d_low_ord;
1792
1793       for (exp = d_exports; exp; exp = exp->next)
1794         {
1795           if (exp->ordinal != i)
1796             {
1797 #if 0
1798               fprintf (f, "\t%s\t%d\t%s %d..%d missing\n",
1799                        ASM_SPACE,
1800                        (exp->ordinal - i) * 4,
1801                        ASM_C,
1802                        i, exp->ordinal - 1);
1803               i = exp->ordinal;
1804 #endif
1805               while (i < exp->ordinal)
1806                 {
1807                   fprintf(f,"\t%s\t0\n", ASM_LONG);
1808                   i++;
1809                 }
1810             }
1811
1812           if (exp->forward == 0)
1813             {
1814               if (exp->internal_name[0] == '@')
1815                 fprintf (f, "\t%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
1816                          exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1817               else
1818                 fprintf (f, "\t%s%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
1819                          ASM_PREFIX,
1820                          exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1821             }
1822           else
1823             fprintf (f, "\t%sf%d%s\t%s %d\n", ASM_RVA_BEFORE,
1824                      exp->forward, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1825           i++;
1826         }
1827
1828       fprintf (f,"%s Export Name Pointer Table\n", ASM_C);
1829       fprintf (f, "anames:\n");
1830
1831       for (i = 0; (exp = d_exports_lexically[i]); i++)
1832         {
1833           if (!exp->noname || show_allnames)
1834             fprintf (f, "\t%sn%d%s\n",
1835                      ASM_RVA_BEFORE, exp->ordinal, ASM_RVA_AFTER);
1836         }
1837
1838       fprintf (f,"%s Export Oridinal Table\n", ASM_C);
1839       fprintf (f, "anords:\n");
1840       for (i = 0; (exp = d_exports_lexically[i]); i++)
1841         {
1842           if (!exp->noname || show_allnames)
1843             fprintf (f, "\t%s   %d\n", ASM_SHORT, exp->ordinal - d_low_ord);
1844         }
1845
1846       fprintf(f,"%s Export Name Table\n", ASM_C);
1847       for (i = 0; (exp = d_exports_lexically[i]); i++)
1848         {
1849           if (!exp->noname || show_allnames)
1850             fprintf (f, "n%d:   %s      \"%s\"\n",
1851                      exp->ordinal, ASM_TEXT, xlate (exp->name));
1852           if (exp->forward != 0)
1853             fprintf (f, "f%d:   %s      \"%s\"\n",
1854                      exp->forward, ASM_TEXT, exp->internal_name);
1855         }
1856
1857       if (a_list)
1858         {
1859           fprintf (f, "\t.section %s\n", DRECTVE_SECTION_NAME);
1860           for (dl = a_list; dl; dl = dl->next)
1861             {
1862               fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, dl->text);
1863             }
1864         }
1865
1866       if (d_list)
1867         {
1868           fprintf (f, "\t.section .rdata\n");
1869           for (dl = d_list; dl; dl = dl->next)
1870             {
1871               char *p;
1872               int l;
1873
1874               /* We don't output as ascii because there can
1875                  be quote characters in the string.  */
1876               l = 0;
1877               for (p = dl->text; *p; p++)
1878                 {
1879                   if (l == 0)
1880                     fprintf (f, "\t%s\t", ASM_BYTE);
1881                   else
1882                     fprintf (f, ",");
1883                   fprintf (f, "%d", *p);
1884                   if (p[1] == 0)
1885                     {
1886                       fprintf (f, ",0\n");
1887                       break;
1888                     }
1889                   if (++l == 10)
1890                     {
1891                       fprintf (f, "\n");
1892                       l = 0;
1893                     }
1894                 }
1895             }
1896         }
1897     }
1898
1899
1900   /* Add to the output file a way of getting to the exported names
1901      without using the import library.  */
1902   if (add_indirect)
1903     {
1904       fprintf (f, "\t.section\t.rdata\n");
1905       for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1906         if (!exp->noname || show_allnames)
1907           {
1908             /* We use a single underscore for MS compatibility, and a
1909                double underscore for backward compatibility with old
1910                cygwin releases.  */
1911             if (create_compat_implib)
1912               fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name);
1913             fprintf (f, "\t%s\t_imp__%s\n", ASM_GLOBAL, exp->name);
1914             if (create_compat_implib)
1915               fprintf (f, "__imp_%s:\n", exp->name);
1916             fprintf (f, "_imp__%s:\n", exp->name);
1917             fprintf (f, "\t%s\t%s\n", ASM_LONG, exp->name);
1918           }
1919     }
1920
1921   /* Dump the reloc section if a base file is provided.  */
1922   if (base_file)
1923     {
1924       int addr;
1925       long need[PAGE_SIZE];
1926       long page_addr;
1927       int numbytes;
1928       int num_entries;
1929       long *copy;
1930       int j;
1931       int on_page;
1932       fprintf (f, "\t.section\t.init\n");
1933       fprintf (f, "lab:\n");
1934
1935       fseek (base_file, 0, SEEK_END);
1936       numbytes = ftell (base_file);
1937       fseek (base_file, 0, SEEK_SET);
1938       copy = xmalloc (numbytes);
1939       fread (copy, 1, numbytes, base_file);
1940       num_entries = numbytes / sizeof (long);
1941
1942
1943       fprintf (f, "\t.section\t.reloc\n");
1944       if (num_entries)
1945         {
1946           int src;
1947           int dst = 0;
1948           int last = -1;
1949           qsort (copy, num_entries, sizeof (long), sfunc);
1950           /* Delete duplicates */
1951           for (src = 0; src < num_entries; src++)
1952             {
1953               if (last != copy[src])
1954                 last = copy[dst++] = copy[src];
1955             }
1956           num_entries = dst;
1957           addr = copy[0];
1958           page_addr = addr & PAGE_MASK;         /* work out the page addr */
1959           on_page = 0;
1960           for (j = 0; j < num_entries; j++)
1961             {
1962               addr = copy[j];
1963               if ((addr & PAGE_MASK) != page_addr)
1964                 {
1965                   flush_page (f, need, page_addr, on_page);
1966                   on_page = 0;
1967                   page_addr = addr & PAGE_MASK;
1968                 }
1969               need[on_page++] = addr;
1970             }
1971           flush_page (f, need, page_addr, on_page);
1972
1973 /*        fprintf (f, "\t%s\t0,0\t%s End\n", ASM_LONG, ASM_C);*/
1974         }
1975     }
1976
1977   generate_idata_ofile (f);
1978
1979   fclose (f);
1980
1981   /* Assemble the file.  */
1982   assemble_file (TMP_ASM, exp_name);
1983
1984   if (dontdeltemps == 0)
1985     unlink (TMP_ASM);
1986
1987   inform (_("Generated exports file"));
1988 }
1989
1990 static const char *
1991 xlate (const char *name)
1992 {
1993   int lead_at = (*name == '@');
1994
1995   if (add_underscore &&  !lead_at)
1996     {
1997       char *copy = xmalloc (strlen (name) + 2);
1998
1999       copy[0] = '_';
2000       strcpy (copy + 1, name);
2001       name = copy;
2002     }
2003
2004   if (killat)
2005     {
2006       char *p;
2007
2008       name += lead_at;
2009       p = strchr (name, '@');
2010       if (p)
2011         *p = 0;
2012     }
2013   return name;
2014 }
2015
2016 /**********************************************************************/
2017
2018 #if 0
2019
2020 static void
2021 dump_iat (FILE *f, export_type *exp)
2022 {
2023   if (exp->noname && !show_allnames )
2024     {
2025       fprintf (f, "\t%s\t0x%08x\n",
2026                ASM_LONG,
2027                exp->ordinal | 0x80000000); /* hint or orindal ?? */
2028     }
2029   else
2030     {
2031       fprintf (f, "\t%sID%d%s\n", ASM_RVA_BEFORE,
2032                exp->ordinal,
2033                ASM_RVA_AFTER);
2034     }
2035 }
2036
2037 #endif
2038
2039 typedef struct
2040 {
2041   int id;
2042   const char *name;
2043   int flags;
2044   int align;
2045   asection *sec;
2046   asymbol *sym;
2047   asymbol **sympp;
2048   int size;
2049   unsigned char *data;
2050 } sinfo;
2051
2052 #ifndef DLLTOOL_PPC
2053
2054 #define TEXT 0
2055 #define DATA 1
2056 #define BSS 2
2057 #define IDATA7 3
2058 #define IDATA5 4
2059 #define IDATA4 5
2060 #define IDATA6 6
2061
2062 #define NSECS 7
2063
2064 #define TEXT_SEC_FLAGS   \
2065         (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY | SEC_HAS_CONTENTS)
2066 #define DATA_SEC_FLAGS   (SEC_ALLOC | SEC_LOAD | SEC_DATA)
2067 #define BSS_SEC_FLAGS     SEC_ALLOC
2068
2069 #define INIT_SEC_DATA(id, name, flags, align) \
2070         { id, name, flags, align, NULL, NULL, NULL, 0, NULL }
2071 static sinfo secdata[NSECS] =
2072 {
2073   INIT_SEC_DATA (TEXT,   ".text",    TEXT_SEC_FLAGS,   2),
2074   INIT_SEC_DATA (DATA,   ".data",    DATA_SEC_FLAGS,   2),
2075   INIT_SEC_DATA (BSS,    ".bss",     BSS_SEC_FLAGS,    2),
2076   INIT_SEC_DATA (IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2),
2077   INIT_SEC_DATA (IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2),
2078   INIT_SEC_DATA (IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2),
2079   INIT_SEC_DATA (IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1)
2080 };
2081
2082 #else
2083
2084 /* Sections numbered to make the order the same as other PowerPC NT
2085    compilers. This also keeps funny alignment thingies from happening.  */
2086 #define TEXT   0
2087 #define PDATA  1
2088 #define RDATA  2
2089 #define IDATA5 3
2090 #define IDATA4 4
2091 #define IDATA6 5
2092 #define IDATA7 6
2093 #define DATA   7
2094 #define BSS    8
2095
2096 #define NSECS 9
2097
2098 static sinfo secdata[NSECS] =
2099 {
2100   { TEXT,   ".text",    SEC_CODE | SEC_HAS_CONTENTS, 3},
2101   { PDATA,  ".pdata",   SEC_HAS_CONTENTS,            2},
2102   { RDATA,  ".reldata", SEC_HAS_CONTENTS,            2},
2103   { IDATA5, ".idata$5", SEC_HAS_CONTENTS,            2},
2104   { IDATA4, ".idata$4", SEC_HAS_CONTENTS,            2},
2105   { IDATA6, ".idata$6", SEC_HAS_CONTENTS,            1},
2106   { IDATA7, ".idata$7", SEC_HAS_CONTENTS,            2},
2107   { DATA,   ".data",    SEC_DATA,                    2},
2108   { BSS,    ".bss",     0,                           2}
2109 };
2110
2111 #endif
2112
2113 /* This is what we're trying to make.  We generate the imp symbols with
2114    both single and double underscores, for compatibility.
2115
2116         .text
2117         .global _GetFileVersionInfoSizeW@8
2118         .global __imp_GetFileVersionInfoSizeW@8
2119 _GetFileVersionInfoSizeW@8:
2120         jmp *   __imp_GetFileVersionInfoSizeW@8
2121         .section        .idata$7        # To force loading of head
2122         .long   __version_a_head
2123 # Import Address Table
2124         .section        .idata$5
2125 __imp_GetFileVersionInfoSizeW@8:
2126         .rva    ID2
2127
2128 # Import Lookup Table
2129         .section        .idata$4
2130         .rva    ID2
2131 # Hint/Name table
2132         .section        .idata$6
2133 ID2:    .short  2
2134         .asciz  "GetFileVersionInfoSizeW"
2135
2136
2137    For the PowerPC, here's the variation on the above scheme:
2138
2139 # Rather than a simple "jmp *", the code to get to the dll function
2140 # looks like:
2141          .text
2142          lwz    r11,[tocv]__imp_function_name(r2)
2143 #                  RELOC: 00000000 TOCREL16,TOCDEFN __imp_function_name
2144          lwz    r12,0(r11)
2145          stw    r2,4(r1)
2146          mtctr  r12
2147          lwz    r2,4(r11)
2148          bctr  */
2149
2150 static char *
2151 make_label (const char *prefix, const char *name)
2152 {
2153   int len = strlen (ASM_PREFIX) + strlen (prefix) + strlen (name);
2154   char *copy = xmalloc (len +1 );
2155
2156   strcpy (copy, ASM_PREFIX);
2157   strcat (copy, prefix);
2158   strcat (copy, name);
2159   return copy;
2160 }
2161
2162 static char *
2163 make_imp_label (const char *prefix, const char *name)
2164 {
2165   int len;
2166   char *copy;
2167
2168   if (name[0] == '@')
2169     {
2170       len = strlen (prefix) + strlen (name);
2171       copy = xmalloc (len + 1);
2172       strcpy (copy, prefix);
2173       strcat (copy, name);
2174     }
2175   else
2176     {
2177       len = strlen (ASM_PREFIX) + strlen (prefix) + strlen (name);
2178       copy = xmalloc (len + 1);
2179       strcpy (copy, prefix);
2180       strcat (copy, ASM_PREFIX);
2181       strcat (copy, name);
2182     }
2183   return copy;
2184 }
2185
2186 static bfd *
2187 make_one_lib_file (export_type *exp, int i)
2188 {
2189 #if 0
2190     {
2191       char *name;
2192       FILE *f;
2193       const char *prefix = "d";
2194       char *dest;
2195
2196       name = (char *) alloca (strlen (prefix) + 10);
2197       sprintf (name, "%ss%05d.s", prefix, i);
2198       f = fopen (name, FOPEN_WT);
2199       fprintf (f, "\t.text\n");
2200       fprintf (f, "\t%s\t%s%s\n", ASM_GLOBAL, ASM_PREFIX, exp->name);
2201       if (create_compat_implib)
2202         fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name);
2203       fprintf (f, "\t%s\t_imp__%s\n", ASM_GLOBAL, exp->name);
2204       if (create_compat_implib)
2205         fprintf (f, "%s%s:\n\t%s\t__imp_%s\n", ASM_PREFIX,
2206                  exp->name, ASM_JUMP, exp->name);
2207
2208       fprintf (f, "\t.section\t.idata$7\t%s To force loading of head\n", ASM_C);
2209       fprintf (f, "\t%s\t%s\n", ASM_LONG, head_label);
2210
2211
2212       fprintf (f,"%s Import Address Table\n", ASM_C);
2213
2214       fprintf (f, "\t.section   .idata$5\n");
2215       if (create_compat_implib)
2216         fprintf (f, "__imp_%s:\n", exp->name);
2217       fprintf (f, "_imp__%s:\n", exp->name);
2218
2219       dump_iat (f, exp);
2220
2221       fprintf (f, "\n%s Import Lookup Table\n", ASM_C);
2222       fprintf (f, "\t.section   .idata$4\n");
2223
2224       dump_iat (f, exp);
2225
2226       if(!exp->noname || show_allnames)
2227         {
2228           fprintf (f, "%s Hint/Name table\n", ASM_C);
2229           fprintf (f, "\t.section       .idata$6\n");
2230           fprintf (f, "ID%d:\t%s\t%d\n", exp->ordinal, ASM_SHORT, exp->hint);
2231           fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, xlate (exp->name));
2232         }
2233
2234       fclose (f);
2235
2236       dest = (char *) alloca (strlen (prefix) + 10);
2237       sprintf (dest, "%ss%05d.o", prefix, i);
2238       assemble_file (name, dest);
2239     }
2240 #else /* if 0 */
2241     {
2242       bfd *      abfd;
2243       asymbol *  exp_label;
2244       asymbol *  iname = 0;
2245       asymbol *  iname2;
2246       asymbol *  iname_lab;
2247       asymbol ** iname_lab_pp;
2248       asymbol ** iname_pp;
2249 #ifdef DLLTOOL_PPC
2250       asymbol ** fn_pp;
2251       asymbol ** toc_pp;
2252 #define EXTRA    2
2253 #endif
2254 #ifndef EXTRA
2255 #define EXTRA    0
2256 #endif
2257       asymbol *  ptrs[NSECS + 4 + EXTRA + 1];
2258       flagword   applicable;
2259
2260       char *     outname = xmalloc (strlen (TMP_STUB) + 10);
2261       int        oidx = 0;
2262
2263
2264       sprintf (outname, "%s%05d.o", TMP_STUB, i);
2265
2266       abfd = bfd_openw (outname, HOW_BFD_WRITE_TARGET);
2267
2268       if (!abfd)
2269         /* xgettext:c-format */
2270         fatal (_("bfd_open failed open stub file: %s"), outname);
2271
2272       /* xgettext:c-format */
2273       inform (_("Creating stub file: %s"), outname);
2274
2275       bfd_set_format (abfd, bfd_object);
2276       bfd_set_arch_mach (abfd, HOW_BFD_ARCH, 0);
2277
2278 #ifdef DLLTOOL_ARM
2279       if (machine == MARM_INTERWORK || machine == MTHUMB)
2280         bfd_set_private_flags (abfd, F_INTERWORK);
2281 #endif
2282
2283       applicable = bfd_applicable_section_flags (abfd);
2284
2285       /* First make symbols for the sections.  */
2286       for (i = 0; i < NSECS; i++)
2287         {
2288           sinfo *si = secdata + i;
2289           if (si->id != i)
2290             abort();
2291           si->sec = bfd_make_section_old_way (abfd, si->name);
2292           bfd_set_section_flags (abfd,
2293                                  si->sec,
2294                                  si->flags & applicable);
2295
2296           bfd_set_section_alignment(abfd, si->sec, si->align);
2297           si->sec->output_section = si->sec;
2298           si->sym = bfd_make_empty_symbol(abfd);
2299           si->sym->name = si->sec->name;
2300           si->sym->section = si->sec;
2301           si->sym->flags = BSF_LOCAL;
2302           si->sym->value = 0;
2303           ptrs[oidx] = si->sym;
2304           si->sympp = ptrs + oidx;
2305           si->size = 0;
2306           si->data = NULL;
2307
2308           oidx++;
2309         }
2310
2311       if (! exp->data)
2312         {
2313           exp_label = bfd_make_empty_symbol (abfd);
2314           exp_label->name = make_imp_label ("", exp->name);
2315
2316           /* On PowerPC, the function name points to a descriptor in
2317              the rdata section, the first element of which is a
2318              pointer to the code (..function_name), and the second
2319              points to the .toc.  */
2320 #ifdef DLLTOOL_PPC
2321           if (machine == MPPC)
2322             exp_label->section = secdata[RDATA].sec;
2323           else
2324 #endif
2325             exp_label->section = secdata[TEXT].sec;
2326
2327           exp_label->flags = BSF_GLOBAL;
2328           exp_label->value = 0;
2329
2330 #ifdef DLLTOOL_ARM
2331           if (machine == MTHUMB)
2332             bfd_coff_set_symbol_class (abfd, exp_label, C_THUMBEXTFUNC);
2333 #endif
2334           ptrs[oidx++] = exp_label;
2335         }
2336
2337       /* Generate imp symbols with one underscore for Microsoft
2338          compatibility, and with two underscores for backward
2339          compatibility with old versions of cygwin.  */
2340       if (create_compat_implib)
2341         {
2342           iname = bfd_make_empty_symbol (abfd);
2343           iname->name = make_imp_label ("___imp", exp->name);
2344           iname->section = secdata[IDATA5].sec;
2345           iname->flags = BSF_GLOBAL;
2346           iname->value = 0;
2347         }
2348
2349       iname2 = bfd_make_empty_symbol (abfd);
2350       iname2->name = make_imp_label ("__imp_", exp->name);
2351       iname2->section = secdata[IDATA5].sec;
2352       iname2->flags = BSF_GLOBAL;
2353       iname2->value = 0;
2354
2355       iname_lab = bfd_make_empty_symbol(abfd);
2356
2357       iname_lab->name = head_label;
2358       iname_lab->section = (asection *)&bfd_und_section;
2359       iname_lab->flags = 0;
2360       iname_lab->value = 0;
2361
2362       iname_pp = ptrs + oidx;
2363       if (create_compat_implib)
2364         ptrs[oidx++] = iname;
2365       ptrs[oidx++] = iname2;
2366
2367       iname_lab_pp = ptrs + oidx;
2368       ptrs[oidx++] = iname_lab;
2369
2370 #ifdef DLLTOOL_PPC
2371       /* The symbol referring to the code (.text).  */
2372       {
2373         asymbol *function_name;
2374
2375         function_name = bfd_make_empty_symbol(abfd);
2376         function_name->name = make_label ("..", exp->name);
2377         function_name->section = secdata[TEXT].sec;
2378         function_name->flags = BSF_GLOBAL;
2379         function_name->value = 0;
2380
2381         fn_pp = ptrs + oidx;
2382         ptrs[oidx++] = function_name;
2383       }
2384
2385       /* The .toc symbol.  */
2386       {
2387         asymbol *toc_symbol;
2388
2389         toc_symbol = bfd_make_empty_symbol (abfd);
2390         toc_symbol->name = make_label (".", "toc");
2391         toc_symbol->section = (asection *)&bfd_und_section;
2392         toc_symbol->flags = BSF_GLOBAL;
2393         toc_symbol->value = 0;
2394
2395         toc_pp = ptrs + oidx;
2396         ptrs[oidx++] = toc_symbol;
2397       }
2398 #endif
2399
2400       ptrs[oidx] = 0;
2401
2402       for (i = 0; i < NSECS; i++)
2403         {
2404           sinfo *si = secdata + i;
2405           asection *sec = si->sec;
2406           arelent *rel;
2407           arelent **rpp;
2408
2409           switch (i)
2410             {
2411             case TEXT:
2412               if (! exp->data)
2413                 {
2414                   si->size = HOW_JTAB_SIZE;
2415                   si->data = xmalloc (HOW_JTAB_SIZE);
2416                   memcpy (si->data, HOW_JTAB, HOW_JTAB_SIZE);
2417
2418                   /* add the reloc into idata$5 */
2419                   rel = xmalloc (sizeof (arelent));
2420
2421                   rpp = xmalloc (sizeof (arelent *) * 2);
2422                   rpp[0] = rel;
2423                   rpp[1] = 0;
2424
2425                   rel->address = HOW_JTAB_ROFF;
2426                   rel->addend = 0;
2427
2428                   if (machine == MPPC)
2429                     {
2430                       rel->howto = bfd_reloc_type_lookup (abfd,
2431                                                           BFD_RELOC_16_GOTOFF);
2432                       rel->sym_ptr_ptr = iname_pp;
2433                     }
2434                   else
2435                     {
2436                       rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2437                       rel->sym_ptr_ptr = secdata[IDATA5].sympp;
2438                     }
2439                   sec->orelocation = rpp;
2440                   sec->reloc_count = 1;
2441                 }
2442               break;
2443             case IDATA4:
2444             case IDATA5:
2445               /* An idata$4 or idata$5 is one word long, and has an
2446                  rva to idata$6.  */
2447
2448               si->data = xmalloc (4);
2449               si->size = 4;
2450
2451               if (exp->noname)
2452                 {
2453                   si->data[0] = exp->ordinal ;
2454                   si->data[1] = exp->ordinal >> 8;
2455                   si->data[2] = exp->ordinal >> 16;
2456                   si->data[3] = 0x80;
2457                 }
2458               else
2459                 {
2460                   sec->reloc_count = 1;
2461                   memset (si->data, 0, si->size);
2462                   rel = xmalloc (sizeof (arelent));
2463                   rpp = xmalloc (sizeof (arelent *) * 2);
2464                   rpp[0] = rel;
2465                   rpp[1] = 0;
2466                   rel->address = 0;
2467                   rel->addend = 0;
2468                   rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2469                   rel->sym_ptr_ptr = secdata[IDATA6].sympp;
2470                   sec->orelocation = rpp;
2471                 }
2472
2473               break;
2474
2475             case IDATA6:
2476               if (!exp->noname)
2477                 {
2478                   /* This used to add 1 to exp->hint.  I don't know
2479                      why it did that, and it does not match what I see
2480                      in programs compiled with the MS tools.  */
2481                   int idx = exp->hint;
2482                   si->size = strlen (xlate (exp->name)) + 3;
2483                   si->data = xmalloc (si->size);
2484                   si->data[0] = idx & 0xff;
2485                   si->data[1] = idx >> 8;
2486                   strcpy (si->data + 2, xlate (exp->name));
2487                 }
2488               break;
2489             case IDATA7:
2490               si->size = 4;
2491               si->data =xmalloc (4);
2492               memset (si->data, 0, si->size);
2493               rel = xmalloc (sizeof (arelent));
2494               rpp = xmalloc (sizeof (arelent *) * 2);
2495               rpp[0] = rel;
2496               rel->address = 0;
2497               rel->addend = 0;
2498               rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2499               rel->sym_ptr_ptr = iname_lab_pp;
2500               sec->orelocation = rpp;
2501               sec->reloc_count = 1;
2502               break;
2503
2504 #ifdef DLLTOOL_PPC
2505             case PDATA:
2506               {
2507                 /* The .pdata section is 5 words long.
2508                    Think of it as:
2509                    struct
2510                    {
2511                      bfd_vma BeginAddress,     [0x00]
2512                              EndAddress,       [0x04]
2513                              ExceptionHandler, [0x08]
2514                              HandlerData,      [0x0c]
2515                              PrologEndAddress; [0x10]
2516                    };  */
2517
2518                 /* So this pdata section setups up this as a glue linkage to
2519                    a dll routine. There are a number of house keeping things
2520                    we need to do:
2521
2522                    1. In the name of glue trickery, the ADDR32 relocs for 0,
2523                       4, and 0x10 are set to point to the same place:
2524                       "..function_name".
2525                    2. There is one more reloc needed in the pdata section.
2526                       The actual glue instruction to restore the toc on
2527                       return is saved as the offset in an IMGLUE reloc.
2528                       So we need a total of four relocs for this section.
2529
2530                    3. Lastly, the HandlerData field is set to 0x03, to indicate
2531                       that this is a glue routine.  */
2532                 arelent *imglue, *ba_rel, *ea_rel, *pea_rel;
2533
2534                 /* Alignment must be set to 2**2 or you get extra stuff.  */
2535                 bfd_set_section_alignment(abfd, sec, 2);
2536
2537                 si->size = 4 * 5;
2538                 si->data = xmalloc (si->size);
2539                 memset (si->data, 0, si->size);
2540                 rpp = xmalloc (sizeof (arelent *) * 5);
2541                 rpp[0] = imglue  = xmalloc (sizeof (arelent));
2542                 rpp[1] = ba_rel  = xmalloc (sizeof (arelent));
2543                 rpp[2] = ea_rel  = xmalloc (sizeof (arelent));
2544                 rpp[3] = pea_rel = xmalloc (sizeof (arelent));
2545                 rpp[4] = 0;
2546
2547                 /* Stick the toc reload instruction in the glue reloc.  */
2548                 bfd_put_32(abfd, ppc_glue_insn, (char *) &imglue->address);
2549
2550                 imglue->addend = 0;
2551                 imglue->howto = bfd_reloc_type_lookup (abfd,
2552                                                        BFD_RELOC_32_GOTOFF);
2553                 imglue->sym_ptr_ptr = fn_pp;
2554
2555                 ba_rel->address = 0;
2556                 ba_rel->addend = 0;
2557                 ba_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2558                 ba_rel->sym_ptr_ptr = fn_pp;
2559
2560                 bfd_put_32 (abfd, 0x18, si->data + 0x04);
2561                 ea_rel->address = 4;
2562                 ea_rel->addend = 0;
2563                 ea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2564                 ea_rel->sym_ptr_ptr = fn_pp;
2565
2566                 /* Mark it as glue.  */
2567                 bfd_put_32 (abfd, 0x03, si->data + 0x0c);
2568
2569                 /* Mark the prolog end address.  */
2570                 bfd_put_32 (abfd, 0x0D, si->data + 0x10);
2571                 pea_rel->address = 0x10;
2572                 pea_rel->addend = 0;
2573                 pea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2574                 pea_rel->sym_ptr_ptr = fn_pp;
2575
2576                 sec->orelocation = rpp;
2577                 sec->reloc_count = 4;
2578                 break;
2579               }
2580             case RDATA:
2581               /* Each external function in a PowerPC PE file has a two word
2582                  descriptor consisting of:
2583                  1. The address of the code.
2584                  2. The address of the appropriate .toc
2585                  We use relocs to build this.  */
2586               si->size = 8;
2587               si->data = xmalloc (8);
2588               memset (si->data, 0, si->size);
2589
2590               rpp = xmalloc (sizeof (arelent *) * 3);
2591               rpp[0] = rel = xmalloc (sizeof (arelent));
2592               rpp[1] = xmalloc (sizeof (arelent));
2593               rpp[2] = 0;
2594
2595               rel->address = 0;
2596               rel->addend = 0;
2597               rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2598               rel->sym_ptr_ptr = fn_pp;
2599
2600               rel = rpp[1];
2601
2602               rel->address = 4;
2603               rel->addend = 0;
2604               rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2605               rel->sym_ptr_ptr = toc_pp;
2606
2607               sec->orelocation = rpp;
2608               sec->reloc_count = 2;
2609               break;
2610 #endif /* DLLTOOL_PPC */
2611             }
2612         }
2613
2614       {
2615         bfd_vma vma = 0;
2616         /* Size up all the sections.  */
2617         for (i = 0; i < NSECS; i++)
2618           {
2619             sinfo *si = secdata + i;
2620
2621             bfd_set_section_size (abfd, si->sec, si->size);
2622             bfd_set_section_vma (abfd, si->sec, vma);
2623
2624 /*          vma += si->size;*/
2625           }
2626       }
2627       /* Write them out.  */
2628       for (i = 0; i < NSECS; i++)
2629         {
2630           sinfo *si = secdata + i;
2631
2632           if (i == IDATA5 && no_idata5)
2633             continue;
2634
2635           if (i == IDATA4 && no_idata4)
2636             continue;
2637
2638           bfd_set_section_contents (abfd, si->sec,
2639                                     si->data, 0,
2640                                     si->size);
2641         }
2642
2643       bfd_set_symtab (abfd, ptrs, oidx);
2644       bfd_close (abfd);
2645       abfd = bfd_openr (outname, HOW_BFD_READ_TARGET);
2646       return abfd;
2647     }
2648 #endif
2649 }
2650
2651 static bfd *
2652 make_head (void)
2653 {
2654   FILE *f = fopen (TMP_HEAD_S, FOPEN_WT);
2655
2656   if (f == NULL)
2657     {
2658       fatal (_("failed to open temporary head file: %s"), TMP_HEAD_S);
2659       return NULL;
2660     }
2661
2662   fprintf (f, "%s IMAGE_IMPORT_DESCRIPTOR\n", ASM_C);
2663   fprintf (f, "\t.section       .idata$2\n");
2664
2665   fprintf(f,"\t%s\t%s\n", ASM_GLOBAL,head_label);
2666
2667   fprintf (f, "%s:\n", head_label);
2668
2669   fprintf (f, "\t%shname%s\t%sPtr to image import by name list\n",
2670            ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
2671
2672   fprintf (f, "\t%sthis should be the timestamp, but NT sometimes\n", ASM_C);
2673   fprintf (f, "\t%sdoesn't load DLLs when this is set.\n", ASM_C);
2674   fprintf (f, "\t%s\t0\t%s loaded time\n", ASM_LONG, ASM_C);
2675   fprintf (f, "\t%s\t0\t%s Forwarder chain\n", ASM_LONG, ASM_C);
2676   fprintf (f, "\t%s__%s_iname%s\t%s imported dll's name\n",
2677            ASM_RVA_BEFORE,
2678            imp_name_lab,
2679            ASM_RVA_AFTER,
2680            ASM_C);
2681   fprintf (f, "\t%sfthunk%s\t%s pointer to firstthunk\n",
2682            ASM_RVA_BEFORE,
2683            ASM_RVA_AFTER, ASM_C);
2684
2685   fprintf (f, "%sStuff for compatibility\n", ASM_C);
2686
2687   if (!no_idata5)
2688     {
2689       fprintf (f, "\t.section\t.idata$5\n");
2690       fprintf (f, "\t%s\t0\n", ASM_LONG);
2691       fprintf (f, "fthunk:\n");
2692     }
2693
2694   if (!no_idata4)
2695     {
2696       fprintf (f, "\t.section\t.idata$4\n");
2697
2698       fprintf (f, "\t%s\t0\n", ASM_LONG);
2699       fprintf (f, "\t.section   .idata$4\n");
2700       fprintf (f, "hname:\n");
2701     }
2702
2703   fclose (f);
2704
2705   assemble_file (TMP_HEAD_S, TMP_HEAD_O);
2706
2707   return bfd_openr (TMP_HEAD_O, HOW_BFD_READ_TARGET);
2708 }
2709
2710 static bfd *
2711 make_tail (void)
2712 {
2713   FILE *f = fopen (TMP_TAIL_S, FOPEN_WT);
2714
2715   if (f == NULL)
2716     {
2717       fatal (_("failed to open temporary tail file: %s"), TMP_TAIL_S);
2718       return NULL;
2719     }
2720
2721   if (!no_idata4)
2722     {
2723       fprintf (f, "\t.section   .idata$4\n");
2724       fprintf (f, "\t%s\t0\n", ASM_LONG);
2725     }
2726
2727   if (!no_idata5)
2728     {
2729       fprintf (f, "\t.section   .idata$5\n");
2730       fprintf (f, "\t%s\t0\n", ASM_LONG);
2731     }
2732
2733 #ifdef DLLTOOL_PPC
2734   /* Normally, we need to see a null descriptor built in idata$3 to
2735      act as the terminator for the list. The ideal way, I suppose,
2736      would be to mark this section as a comdat type 2 section, so
2737      only one would appear in the final .exe (if our linker supported
2738      comdat, that is) or cause it to be inserted by something else (say
2739      crt0).  */
2740
2741   fprintf (f, "\t.section       .idata$3\n");
2742   fprintf (f, "\t%s\t0\n", ASM_LONG);
2743   fprintf (f, "\t%s\t0\n", ASM_LONG);
2744   fprintf (f, "\t%s\t0\n", ASM_LONG);
2745   fprintf (f, "\t%s\t0\n", ASM_LONG);
2746   fprintf (f, "\t%s\t0\n", ASM_LONG);
2747 #endif
2748
2749 #ifdef DLLTOOL_PPC
2750   /* Other PowerPC NT compilers use idata$6 for the dllname, so I
2751      do too. Original, huh?  */
2752   fprintf (f, "\t.section       .idata$6\n");
2753 #else
2754   fprintf (f, "\t.section       .idata$7\n");
2755 #endif
2756
2757   fprintf (f, "\t%s\t__%s_iname\n", ASM_GLOBAL, imp_name_lab);
2758   fprintf (f, "__%s_iname:\t%s\t\"%s\"\n",
2759            imp_name_lab, ASM_TEXT, dll_name);
2760
2761   fclose (f);
2762
2763   assemble_file (TMP_TAIL_S, TMP_TAIL_O);
2764
2765   return bfd_openr (TMP_TAIL_O, HOW_BFD_READ_TARGET);
2766 }
2767
2768 static void
2769 gen_lib_file (void)
2770 {
2771   int i;
2772   export_type *exp;
2773   bfd *ar_head;
2774   bfd *ar_tail;
2775   bfd *outarch;
2776   bfd * head  = 0;
2777
2778   unlink (imp_name);
2779
2780   outarch = bfd_openw (imp_name, HOW_BFD_WRITE_TARGET);
2781
2782   if (!outarch)
2783     /* xgettext:c-format */
2784     fatal (_("Can't open .lib file: %s"), imp_name);
2785
2786   /* xgettext:c-format */
2787   inform (_("Creating library file: %s"), imp_name);
2788
2789   bfd_set_format (outarch, bfd_archive);
2790   outarch->has_armap = 1;
2791
2792   /* Work out a reasonable size of things to put onto one line.  */
2793   ar_head = make_head ();
2794   ar_tail = make_tail();
2795
2796   if (ar_head == NULL || ar_tail == NULL)
2797     return;
2798
2799   for (i = 0; (exp = d_exports_lexically[i]); i++)
2800     {
2801       bfd *n;
2802       /* Don't add PRIVATE entries to import lib.  */
2803       if (exp->private)
2804         continue;
2805       n = make_one_lib_file (exp, i);
2806       n->next = head;
2807       head = n;
2808     }
2809
2810   /* Now stick them all into the archive.  */
2811   ar_head->next = head;
2812   ar_tail->next = ar_head;
2813   head = ar_tail;
2814
2815   if (! bfd_set_archive_head (outarch, head))
2816     bfd_fatal ("bfd_set_archive_head");
2817
2818   if (! bfd_close (outarch))
2819     bfd_fatal (imp_name);
2820
2821   while (head != NULL)
2822     {
2823       bfd *n = head->next;
2824       bfd_close (head);
2825       head = n;
2826     }
2827
2828   /* Delete all the temp files.  */
2829   if (dontdeltemps == 0)
2830     {
2831       unlink (TMP_HEAD_O);
2832       unlink (TMP_HEAD_S);
2833       unlink (TMP_TAIL_O);
2834       unlink (TMP_TAIL_S);
2835     }
2836
2837   if (dontdeltemps < 2)
2838     {
2839       char *name;
2840
2841       name = (char *) alloca (strlen (TMP_STUB) + 10);
2842       for (i = 0; (exp = d_exports_lexically[i]); i++)
2843         {
2844           /* Don't delete non-existent stubs for PRIVATE entries.  */
2845           if (exp->private)
2846             continue;
2847           sprintf (name, "%s%05d.o", TMP_STUB, i);
2848           if (unlink (name) < 0)
2849             /* xgettext:c-format */
2850             non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
2851         }
2852     }
2853
2854   inform (_("Created lib file"));
2855 }
2856
2857 /* Run through the information gathered from the .o files and the
2858    .def file and work out the best stuff.  */
2859
2860 static int
2861 pfunc (const void *a, const void *b)
2862 {
2863   export_type *ap = *(export_type **) a;
2864   export_type *bp = *(export_type **) b;
2865   if (ap->ordinal == bp->ordinal)
2866     return 0;
2867
2868   /* Unset ordinals go to the bottom.  */
2869   if (ap->ordinal == -1)
2870     return 1;
2871   if (bp->ordinal == -1)
2872     return -1;
2873   return (ap->ordinal - bp->ordinal);
2874 }
2875
2876 static int
2877 nfunc (const void *a, const void *b)
2878 {
2879   export_type *ap = *(export_type **) a;
2880   export_type *bp = *(export_type **) b;
2881
2882   return (strcmp (ap->name, bp->name));
2883 }
2884
2885 static void
2886 remove_null_names (export_type **ptr)
2887 {
2888   int src;
2889   int dst;
2890
2891   for (dst = src = 0; src < d_nfuncs; src++)
2892     {
2893       if (ptr[src])
2894         {
2895           ptr[dst] = ptr[src];
2896           dst++;
2897         }
2898     }
2899   d_nfuncs = dst;
2900 }
2901
2902 static void
2903 dtab (export_type **ptr ATTRIBUTE_UNUSED)
2904 {
2905 #ifdef SACDEBUG
2906   int i;
2907   for (i = 0; i < d_nfuncs; i++)
2908     {
2909       if (ptr[i])
2910         {
2911           printf ("%d %s @ %d %s%s%s\n",
2912                   i, ptr[i]->name, ptr[i]->ordinal,
2913                   ptr[i]->noname ? "NONAME " : "",
2914                   ptr[i]->constant ? "CONSTANT" : "",
2915                   ptr[i]->data ? "DATA" : "");
2916         }
2917       else
2918         printf ("empty\n");
2919     }
2920 #endif
2921 }
2922
2923 static void
2924 process_duplicates (export_type **d_export_vec)
2925 {
2926   int more = 1;
2927   int i;
2928
2929   while (more)
2930     {
2931       more = 0;
2932       /* Remove duplicates.  */
2933       qsort (d_export_vec, d_nfuncs, sizeof (export_type *), nfunc);
2934
2935       dtab (d_export_vec);
2936       for (i = 0; i < d_nfuncs - 1; i++)
2937         {
2938           if (strcmp (d_export_vec[i]->name,
2939                       d_export_vec[i + 1]->name) == 0)
2940             {
2941               export_type *a = d_export_vec[i];
2942               export_type *b = d_export_vec[i + 1];
2943
2944               more = 1;
2945
2946               /* xgettext:c-format */
2947               inform (_("Warning, ignoring duplicate EXPORT %s %d,%d"),
2948                       a->name, a->ordinal, b->ordinal);
2949
2950               if (a->ordinal != -1
2951                   && b->ordinal != -1)
2952                 /* xgettext:c-format */
2953                 fatal (_("Error, duplicate EXPORT with oridinals: %s"),
2954                       a->name);
2955
2956               /* Merge attributes.  */
2957               b->ordinal = a->ordinal > 0 ? a->ordinal : b->ordinal;
2958               b->constant |= a->constant;
2959               b->noname |= a->noname;
2960               b->data |= a->data;
2961               d_export_vec[i] = 0;
2962             }
2963
2964           dtab (d_export_vec);
2965           remove_null_names (d_export_vec);
2966           dtab (d_export_vec);
2967         }
2968     }
2969
2970   /* Count the names.  */
2971   for (i = 0; i < d_nfuncs; i++)
2972     if (!d_export_vec[i]->noname)
2973       d_named_nfuncs++;
2974 }
2975
2976 static void
2977 fill_ordinals (export_type **d_export_vec)
2978 {
2979   int lowest = -1;
2980   int i;
2981   char *ptr;
2982   int size = 65536;
2983
2984   qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
2985
2986   /* Fill in the unset ordinals with ones from our range.  */
2987   ptr = (char *) xmalloc (size);
2988
2989   memset (ptr, 0, size);
2990
2991   /* Mark in our large vector all the numbers that are taken.  */
2992   for (i = 0; i < d_nfuncs; i++)
2993     {
2994       if (d_export_vec[i]->ordinal != -1)
2995         {
2996           ptr[d_export_vec[i]->ordinal] = 1;
2997
2998           if (lowest == -1 || d_export_vec[i]->ordinal < lowest)
2999             lowest = d_export_vec[i]->ordinal;
3000         }
3001     }
3002
3003   /* Start at 1 for compatibility with MS toolchain.  */
3004   if (lowest == -1)
3005     lowest = 1;
3006
3007   /* Now fill in ordinals where the user wants us to choose.  */
3008   for (i = 0; i < d_nfuncs; i++)
3009     {
3010       if (d_export_vec[i]->ordinal == -1)
3011         {
3012           int j;
3013
3014           /* First try within or after any user supplied range.  */
3015           for (j = lowest; j < size; j++)
3016             if (ptr[j] == 0)
3017               {
3018                 ptr[j] = 1;
3019                 d_export_vec[i]->ordinal = j;
3020                 goto done;
3021               }
3022
3023           /* Then try before the range.  */
3024           for (j = lowest; j >0; j--)
3025             if (ptr[j] == 0)
3026               {
3027                 ptr[j] = 1;
3028                 d_export_vec[i]->ordinal = j;
3029                 goto done;
3030               }
3031         done:;
3032         }
3033     }
3034
3035   free (ptr);
3036
3037   /* And resort.  */
3038   qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
3039
3040   /* Work out the lowest and highest ordinal numbers.  */
3041   if (d_nfuncs)
3042     {
3043       if (d_export_vec[0])
3044         d_low_ord = d_export_vec[0]->ordinal;
3045       if (d_export_vec[d_nfuncs-1])
3046         d_high_ord = d_export_vec[d_nfuncs-1]->ordinal;
3047     }
3048 }
3049
3050 static int
3051 alphafunc (const void *av, const void *bv)
3052 {
3053   const export_type **a = (const export_type **) av;
3054   const export_type **b = (const export_type **) bv;
3055
3056   return strcmp ((*a)->name, (*b)->name);
3057 }
3058
3059 static void
3060 mangle_defs (void)
3061 {
3062   /* First work out the minimum ordinal chosen.  */
3063   export_type *exp;
3064
3065   int i;
3066   int hint = 0;
3067   export_type **d_export_vec = xmalloc (sizeof (export_type *) * d_nfuncs);
3068
3069   inform (_("Processing definitions"));
3070
3071   for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3072     d_export_vec[i] = exp;
3073
3074   process_duplicates (d_export_vec);
3075   fill_ordinals (d_export_vec);
3076
3077   /* Put back the list in the new order.  */
3078   d_exports = 0;
3079   for (i = d_nfuncs - 1; i >= 0; i--)
3080     {
3081       d_export_vec[i]->next = d_exports;
3082       d_exports = d_export_vec[i];
3083     }
3084
3085   /* Build list in alpha order.  */
3086   d_exports_lexically = (export_type **)
3087     xmalloc (sizeof (export_type *) * (d_nfuncs + 1));
3088
3089   for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3090     d_exports_lexically[i] = exp;
3091
3092   d_exports_lexically[i] = 0;
3093
3094   qsort (d_exports_lexically, i, sizeof (export_type *), alphafunc);
3095
3096   /* Fill exp entries with their hint values.  */
3097   for (i = 0; i < d_nfuncs; i++)
3098     if (!d_exports_lexically[i]->noname || show_allnames)
3099       d_exports_lexically[i]->hint = hint++;
3100
3101   inform (_("Processed definitions"));
3102 }
3103
3104 static void
3105 usage (FILE *file, int status)
3106 {
3107   /* xgetext:c-format */
3108   fprintf (file, _("Usage %s <option(s)> <object-file(s)>\n"), program_name);
3109   /* xgetext:c-format */
3110   fprintf (file, _("   -m --machine <machine>    Create as DLL for <machine>.  [default: %s]\n"), mname);
3111   fprintf (file, _("        possible <machine>: arm[_interwork], i386, mcore[-elf]{-le|-be}, ppc, thumb\n"));
3112   fprintf (file, _("   -e --output-exp <outname> Generate an export file.\n"));
3113   fprintf (file, _("   -l --output-lib <outname> Generate an interface library.\n"));
3114   fprintf (file, _("   -a --add-indirect         Add dll indirects to export file.\n"));
3115   fprintf (file, _("   -D --dllname <name>       Name of input dll to put into interface lib.\n"));
3116   fprintf (file, _("   -d --input-def <deffile>  Name of .def file to be read in.\n"));
3117   fprintf (file, _("   -z --output-def <deffile> Name of .def file to be created.\n"));
3118   fprintf (file, _("      --export-all-symbols   Export all symbols to .def\n"));
3119   fprintf (file, _("      --no-export-all-symbols  Only export listed symbols\n"));
3120   fprintf (file, _("      --exclude-symbols <list> Don't export <list>\n"));
3121   fprintf (file, _("      --no-default-excludes  Clear default exclude symbols\n"));
3122   fprintf (file, _("   -b --base-file <basefile> Read linker generated base file.\n"));
3123   fprintf (file, _("   -x --no-idata4            Don't generate idata$4 section.\n"));
3124   fprintf (file, _("   -c --no-idata5            Don't generate idata$5 section.\n"));
3125   fprintf (file, _("   -U --add-underscore       Add underscores to symbols in interface library.\n"));
3126   fprintf (file, _("   -k --kill-at              Kill @<n> from exported names.\n"));
3127   fprintf (file, _("   -A --add-stdcall-alias    Add aliases without @<n>.\n"));
3128   fprintf (file, _("   -S --as <name>            Use <name> for assembler.\n"));
3129   fprintf (file, _("   -f --as-flags <flags>     Pass <flags> to the assembler.\n"));
3130   fprintf (file, _("   -C --compat-implib        Create backward compatible import library.\n"));
3131   fprintf (file, _("   -n --no-delete            Keep temp files (repeat for extra preservation).\n"));
3132   fprintf (file, _("   -t --temp-prefix <prefix> Use <prefix> to construct temp file names.\n"));
3133   fprintf (file, _("   -v --verbose              Be verbose.\n"));
3134   fprintf (file, _("   -V --version              Display the program version.\n"));
3135   fprintf (file, _("   -h --help                 Display this information.\n"));
3136 #ifdef DLLTOOL_MCORE_ELF
3137   fprintf (file, _("   -M --mcore-elf <outname>  Process mcore-elf object files into <outname>.\n"));
3138   fprintf (file, _("   -L --linker <name>        Use <name> as the linker.\n"));
3139   fprintf (file, _("   -F --linker-flags <flags> Pass <flags> to the linker.\n"));
3140 #endif
3141   exit (status);
3142 }
3143
3144 #define OPTION_EXPORT_ALL_SYMS          150
3145 #define OPTION_NO_EXPORT_ALL_SYMS       (OPTION_EXPORT_ALL_SYMS + 1)
3146 #define OPTION_EXCLUDE_SYMS             (OPTION_NO_EXPORT_ALL_SYMS + 1)
3147 #define OPTION_NO_DEFAULT_EXCLUDES      (OPTION_EXCLUDE_SYMS + 1)
3148
3149 static const struct option long_options[] =
3150 {
3151   {"no-delete", no_argument, NULL, 'n'},
3152   {"dllname", required_argument, NULL, 'D'},
3153   {"no-idata4", no_argument, NULL, 'x'},
3154   {"no-idata5", no_argument, NULL, 'c'},
3155   {"output-exp", required_argument, NULL, 'e'},
3156   {"output-def", required_argument, NULL, 'z'},
3157   {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL_SYMS},
3158   {"no-export-all-symbols", no_argument, NULL, OPTION_NO_EXPORT_ALL_SYMS},
3159   {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMS},
3160   {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
3161   {"output-lib", required_argument, NULL, 'l'},
3162   {"def", required_argument, NULL, 'd'}, /* for compatibility with older versions */
3163   {"input-def", required_argument, NULL, 'd'},
3164   {"add-underscore", no_argument, NULL, 'U'},
3165   {"kill-at", no_argument, NULL, 'k'},
3166   {"add-stdcall-alias", no_argument, NULL, 'A'},
3167   {"verbose", no_argument, NULL, 'v'},
3168   {"version", no_argument, NULL, 'V'},
3169   {"help", no_argument, NULL, 'h'},
3170   {"machine", required_argument, NULL, 'm'},
3171   {"add-indirect", no_argument, NULL, 'a'},
3172   {"base-file", required_argument, NULL, 'b'},
3173   {"as", required_argument, NULL, 'S'},
3174   {"as-flags", required_argument, NULL, 'f'},
3175   {"mcore-elf", required_argument, NULL, 'M'},
3176   {"compat-implib", no_argument, NULL, 'C'},
3177   {"temp-prefix", required_argument, NULL, 't'},
3178   {NULL,0,NULL,0}
3179 };
3180
3181 int main (int, char **);
3182
3183 int
3184 main (int ac, char **av)
3185 {
3186   int c;
3187   int i;
3188   char *firstarg = 0;
3189   program_name = av[0];
3190   oav = av;
3191
3192 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
3193   setlocale (LC_MESSAGES, "");
3194 #endif
3195 #if defined (HAVE_SETLOCALE)
3196   setlocale (LC_CTYPE, "");
3197 #endif
3198   bindtextdomain (PACKAGE, LOCALEDIR);
3199   textdomain (PACKAGE);
3200
3201   while ((c = getopt_long (ac, av,
3202 #ifdef DLLTOOL_MCORE_ELF
3203                            "m:e:l:aD:d:z:b:xcCuUkAS:f:nvVHhM:L:F:",
3204 #else
3205                            "m:e:l:aD:d:z:b:xcCuUkAS:f:nvVHh",
3206 #endif
3207                            long_options, 0))
3208          != EOF)
3209     {
3210       switch (c)
3211         {
3212         case OPTION_EXPORT_ALL_SYMS:
3213           export_all_symbols = TRUE;
3214           break;
3215         case OPTION_NO_EXPORT_ALL_SYMS:
3216           export_all_symbols = FALSE;
3217           break;
3218         case OPTION_EXCLUDE_SYMS:
3219           add_excludes (optarg);
3220           break;
3221         case OPTION_NO_DEFAULT_EXCLUDES:
3222           do_default_excludes = FALSE;
3223           break;
3224         case 'x':
3225           no_idata4 = 1;
3226           break;
3227         case 'c':
3228           no_idata5 = 1;
3229           break;
3230         case 'S':
3231           as_name = optarg;
3232           break;
3233         case 't':
3234           tmp_prefix = optarg;
3235           break;
3236         case 'f':
3237           as_flags = optarg;
3238           break;
3239
3240           /* Ignored for compatibility.  */
3241         case 'u':
3242           break;
3243         case 'a':
3244           add_indirect = 1;
3245           break;
3246         case 'z':
3247           output_def = fopen (optarg, FOPEN_WT);
3248           break;
3249         case 'D':
3250           dll_name = optarg;
3251           break;
3252         case 'l':
3253           imp_name = optarg;
3254           break;
3255         case 'e':
3256           exp_name = optarg;
3257           break;
3258         case 'H':
3259         case 'h':
3260           usage (stdout, 0);
3261           break;
3262         case 'm':
3263           mname = optarg;
3264           break;
3265         case 'v':
3266           verbose = 1;
3267           break;
3268         case 'V':
3269           print_version (program_name);
3270           break;
3271         case 'U':
3272           add_underscore = 1;
3273           break;
3274         case 'k':
3275           killat = 1;
3276           break;
3277         case 'A':
3278           add_stdcall_alias = 1;
3279           break;
3280         case 'd':
3281           def_file = optarg;
3282           break;
3283         case 'n':
3284           dontdeltemps++;
3285           break;
3286         case 'b':
3287           base_file = fopen (optarg, FOPEN_RB);
3288
3289           if (!base_file)
3290             /* xgettext:c-format */
3291             fatal (_("Unable to open base-file: %s"), optarg);
3292
3293           break;
3294 #ifdef DLLTOOL_MCORE_ELF
3295         case 'M':
3296           mcore_elf_out_file = optarg;
3297           break;
3298         case 'L':
3299           mcore_elf_linker = optarg;
3300           break;
3301         case 'F':
3302           mcore_elf_linker_flags = optarg;
3303           break;
3304 #endif
3305         case 'C':
3306           create_compat_implib = 1;
3307           break;
3308         default:
3309           usage (stderr, 1);
3310           break;
3311         }
3312     }
3313
3314   if (!tmp_prefix)
3315     tmp_prefix = prefix_encode ("d", getpid ());
3316
3317   for (i = 0; mtable[i].type; i++)
3318     if (strcmp (mtable[i].type, mname) == 0)
3319       break;
3320
3321   if (!mtable[i].type)
3322     /* xgettext:c-format */
3323     fatal (_("Machine '%s' not supported"), mname);
3324
3325   machine = i;
3326
3327   if (!dll_name && exp_name)
3328     {
3329       int len = strlen (exp_name) + 5;
3330       dll_name = xmalloc (len);
3331       strcpy (dll_name, exp_name);
3332       strcat (dll_name, ".dll");
3333     }
3334
3335   if (as_name == NULL)
3336     as_name = deduce_name ("as");
3337
3338   /* Don't use the default exclude list if we're reading only the
3339      symbols in the .drectve section.  The default excludes are meant
3340      to avoid exporting DLL entry point and Cygwin32 impure_ptr.  */
3341   if (! export_all_symbols)
3342     do_default_excludes = FALSE;
3343
3344   if (do_default_excludes)
3345     set_default_excludes ();
3346
3347   if (def_file)
3348     process_def_file (def_file);
3349
3350   while (optind < ac)
3351     {
3352       if (!firstarg)
3353         firstarg = av[optind];
3354       scan_obj_file (av[optind]);
3355       optind++;
3356     }
3357
3358   mangle_defs ();
3359
3360   if (exp_name)
3361     gen_exp_file ();
3362
3363   if (imp_name)
3364     {
3365       /* Make imp_name safe for use as a label.  */
3366       char *p;
3367
3368       imp_name_lab = xstrdup (imp_name);
3369       for (p = imp_name_lab; *p; p++)
3370         {
3371           if (!ISALNUM (*p))
3372             *p = '_';
3373         }
3374       head_label = make_label("_head_", imp_name_lab);
3375       gen_lib_file ();
3376     }
3377
3378   if (output_def)
3379     gen_def_file ();
3380
3381 #ifdef DLLTOOL_MCORE_ELF
3382   if (mcore_elf_out_file)
3383     mcore_elf_gen_out_file ();
3384 #endif
3385
3386   return 0;
3387 }
3388
3389 /* Look for the program formed by concatenating PROG_NAME and the
3390    string running from PREFIX to END_PREFIX.  If the concatenated
3391    string contains a '/', try appending EXECUTABLE_SUFFIX if it is
3392    appropriate.  */
3393
3394 static char *
3395 look_for_prog (const char *prog_name, const char *prefix, int end_prefix)
3396 {
3397   struct stat s;
3398   char *cmd;
3399
3400   cmd = xmalloc (strlen (prefix)
3401                  + strlen (prog_name)
3402 #ifdef HAVE_EXECUTABLE_SUFFIX
3403                  + strlen (EXECUTABLE_SUFFIX)
3404 #endif
3405                  + 10);
3406   strcpy (cmd, prefix);
3407
3408   sprintf (cmd + end_prefix, "%s", prog_name);
3409
3410   if (strchr (cmd, '/') != NULL)
3411     {
3412       int found;
3413
3414       found = (stat (cmd, &s) == 0
3415 #ifdef HAVE_EXECUTABLE_SUFFIX
3416                || stat (strcat (cmd, EXECUTABLE_SUFFIX), &s) == 0
3417 #endif
3418                );
3419
3420       if (! found)
3421         {
3422           /* xgettext:c-format */
3423           inform (_("Tried file: %s"), cmd);
3424           free (cmd);
3425           return NULL;
3426         }
3427     }
3428
3429   /* xgettext:c-format */
3430   inform (_("Using file: %s"), cmd);
3431
3432   return cmd;
3433 }
3434
3435 /* Deduce the name of the program we are want to invoke.
3436    PROG_NAME is the basic name of the program we want to run,
3437    eg "as" or "ld".  The catch is that we might want actually
3438    run "i386-pe-as" or "ppc-pe-ld".
3439
3440    If argv[0] contains the full path, then try to find the program
3441    in the same place, with and then without a target-like prefix.
3442
3443    Given, argv[0] = /usr/local/bin/i586-cygwin32-dlltool,
3444    deduce_name("as") uses the following search order:
3445
3446      /usr/local/bin/i586-cygwin32-as
3447      /usr/local/bin/as
3448      as
3449
3450    If there's an EXECUTABLE_SUFFIX, it'll use that as well; for each
3451    name, it'll try without and then with EXECUTABLE_SUFFIX.
3452
3453    Given, argv[0] = i586-cygwin32-dlltool, it will not even try "as"
3454    as the fallback, but rather return i586-cygwin32-as.
3455
3456    Oh, and given, argv[0] = dlltool, it'll return "as".
3457
3458    Returns a dynamically allocated string.  */
3459
3460 static char *
3461 deduce_name (const char *prog_name)
3462 {
3463   char *cmd;
3464   char *dash, *slash, *cp;
3465
3466   dash = NULL;
3467   slash = NULL;
3468   for (cp = program_name; *cp != '\0'; ++cp)
3469     {
3470       if (*cp == '-')
3471         dash = cp;
3472       if (
3473 #if defined(__DJGPP__) || defined (__CYGWIN__) || defined(__WIN32__)
3474           *cp == ':' || *cp == '\\' ||
3475 #endif
3476           *cp == '/')
3477         {
3478           slash = cp;
3479           dash = NULL;
3480         }
3481     }
3482
3483   cmd = NULL;
3484
3485   if (dash != NULL)
3486     {
3487       /* First, try looking for a prefixed PROG_NAME in the
3488          PROGRAM_NAME directory, with the same prefix as PROGRAM_NAME.  */
3489       cmd = look_for_prog (prog_name, program_name, dash - program_name + 1);
3490     }
3491
3492   if (slash != NULL && cmd == NULL)
3493     {
3494       /* Next, try looking for a PROG_NAME in the same directory as
3495          that of this program.  */
3496       cmd = look_for_prog (prog_name, program_name, slash - program_name + 1);
3497     }
3498
3499   if (cmd == NULL)
3500     {
3501       /* Just return PROG_NAME as is.  */
3502       cmd = xstrdup (prog_name);
3503     }
3504
3505   return cmd;
3506 }
3507
3508 #ifdef DLLTOOL_MCORE_ELF
3509 typedef struct fname_cache
3510 {
3511   char *               filename;
3512   struct fname_cache * next;
3513 }
3514 fname_cache;
3515
3516 static fname_cache fnames;
3517
3518 static void
3519 mcore_elf_cache_filename (char * filename)
3520 {
3521   fname_cache * ptr;
3522
3523   ptr = & fnames;
3524
3525   while (ptr->next != NULL)
3526     ptr = ptr->next;
3527
3528   ptr->filename = filename;
3529   ptr->next     = (fname_cache *) malloc (sizeof (fname_cache));
3530   if (ptr->next != NULL)
3531     ptr->next->next = NULL;
3532 }
3533
3534 #define MCORE_ELF_TMP_OBJ "mcoreelf.o"
3535 #define MCORE_ELF_TMP_EXP "mcoreelf.exp"
3536 #define MCORE_ELF_TMP_LIB "mcoreelf.lib"
3537
3538 static void
3539 mcore_elf_gen_out_file (void)
3540 {
3541   fname_cache * ptr;
3542   dyn_string_t ds;
3543
3544   /* Step one.  Run 'ld -r' on the input object files in order to resolve
3545      any internal references and to generate a single .exports section.  */
3546   ptr = & fnames;
3547
3548   ds = dyn_string_new (100);
3549   dyn_string_append_cstr (ds, "-r ");
3550
3551   if (mcore_elf_linker_flags != NULL)
3552     dyn_string_append_cstr (ds, mcore_elf_linker_flags);
3553
3554   while (ptr->next != NULL)
3555     {
3556       dyn_string_append_cstr (ds, ptr->filename);
3557       dyn_string_append_cstr (ds, " ");
3558
3559       ptr = ptr->next;
3560     }
3561
3562   dyn_string_append_cstr (ds, "-o ");
3563   dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
3564
3565   if (mcore_elf_linker == NULL)
3566     mcore_elf_linker = deduce_name ("ld");
3567
3568   run (mcore_elf_linker, ds->s);
3569
3570   dyn_string_delete (ds);
3571
3572   /* Step two. Create a .exp file and a .lib file from the temporary file.
3573      Do this by recursively invoking dlltool...  */
3574   ds = dyn_string_new (100);
3575
3576   dyn_string_append_cstr (ds, "-S ");
3577   dyn_string_append_cstr (ds, as_name);
3578
3579   dyn_string_append_cstr (ds, " -e ");
3580   dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP);
3581   dyn_string_append_cstr (ds, " -l ");
3582   dyn_string_append_cstr (ds, MCORE_ELF_TMP_LIB);
3583   dyn_string_append_cstr (ds, " " );
3584   dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
3585
3586   if (verbose)
3587     dyn_string_append_cstr (ds, " -v");
3588
3589   if (dontdeltemps)
3590     {
3591       dyn_string_append_cstr (ds, " -n");
3592
3593       if (dontdeltemps > 1)
3594         dyn_string_append_cstr (ds, " -n");
3595     }
3596
3597   /* XXX - FIME: ought to check/copy other command line options as well.  */
3598   run (program_name, ds->s);
3599
3600   dyn_string_delete (ds);
3601
3602   /* Step four. Feed the .exp and object files to ld -shared to create the dll.  */
3603   ds = dyn_string_new (100);
3604
3605   dyn_string_append_cstr (ds, "-shared ");
3606
3607   if (mcore_elf_linker_flags)
3608     dyn_string_append_cstr (ds, mcore_elf_linker_flags);
3609
3610   dyn_string_append_cstr (ds, " ");
3611   dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP);
3612   dyn_string_append_cstr (ds, " ");
3613   dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
3614   dyn_string_append_cstr (ds, " -o ");
3615   dyn_string_append_cstr (ds, mcore_elf_out_file);
3616
3617   run (mcore_elf_linker, ds->s);
3618
3619   dyn_string_delete (ds);
3620
3621   if (dontdeltemps == 0)
3622     unlink (MCORE_ELF_TMP_EXP);
3623
3624   if (dontdeltemps < 2)
3625     unlink (MCORE_ELF_TMP_OBJ);
3626 }
3627 #endif /* DLLTOOL_MCORE_ELF */