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