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