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