binutils/dlltool.c

   1 /* dlltool.c -- tool to generate stuff for PE style DLLs
   2    Copyright (C) 1995-2016 Free Software Foundation, Inc.
   3
   4    This file is part of GNU Binutils.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  19    02110-1301, USA.  */
  20
  21
  22 /* This program allows you to build the files necessary to create
  23    DLLs to run on a system which understands PE format image files.
  24    (eg, Windows NT)
  25
  26    See "Peering Inside the PE: A Tour of the Win32 Portable Executable
  27    File Format", MSJ 1994, Volume 9 for more information.
  28    Also see "Microsoft Portable Executable and Common Object File Format,
  29    Specification 4.1" for more information.
  30
  31    A DLL contains an export table which contains the information
  32    which the runtime loader needs to tie up references from a
  33    referencing program.
  34
  35    The export table is generated by this program by reading
  36    in a .DEF file or scanning the .a and .o files which will be in the
  37    DLL.  A .o file can contain information in special  ".drectve" sections
  38    with export information.
  39
  40    A DEF file contains any number of the following commands:
  41
  42
  43    NAME <name> [ , <base> ]
  44    The result is going to be <name>.EXE
  45
  46    LIBRARY <name> [ , <base> ]
  47    The result is going to be <name>.DLL
  48
  49    EXPORTS  ( (  ( <name1> [ = <name2> ] )
  50                | ( <name1> = <module-name> . <external-name>))
  51             [ @ <integer> ] [ NONAME ] [CONSTANT] [DATA] [PRIVATE] ) *
  52    Declares name1 as an exported symbol from the
  53    DLL, with optional ordinal number <integer>.
  54    Or declares name1 as an alias (forward) of the function <external-name>
  55    in the DLL <module-name>.
  56
  57    IMPORTS  (  (   <internal-name> =   <module-name> . <integer> )
  58              | ( [ <internal-name> = ] <module-name> . <external-name> )) *
  59    Declares that <external-name> or the exported function whose ordinal number
  60    is <integer> is to be imported from the file <module-name>.  If
  61    <internal-name> is specified then this is the name that the imported
  62    function will be refereed to in the body of the DLL.
  63
  64    DESCRIPTION <string>
  65    Puts <string> into output .exp file in the .rdata section
  66
  67    [STACKSIZE|HEAPSIZE] <number-reserve> [ , <number-commit> ]
  68    Generates --stack|--heap <number-reserve>,<number-commit>
  69    in the output .drectve section.  The linker will
  70    see this and act upon it.
  71
  72    [CODE|DATA] <attr>+
  73    SECTIONS ( <sectionname> <attr>+ )*
  74    <attr> = READ | WRITE | EXECUTE | SHARED
  75    Generates --attr <sectionname> <attr> in the output
  76    .drectve section.  The linker will see this and act
  77    upon it.
  78
  79
  80    A -export:<name> in a .drectve section in an input .o or .a
  81    file to this program is equivalent to a EXPORTS <name>
  82    in a .DEF file.
  83
  84
  85
  86    The program generates output files with the prefix supplied
  87    on the command line, or in the def file, or taken from the first
  88    supplied argument.
  89
  90    The .exp.s file contains the information necessary to export
  91    the routines in the DLL.  The .lib.s file contains the information
  92    necessary to use the DLL's routines from a referencing program.
  93
  94
  95
  96    Example:
  97
  98  file1.c:
  99    asm (".section .drectve");
 100    asm (".ascii \"-export:adef\"");
 101
 102    void adef (char * s)
 103    {
 104      printf ("hello from the dll %s\n", s);
 105    }
 106
 107    void bdef (char * s)
 108    {
 109      printf ("hello from the dll and the other entry point %s\n", s);
 110    }
 111
 112  file2.c:
 113    asm (".section .drectve");
 114    asm (".ascii \"-export:cdef\"");
 115    asm (".ascii \"-export:ddef\"");
 116
 117    void cdef (char * s)
 118    {
 119      printf ("hello from the dll %s\n", s);
 120    }
 121
 122    void ddef (char * s)
 123    {
 124      printf ("hello from the dll and the other entry point %s\n", s);
 125    }
 126
 127    int printf (void)
 128    {
 129      return 9;
 130    }
 131
 132  themain.c:
 133    int main (void)
 134    {
 135      cdef ();
 136      return 0;
 137    }
 138
 139  thedll.def
 140
 141    LIBRARY thedll
 142    HEAPSIZE 0x40000, 0x2000
 143    EXPORTS bdef @ 20
 144            cdef @ 30 NONAME
 145
 146    SECTIONS donkey READ WRITE
 147    aardvark EXECUTE
 148
 149  # Compile up the parts of the dll and the program
 150
 151    gcc -c file1.c file2.c themain.c
 152
 153  # Optional: put the dll objects into a library
 154  # (you don't have to, you could name all the object
 155  # files on the dlltool line)
 156
 157    ar  qcv thedll.in file1.o file2.o
 158    ranlib thedll.in
 159
 160  # Run this tool over the DLL's .def file and generate an exports
 161  # file (thedll.o) and an imports file (thedll.a).
 162  # (You may have to use -S to tell dlltool where to find the assembler).
 163
 164    dlltool --def thedll.def --output-exp thedll.o --output-lib thedll.a
 165
 166  # Build the dll with the library and the export table
 167
 168    ld -o thedll.dll thedll.o thedll.in
 169
 170  # Link the executable with the import library
 171
 172    gcc -o themain.exe themain.o thedll.a
 173
 174  This example can be extended if relocations are needed in the DLL:
 175
 176  # Compile up the parts of the dll and the program
 177
 178    gcc -c file1.c file2.c themain.c
 179
 180  # Run this tool over the DLL's .def file and generate an imports file.
 181
 182    dlltool --def thedll.def --output-lib thedll.lib
 183
 184  # Link the executable with the import library and generate a base file
 185  # at the same time
 186
 187    gcc -o themain.exe themain.o thedll.lib -Wl,--base-file -Wl,themain.base
 188
 189  # Run this tool over the DLL's .def file and generate an exports file
 190  # which includes the relocations from the base file.
 191
 192    dlltool --def thedll.def --base-file themain.base --output-exp thedll.exp
 193
 194  # Build the dll with file1.o, file2.o and the export table
 195
 196    ld -o thedll.dll thedll.exp file1.o file2.o  */
 197
 198 /* .idata section description
 199
 200    The .idata section is the import table.  It is a collection of several
 201    subsections used to keep the pieces for each dll together: .idata$[234567].
 202    IE: Each dll's .idata$2's are catenated together, each .idata$3's, etc.
 203
 204    .idata$2 = Import Directory Table
 205    = array of IMAGE_IMPORT_DESCRIPTOR's.
 206
 207         DWORD   Import Lookup Table;  - pointer to .idata$4
 208         DWORD   TimeDateStamp;        - currently always 0
 209         DWORD   ForwarderChain;       - currently always 0
 210         DWORD   Name;                 - pointer to dll's name
 211         PIMAGE_THUNK_DATA FirstThunk; - pointer to .idata$5
 212
 213    .idata$3 = null terminating entry for .idata$2.
 214
 215    .idata$4 = Import Lookup Table
 216    = array of array of pointers to hint name table.
 217    There is one for each dll being imported from, and each dll's set is
 218    terminated by a trailing NULL.
 219
 220    .idata$5 = Import Address Table
 221    = array of array of pointers to hint name table.
 222    There is one for each dll being imported from, and each dll's set is
 223    terminated by a trailing NULL.
 224    Initially, this table is identical to the Import Lookup Table.  However,
 225    at load time, the loader overwrites the entries with the address of the
 226    function.
 227
 228    .idata$6 = Hint Name Table
 229    = Array of { short, asciz } entries, one for each imported function.
 230    The `short' is the function's ordinal number.
 231
 232    .idata$7 = dll name (eg: "kernel32.dll"). (.idata$6 for ppc).  */
 233
 234 #include "sysdep.h"
 235 #include "bfd.h"
 236 #include "libiberty.h"
 237 #include "getopt.h"
 238 #include "demangle.h"
 239 #include "dyn-string.h"
 240 #include "bucomm.h"
 241 #include "dlltool.h"
 242 #include "safe-ctype.h"
 243
 244 #include <time.h>
 245 #include <assert.h>
 246
 247 #ifdef DLLTOOL_ARM
 248 #include "coff/arm.h"
 249 #include "coff/internal.h"
 250 #endif
 251 #ifdef DLLTOOL_DEFAULT_MX86_64
 252 #include "coff/x86_64.h"
 253 #endif
 254 #ifdef DLLTOOL_DEFAULT_I386
 255 #include "coff/i386.h"
 256 #endif
 257
 258 #ifndef COFF_PAGE_SIZE
 259 #define COFF_PAGE_SIZE ((bfd_vma) 4096)
 260 #endif
 261
 262 #ifndef PAGE_MASK
 263 #define PAGE_MASK ((bfd_vma) (- COFF_PAGE_SIZE))
 264 #endif
 265
 266 /* Get current BFD error message.  */
 267 #define bfd_get_errmsg() (bfd_errmsg (bfd_get_error ()))
 268
 269 /* Forward references.  */
 270 static char *look_for_prog (const char *, const char *, int);
 271 static char *deduce_name (const char *);
 272
 273 #ifdef DLLTOOL_MCORE_ELF
 274 static void mcore_elf_cache_filename (const char *);
 275 static void mcore_elf_gen_out_file (void);
 276 #endif
 277
 278 #ifdef HAVE_SYS_WAIT_H
 279 #include <sys/wait.h>
 280 #else /* ! HAVE_SYS_WAIT_H */
 281 #if ! defined (_WIN32) || defined (__CYGWIN32__)
 282 #ifndef WIFEXITED
 283 #define WIFEXITED(w)    (((w) & 0377) == 0)
 284 #endif
 285 #ifndef WIFSIGNALED
 286 #define WIFSIGNALED(w)  (((w) & 0377) != 0177 && ((w) & ~0377) == 0)
 287 #endif
 288 #ifndef WTERMSIG
 289 #define WTERMSIG(w)     ((w) & 0177)
 290 #endif
 291 #ifndef WEXITSTATUS
 292 #define WEXITSTATUS(w)  (((w) >> 8) & 0377)
 293 #endif
 294 #else /* defined (_WIN32) && ! defined (__CYGWIN32__) */
 295 #ifndef WIFEXITED
 296 #define WIFEXITED(w)    (((w) & 0xff) == 0)
 297 #endif
 298 #ifndef WIFSIGNALED
 299 #define WIFSIGNALED(w)  (((w) & 0xff) != 0 && ((w) & 0xff) != 0x7f)
 300 #endif
 301 #ifndef WTERMSIG
 302 #define WTERMSIG(w)     ((w) & 0x7f)
 303 #endif
 304 #ifndef WEXITSTATUS
 305 #define WEXITSTATUS(w)  (((w) & 0xff00) >> 8)
 306 #endif
 307 #endif /* defined (_WIN32) && ! defined (__CYGWIN32__) */
 308 #endif /* ! HAVE_SYS_WAIT_H */
 309
 310 #define show_allnames 0
 311
 312 /* ifunc and ihead data structures: ttk@cygnus.com 1997
 313
 314    When IMPORT declarations are encountered in a .def file the
 315    function import information is stored in a structure referenced by
 316    the global variable IMPORT_LIST.  The structure is a linked list
 317    containing the names of the dll files each function is imported
 318    from and a linked list of functions being imported from that dll
 319    file.  This roughly parallels the structure of the .idata section
 320    in the PE object file.
 321
 322    The contents of .def file are interpreted from within the
 323    process_def_file function.  Every time an IMPORT declaration is
 324    encountered, it is broken up into its component parts and passed to
 325    def_import.  IMPORT_LIST is initialized to NULL in function main.  */
 326
 327 typedef struct ifunct
 328 {
 329   char *         name;   /* Name of function being imported.  */
 330   char *     its_name;   /* Optional import table symbol name.  */
 331   int            ord;    /* Two-byte ordinal value associated with function.  */
 332   struct ifunct *next;
 333 } ifunctype;
 334
 335 typedef struct iheadt
 336 {
 337   char *         dllname;  /* Name of dll file imported from.  */
 338   long           nfuncs;   /* Number of functions in list.  */
 339   struct ifunct *funchead; /* First function in list.  */
 340   struct ifunct *functail; /* Last  function in list.  */
 341   struct iheadt *next;     /* Next dll file in list.  */
 342 } iheadtype;
 343
 344 /* Structure containing all import information as defined in .def file
 345    (qv "ihead structure").  */
 346
 347 static iheadtype *import_list = NULL;
 348 static char *as_name = NULL;
 349 static char * as_flags = "";
 350 static char *tmp_prefix;
 351 static int no_idata4;
 352 static int no_idata5;
 353 static char *exp_name;
 354 static char *imp_name;
 355 static char *delayimp_name;
 356 static char *identify_imp_name;
 357 static bfd_boolean identify_strict;
 358
 359 /* Types used to implement a linked list of dllnames associated
 360    with the specified import lib. Used by the identify_* code.
 361    The head entry is acts as a sentinal node and is always empty
 362    (head->dllname is NULL).  */
 363 typedef struct dll_name_list_node_t
 364 {
 365   char *                        dllname;
 366   struct dll_name_list_node_t * next;
 367 } dll_name_list_node_type;
 368
 369 typedef struct dll_name_list_t
 370 {
 371   dll_name_list_node_type * head;
 372   dll_name_list_node_type * tail;
 373 } dll_name_list_type;
 374
 375 /* Types used to pass data to iterator functions.  */
 376 typedef struct symname_search_data_t
 377 {
 378   const char * symname;
 379   bfd_boolean  found;
 380 } symname_search_data_type;
 381
 382 typedef struct identify_data_t
 383 {
 384    dll_name_list_type * list;
 385    bfd_boolean          ms_style_implib;
 386 } identify_data_type;
 387
 388
 389 static char *head_label;
 390 static char *imp_name_lab;
 391 static char *dll_name;
 392 static int dll_name_set_by_exp_name;
 393 static int add_indirect = 0;
 394 static int add_underscore = 0;
 395 static int add_stdcall_underscore = 0;
 396 /* This variable can hold three different values. The value
 397    -1 (default) means that default underscoring should be used,
 398    zero means that no underscoring should be done, and one
 399    indicates that underscoring should be done.  */
 400 static int leading_underscore = -1;
 401 static int dontdeltemps = 0;
 402
 403 /* TRUE if we should export all symbols.  Otherwise, we only export
 404    symbols listed in .drectve sections or in the def file.  */
 405 static bfd_boolean export_all_symbols;
 406
 407 /* TRUE if we should exclude the symbols in DEFAULT_EXCLUDES when
 408    exporting all symbols.  */
 409 static bfd_boolean do_default_excludes = TRUE;
 410
 411 static bfd_boolean use_nul_prefixed_import_tables = FALSE;
 412
 413 /* Default symbols to exclude when exporting all the symbols.  */
 414 static const char *default_excludes = "DllMain@12,DllEntryPoint@0,impure_ptr";
 415
 416 /* TRUE if we should add __imp_<SYMBOL> to import libraries for backward
 417    compatibility to old Cygwin releases.  */
 418 static bfd_boolean create_compat_implib;
 419
 420 /* TRUE if we have to write PE+ import libraries.  */
 421 static bfd_boolean create_for_pep;
 422
 423 static char *def_file;
 424
 425 extern char * program_name;
 426
 427 static int machine;
 428 static int killat;
 429 static int add_stdcall_alias;
 430 static const char *ext_prefix_alias;
 431 static int verbose;
 432 static FILE *output_def;
 433 static FILE *base_file;
 434
 435 #ifdef DLLTOOL_DEFAULT_ARM
 436 static const char *mname = "arm";
 437 #endif
 438
 439 #ifdef DLLTOOL_DEFAULT_ARM_EPOC
 440 static const char *mname = "arm-epoc";
 441 #endif
 442
 443 #ifdef DLLTOOL_DEFAULT_ARM_WINCE
 444 static const char *mname = "arm-wince";
 445 #endif
 446
 447 #ifdef DLLTOOL_DEFAULT_I386
 448 static const char *mname = "i386";
 449 #endif
 450
 451 #ifdef DLLTOOL_DEFAULT_MX86_64
 452 static const char *mname = "i386:x86-64";
 453 #endif
 454
 455 #ifdef DLLTOOL_DEFAULT_PPC
 456 static const char *mname = "ppc";
 457 #endif
 458
 459 #ifdef DLLTOOL_DEFAULT_SH
 460 static const char *mname = "sh";
 461 #endif
 462
 463 #ifdef DLLTOOL_DEFAULT_MIPS
 464 static const char *mname = "mips";
 465 #endif
 466
 467 #ifdef DLLTOOL_DEFAULT_MCORE
 468 static const char * mname = "mcore-le";
 469 #endif
 470
 471 #ifdef DLLTOOL_DEFAULT_MCORE_ELF
 472 static const char * mname = "mcore-elf";
 473 static char * mcore_elf_out_file = NULL;
 474 static char * mcore_elf_linker   = NULL;
 475 static char * mcore_elf_linker_flags = NULL;
 476
 477 #define DRECTVE_SECTION_NAME ((machine == MMCORE_ELF || machine == MMCORE_ELF_LE) ? ".exports" : ".drectve")
 478 #endif
 479
 480 #ifndef DRECTVE_SECTION_NAME
 481 #define DRECTVE_SECTION_NAME ".drectve"
 482 #endif
 483
 484 /* What's the right name for this ?  */
 485 #define PATHMAX 250
 486
 487 /* External name alias numbering starts here.  */
 488 #define PREFIX_ALIAS_BASE       20000
 489
 490 char *tmp_asm_buf;
 491 char *tmp_head_s_buf;
 492 char *tmp_head_o_buf;
 493 char *tmp_tail_s_buf;
 494 char *tmp_tail_o_buf;
 495 char *tmp_stub_buf;
 496
 497 #define TMP_ASM         dlltmp (&tmp_asm_buf, "%sc.s")
 498 #define TMP_HEAD_S      dlltmp (&tmp_head_s_buf, "%sh.s")
 499 #define TMP_HEAD_O      dlltmp (&tmp_head_o_buf, "%sh.o")
 500 #define TMP_TAIL_S      dlltmp (&tmp_tail_s_buf, "%st.s")
 501 #define TMP_TAIL_O      dlltmp (&tmp_tail_o_buf, "%st.o")
 502 #define TMP_STUB        dlltmp (&tmp_stub_buf, "%ss")
 503
 504 /* This bit of assembly does jmp * ....  */
 505 static const unsigned char i386_jtab[] =
 506 {
 507   0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
 508 };
 509
 510 static const unsigned char i386_dljtab[] =
 511 {
 512   0xFF, 0x25, 0x00, 0x00, 0x00, 0x00, /* jmp __imp__function             */
 513   0xB8, 0x00, 0x00, 0x00, 0x00,       /* mov eax, offset __imp__function */
 514   0xE9, 0x00, 0x00, 0x00, 0x00        /* jmp __tailMerge__dllname        */
 515 };
 516
 517 static const unsigned char i386_x64_dljtab[] =
 518 {
 519   0xFF, 0x25, 0x00, 0x00, 0x00, 0x00, /* jmp __imp__function             */
 520   0x48, 0x8d, 0x05,                   /* leaq rax, (__imp__function) */
 521         0x00, 0x00, 0x00, 0x00,
 522   0xE9, 0x00, 0x00, 0x00, 0x00        /* jmp __tailMerge__dllname        */
 523 };
 524
 525 static const unsigned char arm_jtab[] =
 526 {
 527   0x00, 0xc0, 0x9f, 0xe5,       /* ldr  ip, [pc] */
 528   0x00, 0xf0, 0x9c, 0xe5,       /* ldr  pc, [ip] */
 529   0,    0,    0,    0
 530 };
 531
 532 static const unsigned char arm_interwork_jtab[] =
 533 {
 534   0x04, 0xc0, 0x9f, 0xe5,       /* ldr  ip, [pc] */
 535   0x00, 0xc0, 0x9c, 0xe5,       /* ldr  ip, [ip] */
 536   0x1c, 0xff, 0x2f, 0xe1,       /* bx   ip       */
 537   0,    0,    0,    0
 538 };
 539
 540 static const unsigned char thumb_jtab[] =
 541 {
 542   0x40, 0xb4,           /* push {r6}         */
 543   0x02, 0x4e,           /* ldr  r6, [pc, #8] */
 544   0x36, 0x68,           /* ldr  r6, [r6]     */
 545   0xb4, 0x46,           /* mov  ip, r6       */
 546   0x40, 0xbc,           /* pop  {r6}         */
 547   0x60, 0x47,           /* bx   ip           */
 548   0,    0,    0,    0
 549 };
 550
 551 static const unsigned char mcore_be_jtab[] =
 552 {
 553   0x71, 0x02,            /* lrw r1,2       */
 554   0x81, 0x01,            /* ld.w r1,(r1,0) */
 555   0x00, 0xC1,            /* jmp r1         */
 556   0x12, 0x00,            /* nop            */
 557   0x00, 0x00, 0x00, 0x00 /* <address>      */
 558 };
 559
 560 static const unsigned char mcore_le_jtab[] =
 561 {
 562   0x02, 0x71,            /* lrw r1,2       */
 563   0x01, 0x81,            /* ld.w r1,(r1,0) */
 564   0xC1, 0x00,            /* jmp r1         */
 565   0x00, 0x12,            /* nop            */
 566   0x00, 0x00, 0x00, 0x00 /* <address>      */
 567 };
 568
 569 /* This is the glue sequence for PowerPC PE. There is a
 570    tocrel16-tocdefn reloc against the first instruction.
 571    We also need a IMGLUE reloc against the glue function
 572    to restore the toc saved by the third instruction in
 573    the glue.  */
 574 static const unsigned char ppc_jtab[] =
 575 {
 576   0x00, 0x00, 0x62, 0x81, /* lwz r11,0(r2)               */
 577                           /*   Reloc TOCREL16 __imp_xxx  */
 578   0x00, 0x00, 0x8B, 0x81, /* lwz r12,0(r11)              */
 579   0x04, 0x00, 0x41, 0x90, /* stw r2,4(r1)                */
 580   0xA6, 0x03, 0x89, 0x7D, /* mtctr r12                   */
 581   0x04, 0x00, 0x4B, 0x80, /* lwz r2,4(r11)               */
 582   0x20, 0x04, 0x80, 0x4E  /* bctr                        */
 583 };
 584
 585 #ifdef DLLTOOL_PPC
 586 /* The glue instruction, picks up the toc from the stw in
 587    the above code: "lwz r2,4(r1)".  */
 588 static bfd_vma ppc_glue_insn = 0x80410004;
 589 #endif
 590
 591 static const char i386_trampoline[] =
 592   "\tpushl %%ecx\n"
 593   "\tpushl %%edx\n"
 594   "\tpushl %%eax\n"
 595   "\tpushl $__DELAY_IMPORT_DESCRIPTOR_%s\n"
 596   "\tcall ___delayLoadHelper2@8\n"
 597   "\tpopl %%edx\n"
 598   "\tpopl %%ecx\n"
 599   "\tjmp *%%eax\n";
 600
 601 static const char i386_x64_trampoline[] =
 602   "\tpushq %%rcx\n"
 603   "\tpushq %%rdx\n"
 604   "\tpushq %%r8\n"
 605   "\tpushq %%r9\n"
 606   "\tsubq  $40, %%rsp\n"
 607   "\tmovq  %%rax, %%rdx\n"
 608   "\tleaq  __DELAY_IMPORT_DESCRIPTOR_%s(%%rip), %%rcx\n"
 609   "\tcall __delayLoadHelper2\n"
 610   "\taddq  $40, %%rsp\n"
 611   "\tpopq %%r9\n"
 612   "\tpopq %%r8\n"
 613   "\tpopq %%rdx\n"
 614   "\tpopq %%rcx\n"
 615   "\tjmp *%%rax\n";
 616
 617 struct mac
 618 {
 619   const char *type;
 620   const char *how_byte;
 621   const char *how_short;
 622   const char *how_long;
 623   const char *how_asciz;
 624   const char *how_comment;
 625   const char *how_jump;
 626   const char *how_global;
 627   const char *how_space;
 628   const char *how_align_short;
 629   const char *how_align_long;
 630   const char *how_default_as_switches;
 631   const char *how_bfd_target;
 632   enum bfd_architecture how_bfd_arch;
 633   const unsigned char *how_jtab;
 634   int how_jtab_size; /* Size of the jtab entry.  */
 635   int how_jtab_roff; /* Offset into it for the ind 32 reloc into idata 5.  */
 636   const unsigned char *how_dljtab;
 637   int how_dljtab_size; /* Size of the dljtab entry.  */
 638   int how_dljtab_roff1; /* Offset for the ind 32 reloc into idata 5.  */
 639   int how_dljtab_roff2; /* Offset for the ind 32 reloc into idata 5.  */
 640   int how_dljtab_roff3; /* Offset for the ind 32 reloc into idata 5.  */
 641   const char *trampoline;
 642 };
 643
 644 static const struct mac
 645 mtable[] =
 646 {
 647   {
 648 #define MARM 0
 649     "arm", ".byte", ".short", ".long", ".asciz", "@",
 650     "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
 651     ".global", ".space", ".align\t2",".align\t4", "-mapcs-32",
 652     "pe-arm-little", bfd_arch_arm,
 653     arm_jtab, sizeof (arm_jtab), 8,
 654     0, 0, 0, 0, 0, 0
 655   }
 656   ,
 657   {
 658 #define M386 1
 659     "i386", ".byte", ".short", ".long", ".asciz", "#",
 660     "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
 661     "pe-i386",bfd_arch_i386,
 662     i386_jtab, sizeof (i386_jtab), 2,
 663     i386_dljtab, sizeof (i386_dljtab), 2, 7, 12, i386_trampoline
 664   }
 665   ,
 666   {
 667 #define MPPC 2
 668     "ppc", ".byte", ".short", ".long", ".asciz", "#",
 669     "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
 670     "pe-powerpcle",bfd_arch_powerpc,
 671     ppc_jtab, sizeof (ppc_jtab), 0,
 672     0, 0, 0, 0, 0, 0
 673   }
 674   ,
 675   {
 676 #define MTHUMB 3
 677     "thumb", ".byte", ".short", ".long", ".asciz", "@",
 678     "push\t{r6}\n\tldr\tr6, [pc, #8]\n\tldr\tr6, [r6]\n\tmov\tip, r6\n\tpop\t{r6}\n\tbx\tip",
 679     ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
 680     "pe-arm-little", bfd_arch_arm,
 681     thumb_jtab, sizeof (thumb_jtab), 12,
 682     0, 0, 0, 0, 0, 0
 683   }
 684   ,
 685 #define MARM_INTERWORK 4
 686   {
 687     "arm_interwork", ".byte", ".short", ".long", ".asciz", "@",
 688     "ldr\tip,[pc]\n\tldr\tip,[ip]\n\tbx\tip\n\t.long",
 689     ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
 690     "pe-arm-little", bfd_arch_arm,
 691     arm_interwork_jtab, sizeof (arm_interwork_jtab), 12,
 692     0, 0, 0, 0, 0, 0
 693   }
 694   ,
 695   {
 696 #define MMCORE_BE 5
 697     "mcore-be", ".byte", ".short", ".long", ".asciz", "//",
 698     "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
 699     ".global", ".space", ".align\t2",".align\t4", "",
 700     "pe-mcore-big", bfd_arch_mcore,
 701     mcore_be_jtab, sizeof (mcore_be_jtab), 8,
 702     0, 0, 0, 0, 0, 0
 703   }
 704   ,
 705   {
 706 #define MMCORE_LE 6
 707     "mcore-le", ".byte", ".short", ".long", ".asciz", "//",
 708     "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
 709     ".global", ".space", ".align\t2",".align\t4", "-EL",
 710     "pe-mcore-little", bfd_arch_mcore,
 711     mcore_le_jtab, sizeof (mcore_le_jtab), 8,
 712     0, 0, 0, 0, 0, 0
 713   }
 714   ,
 715   {
 716 #define MMCORE_ELF 7
 717     "mcore-elf-be", ".byte", ".short", ".long", ".asciz", "//",
 718     "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
 719     ".global", ".space", ".align\t2",".align\t4", "",
 720     "elf32-mcore-big", bfd_arch_mcore,
 721     mcore_be_jtab, sizeof (mcore_be_jtab), 8,
 722     0, 0, 0, 0, 0, 0
 723   }
 724   ,
 725   {
 726 #define MMCORE_ELF_LE 8
 727     "mcore-elf-le", ".byte", ".short", ".long", ".asciz", "//",
 728     "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
 729     ".global", ".space", ".align\t2",".align\t4", "-EL",
 730     "elf32-mcore-little", bfd_arch_mcore,
 731     mcore_le_jtab, sizeof (mcore_le_jtab), 8,
 732     0, 0, 0, 0, 0, 0
 733   }
 734   ,
 735   {
 736 #define MARM_EPOC 9
 737     "arm-epoc", ".byte", ".short", ".long", ".asciz", "@",
 738     "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
 739     ".global", ".space", ".align\t2",".align\t4", "",
 740     "epoc-pe-arm-little", bfd_arch_arm,
 741     arm_jtab, sizeof (arm_jtab), 8,
 742     0, 0, 0, 0, 0, 0
 743   }
 744   ,
 745   {
 746 #define MARM_WINCE 10
 747     "arm-wince", ".byte", ".short", ".long", ".asciz", "@",
 748     "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
 749     ".global", ".space", ".align\t2",".align\t4", "-mapcs-32",
 750     "pe-arm-wince-little", bfd_arch_arm,
 751     arm_jtab, sizeof (arm_jtab), 8,
 752     0, 0, 0, 0, 0, 0
 753   }
 754   ,
 755   {
 756 #define MX86 11
 757     "i386:x86-64", ".byte", ".short", ".long", ".asciz", "#",
 758     "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
 759     "pe-x86-64",bfd_arch_i386,
 760     i386_jtab, sizeof (i386_jtab), 2,
 761     i386_x64_dljtab, sizeof (i386_x64_dljtab), 2, 9, 14, i386_x64_trampoline
 762   }
 763   ,
 764   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
 765 };
 766
 767 typedef struct dlist
 768 {
 769   char *text;
 770   struct dlist *next;
 771 }
 772 dlist_type;
 773
 774 typedef struct export
 775 {
 776   const char *name;
 777   const char *internal_name;
 778   const char *import_name;
 779   const char *its_name;
 780   int ordinal;
 781   int constant;
 782   int noname;           /* Don't put name in image file.  */
 783   int private;  /* Don't put reference in import lib.  */
 784   int data;
 785   int hint;
 786   int forward;  /* Number of forward label, 0 means no forward.  */
 787   struct export *next;
 788 }
 789 export_type;
 790
 791 /* A list of symbols which we should not export.  */
 792
 793 struct string_list
 794 {
 795   struct string_list *next;
 796   char *string;
 797 };
 798
 799 static struct string_list *excludes;
 800
 801 static const char *rvaafter (int);
 802 static const char *rvabefore (int);
 803 static const char *asm_prefix (int, const char *);
 804 static void process_def_file (const char *);
 805 static void new_directive (char *);
 806 static void append_import (const char *, const char *, int, const char *);
 807 static void run (const char *, char *);
 808 static void scan_drectve_symbols (bfd *);
 809 static void scan_filtered_symbols (bfd *, void *, long, unsigned int);
 810 static void add_excludes (const char *);
 811 static bfd_boolean match_exclude (const char *);
 812 static void set_default_excludes (void);
 813 static long filter_symbols (bfd *, void *, long, unsigned int);
 814 static void scan_all_symbols (bfd *);
 815 static void scan_open_obj_file (bfd *);
 816 static void scan_obj_file (const char *);
 817 static void dump_def_info (FILE *);
 818 static int sfunc (const void *, const void *);
 819 static void flush_page (FILE *, bfd_vma *, bfd_vma, int);
 820 static void gen_def_file (void);
 821 static void generate_idata_ofile (FILE *);
 822 static void assemble_file (const char *, const char *);
 823 static void gen_exp_file (void);
 824 static const char *xlate (const char *);
 825 static char *make_label (const char *, const char *);
 826 static char *make_imp_label (const char *, const char *);
 827 static bfd *make_one_lib_file (export_type *, int, int);
 828 static bfd *make_head (void);
 829 static bfd *make_tail (void);
 830 static bfd *make_delay_head (void);
 831 static void gen_lib_file (int);
 832 static void dll_name_list_append (dll_name_list_type *, bfd_byte *);
 833 static int  dll_name_list_count (dll_name_list_type *);
 834 static void dll_name_list_print (dll_name_list_type *);
 835 static void dll_name_list_free_contents (dll_name_list_node_type *);
 836 static void dll_name_list_free (dll_name_list_type *);
 837 static dll_name_list_type * dll_name_list_create (void);
 838 static void identify_dll_for_implib (void);
 839 static void identify_search_archive
 840   (bfd *, void (*) (bfd *, bfd *, void *),  void *);
 841 static void identify_search_member (bfd *, bfd *, void *);
 842 static bfd_boolean identify_process_section_p (asection *, bfd_boolean);
 843 static void identify_search_section (bfd *, asection *, void *);
 844 static void identify_member_contains_symname (bfd *, bfd  *, void *);
 845
 846 static int pfunc (const void *, const void *);
 847 static int nfunc (const void *, const void *);
 848 static void remove_null_names (export_type **);
 849 static void process_duplicates (export_type **);
 850 static void fill_ordinals (export_type **);
 851 static void mangle_defs (void);
 852 static void usage (FILE *, int);
 853 static void inform (const char *, ...) ATTRIBUTE_PRINTF_1;
 854 static void set_dll_name_from_def (const char *name, char is_dll);
 855
 856 static char *
 857 prefix_encode (char *start, unsigned code)
 858 {
 859   static char alpha[26] = "abcdefghijklmnopqrstuvwxyz";
 860   static char buf[32];
 861   char *p;
 862   strcpy (buf, start);
 863   p = strchr (buf, '\0');
 864   do
 865     *p++ = alpha[code % sizeof (alpha)];
 866   while ((code /= sizeof (alpha)) != 0);
 867   *p = '\0';
 868   return buf;
 869 }
 870
 871 static char *
 872 dlltmp (char **buf, const char *fmt)
 873 {
 874   if (!*buf)
 875     {
 876       *buf = malloc (strlen (tmp_prefix) + 64);
 877       sprintf (*buf, fmt, tmp_prefix);
 878     }
 879   return *buf;
 880 }
 881
 882 static void
 883 inform (const char * message, ...)
 884 {
 885   va_list args;
 886
 887   va_start (args, message);
 888
 889   if (!verbose)
 890     return;
 891
 892   report (message, args);
 893
 894   va_end (args);
 895 }
 896
 897 static const char *
 898 rvaafter (int mach)
 899 {
 900   switch (mach)
 901     {
 902     case MARM:
 903     case M386:
 904     case MX86:
 905     case MPPC:
 906     case MTHUMB:
 907     case MARM_INTERWORK:
 908     case MMCORE_BE:
 909     case MMCORE_LE:
 910     case MMCORE_ELF:
 911     case MMCORE_ELF_LE:
 912     case MARM_EPOC:
 913     case MARM_WINCE:
 914       break;
 915     default:
 916       /* xgettext:c-format */
 917       fatal (_("Internal error: Unknown machine type: %d"), mach);
 918       break;
 919     }
 920   return "";
 921 }
 922
 923 static const char *
 924 rvabefore (int mach)
 925 {
 926   switch (mach)
 927     {
 928     case MARM:
 929     case M386:
 930     case MX86:
 931     case MPPC:
 932     case MTHUMB:
 933     case MARM_INTERWORK:
 934     case MMCORE_BE:
 935     case MMCORE_LE:
 936     case MMCORE_ELF:
 937     case MMCORE_ELF_LE:
 938     case MARM_EPOC:
 939     case MARM_WINCE:
 940       return ".rva\t";
 941     default:
 942       /* xgettext:c-format */
 943       fatal (_("Internal error: Unknown machine type: %d"), mach);
 944       break;
 945     }
 946   return "";
 947 }
 948
 949 static const char *
 950 asm_prefix (int mach, const char *name)
 951 {
 952   switch (mach)
 953     {
 954     case MARM:
 955     case MPPC:
 956     case MTHUMB:
 957     case MARM_INTERWORK:
 958     case MMCORE_BE:
 959     case MMCORE_LE:
 960     case MMCORE_ELF:
 961     case MMCORE_ELF_LE:
 962     case MARM_EPOC:
 963     case MARM_WINCE:
 964       break;
 965     case M386:
 966     case MX86:
 967       /* Symbol names starting with ? do not have a leading underscore. */
 968       if ((name && *name == '?') || leading_underscore == 0)
 969         break;
 970       else
 971         return "_";
 972     default:
 973       /* xgettext:c-format */
 974       fatal (_("Internal error: Unknown machine type: %d"), mach);
 975       break;
 976     }
 977   return "";
 978 }
 979
 980 #define ASM_BYTE                mtable[machine].how_byte
 981 #define ASM_SHORT               mtable[machine].how_short
 982 #define ASM_LONG                mtable[machine].how_long
 983 #define ASM_TEXT                mtable[machine].how_asciz
 984 #define ASM_C                   mtable[machine].how_comment
 985 #define ASM_JUMP                mtable[machine].how_jump
 986 #define ASM_GLOBAL              mtable[machine].how_global
 987 #define ASM_SPACE               mtable[machine].how_space
 988 #define ASM_ALIGN_SHORT         mtable[machine].how_align_short
 989 #define ASM_RVA_BEFORE          rvabefore (machine)
 990 #define ASM_RVA_AFTER           rvaafter (machine)
 991 #define ASM_PREFIX(NAME)        asm_prefix (machine, (NAME))
 992 #define ASM_ALIGN_LONG          mtable[machine].how_align_long
 993 #define HOW_BFD_READ_TARGET     0  /* Always default.  */
 994 #define HOW_BFD_WRITE_TARGET    mtable[machine].how_bfd_target
 995 #define HOW_BFD_ARCH            mtable[machine].how_bfd_arch
 996 #define HOW_JTAB                (delay ? mtable[machine].how_dljtab \
 997                                         : mtable[machine].how_jtab)
 998 #define HOW_JTAB_SIZE           (delay ? mtable[machine].how_dljtab_size \
 999                                         : mtable[machine].how_jtab_size)
1000 #define HOW_JTAB_ROFF           (delay ? mtable[machine].how_dljtab_roff1 \
1001                                         : mtable[machine].how_jtab_roff)
1002 #define HOW_JTAB_ROFF2          (delay ? mtable[machine].how_dljtab_roff2 : 0)
1003 #define HOW_JTAB_ROFF3          (delay ? mtable[machine].how_dljtab_roff3 : 0)
1004 #define ASM_SWITCHES            mtable[machine].how_default_as_switches
1005
1006 static char **oav;
1007
1008 static void
1009 process_def_file (const char *name)
1010 {
1011   FILE *f = fopen (name, FOPEN_RT);
1012
1013   if (!f)
1014     /* xgettext:c-format */
1015     fatal (_("Can't open def file: %s"), name);
1016
1017   yyin = f;
1018
1019   /* xgettext:c-format */
1020   inform (_("Processing def file: %s"), name);
1021
1022   yyparse ();
1023
1024   inform (_("Processed def file"));
1025 }
1026
1027 /**********************************************************************/
1028
1029 /* Communications with the parser.  */
1030
1031 static int d_nfuncs;            /* Number of functions exported.  */
1032 static int d_named_nfuncs;      /* Number of named functions exported.  */
1033 static int d_low_ord;           /* Lowest ordinal index.  */
1034 static int d_high_ord;          /* Highest ordinal index.  */
1035 static export_type *d_exports;  /* List of exported functions.  */
1036 static export_type **d_exports_lexically;  /* Vector of exported functions in alpha order.  */
1037 static dlist_type *d_list;      /* Descriptions.  */
1038 static dlist_type *a_list;      /* Stuff to go in directives.  */
1039 static int d_nforwards = 0;     /* Number of forwarded exports.  */
1040
1041 static int d_is_dll;
1042 static int d_is_exe;
1043
1044 int
1045 yyerror (const char * err ATTRIBUTE_UNUSED)
1046 {
1047   /* xgettext:c-format */
1048   non_fatal (_("Syntax error in def file %s:%d"), def_file, linenumber);
1049
1050   return 0;
1051 }
1052
1053 void
1054 def_exports (const char *name, const char *internal_name, int ordinal,
1055              int noname, int constant, int data, int private,
1056              const char *its_name)
1057 {
1058   struct export *p = (struct export *) xmalloc (sizeof (*p));
1059
1060   p->name = name;
1061   p->internal_name = internal_name ? internal_name : name;
1062   p->its_name = its_name;
1063   p->import_name = name;
1064   p->ordinal = ordinal;
1065   p->constant = constant;
1066   p->noname = noname;
1067   p->private = private;
1068   p->data = data;
1069   p->next = d_exports;
1070   d_exports = p;
1071   d_nfuncs++;
1072
1073   if ((internal_name != NULL)
1074       && (strchr (internal_name, '.') != NULL))
1075     p->forward = ++d_nforwards;
1076   else
1077     p->forward = 0; /* no forward */
1078 }
1079
1080 static void
1081 set_dll_name_from_def (const char *name, char is_dll)
1082 {
1083   const char *image_basename = lbasename (name);
1084   if (image_basename != name)
1085     non_fatal (_("%s: Path components stripped from image name, '%s'."),
1086               def_file, name);
1087   /* Append the default suffix, if none specified.  */
1088   if (strchr (image_basename, '.') == 0)
1089     {
1090       const char * suffix = is_dll ? ".dll" : ".exe";
1091
1092       dll_name = xmalloc (strlen (image_basename) + strlen (suffix) + 1);
1093       sprintf (dll_name, "%s%s", image_basename, suffix);
1094     }
1095   else
1096     dll_name = xstrdup (image_basename);
1097 }
1098
1099 void
1100 def_name (const char *name, int base)
1101 {
1102   /* xgettext:c-format */
1103   inform (_("NAME: %s base: %x"), name, base);
1104
1105   if (d_is_dll)
1106     non_fatal (_("Can't have LIBRARY and NAME"));
1107
1108   if (dll_name_set_by_exp_name && name && *name != 0)
1109     {
1110       dll_name = NULL;
1111       dll_name_set_by_exp_name = 0;
1112     }
1113   /* If --dllname not provided, use the one in the DEF file.
1114      FIXME: Is this appropriate for executables?  */
1115   if (!dll_name)
1116     set_dll_name_from_def (name, 0);
1117   d_is_exe = 1;
1118 }
1119
1120 void
1121 def_library (const char *name, int base)
1122 {
1123   /* xgettext:c-format */
1124   inform (_("LIBRARY: %s base: %x"), name, base);
1125
1126   if (d_is_exe)
1127     non_fatal (_("Can't have LIBRARY and NAME"));
1128
1129   if (dll_name_set_by_exp_name && name && *name != 0)
1130     {
1131       dll_name = NULL;
1132       dll_name_set_by_exp_name = 0;
1133     }
1134
1135   /* If --dllname not provided, use the one in the DEF file.  */
1136   if (!dll_name)
1137     set_dll_name_from_def (name, 1);
1138   d_is_dll = 1;
1139 }
1140
1141 void
1142 def_description (const char *desc)
1143 {
1144   dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
1145   d->text = xstrdup (desc);
1146   d->next = d_list;
1147   d_list = d;
1148 }
1149
1150 static void
1151 new_directive (char *dir)
1152 {
1153   dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
1154   d->text = xstrdup (dir);
1155   d->next = a_list;
1156   a_list = d;
1157 }
1158
1159 void
1160 def_heapsize (int reserve, int commit)
1161 {
1162   char b[200];
1163   if (commit > 0)
1164     sprintf (b, "-heap 0x%x,0x%x ", reserve, commit);
1165   else
1166     sprintf (b, "-heap 0x%x ", reserve);
1167   new_directive (xstrdup (b));
1168 }
1169
1170 void
1171 def_stacksize (int reserve, int commit)
1172 {
1173   char b[200];
1174   if (commit > 0)
1175     sprintf (b, "-stack 0x%x,0x%x ", reserve, commit);
1176   else
1177     sprintf (b, "-stack 0x%x ", reserve);
1178   new_directive (xstrdup (b));
1179 }
1180
1181 /* append_import simply adds the given import definition to the global
1182    import_list.  It is used by def_import.  */
1183
1184 static void
1185 append_import (const char *symbol_name, const char *dllname, int func_ordinal,
1186                const char *its_name)
1187 {
1188   iheadtype **pq;
1189   iheadtype *q;
1190
1191   for (pq = &import_list; *pq != NULL; pq = &(*pq)->next)
1192     {
1193       if (strcmp ((*pq)->dllname, dllname) == 0)
1194         {
1195           q = *pq;
1196           q->functail->next = xmalloc (sizeof (ifunctype));
1197           q->functail = q->functail->next;
1198           q->functail->ord  = func_ordinal;
1199           q->functail->name = xstrdup (symbol_name);
1200           q->functail->its_name = (its_name ? xstrdup (its_name) : NULL);
1201           q->functail->next = NULL;
1202           q->nfuncs++;
1203           return;
1204         }
1205     }
1206
1207   q = xmalloc (sizeof (iheadtype));
1208   q->dllname = xstrdup (dllname);
1209   q->nfuncs = 1;
1210   q->funchead = xmalloc (sizeof (ifunctype));
1211   q->functail = q->funchead;
1212   q->next = NULL;
1213   q->functail->name = xstrdup (symbol_name);
1214   q->functail->its_name = (its_name ? xstrdup (its_name) : NULL);
1215   q->functail->ord  = func_ordinal;
1216   q->functail->next = NULL;
1217
1218   *pq = q;
1219 }
1220
1221 /* def_import is called from within defparse.y when an IMPORT
1222    declaration is encountered.  Depending on the form of the
1223    declaration, the module name may or may not need ".dll" to be
1224    appended to it, the name of the function may be stored in internal
1225    or entry, and there may or may not be an ordinal value associated
1226    with it.  */
1227
1228 /* A note regarding the parse modes:
1229    In defparse.y we have to accept import declarations which follow
1230    any one of the following forms:
1231      <func_name_in_app> = <dll_name>.<func_name_in_dll>
1232      <func_name_in_app> = <dll_name>.<number>
1233      <dll_name>.<func_name_in_dll>
1234      <dll_name>.<number>
1235    Furthermore, the dll's name may or may not end with ".dll", which
1236    complicates the parsing a little.  Normally the dll's name is
1237    passed to def_import() in the "module" parameter, but when it ends
1238    with ".dll" it gets passed in "module" sans ".dll" and that needs
1239    to be reappended.
1240
1241   def_import gets five parameters:
1242   APP_NAME - the name of the function in the application, if
1243              present, or NULL if not present.
1244   MODULE   - the name of the dll, possibly sans extension (ie, '.dll').
1245   DLLEXT   - the extension of the dll, if present, NULL if not present.
1246   ENTRY    - the name of the function in the dll, if present, or NULL.
1247   ORD_VAL  - the numerical tag of the function in the dll, if present,
1248              or NULL.  Exactly one of <entry> or <ord_val> must be
1249              present (i.e., not NULL).  */
1250
1251 void
1252 def_import (const char *app_name, const char *module, const char *dllext,
1253             const char *entry, int ord_val, const char *its_name)
1254 {
1255   const char *application_name;
1256   char *buf = NULL;
1257
1258   if (entry != NULL)
1259     application_name = entry;
1260   else
1261     {
1262       if (app_name != NULL)
1263         application_name = app_name;
1264       else
1265         application_name = "";
1266     }
1267
1268   if (dllext != NULL)
1269     module = buf = concat (module, ".", dllext, NULL);
1270
1271   append_import (application_name, module, ord_val, its_name);
1272
1273   if (buf)
1274     free (buf);
1275 }
1276
1277 void
1278 def_version (int major, int minor)
1279 {
1280   printf (_("VERSION %d.%d\n"), major, minor);
1281 }
1282
1283 void
1284 def_section (const char *name, int attr)
1285 {
1286   char buf[200];
1287   char atts[5];
1288   char *d = atts;
1289   if (attr & 1)
1290     *d++ = 'R';
1291
1292   if (attr & 2)
1293     *d++ = 'W';
1294   if (attr & 4)
1295     *d++ = 'X';
1296   if (attr & 8)
1297     *d++ = 'S';
1298   *d++ = 0;
1299   sprintf (buf, "-attr %s %s", name, atts);
1300   new_directive (xstrdup (buf));
1301 }
1302
1303 void
1304 def_code (int attr)
1305 {
1306
1307   def_section ("CODE", attr);
1308 }
1309
1310 void
1311 def_data (int attr)
1312 {
1313   def_section ("DATA", attr);
1314 }
1315
1316 /**********************************************************************/
1317
1318 static void
1319 run (const char *what, char *args)
1320 {
1321   char *s;
1322   int pid, wait_status;
1323   int i;
1324   const char **argv;
1325   char *errmsg_fmt, *errmsg_arg;
1326   char *temp_base = choose_temp_base ();
1327
1328   inform (_("run: %s %s"), what, args);
1329
1330   /* Count the args */
1331   i = 0;
1332   for (s = args; *s; s++)
1333     if (*s == ' ')
1334       i++;
1335   i++;
1336   argv = xmalloc (sizeof (char *) * (i + 3));
1337   i = 0;
1338   argv[i++] = what;
1339   s = args;
1340   while (1)
1341     {
1342       while (*s == ' ')
1343         ++s;
1344       argv[i++] = s;
1345       while (*s != ' ' && *s != 0)
1346         s++;
1347       if (*s == 0)
1348         break;
1349       *s++ = 0;
1350     }
1351   argv[i++] = NULL;
1352
1353   pid = pexecute (argv[0], (char * const *) argv, program_name, temp_base,
1354                   &errmsg_fmt, &errmsg_arg, PEXECUTE_ONE | PEXECUTE_SEARCH);
1355   free(argv);
1356
1357   if (pid == -1)
1358     {
1359       inform ("%s", strerror (errno));
1360
1361       fatal (errmsg_fmt, errmsg_arg);
1362     }
1363
1364   pid = pwait (pid, & wait_status, 0);
1365
1366   if (pid == -1)
1367     {
1368       /* xgettext:c-format */
1369       fatal (_("wait: %s"), strerror (errno));
1370     }
1371   else if (WIFSIGNALED (wait_status))
1372     {
1373       /* xgettext:c-format */
1374       fatal (_("subprocess got fatal signal %d"), WTERMSIG (wait_status));
1375     }
1376   else if (WIFEXITED (wait_status))
1377     {
1378       if (WEXITSTATUS (wait_status) != 0)
1379         /* xgettext:c-format */
1380         non_fatal (_("%s exited with status %d"),
1381                    what, WEXITSTATUS (wait_status));
1382     }
1383   else
1384     abort ();
1385 }
1386
1387 /* Look for a list of symbols to export in the .drectve section of
1388    ABFD.  Pass each one to def_exports.  */
1389
1390 static void
1391 scan_drectve_symbols (bfd *abfd)
1392 {
1393   asection * s;
1394   int        size;
1395   char *     buf;
1396   char *     p;
1397   char *     e;
1398
1399   /* Look for .drectve's */
1400   s = bfd_get_section_by_name (abfd, DRECTVE_SECTION_NAME);
1401
1402   if (s == NULL)
1403     return;
1404
1405   size = bfd_get_section_size (s);
1406   buf  = xmalloc (size);
1407
1408   bfd_get_section_contents (abfd, s, buf, 0, size);
1409
1410   /* xgettext:c-format */
1411   inform (_("Sucking in info from %s section in %s"),
1412           DRECTVE_SECTION_NAME, bfd_get_filename (abfd));
1413
1414   /* Search for -export: strings. The exported symbols can optionally
1415      have type tags (eg., -export:foo,data), so handle those as well.
1416      Currently only data tag is supported.  */
1417   p = buf;
1418   e = buf + size;
1419   while (p < e)
1420     {
1421       if (p[0] == '-'
1422           && CONST_STRNEQ (p, "-export:"))
1423         {
1424           char * name;
1425           char * c;
1426           flagword flags = BSF_FUNCTION;
1427
1428           p += 8;
1429           /* Do we have a quoted export?  */
1430           if (*p == '"')
1431             {
1432               p++;
1433               name = p;
1434               while (p < e && *p != '"')
1435                 ++p;
1436             }
1437           else
1438             {
1439               name = p;
1440               while (p < e && *p != ',' && *p != ' ' && *p != '-')
1441                 p++;
1442             }
1443           c = xmalloc (p - name + 1);
1444           memcpy (c, name, p - name);
1445           c[p - name] = 0;
1446           /* Advance over trailing quote.  */
1447           if (p < e && *p == '"')
1448             ++p;
1449           if (p < e && *p == ',')       /* found type tag.  */
1450             {
1451               char *tag_start = ++p;
1452               while (p < e && *p != ' ' && *p != '-')
1453                 p++;
1454               if (CONST_STRNEQ (tag_start, "data"))
1455                 flags &= ~BSF_FUNCTION;
1456             }
1457
1458           /* FIXME: The 5th arg is for the `constant' field.
1459              What should it be?  Not that it matters since it's not
1460              currently useful.  */
1461           def_exports (c, 0, -1, 0, 0, ! (flags & BSF_FUNCTION), 0, NULL);
1462
1463           if (add_stdcall_alias && strchr (c, '@'))
1464             {
1465               int lead_at = (*c == '@') ;
1466               char *exported_name = xstrdup (c + lead_at);
1467               char *atsym = strchr (exported_name, '@');
1468               *atsym = '\0';
1469               /* Note: stdcall alias symbols can never be data.  */
1470               def_exports (exported_name, xstrdup (c), -1, 0, 0, 0, 0, NULL);
1471             }
1472         }
1473       else
1474         p++;
1475     }
1476   free (buf);
1477 }
1478
1479 /* Look through the symbols in MINISYMS, and add each one to list of
1480    symbols to export.  */
1481
1482 static void
1483 scan_filtered_symbols (bfd *abfd, void *minisyms, long symcount,
1484                        unsigned int size)
1485 {
1486   asymbol *store;
1487   bfd_byte *from, *fromend;
1488
1489   store = bfd_make_empty_symbol (abfd);
1490   if (store == NULL)
1491     bfd_fatal (bfd_get_filename (abfd));
1492
1493   from = (bfd_byte *) minisyms;
1494   fromend = from + symcount * size;
1495   for (; from < fromend; from += size)
1496     {
1497       asymbol *sym;
1498       const char *symbol_name;
1499
1500       sym = bfd_minisymbol_to_symbol (abfd, FALSE, from, store);
1501       if (sym == NULL)
1502         bfd_fatal (bfd_get_filename (abfd));
1503
1504       symbol_name = bfd_asymbol_name (sym);
1505       if (bfd_get_symbol_leading_char (abfd) == symbol_name[0])
1506         ++symbol_name;
1507
1508       def_exports (xstrdup (symbol_name) , 0, -1, 0, 0,
1509                    ! (sym->flags & BSF_FUNCTION), 0, NULL);
1510
1511       if (add_stdcall_alias && strchr (symbol_name, '@'))
1512         {
1513           int lead_at = (*symbol_name == '@');
1514           char *exported_name = xstrdup (symbol_name + lead_at);
1515           char *atsym = strchr (exported_name, '@');
1516           *atsym = '\0';
1517           /* Note: stdcall alias symbols can never be data.  */
1518           def_exports (exported_name, xstrdup (symbol_name), -1, 0, 0, 0, 0, NULL);
1519         }
1520     }
1521 }
1522
1523 /* Add a list of symbols to exclude.  */
1524
1525 static void
1526 add_excludes (const char *new_excludes)
1527 {
1528   char *local_copy;
1529   char *exclude_string;
1530
1531   local_copy = xstrdup (new_excludes);
1532
1533   exclude_string = strtok (local_copy, ",:");
1534   for (; exclude_string; exclude_string = strtok (NULL, ",:"))
1535     {
1536       struct string_list *new_exclude;
1537
1538       new_exclude = ((struct string_list *)
1539                      xmalloc (sizeof (struct string_list)));
1540       new_exclude->string = (char *) xmalloc (strlen (exclude_string) + 2);
1541       /* Don't add a leading underscore for fastcall symbols.  */
1542       if (*exclude_string == '@')
1543         sprintf (new_exclude->string, "%s", exclude_string);
1544       else
1545         sprintf (new_exclude->string, "%s%s", (!leading_underscore ? "" : "_"),
1546                  exclude_string);
1547       new_exclude->next = excludes;
1548       excludes = new_exclude;
1549
1550       /* xgettext:c-format */
1551       inform (_("Excluding symbol: %s"), exclude_string);
1552     }
1553
1554   free (local_copy);
1555 }
1556
1557 /* See if STRING is on the list of symbols to exclude.  */
1558
1559 static bfd_boolean
1560 match_exclude (const char *string)
1561 {
1562   struct string_list *excl_item;
1563
1564   for (excl_item = excludes; excl_item; excl_item = excl_item->next)
1565     if (strcmp (string, excl_item->string) == 0)
1566       return TRUE;
1567   return FALSE;
1568 }
1569
1570 /* Add the default list of symbols to exclude.  */
1571
1572 static void
1573 set_default_excludes (void)
1574 {
1575   add_excludes (default_excludes);
1576 }
1577
1578 /* Choose which symbols to export.  */
1579
1580 static long
1581 filter_symbols (bfd *abfd, void *minisyms, long symcount, unsigned int size)
1582 {
1583   bfd_byte *from, *fromend, *to;
1584   asymbol *store;
1585
1586   store = bfd_make_empty_symbol (abfd);
1587   if (store == NULL)
1588     bfd_fatal (bfd_get_filename (abfd));
1589
1590   from = (bfd_byte *) minisyms;
1591   fromend = from + symcount * size;
1592   to = (bfd_byte *) minisyms;
1593
1594   for (; from < fromend; from += size)
1595     {
1596       int keep = 0;
1597       asymbol *sym;
1598
1599       sym = bfd_minisymbol_to_symbol (abfd, FALSE, (const void *) from, store);
1600       if (sym == NULL)
1601         bfd_fatal (bfd_get_filename (abfd));
1602
1603       /* Check for external and defined only symbols.  */
1604       keep = (((sym->flags & BSF_GLOBAL) != 0
1605                || (sym->flags & BSF_WEAK) != 0
1606                || bfd_is_com_section (sym->section))
1607               && ! bfd_is_und_section (sym->section));
1608
1609       keep = keep && ! match_exclude (sym->name);
1610
1611       if (keep)
1612         {
1613           memcpy (to, from, size);
1614           to += size;
1615         }
1616     }
1617
1618   return (to - (bfd_byte *) minisyms) / size;
1619 }
1620
1621 /* Export all symbols in ABFD, except for ones we were told not to
1622    export.  */
1623
1624 static void
1625 scan_all_symbols (bfd *abfd)
1626 {
1627   long symcount;
1628   void *minisyms;
1629   unsigned int size;
1630
1631   /* Ignore bfds with an import descriptor table.  We assume that any
1632      such BFD contains symbols which are exported from another DLL,
1633      and we don't want to reexport them from here.  */
1634   if (bfd_get_section_by_name (abfd, ".idata$4"))
1635     return;
1636
1637   if (! (bfd_get_file_flags (abfd) & HAS_SYMS))
1638     {
1639       /* xgettext:c-format */
1640       non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1641       return;
1642     }
1643
1644   symcount = bfd_read_minisymbols (abfd, FALSE, &minisyms, &size);
1645   if (symcount < 0)
1646     bfd_fatal (bfd_get_filename (abfd));
1647
1648   if (symcount == 0)
1649     {
1650       /* xgettext:c-format */
1651       non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1652       return;
1653     }
1654
1655   /* Discard the symbols we don't want to export.  It's OK to do this
1656      in place; we'll free the storage anyway.  */
1657
1658   symcount = filter_symbols (abfd, minisyms, symcount, size);
1659   scan_filtered_symbols (abfd, minisyms, symcount, size);
1660
1661   free (minisyms);
1662 }
1663
1664 /* Look at the object file to decide which symbols to export.  */
1665
1666 static void
1667 scan_open_obj_file (bfd *abfd)
1668 {
1669   if (export_all_symbols)
1670     scan_all_symbols (abfd);
1671   else
1672     scan_drectve_symbols (abfd);
1673
1674   /* FIXME: we ought to read in and block out the base relocations.  */
1675
1676   /* xgettext:c-format */
1677   inform (_("Done reading %s"), bfd_get_filename (abfd));
1678 }
1679
1680 static void
1681 scan_obj_file (const char *filename)
1682 {
1683   bfd * f = bfd_openr (filename, 0);
1684
1685   if (!f)
1686     /* xgettext:c-format */
1687     fatal (_("Unable to open object file: %s: %s"), filename, bfd_get_errmsg ());
1688
1689   /* xgettext:c-format */
1690   inform (_("Scanning object file %s"), filename);
1691
1692   if (bfd_check_format (f, bfd_archive))
1693     {
1694       bfd *arfile = bfd_openr_next_archived_file (f, 0);
1695       while (arfile)
1696         {
1697           bfd *next;
1698           if (bfd_check_format (arfile, bfd_object))
1699             scan_open_obj_file (arfile);
1700           next = bfd_openr_next_archived_file (f, arfile);
1701           bfd_close (arfile);
1702           /* PR 17512: file: 58715298.  */
1703           if (next == arfile)
1704             break;
1705           arfile = next;
1706         }
1707
1708 #ifdef DLLTOOL_MCORE_ELF
1709       if (mcore_elf_out_file)
1710         inform (_("Cannot produce mcore-elf dll from archive file: %s"), filename);
1711 #endif
1712     }
1713   else if (bfd_check_format (f, bfd_object))
1714     {
1715       scan_open_obj_file (f);
1716
1717 #ifdef DLLTOOL_MCORE_ELF
1718       if (mcore_elf_out_file)
1719         mcore_elf_cache_filename (filename);
1720 #endif
1721     }
1722
1723   bfd_close (f);
1724 }
1725
1726 \f
1727
1728 static void
1729 dump_def_info (FILE *f)
1730 {
1731   int i;
1732   export_type *exp;
1733   fprintf (f, "%s ", ASM_C);
1734   for (i = 0; oav[i]; i++)
1735     fprintf (f, "%s ", oav[i]);
1736   fprintf (f, "\n");
1737   for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1738     {
1739       fprintf (f, "%s  %d = %s %s @ %d %s%s%s%s%s%s\n",
1740                ASM_C,
1741                i,
1742                exp->name,
1743                exp->internal_name,
1744                exp->ordinal,
1745                exp->noname ? "NONAME " : "",
1746                exp->private ? "PRIVATE " : "",
1747                exp->constant ? "CONSTANT" : "",
1748                exp->data ? "DATA" : "",
1749                exp->its_name ? " ==" : "",
1750                exp->its_name ? exp->its_name : "");
1751     }
1752 }
1753
1754 /* Generate the .exp file.  */
1755
1756 static int
1757 sfunc (const void *a, const void *b)
1758 {
1759   if (*(const bfd_vma *) a == *(const bfd_vma *) b)
1760     return 0;
1761
1762   return ((*(const bfd_vma *) a > *(const bfd_vma *) b) ? 1 : -1);
1763 }
1764
1765 static void
1766 flush_page (FILE *f, bfd_vma *need, bfd_vma page_addr, int on_page)
1767 {
1768   int i;
1769
1770   /* Flush this page.  */
1771   fprintf (f, "\t%s\t0x%08x\t%s Starting RVA for chunk\n",
1772            ASM_LONG,
1773            (int) page_addr,
1774            ASM_C);
1775   fprintf (f, "\t%s\t0x%x\t%s Size of block\n",
1776            ASM_LONG,
1777            (on_page * 2) + (on_page & 1) * 2 + 8,
1778            ASM_C);
1779
1780   for (i = 0; i < on_page; i++)
1781     {
1782       bfd_vma needed = need[i];
1783
1784       if (needed)
1785         {
1786           if (!create_for_pep)
1787             {
1788               /* Relocation via HIGHLOW.  */
1789               needed = ((needed - page_addr) | 0x3000) & 0xffff;
1790             }
1791           else
1792             {
1793               /* Relocation via DIR64.  */
1794               needed = ((needed - page_addr) | 0xa000) & 0xffff;
1795             }
1796         }
1797
1798       fprintf (f, "\t%s\t0x%lx\n", ASM_SHORT, (long) needed);
1799     }
1800
1801   /* And padding */
1802   if (on_page & 1)
1803     fprintf (f, "\t%s\t0x%x\n", ASM_SHORT, 0 | 0x0000);
1804 }
1805
1806 static void
1807 gen_def_file (void)
1808 {
1809   int i;
1810   export_type *exp;
1811
1812   inform (_("Adding exports to output file"));
1813
1814   fprintf (output_def, ";");
1815   for (i = 0; oav[i]; i++)
1816     fprintf (output_def, " %s", oav[i]);
1817
1818   fprintf (output_def, "\nEXPORTS\n");
1819
1820   for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1821     {
1822       char *quote = strchr (exp->name, '.') ? "\"" : "";
1823       char *res = cplus_demangle (exp->internal_name, DMGL_ANSI | DMGL_PARAMS);
1824
1825       if (res)
1826         {
1827           fprintf (output_def,";\t%s\n", res);
1828           free (res);
1829         }
1830
1831       if (strcmp (exp->name, exp->internal_name) == 0)
1832         {
1833           fprintf (output_def, "\t%s%s%s @ %d%s%s%s%s%s\n",
1834                    quote,
1835                    exp->name,
1836                    quote,
1837                    exp->ordinal,
1838                    exp->noname ? " NONAME" : "",
1839                    exp->private ? "PRIVATE " : "",
1840                    exp->data ? " DATA" : "",
1841                    exp->its_name ? " ==" : "",
1842                    exp->its_name ? exp->its_name : "");
1843         }
1844       else
1845         {
1846           char * quote1 = strchr (exp->internal_name, '.') ? "\"" : "";
1847           /* char *alias =  */
1848           fprintf (output_def, "\t%s%s%s = %s%s%s @ %d%s%s%s%s%s\n",
1849                    quote,
1850                    exp->name,
1851                    quote,
1852                    quote1,
1853                    exp->internal_name,
1854                    quote1,
1855                    exp->ordinal,
1856                    exp->noname ? " NONAME" : "",
1857                    exp->private ? "PRIVATE " : "",
1858                    exp->data ? " DATA" : "",
1859                    exp->its_name ? " ==" : "",
1860                    exp->its_name ? exp->its_name : "");
1861         }
1862     }
1863
1864   inform (_("Added exports to output file"));
1865 }
1866
1867 /* generate_idata_ofile generates the portable assembly source code
1868    for the idata sections.  It appends the source code to the end of
1869    the file.  */
1870
1871 static void
1872 generate_idata_ofile (FILE *filvar)
1873 {
1874   iheadtype *headptr;
1875   ifunctype *funcptr;
1876   int        headindex;
1877   int        funcindex;
1878   int        nheads;
1879
1880   if (import_list == NULL)
1881     return;
1882
1883   fprintf (filvar, "%s Import data sections\n", ASM_C);
1884   fprintf (filvar, "\n\t.section\t.idata$2\n");
1885   fprintf (filvar, "\t%s\tdoi_idata\n", ASM_GLOBAL);
1886   fprintf (filvar, "doi_idata:\n");
1887
1888   nheads = 0;
1889   for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1890     {
1891       fprintf (filvar, "\t%slistone%d%s\t%s %s\n",
1892                ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER,
1893                ASM_C, headptr->dllname);
1894       fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1895       fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1896       fprintf (filvar, "\t%sdllname%d%s\n",
1897                ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1898       fprintf (filvar, "\t%slisttwo%d%s\n\n",
1899                ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1900       nheads++;
1901     }
1902
1903   fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL record at */
1904   fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* end of idata$2 */
1905   fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* section        */
1906   fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1907   fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1908
1909   fprintf (filvar, "\n\t.section\t.idata$4\n");
1910   headindex = 0;
1911   for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1912     {
1913       fprintf (filvar, "listone%d:\n", headindex);
1914       for (funcindex = 0; funcindex < headptr->nfuncs; funcindex++)
1915         {
1916           if (create_for_pep)
1917             fprintf (filvar, "\t%sfuncptr%d_%d%s\n%s\t0\n",
1918                      ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER,
1919                      ASM_LONG);
1920           else
1921             fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1922                      ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1923         }
1924       if (create_for_pep)
1925         fprintf (filvar, "\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
1926       else
1927         fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list.  */
1928       headindex++;
1929     }
1930
1931   fprintf (filvar, "\n\t.section\t.idata$5\n");
1932   headindex = 0;
1933   for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1934     {
1935       fprintf (filvar, "listtwo%d:\n", headindex);
1936       for (funcindex = 0; funcindex < headptr->nfuncs; funcindex++)
1937         {
1938           if (create_for_pep)
1939             fprintf (filvar, "\t%sfuncptr%d_%d%s\n%s\t0\n",
1940                      ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER,
1941                      ASM_LONG);
1942           else
1943             fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1944                      ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1945         }
1946       if (create_for_pep)
1947         fprintf (filvar, "\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
1948       else
1949         fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list.  */
1950       headindex++;
1951     }
1952
1953   fprintf (filvar, "\n\t.section\t.idata$6\n");
1954   headindex = 0;
1955   for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1956     {
1957       funcindex = 0;
1958       for (funcptr = headptr->funchead; funcptr != NULL;
1959            funcptr = funcptr->next)
1960         {
1961           fprintf (filvar,"funcptr%d_%d:\n", headindex, funcindex);
1962           fprintf (filvar,"\t%s\t%d\n", ASM_SHORT,
1963                    ((funcptr->ord) & 0xFFFF));
1964           fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT,
1965             (funcptr->its_name ? funcptr->its_name : funcptr->name));
1966           fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1967           funcindex++;
1968         }
1969       headindex++;
1970     }
1971
1972   fprintf (filvar, "\n\t.section\t.idata$7\n");
1973   headindex = 0;
1974   for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1975     {
1976       fprintf (filvar,"dllname%d:\n", headindex);
1977       fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, headptr->dllname);
1978       fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1979       headindex++;
1980     }
1981 }
1982
1983 /* Assemble the specified file.  */
1984 static void
1985 assemble_file (const char * source, const char * dest)
1986 {
1987   char * cmd;
1988
1989   cmd = xmalloc (strlen (ASM_SWITCHES) + strlen (as_flags)
1990                  + strlen (source) + strlen (dest) + 50);
1991
1992   sprintf (cmd, "%s %s -o %s %s", ASM_SWITCHES, as_flags, dest, source);
1993
1994   run (as_name, cmd);
1995   free (cmd);
1996 }
1997
1998 static const char * temp_file_to_remove[5];
1999 #define TEMP_EXPORT_FILE 0
2000 #define TEMP_HEAD_FILE   1
2001 #define TEMP_TAIL_FILE   2
2002 #define TEMP_HEAD_O_FILE 3
2003 #define TEMP_TAIL_O_FILE 4
2004
2005 static void
2006 unlink_temp_files (void)
2007 {
2008   unsigned i;
2009
2010   if (dontdeltemps > 0)
2011     return;
2012
2013   for (i = 0; i < ARRAY_SIZE (temp_file_to_remove); i++)
2014     {
2015       if (temp_file_to_remove[i])
2016         {
2017           unlink (temp_file_to_remove[i]);
2018           temp_file_to_remove[i] = NULL;
2019         }
2020     }
2021 }
2022
2023 static void
2024 gen_exp_file (void)
2025 {
2026   FILE *f;
2027   int i;
2028   export_type *exp;
2029   dlist_type *dl;
2030
2031   /* xgettext:c-format */
2032   inform (_("Generating export file: %s"), exp_name);
2033
2034   f = fopen (TMP_ASM, FOPEN_WT);
2035   if (!f)
2036     /* xgettext:c-format */
2037     fatal (_("Unable to open temporary assembler file: %s"), TMP_ASM);
2038
2039   temp_file_to_remove[TEMP_EXPORT_FILE] = TMP_ASM;
2040
2041   /* xgettext:c-format */
2042   inform (_("Opened temporary file: %s"), TMP_ASM);
2043
2044   dump_def_info (f);
2045
2046   if (d_exports)
2047     {
2048       fprintf (f, "\t.section   .edata\n\n");
2049       fprintf (f, "\t%s 0       %s Allways 0\n", ASM_LONG, ASM_C);
2050       fprintf (f, "\t%s 0x%lx   %s Time and date\n", ASM_LONG,
2051                (unsigned long) time(0), ASM_C);
2052       fprintf (f, "\t%s 0       %s Major and Minor version\n", ASM_LONG, ASM_C);
2053       fprintf (f, "\t%sname%s   %s Ptr to name of dll\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
2054       fprintf (f, "\t%s %d      %s Starting ordinal of exports\n", ASM_LONG, d_low_ord, ASM_C);
2055
2056
2057       fprintf (f, "\t%s %d      %s Number of functions\n", ASM_LONG, d_high_ord - d_low_ord + 1, ASM_C);
2058       fprintf(f,"\t%s named funcs %d, low ord %d, high ord %d\n",
2059               ASM_C,
2060               d_named_nfuncs, d_low_ord, d_high_ord);
2061       fprintf (f, "\t%s %d      %s Number of names\n", ASM_LONG,
2062                show_allnames ? d_high_ord - d_low_ord + 1 : d_named_nfuncs, ASM_C);
2063       fprintf (f, "\t%safuncs%s  %s Address of functions\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
2064
2065       fprintf (f, "\t%sanames%s %s Address of Name Pointer Table\n",
2066                ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
2067
2068       fprintf (f, "\t%sanords%s %s Address of ordinals\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
2069
2070       fprintf (f, "name:        %s      \"%s\"\n", ASM_TEXT, dll_name);
2071
2072
2073       fprintf(f,"%s Export address Table\n", ASM_C);
2074       fprintf(f,"\t%s\n", ASM_ALIGN_LONG);
2075       fprintf (f, "afuncs:\n");
2076       i = d_low_ord;
2077
2078       for (exp = d_exports; exp; exp = exp->next)
2079         {
2080           if (exp->ordinal != i)
2081             {
2082               while (i < exp->ordinal)
2083                 {
2084                   fprintf(f,"\t%s\t0\n", ASM_LONG);
2085                   i++;
2086                 }
2087             }
2088
2089           if (exp->forward == 0)
2090             {
2091               if (exp->internal_name[0] == '@')
2092                 fprintf (f, "\t%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
2093                          exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
2094               else
2095                 fprintf (f, "\t%s%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
2096                          ASM_PREFIX (exp->internal_name),
2097                          exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
2098             }
2099           else
2100             fprintf (f, "\t%sf%d%s\t%s %d\n", ASM_RVA_BEFORE,
2101                      exp->forward, ASM_RVA_AFTER, ASM_C, exp->ordinal);
2102           i++;
2103         }
2104
2105       fprintf (f,"%s Export Name Pointer Table\n", ASM_C);
2106       fprintf (f, "anames:\n");
2107
2108       for (i = 0; (exp = d_exports_lexically[i]); i++)
2109         {
2110           if (!exp->noname || show_allnames)
2111             fprintf (f, "\t%sn%d%s\n",
2112                      ASM_RVA_BEFORE, exp->ordinal, ASM_RVA_AFTER);
2113         }
2114
2115       fprintf (f,"%s Export Ordinal Table\n", ASM_C);
2116       fprintf (f, "anords:\n");
2117       for (i = 0; (exp = d_exports_lexically[i]); i++)
2118         {
2119           if (!exp->noname || show_allnames)
2120             fprintf (f, "\t%s   %d\n", ASM_SHORT, exp->ordinal - d_low_ord);
2121         }
2122
2123       fprintf(f,"%s Export Name Table\n", ASM_C);
2124       for (i = 0; (exp = d_exports_lexically[i]); i++)
2125         {
2126           if (!exp->noname || show_allnames)
2127             fprintf (f, "n%d:   %s      \"%s\"\n",
2128                      exp->ordinal, ASM_TEXT,
2129                      (exp->its_name ? exp->its_name : xlate (exp->name)));
2130           if (exp->forward != 0)
2131             fprintf (f, "f%d:   %s      \"%s\"\n",
2132                      exp->forward, ASM_TEXT, exp->internal_name);
2133         }
2134
2135       if (a_list)
2136         {
2137           fprintf (f, "\t.section %s\n", DRECTVE_SECTION_NAME);
2138           for (dl = a_list; dl; dl = dl->next)
2139             {
2140               fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, dl->text);
2141             }
2142         }
2143
2144       if (d_list)
2145         {
2146           fprintf (f, "\t.section .rdata\n");
2147           for (dl = d_list; dl; dl = dl->next)
2148             {
2149               char *p;
2150               int l;
2151
2152               /* We don't output as ascii because there can
2153                  be quote characters in the string.  */
2154               l = 0;
2155               for (p = dl->text; *p; p++)
2156                 {
2157                   if (l == 0)
2158                     fprintf (f, "\t%s\t", ASM_BYTE);
2159                   else
2160                     fprintf (f, ",");
2161                   fprintf (f, "%d", *p);
2162                   if (p[1] == 0)
2163                     {
2164                       fprintf (f, ",0\n");
2165                       break;
2166                     }
2167                   if (++l == 10)
2168                     {
2169                       fprintf (f, "\n");
2170                       l = 0;
2171                     }
2172                 }
2173             }
2174         }
2175     }
2176
2177   /* Add to the output file a way of getting to the exported names
2178      without using the import library.  */
2179   if (add_indirect)
2180     {
2181       fprintf (f, "\t.section\t.rdata\n");
2182       for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
2183         if (!exp->noname || show_allnames)
2184           {
2185             /* We use a single underscore for MS compatibility, and a
2186                double underscore for backward compatibility with old
2187                cygwin releases.  */
2188             if (create_compat_implib)
2189               fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name);
2190             fprintf (f, "\t%s\t_imp_%s%s\n", ASM_GLOBAL,
2191                      (!leading_underscore ? "" : "_"), exp->name);
2192             if (create_compat_implib)
2193               fprintf (f, "__imp_%s:\n", exp->name);
2194             fprintf (f, "_imp_%s%s:\n", (!leading_underscore ? "" : "_"), exp->name);
2195             fprintf (f, "\t%s\t%s\n", ASM_LONG, exp->name);
2196           }
2197     }
2198
2199   /* Dump the reloc section if a base file is provided.  */
2200   if (base_file)
2201     {
2202       bfd_vma addr;
2203       bfd_vma need[COFF_PAGE_SIZE];
2204       bfd_vma page_addr;
2205       bfd_size_type numbytes;
2206       int num_entries;
2207       bfd_vma *copy;
2208       int j;
2209       int on_page;
2210       fprintf (f, "\t.section\t.init\n");
2211       fprintf (f, "lab:\n");
2212
2213       fseek (base_file, 0, SEEK_END);
2214       numbytes = ftell (base_file);
2215       fseek (base_file, 0, SEEK_SET);
2216       copy = xmalloc (numbytes);
2217       if (fread (copy, 1, numbytes, base_file) < numbytes)
2218         fatal (_("failed to read the number of entries from base file"));
2219       num_entries = numbytes / sizeof (bfd_vma);
2220
2221
2222       fprintf (f, "\t.section\t.reloc\n");
2223       if (num_entries)
2224         {
2225           int src;
2226           int dst = 0;
2227           bfd_vma last = (bfd_vma) -1;
2228           qsort (copy, num_entries, sizeof (bfd_vma), sfunc);
2229           /* Delete duplicates */
2230           for (src = 0; src < num_entries; src++)
2231             {
2232               if (last != copy[src])
2233                 last = copy[dst++] = copy[src];
2234             }
2235           num_entries = dst;
2236           addr = copy[0];
2237           page_addr = addr & PAGE_MASK;         /* work out the page addr */
2238           on_page = 0;
2239           for (j = 0; j < num_entries; j++)
2240             {
2241               addr = copy[j];
2242               if ((addr & PAGE_MASK) != page_addr)
2243                 {
2244                   flush_page (f, need, page_addr, on_page);
2245                   on_page = 0;
2246                   page_addr = addr & PAGE_MASK;
2247                 }
2248               need[on_page++] = addr;
2249             }
2250           flush_page (f, need, page_addr, on_page);
2251
2252 /*        fprintf (f, "\t%s\t0,0\t%s End\n", ASM_LONG, ASM_C);*/
2253         }
2254     }
2255
2256   generate_idata_ofile (f);
2257
2258   fclose (f);
2259
2260   /* Assemble the file.  */
2261   assemble_file (TMP_ASM, exp_name);
2262
2263   if (dontdeltemps == 0)
2264     {
2265       temp_file_to_remove[TEMP_EXPORT_FILE] = NULL;
2266       unlink (TMP_ASM);
2267     }
2268
2269   inform (_("Generated exports file"));
2270 }
2271
2272 static const char *
2273 xlate (const char *name)
2274 {
2275   int lead_at = (*name == '@');
2276   int is_stdcall = (!lead_at && strchr (name, '@') != NULL);
2277
2278   if (!lead_at && (add_underscore
2279                    || (add_stdcall_underscore && is_stdcall)))
2280     {
2281       char *copy = xmalloc (strlen (name) + 2);
2282
2283       copy[0] = '_';
2284       strcpy (copy + 1, name);
2285       name = copy;
2286     }
2287
2288   if (killat)
2289     {
2290       char *p;
2291
2292       name += lead_at;
2293       /* PR 9766: Look for the last @ sign in the name.  */
2294       p = strrchr (name, '@');
2295       if (p && ISDIGIT (p[1]))
2296         *p = 0;
2297     }
2298   return name;
2299 }
2300
2301 typedef struct
2302 {
2303   int id;
2304   const char *name;
2305   int flags;
2306   int align;
2307   asection *sec;
2308   asymbol *sym;
2309   asymbol **sympp;
2310   int size;
2311   unsigned char *data;
2312 } sinfo;
2313
2314 #define INIT_SEC_DATA(id, name, flags, align) \
2315         { id, name, flags, align, NULL, NULL, NULL, 0, NULL }
2316
2317 #ifndef DLLTOOL_PPC
2318
2319 #define TEXT 0
2320 #define DATA 1
2321 #define BSS 2
2322 #define IDATA7 3
2323 #define IDATA5 4
2324 #define IDATA4 5
2325 #define IDATA6 6
2326
2327 #define NSECS 7
2328
2329 #define TEXT_SEC_FLAGS   \
2330         (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY | SEC_HAS_CONTENTS)
2331 #define DATA_SEC_FLAGS   (SEC_ALLOC | SEC_LOAD | SEC_DATA)
2332 #define BSS_SEC_FLAGS     SEC_ALLOC
2333
2334 static sinfo secdata[NSECS] =
2335 {
2336   INIT_SEC_DATA (TEXT,   ".text",    TEXT_SEC_FLAGS,   2),
2337   INIT_SEC_DATA (DATA,   ".data",    DATA_SEC_FLAGS,   2),
2338   INIT_SEC_DATA (BSS,    ".bss",     BSS_SEC_FLAGS,    2),
2339   INIT_SEC_DATA (IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2),
2340   INIT_SEC_DATA (IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2),
2341   INIT_SEC_DATA (IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2),
2342   INIT_SEC_DATA (IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1)
2343 };
2344
2345 #else
2346
2347 /* Sections numbered to make the order the same as other PowerPC NT
2348    compilers. This also keeps funny alignment thingies from happening.  */
2349 #define TEXT   0
2350 #define PDATA  1
2351 #define RDATA  2
2352 #define IDATA5 3
2353 #define IDATA4 4
2354 #define IDATA6 5
2355 #define IDATA7 6
2356 #define DATA   7
2357 #define BSS    8
2358
2359 #define NSECS 9
2360
2361 static sinfo secdata[NSECS] =
2362 {
2363   INIT_SEC_DATA (TEXT,   ".text",    SEC_CODE | SEC_HAS_CONTENTS, 3),
2364   INIT_SEC_DATA (PDATA,  ".pdata",   SEC_HAS_CONTENTS,            2),
2365   INIT_SEC_DATA (RDATA,  ".reldata", SEC_HAS_CONTENTS,            2),
2366   INIT_SEC_DATA (IDATA5, ".idata$5", SEC_HAS_CONTENTS,            2),
2367   INIT_SEC_DATA (IDATA4, ".idata$4", SEC_HAS_CONTENTS,            2),
2368   INIT_SEC_DATA (IDATA6, ".idata$6", SEC_HAS_CONTENTS,            1),
2369   INIT_SEC_DATA (IDATA7, ".idata$7", SEC_HAS_CONTENTS,            2),
2370   INIT_SEC_DATA (DATA,   ".data",    SEC_DATA,                    2),
2371   INIT_SEC_DATA (BSS,    ".bss",     0,                           2)
2372 };
2373
2374 #endif
2375
2376 /* This is what we're trying to make.  We generate the imp symbols with
2377    both single and double underscores, for compatibility.
2378
2379         .text
2380         .global _GetFileVersionInfoSizeW@8
2381         .global __imp_GetFileVersionInfoSizeW@8
2382 _GetFileVersionInfoSizeW@8:
2383         jmp *   __imp_GetFileVersionInfoSizeW@8
2384         .section        .idata$7        # To force loading of head
2385         .long   __version_a_head
2386 # Import Address Table
2387         .section        .idata$5
2388 __imp_GetFileVersionInfoSizeW@8:
2389         .rva    ID2
2390
2391 # Import Lookup Table
2392         .section        .idata$4
2393         .rva    ID2
2394 # Hint/Name table
2395         .section        .idata$6
2396 ID2:    .short  2
2397         .asciz  "GetFileVersionInfoSizeW"
2398
2399
2400    For the PowerPC, here's the variation on the above scheme:
2401
2402 # Rather than a simple "jmp *", the code to get to the dll function
2403 # looks like:
2404          .text
2405          lwz    r11,[tocv]__imp_function_name(r2)
2406 #                  RELOC: 00000000 TOCREL16,TOCDEFN __imp_function_name
2407          lwz    r12,0(r11)
2408          stw    r2,4(r1)
2409          mtctr  r12
2410          lwz    r2,4(r11)
2411          bctr  */
2412
2413 static char *
2414 make_label (const char *prefix, const char *name)
2415 {
2416   int len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name);
2417   char *copy = xmalloc (len + 1);
2418
2419   strcpy (copy, ASM_PREFIX (name));
2420   strcat (copy, prefix);
2421   strcat (copy, name);
2422   return copy;
2423 }
2424
2425 static char *
2426 make_imp_label (const char *prefix, const char *name)
2427 {
2428   int len;
2429   char *copy;
2430
2431   if (name[0] == '@')
2432     {
2433       len = strlen (prefix) + strlen (name);
2434       copy = xmalloc (len + 1);
2435       strcpy (copy, prefix);
2436       strcat (copy, name);
2437     }
2438   else
2439     {
2440       len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name);
2441       copy = xmalloc (len + 1);
2442       strcpy (copy, prefix);
2443       strcat (copy, ASM_PREFIX (name));
2444       strcat (copy, name);
2445     }
2446   return copy;
2447 }
2448
2449 static bfd *
2450 make_one_lib_file (export_type *exp, int i, int delay)
2451 {
2452   bfd *      abfd;
2453   asymbol *  exp_label;
2454   asymbol *  iname = 0;
2455   asymbol *  iname2;
2456   asymbol *  iname_lab;
2457   asymbol ** iname_lab_pp;
2458   asymbol ** iname_pp;
2459 #ifdef DLLTOOL_PPC
2460   asymbol ** fn_pp;
2461   asymbol ** toc_pp;
2462 #define EXTRA    2
2463 #endif
2464 #ifndef EXTRA
2465 #define EXTRA    0
2466 #endif
2467   asymbol *  ptrs[NSECS + 4 + EXTRA + 1];
2468   flagword   applicable;
2469   char *     outname = xmalloc (strlen (TMP_STUB) + 10);
2470   int        oidx = 0;
2471
2472
2473   sprintf (outname, "%s%05d.o", TMP_STUB, i);
2474
2475   abfd = bfd_openw (outname, HOW_BFD_WRITE_TARGET);
2476
2477   if (!abfd)
2478     /* xgettext:c-format */
2479     fatal (_("bfd_open failed open stub file: %s: %s"),
2480            outname, bfd_get_errmsg ());
2481
2482   /* xgettext:c-format */
2483   inform (_("Creating stub file: %s"), outname);
2484
2485   bfd_set_format (abfd, bfd_object);
2486   bfd_set_arch_mach (abfd, HOW_BFD_ARCH, 0);
2487
2488 #ifdef DLLTOOL_ARM
2489   if (machine == MARM_INTERWORK || machine == MTHUMB)
2490     bfd_set_private_flags (abfd, F_INTERWORK);
2491 #endif
2492
2493   applicable = bfd_applicable_section_flags (abfd);
2494
2495   /* First make symbols for the sections.  */
2496   for (i = 0; i < NSECS; i++)
2497     {
2498       sinfo *si = secdata + i;
2499
2500       if (si->id != i)
2501         abort ();
2502       si->sec = bfd_make_section_old_way (abfd, si->name);
2503       bfd_set_section_flags (abfd,
2504                              si->sec,
2505                              si->flags & applicable);
2506
2507       bfd_set_section_alignment(abfd, si->sec, si->align);
2508       si->sec->output_section = si->sec;
2509       si->sym = bfd_make_empty_symbol(abfd);
2510       si->sym->name = si->sec->name;
2511       si->sym->section = si->sec;
2512       si->sym->flags = BSF_LOCAL;
2513       si->sym->value = 0;
2514       ptrs[oidx] = si->sym;
2515       si->sympp = ptrs + oidx;
2516       si->size = 0;
2517       si->data = NULL;
2518
2519       oidx++;
2520     }
2521
2522   if (! exp->data)
2523     {
2524       exp_label = bfd_make_empty_symbol (abfd);
2525       exp_label->name = make_imp_label ("", exp->name);
2526
2527       /* On PowerPC, the function name points to a descriptor in
2528          the rdata section, the first element of which is a
2529          pointer to the code (..function_name), and the second
2530          points to the .toc.  */
2531 #ifdef DLLTOOL_PPC
2532       if (machine == MPPC)
2533         exp_label->section = secdata[RDATA].sec;
2534       else
2535 #endif
2536         exp_label->section = secdata[TEXT].sec;
2537
2538       exp_label->flags = BSF_GLOBAL;
2539       exp_label->value = 0;
2540
2541 #ifdef DLLTOOL_ARM
2542       if (machine == MTHUMB)
2543         bfd_coff_set_symbol_class (abfd, exp_label, C_THUMBEXTFUNC);
2544 #endif
2545       ptrs[oidx++] = exp_label;
2546     }
2547
2548   /* Generate imp symbols with one underscore for Microsoft
2549      compatibility, and with two underscores for backward
2550      compatibility with old versions of cygwin.  */
2551   if (create_compat_implib)
2552     {
2553       iname = bfd_make_empty_symbol (abfd);
2554       iname->name = make_imp_label ("___imp", exp->name);
2555       iname->section = secdata[IDATA5].sec;
2556       iname->flags = BSF_GLOBAL;
2557       iname->value = 0;
2558     }
2559
2560   iname2 = bfd_make_empty_symbol (abfd);
2561   iname2->name = make_imp_label ("__imp_", exp->name);
2562   iname2->section = secdata[IDATA5].sec;
2563   iname2->flags = BSF_GLOBAL;
2564   iname2->value = 0;
2565
2566   iname_lab = bfd_make_empty_symbol (abfd);
2567
2568   iname_lab->name = head_label;
2569   iname_lab->section = bfd_und_section_ptr;
2570   iname_lab->flags = 0;
2571   iname_lab->value = 0;
2572
2573   iname_pp = ptrs + oidx;
2574   if (create_compat_implib)
2575     ptrs[oidx++] = iname;
2576   ptrs[oidx++] = iname2;
2577
2578   iname_lab_pp = ptrs + oidx;
2579   ptrs[oidx++] = iname_lab;
2580
2581 #ifdef DLLTOOL_PPC
2582   /* The symbol referring to the code (.text).  */
2583   {
2584     asymbol *function_name;
2585
2586     function_name = bfd_make_empty_symbol(abfd);
2587     function_name->name = make_label ("..", exp->name);
2588     function_name->section = secdata[TEXT].sec;
2589     function_name->flags = BSF_GLOBAL;
2590     function_name->value = 0;
2591
2592     fn_pp = ptrs + oidx;
2593     ptrs[oidx++] = function_name;
2594   }
2595
2596   /* The .toc symbol.  */
2597   {
2598     asymbol *toc_symbol;
2599
2600     toc_symbol = bfd_make_empty_symbol (abfd);
2601     toc_symbol->name = make_label (".", "toc");
2602     toc_symbol->section = bfd_und_section_ptr;
2603     toc_symbol->flags = BSF_GLOBAL;
2604     toc_symbol->value = 0;
2605
2606     toc_pp = ptrs + oidx;
2607     ptrs[oidx++] = toc_symbol;
2608   }
2609 #endif
2610
2611   ptrs[oidx] = 0;
2612
2613   for (i = 0; i < NSECS; i++)
2614     {
2615       sinfo *si = secdata + i;
2616       asection *sec = si->sec;
2617       arelent *rel, *rel2 = 0, *rel3 = 0;
2618       arelent **rpp;
2619
2620       switch (i)
2621         {
2622         case TEXT:
2623           if (! exp->data)
2624             {
2625               si->size = HOW_JTAB_SIZE;
2626               si->data = xmalloc (HOW_JTAB_SIZE);
2627               memcpy (si->data, HOW_JTAB, HOW_JTAB_SIZE);
2628
2629               /* Add the reloc into idata$5.  */
2630               rel = xmalloc (sizeof (arelent));
2631
2632               rpp = xmalloc (sizeof (arelent *) * (delay ? 4 : 2));
2633               rpp[0] = rel;
2634               rpp[1] = 0;
2635
2636               rel->address = HOW_JTAB_ROFF;
2637               rel->addend = 0;
2638
2639               if (delay)
2640                 {
2641                   rel2 = xmalloc (sizeof (arelent));
2642                   rpp[1] = rel2;
2643                   rel2->address = HOW_JTAB_ROFF2;
2644                   rel2->addend = 0;
2645                   rel3 = xmalloc (sizeof (arelent));
2646                   rpp[2] = rel3;
2647                   rel3->address = HOW_JTAB_ROFF3;
2648                   rel3->addend = 0;
2649                   rpp[3] = 0;
2650                 }
2651
2652               if (machine == MPPC)
2653                 {
2654                   rel->howto = bfd_reloc_type_lookup (abfd,
2655                                                       BFD_RELOC_16_GOTOFF);
2656                   rel->sym_ptr_ptr = iname_pp;
2657                 }
2658               else if (machine == MX86)
2659                 {
2660                   rel->howto = bfd_reloc_type_lookup (abfd,
2661                                                       BFD_RELOC_32_PCREL);
2662                   rel->sym_ptr_ptr = iname_pp;
2663                 }
2664               else
2665                 {
2666                   rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2667                   rel->sym_ptr_ptr = secdata[IDATA5].sympp;
2668                 }
2669
2670               if (delay)
2671                 {
2672                   if (machine == MX86)
2673                    rel2->howto = bfd_reloc_type_lookup (abfd,
2674                                                         BFD_RELOC_32_PCREL);
2675                   else
2676                     rel2->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2677                   rel2->sym_ptr_ptr = rel->sym_ptr_ptr;
2678                   rel3->howto = bfd_reloc_type_lookup (abfd,
2679                                                        BFD_RELOC_32_PCREL);
2680                   rel3->sym_ptr_ptr = iname_lab_pp;
2681                 }
2682
2683               sec->orelocation = rpp;
2684               sec->reloc_count = delay ? 3 : 1;
2685             }
2686           break;
2687
2688         case IDATA5:
2689           if (delay)
2690             {
2691               si->size = create_for_pep ? 8 : 4;
2692               si->data = xmalloc (si->size);
2693               sec->reloc_count = 1;
2694               memset (si->data, 0, si->size);
2695               /* Point after jmp [__imp_...] instruction.  */
2696               si->data[0] = 6;
2697               rel = xmalloc (sizeof (arelent));
2698               rpp = xmalloc (sizeof (arelent *) * 2);
2699               rpp[0] = rel;
2700               rpp[1] = 0;
2701               rel->address = 0;
2702               rel->addend = 0;
2703               if (create_for_pep)
2704                 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_64);
2705               else
2706                 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2707               rel->sym_ptr_ptr = secdata[TEXT].sympp;
2708               sec->orelocation = rpp;
2709               break;
2710             }
2711           /* Fall through.  */
2712
2713         case IDATA4:
2714           /* An idata$4 or idata$5 is one word long, and has an
2715              rva to idata$6.  */
2716
2717           if (create_for_pep)
2718             {
2719               si->data = xmalloc (8);
2720               si->size = 8;
2721               if (exp->noname)
2722                 {
2723                   si->data[0] = exp->ordinal ;
2724                   si->data[1] = exp->ordinal >> 8;
2725                   si->data[2] = exp->ordinal >> 16;
2726                   si->data[3] = exp->ordinal >> 24;
2727                   si->data[4] = 0;
2728                   si->data[5] = 0;
2729                   si->data[6] = 0;
2730                   si->data[7] = 0x80;
2731                 }
2732               else
2733                 {
2734                   sec->reloc_count = 1;
2735                   memset (si->data, 0, si->size);
2736                   rel = xmalloc (sizeof (arelent));
2737                   rpp = xmalloc (sizeof (arelent *) * 2);
2738                   rpp[0] = rel;
2739                   rpp[1] = 0;
2740                   rel->address = 0;
2741                   rel->addend = 0;
2742                   rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2743                   rel->sym_ptr_ptr = secdata[IDATA6].sympp;
2744                   sec->orelocation = rpp;
2745                 }
2746             }
2747           else
2748             {
2749               si->data = xmalloc (4);
2750               si->size = 4;
2751
2752               if (exp->noname)
2753                 {
2754                   si->data[0] = exp->ordinal ;
2755                   si->data[1] = exp->ordinal >> 8;
2756                   si->data[2] = exp->ordinal >> 16;
2757                   si->data[3] = 0x80;
2758                 }
2759               else
2760                 {
2761                   sec->reloc_count = 1;
2762                   memset (si->data, 0, si->size);
2763                   rel = xmalloc (sizeof (arelent));
2764                   rpp = xmalloc (sizeof (arelent *) * 2);
2765                   rpp[0] = rel;
2766                   rpp[1] = 0;
2767                   rel->address = 0;
2768                   rel->addend = 0;
2769                   rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2770                   rel->sym_ptr_ptr = secdata[IDATA6].sympp;
2771                   sec->orelocation = rpp;
2772               }
2773             }
2774           break;
2775
2776         case IDATA6:
2777           if (!exp->noname)
2778             {
2779               /* This used to add 1 to exp->hint.  I don't know
2780                  why it did that, and it does not match what I see
2781                  in programs compiled with the MS tools.  */
2782               int idx = exp->hint;
2783               if (exp->its_name)
2784                 si->size = strlen (exp->its_name) + 3;
2785               else
2786                 si->size = strlen (xlate (exp->import_name)) + 3;
2787               si->data = xmalloc (si->size);
2788               memset (si->data, 0, si->size);
2789               si->data[0] = idx & 0xff;
2790               si->data[1] = idx >> 8;
2791               if (exp->its_name)
2792                 strcpy ((char *) si->data + 2, exp->its_name);
2793               else
2794                 strcpy ((char *) si->data + 2, xlate (exp->import_name));
2795             }
2796           break;
2797         case IDATA7:
2798           if (delay)
2799             break;
2800           si->size = 4;
2801           si->data = xmalloc (4);
2802           memset (si->data, 0, si->size);
2803           rel = xmalloc (sizeof (arelent));
2804           rpp = xmalloc (sizeof (arelent *) * 2);
2805           rpp[0] = rel;
2806           rel->address = 0;
2807           rel->addend = 0;
2808           rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2809           rel->sym_ptr_ptr = iname_lab_pp;
2810           sec->orelocation = rpp;
2811           sec->reloc_count = 1;
2812           break;
2813
2814 #ifdef DLLTOOL_PPC
2815         case PDATA:
2816           {
2817             /* The .pdata section is 5 words long.
2818                Think of it as:
2819                struct
2820                {
2821                bfd_vma BeginAddress,     [0x00]
2822                EndAddress,       [0x04]
2823                ExceptionHandler, [0x08]
2824                HandlerData,      [0x0c]
2825                PrologEndAddress; [0x10]
2826                };  */
2827
2828             /* So this pdata section setups up this as a glue linkage to
2829                a dll routine. There are a number of house keeping things
2830                we need to do:
2831
2832                1. In the name of glue trickery, the ADDR32 relocs for 0,
2833                4, and 0x10 are set to point to the same place:
2834                "..function_name".
2835                2. There is one more reloc needed in the pdata section.
2836                The actual glue instruction to restore the toc on
2837                return is saved as the offset in an IMGLUE reloc.
2838                So we need a total of four relocs for this section.
2839
2840                3. Lastly, the HandlerData field is set to 0x03, to indicate
2841                that this is a glue routine.  */
2842             arelent *imglue, *ba_rel, *ea_rel, *pea_rel;
2843
2844             /* Alignment must be set to 2**2 or you get extra stuff.  */
2845             bfd_set_section_alignment(abfd, sec, 2);
2846
2847             si->size = 4 * 5;
2848             si->data = xmalloc (si->size);
2849             memset (si->data, 0, si->size);
2850             rpp = xmalloc (sizeof (arelent *) * 5);
2851             rpp[0] = imglue  = xmalloc (sizeof (arelent));
2852             rpp[1] = ba_rel  = xmalloc (sizeof (arelent));
2853             rpp[2] = ea_rel  = xmalloc (sizeof (arelent));
2854             rpp[3] = pea_rel = xmalloc (sizeof (arelent));
2855             rpp[4] = 0;
2856
2857             /* Stick the toc reload instruction in the glue reloc.  */
2858             bfd_put_32(abfd, ppc_glue_insn, (char *) &imglue->address);
2859
2860             imglue->addend = 0;
2861             imglue->howto = bfd_reloc_type_lookup (abfd,
2862                                                    BFD_RELOC_32_GOTOFF);
2863             imglue->sym_ptr_ptr = fn_pp;
2864
2865             ba_rel->address = 0;
2866             ba_rel->addend = 0;
2867             ba_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2868             ba_rel->sym_ptr_ptr = fn_pp;
2869
2870             bfd_put_32 (abfd, 0x18, si->data + 0x04);
2871             ea_rel->address = 4;
2872             ea_rel->addend = 0;
2873             ea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2874             ea_rel->sym_ptr_ptr = fn_pp;
2875
2876             /* Mark it as glue.  */
2877             bfd_put_32 (abfd, 0x03, si->data + 0x0c);
2878
2879             /* Mark the prolog end address.  */
2880             bfd_put_32 (abfd, 0x0D, si->data + 0x10);
2881             pea_rel->address = 0x10;
2882             pea_rel->addend = 0;
2883             pea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2884             pea_rel->sym_ptr_ptr = fn_pp;
2885
2886             sec->orelocation = rpp;
2887             sec->reloc_count = 4;
2888             break;
2889           }
2890         case RDATA:
2891           /* Each external function in a PowerPC PE file has a two word
2892              descriptor consisting of:
2893              1. The address of the code.
2894              2. The address of the appropriate .toc
2895              We use relocs to build this.  */
2896           si->size = 8;
2897           si->data = xmalloc (8);
2898           memset (si->data, 0, si->size);
2899
2900           rpp = xmalloc (sizeof (arelent *) * 3);
2901           rpp[0] = rel = xmalloc (sizeof (arelent));
2902           rpp[1] = xmalloc (sizeof (arelent));
2903           rpp[2] = 0;
2904
2905           rel->address = 0;
2906           rel->addend = 0;
2907           rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2908           rel->sym_ptr_ptr = fn_pp;
2909
2910           rel = rpp[1];
2911
2912           rel->address = 4;
2913           rel->addend = 0;
2914           rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2915           rel->sym_ptr_ptr = toc_pp;
2916
2917           sec->orelocation = rpp;
2918           sec->reloc_count = 2;
2919           break;
2920 #endif /* DLLTOOL_PPC */
2921         }
2922     }
2923
2924   {
2925     bfd_vma vma = 0;
2926     /* Size up all the sections.  */
2927     for (i = 0; i < NSECS; i++)
2928       {
2929         sinfo *si = secdata + i;
2930
2931         bfd_set_section_size (abfd, si->sec, si->size);
2932         bfd_set_section_vma (abfd, si->sec, vma);
2933       }
2934   }
2935   /* Write them out.  */
2936   for (i = 0; i < NSECS; i++)
2937     {
2938       sinfo *si = secdata + i;
2939
2940       if (i == IDATA5 && no_idata5)
2941         continue;
2942
2943       if (i == IDATA4 && no_idata4)
2944         continue;
2945
2946       bfd_set_section_contents (abfd, si->sec,
2947                                 si->data, 0,
2948                                 si->size);
2949     }
2950
2951   bfd_set_symtab (abfd, ptrs, oidx);
2952   bfd_close (abfd);
2953   abfd = bfd_openr (outname, HOW_BFD_READ_TARGET);
2954   if (!abfd)
2955     /* xgettext:c-format */
2956     fatal (_("bfd_open failed reopen stub file: %s: %s"),
2957            outname, bfd_get_errmsg ());
2958
2959   return abfd;
2960 }
2961
2962 static bfd *
2963 make_head (void)
2964 {
2965   FILE *f = fopen (TMP_HEAD_S, FOPEN_WT);
2966   bfd *abfd;
2967
2968   if (f == NULL)
2969     {
2970       fatal (_("failed to open temporary head file: %s"), TMP_HEAD_S);
2971       return NULL;
2972     }
2973
2974   temp_file_to_remove[TEMP_HEAD_FILE] = TMP_HEAD_S;
2975
2976   fprintf (f, "%s IMAGE_IMPORT_DESCRIPTOR\n", ASM_C);
2977   fprintf (f, "\t.section\t.idata$2\n");
2978
2979   fprintf (f,"\t%s\t%s\n", ASM_GLOBAL, head_label);
2980
2981   fprintf (f, "%s:\n", head_label);
2982
2983   fprintf (f, "\t%shname%s\t%sPtr to image import by name list\n",
2984            ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
2985
2986   fprintf (f, "\t%sthis should be the timestamp, but NT sometimes\n", ASM_C);
2987   fprintf (f, "\t%sdoesn't load DLLs when this is set.\n", ASM_C);
2988   fprintf (f, "\t%s\t0\t%s loaded time\n", ASM_LONG, ASM_C);
2989   fprintf (f, "\t%s\t0\t%s Forwarder chain\n", ASM_LONG, ASM_C);
2990   fprintf (f, "\t%s__%s_iname%s\t%s imported dll's name\n",
2991            ASM_RVA_BEFORE,
2992            imp_name_lab,
2993            ASM_RVA_AFTER,
2994            ASM_C);
2995   fprintf (f, "\t%sfthunk%s\t%s pointer to firstthunk\n",
2996            ASM_RVA_BEFORE,
2997            ASM_RVA_AFTER, ASM_C);
2998
2999   fprintf (f, "%sStuff for compatibility\n", ASM_C);
3000
3001   if (!no_idata5)
3002     {
3003       fprintf (f, "\t.section\t.idata$5\n");
3004       if (use_nul_prefixed_import_tables)
3005         {
3006           if (create_for_pep)
3007             fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
3008           else
3009             fprintf (f,"\t%s\t0\n", ASM_LONG);
3010         }
3011       fprintf (f, "fthunk:\n");
3012     }
3013
3014   if (!no_idata4)
3015     {
3016       fprintf (f, "\t.section\t.idata$4\n");
3017       if (use_nul_prefixed_import_tables)
3018         {
3019           if (create_for_pep)
3020             fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
3021           else
3022             fprintf (f,"\t%s\t0\n", ASM_LONG);
3023         }
3024       fprintf (f, "hname:\n");
3025     }
3026
3027   fclose (f);
3028
3029   assemble_file (TMP_HEAD_S, TMP_HEAD_O);
3030
3031   abfd = bfd_openr (TMP_HEAD_O, HOW_BFD_READ_TARGET);
3032   if (abfd == NULL)
3033     /* xgettext:c-format */
3034     fatal (_("failed to open temporary head file: %s: %s"),
3035            TMP_HEAD_O, bfd_get_errmsg ());
3036
3037   temp_file_to_remove[TEMP_HEAD_O_FILE] = TMP_HEAD_O;
3038   return abfd;
3039 }
3040
3041 bfd *
3042 make_delay_head (void)
3043 {
3044   FILE *f = fopen (TMP_HEAD_S, FOPEN_WT);
3045   bfd *abfd;
3046
3047   if (f == NULL)
3048     {
3049       fatal (_("failed to open temporary head file: %s"), TMP_HEAD_S);
3050       return NULL;
3051     }
3052
3053   temp_file_to_remove[TEMP_HEAD_FILE] = TMP_HEAD_S;
3054
3055   /* Output the __tailMerge__xxx function */
3056   fprintf (f, "%s Import trampoline\n", ASM_C);
3057   fprintf (f, "\t.section\t.text\n");
3058   fprintf(f,"\t%s\t%s\n", ASM_GLOBAL, head_label);
3059   fprintf (f, "%s:\n", head_label);
3060   fprintf (f, mtable[machine].trampoline, imp_name_lab);
3061
3062   /* Output the delay import descriptor */
3063   fprintf (f, "\n%s DELAY_IMPORT_DESCRIPTOR\n", ASM_C);
3064   fprintf (f, ".section\t.text$2\n");
3065   fprintf (f,"%s __DELAY_IMPORT_DESCRIPTOR_%s\n", ASM_GLOBAL,imp_name_lab);
3066   fprintf (f, "__DELAY_IMPORT_DESCRIPTOR_%s:\n", imp_name_lab);
3067   fprintf (f, "\t%s 1\t%s grAttrs\n", ASM_LONG, ASM_C);
3068   fprintf (f, "\t%s__%s_iname%s\t%s rvaDLLName\n",
3069            ASM_RVA_BEFORE, imp_name_lab, ASM_RVA_AFTER, ASM_C);
3070   fprintf (f, "\t%s__DLL_HANDLE_%s%s\t%s rvaHmod\n",
3071            ASM_RVA_BEFORE, imp_name_lab, ASM_RVA_AFTER, ASM_C);
3072   fprintf (f, "\t%s__IAT_%s%s\t%s rvaIAT\n",
3073            ASM_RVA_BEFORE, imp_name_lab, ASM_RVA_AFTER, ASM_C);
3074   fprintf (f, "\t%s__INT_%s%s\t%s rvaINT\n",
3075            ASM_RVA_BEFORE, imp_name_lab, ASM_RVA_AFTER, ASM_C);
3076   fprintf (f, "\t%s\t0\t%s rvaBoundIAT\n", ASM_LONG, ASM_C);
3077   fprintf (f, "\t%s\t0\t%s rvaUnloadIAT\n", ASM_LONG, ASM_C);
3078   fprintf (f, "\t%s\t0\t%s dwTimeStamp\n", ASM_LONG, ASM_C);
3079
3080   /* Output the dll_handle */
3081   fprintf (f, "\n.section .data\n");
3082   fprintf (f, "__DLL_HANDLE_%s:\n", imp_name_lab);
3083   fprintf (f, "\t%s\t0\t%s Handle\n", ASM_LONG, ASM_C);
3084   if (create_for_pep)
3085     fprintf (f, "\t%s\t0\n", ASM_LONG);
3086   fprintf (f, "\n");
3087
3088   fprintf (f, "%sStuff for compatibility\n", ASM_C);
3089
3090   if (!no_idata5)
3091     {
3092       fprintf (f, "\t.section\t.idata$5\n");
3093       /* NULL terminating list.  */
3094       if (create_for_pep)
3095         fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
3096       else
3097         fprintf (f,"\t%s\t0\n", ASM_LONG);
3098       fprintf (f, "__IAT_%s:\n", imp_name_lab);
3099     }
3100
3101   if (!no_idata4)
3102     {
3103       fprintf (f, "\t.section\t.idata$4\n");
3104       fprintf (f, "\t%s\t0\n", ASM_LONG);
3105       if (create_for_pep)
3106         fprintf (f, "\t%s\t0\n", ASM_LONG);
3107       fprintf (f, "\t.section\t.idata$4\n");
3108       fprintf (f, "__INT_%s:\n", imp_name_lab);
3109     }
3110
3111   fprintf (f, "\t.section\t.idata$2\n");
3112
3113   fclose (f);
3114
3115   assemble_file (TMP_HEAD_S, TMP_HEAD_O);
3116
3117   abfd = bfd_openr (TMP_HEAD_O, HOW_BFD_READ_TARGET);
3118   if (abfd == NULL)
3119     /* xgettext:c-format */
3120     fatal (_("failed to open temporary head file: %s: %s"),
3121            TMP_HEAD_O, bfd_get_errmsg ());
3122
3123   temp_file_to_remove[TEMP_HEAD_O_FILE] = TMP_HEAD_O;
3124   return abfd;
3125 }
3126
3127 static bfd *
3128 make_tail (void)
3129 {
3130   FILE *f = fopen (TMP_TAIL_S, FOPEN_WT);
3131   bfd *abfd;
3132
3133   if (f == NULL)
3134     {
3135       fatal (_("failed to open temporary tail file: %s"), TMP_TAIL_S);
3136       return NULL;
3137     }
3138
3139   temp_file_to_remove[TEMP_TAIL_FILE] = TMP_TAIL_S;
3140
3141   if (!no_idata4)
3142     {
3143       fprintf (f, "\t.section\t.idata$4\n");
3144       if (create_for_pep)
3145         fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
3146       else
3147         fprintf (f,"\t%s\t0\n", ASM_LONG); /* NULL terminating list.  */
3148     }
3149
3150   if (!no_idata5)
3151     {
3152       fprintf (f, "\t.section\t.idata$5\n");
3153       if (create_for_pep)
3154         fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
3155       else
3156         fprintf (f,"\t%s\t0\n", ASM_LONG); /* NULL terminating list.  */
3157     }
3158
3159 #ifdef DLLTOOL_PPC
3160   /* Normally, we need to see a null descriptor built in idata$3 to
3161      act as the terminator for the list. The ideal way, I suppose,
3162      would be to mark this section as a comdat type 2 section, so
3163      only one would appear in the final .exe (if our linker supported
3164      comdat, that is) or cause it to be inserted by something else (say
3165      crt0).  */
3166
3167   fprintf (f, "\t.section\t.idata$3\n");
3168   fprintf (f, "\t%s\t0\n", ASM_LONG);
3169   fprintf (f, "\t%s\t0\n", ASM_LONG);
3170   fprintf (f, "\t%s\t0\n", ASM_LONG);
3171   fprintf (f, "\t%s\t0\n", ASM_LONG);
3172   fprintf (f, "\t%s\t0\n", ASM_LONG);
3173 #endif
3174
3175 #ifdef DLLTOOL_PPC
3176   /* Other PowerPC NT compilers use idata$6 for the dllname, so I
3177      do too. Original, huh?  */
3178   fprintf (f, "\t.section\t.idata$6\n");
3179 #else
3180   fprintf (f, "\t.section\t.idata$7\n");
3181 #endif
3182
3183   fprintf (f, "\t%s\t__%s_iname\n", ASM_GLOBAL, imp_name_lab);
3184   fprintf (f, "__%s_iname:\t%s\t\"%s\"\n",
3185            imp_name_lab, ASM_TEXT, dll_name);
3186
3187   fclose (f);
3188
3189   assemble_file (TMP_TAIL_S, TMP_TAIL_O);
3190
3191   abfd = bfd_openr (TMP_TAIL_O, HOW_BFD_READ_TARGET);
3192   if (abfd == NULL)
3193     /* xgettext:c-format */
3194     fatal (_("failed to open temporary tail file: %s: %s"),
3195            TMP_TAIL_O, bfd_get_errmsg ());
3196
3197   temp_file_to_remove[TEMP_TAIL_O_FILE] = TMP_TAIL_O;
3198   return abfd;
3199 }
3200
3201 static void
3202 gen_lib_file (int delay)
3203 {
3204   int i;
3205   export_type *exp;
3206   bfd *ar_head;
3207   bfd *ar_tail;
3208   bfd *outarch;
3209   bfd * head  = 0;
3210
3211   unlink (imp_name);
3212
3213   outarch = bfd_openw (imp_name, HOW_BFD_WRITE_TARGET);
3214
3215   if (!outarch)
3216     /* xgettext:c-format */
3217     fatal (_("Can't create .lib file: %s: %s"),
3218            imp_name, bfd_get_errmsg ());
3219
3220   /* xgettext:c-format */
3221   inform (_("Creating library file: %s"), imp_name);
3222
3223   xatexit (unlink_temp_files);
3224
3225   bfd_set_format (outarch, bfd_archive);
3226   outarch->has_armap = 1;
3227   outarch->is_thin_archive = 0;
3228
3229   /* Work out a reasonable size of things to put onto one line.  */
3230   if (delay)
3231     {
3232       ar_head = make_delay_head ();
3233     }
3234   else
3235     {
3236       ar_head = make_head ();
3237     }
3238   ar_tail = make_tail();
3239
3240   if (ar_head == NULL || ar_tail == NULL)
3241     return;
3242
3243   for (i = 0; (exp = d_exports_lexically[i]); i++)
3244     {
3245       bfd *n;
3246       /* Don't add PRIVATE entries to import lib.  */
3247       if (exp->private)
3248         continue;
3249       n = make_one_lib_file (exp, i, delay);
3250       n->archive_next = head;
3251       head = n;
3252       if (ext_prefix_alias)
3253         {
3254           export_type alias_exp;
3255
3256           assert (i < PREFIX_ALIAS_BASE);
3257           alias_exp.name = make_imp_label (ext_prefix_alias, exp->name);
3258           alias_exp.internal_name = exp->internal_name;
3259           alias_exp.its_name = exp->its_name;
3260           alias_exp.import_name = exp->name;
3261           alias_exp.ordinal = exp->ordinal;
3262           alias_exp.constant = exp->constant;
3263           alias_exp.noname = exp->noname;
3264           alias_exp.private = exp->private;
3265           alias_exp.data = exp->data;
3266           alias_exp.hint = exp->hint;
3267           alias_exp.forward = exp->forward;
3268           alias_exp.next = exp->next;
3269           n = make_one_lib_file (&alias_exp, i + PREFIX_ALIAS_BASE, delay);
3270           n->archive_next = head;
3271           head = n;
3272         }
3273     }
3274
3275   /* Now stick them all into the archive.  */
3276   ar_head->archive_next = head;
3277   ar_tail->archive_next = ar_head;
3278   head = ar_tail;
3279
3280   if (! bfd_set_archive_head (outarch, head))
3281     bfd_fatal ("bfd_set_archive_head");
3282
3283   if (! bfd_close (outarch))
3284     bfd_fatal (imp_name);
3285
3286   while (head != NULL)
3287     {
3288       bfd *n = head->archive_next;
3289       bfd_close (head);
3290       head = n;
3291     }
3292
3293   /* Delete all the temp files.  */
3294   unlink_temp_files ();
3295
3296   if (dontdeltemps < 2)
3297     {
3298       char *name;
3299
3300       name = xmalloc (strlen (TMP_STUB) + 10);
3301       for (i = 0; (exp = d_exports_lexically[i]); i++)
3302         {
3303           /* Don't delete non-existent stubs for PRIVATE entries.  */
3304           if (exp->private)
3305             continue;
3306           sprintf (name, "%s%05d.o", TMP_STUB, i);
3307           if (unlink (name) < 0)
3308             /* xgettext:c-format */
3309             non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
3310           if (ext_prefix_alias)
3311             {
3312               sprintf (name, "%s%05d.o", TMP_STUB, i + PREFIX_ALIAS_BASE);
3313               if (unlink (name) < 0)
3314                 /* xgettext:c-format */
3315                 non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
3316             }
3317         }
3318       free (name);
3319     }
3320
3321   inform (_("Created lib file"));
3322 }
3323
3324 /* Append a copy of data (cast to char *) to list.  */
3325
3326 static void
3327 dll_name_list_append (dll_name_list_type * list, bfd_byte * data)
3328 {
3329   dll_name_list_node_type * entry;
3330
3331   /* Error checking.  */
3332   if (! list || ! list->tail)
3333     return;
3334
3335   /* Allocate new node.  */
3336   entry = ((dll_name_list_node_type *)
3337            xmalloc (sizeof (dll_name_list_node_type)));
3338
3339   /* Initialize its values.  */
3340   entry->dllname = xstrdup ((char *) data);
3341   entry->next = NULL;
3342
3343   /* Add to tail, and move tail.  */
3344   list->tail->next = entry;
3345   list->tail = entry;
3346 }
3347
3348 /* Count the number of entries in list.  */
3349
3350 static int
3351 dll_name_list_count (dll_name_list_type * list)
3352 {
3353   dll_name_list_node_type * p;
3354   int count = 0;
3355
3356   /* Error checking.  */
3357   if (! list || ! list->head)
3358     return 0;
3359
3360   p = list->head;
3361
3362   while (p && p->next)
3363     {
3364       count++;
3365       p = p->next;
3366     }
3367   return count;
3368 }
3369
3370 /* Print each entry in list to stdout.  */
3371
3372 static void
3373 dll_name_list_print (dll_name_list_type * list)
3374 {
3375   dll_name_list_node_type * p;
3376
3377   /* Error checking.  */
3378   if (! list || ! list->head)
3379     return;
3380
3381   p = list->head;
3382
3383   while (p && p->next && p->next->dllname && *(p->next->dllname))
3384     {
3385       printf ("%s\n", p->next->dllname);
3386       p = p->next;
3387     }
3388 }
3389
3390 /* Free all entries in list, and list itself.  */
3391
3392 static void
3393 dll_name_list_free (dll_name_list_type * list)
3394 {
3395   if (list)
3396     {
3397       dll_name_list_free_contents (list->head);
3398       list->head = NULL;
3399       list->tail = NULL;
3400       free (list);
3401     }
3402 }
3403
3404 /* Recursive function to free all nodes entry->next->next...
3405    as well as entry itself.  */
3406
3407 static void
3408 dll_name_list_free_contents (dll_name_list_node_type * entry)
3409 {
3410   if (entry)
3411     {
3412       if (entry->next)
3413         {
3414           dll_name_list_free_contents (entry->next);
3415           entry->next = NULL;
3416         }
3417       if (entry->dllname)
3418         {
3419           free (entry->dllname);
3420           entry->dllname = NULL;
3421         }
3422       free (entry);
3423     }
3424 }
3425
3426 /* Allocate and initialize a dll_name_list_type object,
3427    including its sentinel node.  Caller is responsible
3428    for calling dll_name_list_free when finished with
3429    the list.  */
3430
3431 static dll_name_list_type *
3432 dll_name_list_create (void)
3433 {
3434   /* Allocate list.  */
3435   dll_name_list_type * list = xmalloc (sizeof (dll_name_list_type));
3436
3437   /* Allocate and initialize sentinel node.  */
3438   list->head = xmalloc (sizeof (dll_name_list_node_type));
3439   list->head->dllname = NULL;
3440   list->head->next = NULL;
3441
3442   /* Bookkeeping for empty list.  */
3443   list->tail = list->head;
3444
3445   return list;
3446 }
3447
3448 /* Search the symbol table of the suppled BFD for a symbol whose name matches
3449    OBJ (where obj is cast to const char *).  If found, set global variable
3450    identify_member_contains_symname_result TRUE.  It is the caller's
3451    responsibility to set the result variable FALSE before iterating with
3452    this function.  */
3453
3454 static void
3455 identify_member_contains_symname (bfd  * abfd,
3456                                   bfd  * archive_bfd ATTRIBUTE_UNUSED,
3457                                   void * obj)
3458 {
3459   long storage_needed;
3460   asymbol ** symbol_table;
3461   long number_of_symbols;
3462   long i;
3463   symname_search_data_type * search_data = (symname_search_data_type *) obj;
3464
3465   /* If we already found the symbol in a different member,
3466      short circuit.  */
3467   if (search_data->found)
3468     return;
3469
3470   storage_needed = bfd_get_symtab_upper_bound (abfd);
3471   if (storage_needed <= 0)
3472     return;
3473
3474   symbol_table = xmalloc (storage_needed);
3475   number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
3476   if (number_of_symbols < 0)
3477     {
3478       free (symbol_table);
3479       return;
3480     }
3481
3482   for (i = 0; i < number_of_symbols; i++)
3483     {
3484       if (strncmp (symbol_table[i]->name,
3485                    search_data->symname,
3486                    strlen (search_data->symname)) == 0)
3487         {
3488           search_data->found = TRUE;
3489           break;
3490         }
3491     }
3492   free (symbol_table);
3493 }
3494
3495 /* This is the main implementation for the --identify option.
3496    Given the name of an import library in identify_imp_name, first determine
3497    if the import library is a GNU binutils-style one (where the DLL name is
3498    stored in an .idata$7 (.idata$6 on PPC) section, or if it is a MS-style
3499    one (where the DLL name, along with much other data, is stored in the
3500    .idata$6 section). We determine the style of import library by searching
3501    for the DLL-structure symbol inserted by MS tools:
3502    __NULL_IMPORT_DESCRIPTOR.
3503
3504    Once we know which section to search, evaluate each section for the
3505    appropriate properties that indicate it may contain the name of the
3506    associated DLL (this differs depending on the style).  Add the contents
3507    of all sections which meet the criteria to a linked list of dll names.
3508
3509    Finally, print them all to stdout. (If --identify-strict, an error is
3510    reported if more than one match was found).  */
3511
3512 static void
3513 identify_dll_for_implib (void)
3514 {
3515   bfd * abfd = NULL;
3516   int count = 0;
3517   identify_data_type identify_data;
3518   symname_search_data_type search_data;
3519
3520   /* Initialize identify_data.  */
3521   identify_data.list = dll_name_list_create ();
3522   identify_data.ms_style_implib = FALSE;
3523
3524   /* Initialize search_data.  */
3525   search_data.symname = "__NULL_IMPORT_DESCRIPTOR";
3526   search_data.found = FALSE;
3527
3528   bfd_init ();
3529
3530   abfd = bfd_openr (identify_imp_name, 0);
3531   if (abfd == NULL)
3532     /* xgettext:c-format */
3533     fatal (_("Can't open .lib file: %s: %s"),
3534            identify_imp_name, bfd_get_errmsg ());
3535
3536   if (! bfd_check_format (abfd, bfd_archive))
3537     {
3538       if (! bfd_close (abfd))
3539         bfd_fatal (identify_imp_name);
3540
3541       fatal (_("%s is not a library"), identify_imp_name);
3542     }
3543
3544   /* Detect if this a Microsoft import library.  */
3545   identify_search_archive (abfd,
3546                            identify_member_contains_symname,
3547                            (void *)(& search_data));
3548   if (search_data.found)
3549     identify_data.ms_style_implib = TRUE;
3550
3551   /* Rewind the bfd.  */
3552   if (! bfd_close (abfd))
3553     bfd_fatal (identify_imp_name);
3554   abfd = bfd_openr (identify_imp_name, 0);
3555   if (abfd == NULL)
3556     bfd_fatal (identify_imp_name);
3557
3558   if (!bfd_check_format (abfd, bfd_archive))
3559     {
3560       if (!bfd_close (abfd))
3561         bfd_fatal (identify_imp_name);
3562
3563       fatal (_("%s is not a library"), identify_imp_name);
3564     }
3565
3566   /* Now search for the dll name.  */
3567   identify_search_archive (abfd,
3568                            identify_search_member,
3569                            (void *)(& identify_data));
3570
3571   if (! bfd_close (abfd))
3572     bfd_fatal (identify_imp_name);
3573
3574   count = dll_name_list_count (identify_data.list);
3575   if (count > 0)
3576     {
3577       if (identify_strict && count > 1)
3578         {
3579           dll_name_list_free (identify_data.list);
3580           identify_data.list = NULL;
3581           fatal (_("Import library `%s' specifies two or more dlls"),
3582                  identify_imp_name);
3583         }
3584       dll_name_list_print (identify_data.list);
3585       dll_name_list_free (identify_data.list);
3586       identify_data.list = NULL;
3587     }
3588   else
3589     {
3590       dll_name_list_free (identify_data.list);
3591       identify_data.list = NULL;
3592       fatal (_("Unable to determine dll name for `%s' (not an import library?)"),
3593              identify_imp_name);
3594     }
3595 }
3596
3597 /* Loop over all members of the archive, applying the supplied function to
3598    each member that is a bfd_object.  The function will be called as if:
3599       func (member_bfd, abfd, user_storage)  */
3600
3601 static void
3602 identify_search_archive (bfd * abfd,
3603                          void (* operation) (bfd *, bfd *, void *),
3604                          void * user_storage)
3605 {
3606   bfd *   arfile = NULL;
3607   bfd *   last_arfile = NULL;
3608   char ** matching;
3609
3610   while (1)
3611     {
3612       arfile = bfd_openr_next_archived_file (abfd, arfile);
3613
3614       if (arfile == NULL)
3615         {
3616           if (bfd_get_error () != bfd_error_no_more_archived_files)
3617             bfd_fatal (bfd_get_filename (abfd));
3618           break;
3619         }
3620
3621       if (bfd_check_format_matches (arfile, bfd_object, &matching))
3622         (*operation) (arfile, abfd, user_storage);
3623       else
3624         {
3625           bfd_nonfatal (bfd_get_filename (arfile));
3626           free (matching);
3627         }
3628
3629       if (last_arfile != NULL)
3630         {
3631           bfd_close (last_arfile);
3632           /* PR 17512: file: 8b2168d4.  */
3633           if (last_arfile == arfile)
3634             {
3635               last_arfile = NULL;
3636               break;
3637             }
3638         }
3639
3640       last_arfile = arfile;
3641     }
3642
3643   if (last_arfile != NULL)
3644     {
3645       bfd_close (last_arfile);
3646     }
3647 }
3648
3649 /* Call the identify_search_section() function for each section of this
3650    archive member.  */
3651
3652 static void
3653 identify_search_member (bfd  *abfd,
3654                         bfd  *archive_bfd ATTRIBUTE_UNUSED,
3655                         void *obj)
3656 {
3657   bfd_map_over_sections (abfd, identify_search_section, obj);
3658 }
3659
3660 /* This predicate returns true if section->name matches the desired value.
3661    By default, this is .idata$7 (.idata$6 on PPC, or if the import
3662    library is ms-style).  */
3663
3664 static bfd_boolean
3665 identify_process_section_p (asection * section, bfd_boolean ms_style_implib)
3666 {
3667   static const char * SECTION_NAME =
3668 #ifdef DLLTOOL_PPC
3669   /* dllname is stored in idata$6 on PPC */
3670   ".idata$6";
3671 #else
3672   ".idata$7";
3673 #endif
3674   static const char * MS_SECTION_NAME = ".idata$6";
3675
3676   const char * section_name =
3677     (ms_style_implib ? MS_SECTION_NAME : SECTION_NAME);
3678
3679   if (strcmp (section_name, section->name) == 0)
3680     return TRUE;
3681   return FALSE;
3682 }
3683
3684 /* If *section has contents and its name is .idata$7 (.data$6 on PPC or if
3685    import lib ms-generated) -- and it satisfies several other constraints
3686    -- then add the contents of the section to obj->list.  */
3687
3688 static void
3689 identify_search_section (bfd * abfd, asection * section, void * obj)
3690 {
3691   bfd_byte *data = 0;
3692   bfd_size_type datasize;
3693   identify_data_type * identify_data = (identify_data_type *)obj;
3694   bfd_boolean ms_style = identify_data->ms_style_implib;
3695
3696   if ((section->flags & SEC_HAS_CONTENTS) == 0)
3697     return;
3698
3699   if (! identify_process_section_p (section, ms_style))
3700     return;
3701
3702   /* Binutils import libs seem distinguish the .idata$7 section that contains
3703      the DLL name from other .idata$7 sections by the absence of the
3704      SEC_RELOC flag.  */
3705   if (!ms_style && ((section->flags & SEC_RELOC) == SEC_RELOC))
3706     return;
3707
3708   /* MS import libs seem to distinguish the .idata$6 section
3709      that contains the DLL name from other .idata$6 sections
3710      by the presence of the SEC_DATA flag.  */
3711   if (ms_style && ((section->flags & SEC_DATA) == 0))
3712     return;
3713
3714   if ((datasize = bfd_section_size (abfd, section)) == 0)
3715     return;
3716
3717   data = (bfd_byte *) xmalloc (datasize + 1);
3718   data[0] = '\0';
3719
3720   bfd_get_section_contents (abfd, section, data, 0, datasize);
3721   data[datasize] = '\0';
3722
3723   /* Use a heuristic to determine if data is a dll name.
3724      Possible to defeat this if (a) the library has MANY
3725      (more than 0x302f) imports, (b) it is an ms-style
3726      import library, but (c) it is buggy, in that the SEC_DATA
3727      flag is set on the "wrong" sections.  This heuristic might
3728      also fail to record a valid dll name if the dllname uses
3729      a multibyte or unicode character set (is that valid?).
3730
3731      This heuristic is based on the fact that symbols names in
3732      the chosen section -- as opposed to the dll name -- begin
3733      at offset 2 in the data. The first two bytes are a 16bit
3734      little-endian count, and start at 0x0000. However, the dll
3735      name begins at offset 0 in the data. We assume that the
3736      dll name does not contain unprintable characters.   */
3737   if (data[0] != '\0' && ISPRINT (data[0])
3738       && ((datasize < 2) || ISPRINT (data[1])))
3739     dll_name_list_append (identify_data->list, data);
3740
3741   free (data);
3742 }
3743
3744 /* Run through the information gathered from the .o files and the
3745    .def file and work out the best stuff.  */
3746
3747 static int
3748 pfunc (const void *a, const void *b)
3749 {
3750   export_type *ap = *(export_type **) a;
3751   export_type *bp = *(export_type **) b;
3752
3753   if (ap->ordinal == bp->ordinal)
3754     return 0;
3755
3756   /* Unset ordinals go to the bottom.  */
3757   if (ap->ordinal == -1)
3758     return 1;
3759   if (bp->ordinal == -1)
3760     return -1;
3761   return (ap->ordinal - bp->ordinal);
3762 }
3763
3764 static int
3765 nfunc (const void *a, const void *b)
3766 {
3767   export_type *ap = *(export_type **) a;
3768   export_type *bp = *(export_type **) b;
3769   const char *an = ap->name;
3770   const char *bn = bp->name;
3771   if (ap->its_name)
3772     an = ap->its_name;
3773   if (bp->its_name)
3774     an = bp->its_name;
3775   if (killat)
3776     {
3777       an = (an[0] == '@') ? an + 1 : an;
3778       bn = (bn[0] == '@') ? bn + 1 : bn;
3779     }
3780
3781   return (strcmp (an, bn));
3782 }
3783
3784 static void
3785 remove_null_names (export_type **ptr)
3786 {
3787   int src;
3788   int dst;
3789
3790   for (dst = src = 0; src < d_nfuncs; src++)
3791     {
3792       if (ptr[src])
3793         {
3794           ptr[dst] = ptr[src];
3795           dst++;
3796         }
3797     }
3798   d_nfuncs = dst;
3799 }
3800
3801 static void
3802 process_duplicates (export_type **d_export_vec)
3803 {
3804   int more = 1;
3805   int i;
3806
3807   while (more)
3808     {
3809       more = 0;
3810       /* Remove duplicates.  */
3811       qsort (d_export_vec, d_nfuncs, sizeof (export_type *), nfunc);
3812
3813       for (i = 0; i < d_nfuncs - 1; i++)
3814         {
3815           if (strcmp (d_export_vec[i]->name,
3816                       d_export_vec[i + 1]->name) == 0)
3817             {
3818               export_type *a = d_export_vec[i];
3819               export_type *b = d_export_vec[i + 1];
3820
3821               more = 1;
3822
3823               /* xgettext:c-format */
3824               inform (_("Warning, ignoring duplicate EXPORT %s %d,%d"),
3825                       a->name, a->ordinal, b->ordinal);
3826
3827               if (a->ordinal != -1
3828                   && b->ordinal != -1)
3829                 /* xgettext:c-format */
3830                 fatal (_("Error, duplicate EXPORT with ordinals: %s"),
3831                       a->name);
3832
3833               /* Merge attributes.  */
3834               b->ordinal = a->ordinal > 0 ? a->ordinal : b->ordinal;
3835               b->constant |= a->constant;
3836               b->noname |= a->noname;
3837               b->data |= a->data;
3838               d_export_vec[i] = 0;
3839             }
3840
3841           remove_null_names (d_export_vec);
3842         }
3843     }
3844
3845   /* Count the names.  */
3846   for (i = 0; i < d_nfuncs; i++)
3847     if (!d_export_vec[i]->noname)
3848       d_named_nfuncs++;
3849 }
3850
3851 static void
3852 fill_ordinals (export_type **d_export_vec)
3853 {
3854   int lowest = -1;
3855   int i;
3856   char *ptr;
3857   int size = 65536;
3858
3859   qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
3860
3861   /* Fill in the unset ordinals with ones from our range.  */
3862   ptr = (char *) xmalloc (size);
3863
3864   memset (ptr, 0, size);
3865
3866   /* Mark in our large vector all the numbers that are taken.  */
3867   for (i = 0; i < d_nfuncs; i++)
3868     {
3869       if (d_export_vec[i]->ordinal != -1)
3870         {
3871           ptr[d_export_vec[i]->ordinal] = 1;
3872
3873           if (lowest == -1 || d_export_vec[i]->ordinal < lowest)
3874             lowest = d_export_vec[i]->ordinal;
3875         }
3876     }
3877
3878   /* Start at 1 for compatibility with MS toolchain.  */
3879   if (lowest == -1)
3880     lowest = 1;
3881
3882   /* Now fill in ordinals where the user wants us to choose.  */
3883   for (i = 0; i < d_nfuncs; i++)
3884     {
3885       if (d_export_vec[i]->ordinal == -1)
3886         {
3887           int j;
3888
3889           /* First try within or after any user supplied range.  */
3890           for (j = lowest; j < size; j++)
3891             if (ptr[j] == 0)
3892               {
3893                 ptr[j] = 1;
3894                 d_export_vec[i]->ordinal = j;
3895                 goto done;
3896               }
3897
3898           /* Then try before the range.  */
3899           for (j = lowest; j >0; j--)
3900             if (ptr[j] == 0)
3901               {
3902                 ptr[j] = 1;
3903                 d_export_vec[i]->ordinal = j;
3904                 goto done;
3905               }
3906         done:;
3907         }
3908     }
3909
3910   free (ptr);
3911
3912   /* And resort.  */
3913   qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
3914
3915   /* Work out the lowest and highest ordinal numbers.  */
3916   if (d_nfuncs)
3917     {
3918       if (d_export_vec[0])
3919         d_low_ord = d_export_vec[0]->ordinal;
3920       if (d_export_vec[d_nfuncs-1])
3921         d_high_ord = d_export_vec[d_nfuncs-1]->ordinal;
3922     }
3923 }
3924
3925 static void
3926 mangle_defs (void)
3927 {
3928   /* First work out the minimum ordinal chosen.  */
3929   export_type *exp;
3930
3931   int i;
3932   int hint = 0;
3933   export_type **d_export_vec = xmalloc (sizeof (export_type *) * d_nfuncs);
3934
3935   inform (_("Processing definitions"));
3936
3937   for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3938     d_export_vec[i] = exp;
3939
3940   process_duplicates (d_export_vec);
3941   fill_ordinals (d_export_vec);
3942
3943   /* Put back the list in the new order.  */
3944   d_exports = 0;
3945   for (i = d_nfuncs - 1; i >= 0; i--)
3946     {
3947       d_export_vec[i]->next = d_exports;
3948       d_exports = d_export_vec[i];
3949     }
3950
3951   /* Build list in alpha order.  */
3952   d_exports_lexically = (export_type **)
3953     xmalloc (sizeof (export_type *) * (d_nfuncs + 1));
3954
3955   for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3956     d_exports_lexically[i] = exp;
3957
3958   d_exports_lexically[i] = 0;
3959
3960   qsort (d_exports_lexically, i, sizeof (export_type *), nfunc);
3961
3962   /* Fill exp entries with their hint values.  */
3963   for (i = 0; i < d_nfuncs; i++)
3964     if (!d_exports_lexically[i]->noname || show_allnames)
3965       d_exports_lexically[i]->hint = hint++;
3966
3967   inform (_("Processed definitions"));
3968 }
3969
3970 static void
3971 usage (FILE *file, int status)
3972 {
3973   /* xgetext:c-format */
3974   fprintf (file, _("Usage %s <option(s)> <object-file(s)>\n"), program_name);
3975   /* xgetext:c-format */
3976   fprintf (file, _("   -m --machine <machine>    Create as DLL for <machine>.  [default: %s]\n"), mname);
3977   fprintf (file, _("        possible <machine>: arm[_interwork], i386, mcore[-elf]{-le|-be}, ppc, thumb\n"));
3978   fprintf (file, _("   -e --output-exp <outname> Generate an export file.\n"));
3979   fprintf (file, _("   -l --output-lib <outname> Generate an interface library.\n"));
3980   fprintf (file, _("   -y --output-delaylib <outname> Create a delay-import library.\n"));
3981   fprintf (file, _("   -a --add-indirect         Add dll indirects to export file.\n"));
3982   fprintf (file, _("   -D --dllname <name>       Name of input dll to put into interface lib.\n"));
3983   fprintf (file, _("   -d --input-def <deffile>  Name of .def file to be read in.\n"));
3984   fprintf (file, _("   -z --output-def <deffile> Name of .def file to be created.\n"));
3985   fprintf (file, _("      --export-all-symbols   Export all symbols to .def\n"));
3986   fprintf (file, _("      --no-export-all-symbols  Only export listed symbols\n"));
3987   fprintf (file, _("      --exclude-symbols <list> Don't export <list>\n"));
3988   fprintf (file, _("      --no-default-excludes  Clear default exclude symbols\n"));
3989   fprintf (file, _("   -b --base-file <basefile> Read linker generated base file.\n"));
3990   fprintf (file, _("   -x --no-idata4            Don't generate idata$4 section.\n"));
3991   fprintf (file, _("   -c --no-idata5            Don't generate idata$5 section.\n"));
3992   fprintf (file, _("      --use-nul-prefixed-import-tables Use zero prefixed idata$4 and idata$5.\n"));
3993   fprintf (file, _("   -U --add-underscore       Add underscores to all symbols in interface library.\n"));
3994   fprintf (file, _("      --add-stdcall-underscore Add underscores to stdcall symbols in interface library.\n"));
3995   fprintf (file, _("      --no-leading-underscore All symbols shouldn't be prefixed by an underscore.\n"));
3996   fprintf (file, _("      --leading-underscore   All symbols should be prefixed by an underscore.\n"));
3997   fprintf (file, _("   -k --kill-at              Kill @<n> from exported names.\n"));
3998   fprintf (file, _("   -A --add-stdcall-alias    Add aliases without @<n>.\n"));
3999   fprintf (file, _("   -p --ext-prefix-alias <prefix> Add aliases with <prefix>.\n"));
4000   fprintf (file, _("   -S --as <name>            Use <name> for assembler.\n"));
4001   fprintf (file, _("   -f --as-flags <flags>     Pass <flags> to the assembler.\n"));
4002   fprintf (file, _("   -C --compat-implib        Create backward compatible import library.\n"));
4003   fprintf (file, _("   -n --no-delete            Keep temp files (repeat for extra preservation).\n"));
4004   fprintf (file, _("   -t --temp-prefix <prefix> Use <prefix> to construct temp file names.\n"));
4005   fprintf (file, _("   -I --identify <implib>    Report the name of the DLL associated with <implib>.\n"));
4006   fprintf (file, _("      --identify-strict      Causes --identify to report error when multiple DLLs.\n"));
4007   fprintf (file, _("   -v --verbose              Be verbose.\n"));
4008   fprintf (file, _("   -V --version              Display the program version.\n"));
4009   fprintf (file, _("   -h --help                 Display this information.\n"));
4010   fprintf (file, _("   @<file>                   Read options from <file>.\n"));
4011 #ifdef DLLTOOL_MCORE_ELF
4012   fprintf (file, _("   -M --mcore-elf <outname>  Process mcore-elf object files into <outname>.\n"));
4013   fprintf (file, _("   -L --linker <name>        Use <name> as the linker.\n"));
4014   fprintf (file, _("   -F --linker-flags <flags> Pass <flags> to the linker.\n"));
4015 #endif
4016   if (REPORT_BUGS_TO[0] && status == 0)
4017     fprintf (file, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4018   exit (status);
4019 }
4020
4021 #define OPTION_EXPORT_ALL_SYMS          150
4022 #define OPTION_NO_EXPORT_ALL_SYMS       (OPTION_EXPORT_ALL_SYMS + 1)
4023 #define OPTION_EXCLUDE_SYMS             (OPTION_NO_EXPORT_ALL_SYMS + 1)
4024 #define OPTION_NO_DEFAULT_EXCLUDES      (OPTION_EXCLUDE_SYMS + 1)
4025 #define OPTION_ADD_STDCALL_UNDERSCORE   (OPTION_NO_DEFAULT_EXCLUDES + 1)
4026 #define OPTION_USE_NUL_PREFIXED_IMPORT_TABLES \
4027   (OPTION_ADD_STDCALL_UNDERSCORE + 1)
4028 #define OPTION_IDENTIFY_STRICT          (OPTION_USE_NUL_PREFIXED_IMPORT_TABLES + 1)
4029 #define OPTION_NO_LEADING_UNDERSCORE    (OPTION_IDENTIFY_STRICT + 1)
4030 #define OPTION_LEADING_UNDERSCORE       (OPTION_NO_LEADING_UNDERSCORE + 1)
4031
4032 static const struct option long_options[] =
4033 {
4034   {"no-delete", no_argument, NULL, 'n'},
4035   {"dllname", required_argument, NULL, 'D'},
4036   {"no-idata4", no_argument, NULL, 'x'},
4037   {"no-idata5", no_argument, NULL, 'c'},
4038   {"use-nul-prefixed-import-tables", no_argument, NULL,
4039    OPTION_USE_NUL_PREFIXED_IMPORT_TABLES},
4040   {"output-exp", required_argument, NULL, 'e'},
4041   {"output-def", required_argument, NULL, 'z'},
4042   {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL_SYMS},
4043   {"no-export-all-symbols", no_argument, NULL, OPTION_NO_EXPORT_ALL_SYMS},
4044   {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMS},
4045   {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
4046   {"output-lib", required_argument, NULL, 'l'},
4047   {"def", required_argument, NULL, 'd'}, /* for compatibility with older versions */
4048   {"input-def", required_argument, NULL, 'd'},
4049   {"add-underscore", no_argument, NULL, 'U'},
4050   {"add-stdcall-underscore", no_argument, NULL, OPTION_ADD_STDCALL_UNDERSCORE},
4051   {"no-leading-underscore", no_argument, NULL, OPTION_NO_LEADING_UNDERSCORE},
4052   {"leading-underscore", no_argument, NULL, OPTION_LEADING_UNDERSCORE},
4053   {"kill-at", no_argument, NULL, 'k'},
4054   {"add-stdcall-alias", no_argument, NULL, 'A'},
4055   {"ext-prefix-alias", required_argument, NULL, 'p'},
4056   {"identify", required_argument, NULL, 'I'},
4057   {"identify-strict", no_argument, NULL, OPTION_IDENTIFY_STRICT},
4058   {"verbose", no_argument, NULL, 'v'},
4059   {"version", no_argument, NULL, 'V'},
4060   {"help", no_argument, NULL, 'h'},
4061   {"machine", required_argument, NULL, 'm'},
4062   {"add-indirect", no_argument, NULL, 'a'},
4063   {"base-file", required_argument, NULL, 'b'},
4064   {"as", required_argument, NULL, 'S'},
4065   {"as-flags", required_argument, NULL, 'f'},
4066   {"mcore-elf", required_argument, NULL, 'M'},
4067   {"compat-implib", no_argument, NULL, 'C'},
4068   {"temp-prefix", required_argument, NULL, 't'},
4069   {"output-delaylib", required_argument, NULL, 'y'},
4070   {NULL,0,NULL,0}
4071 };
4072
4073 int main (int, char **);
4074
4075 int
4076 main (int ac, char **av)
4077 {
4078   int c;
4079   int i;
4080   char *firstarg = 0;
4081   program_name = av[0];
4082   oav = av;
4083
4084 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
4085   setlocale (LC_MESSAGES, "");
4086 #endif
4087 #if defined (HAVE_SETLOCALE)
4088   setlocale (LC_CTYPE, "");
4089 #endif
4090   bindtextdomain (PACKAGE, LOCALEDIR);
4091   textdomain (PACKAGE);
4092
4093   bfd_set_error_program_name (program_name);
4094   expandargv (&ac, &av);
4095
4096   while ((c = getopt_long (ac, av,
4097 #ifdef DLLTOOL_MCORE_ELF
4098                            "m:e:l:aD:d:z:b:xp:cCuUkAS:t:f:nI:vVHhM:L:F:",
4099 #else
4100                            "m:e:l:y:aD:d:z:b:xp:cCuUkAS:t:f:nI:vVHh",
4101 #endif
4102                            long_options, 0))
4103          != EOF)
4104     {
4105       switch (c)
4106         {
4107         case OPTION_EXPORT_ALL_SYMS:
4108           export_all_symbols = TRUE;
4109           break;
4110         case OPTION_NO_EXPORT_ALL_SYMS:
4111           export_all_symbols = FALSE;
4112           break;
4113         case OPTION_EXCLUDE_SYMS:
4114           add_excludes (optarg);
4115           break;
4116         case OPTION_NO_DEFAULT_EXCLUDES:
4117           do_default_excludes = FALSE;
4118           break;
4119         case OPTION_USE_NUL_PREFIXED_IMPORT_TABLES:
4120           use_nul_prefixed_import_tables = TRUE;
4121           break;
4122         case OPTION_ADD_STDCALL_UNDERSCORE:
4123           add_stdcall_underscore = 1;
4124           break;
4125         case OPTION_NO_LEADING_UNDERSCORE:
4126           leading_underscore = 0;
4127           break;
4128         case OPTION_LEADING_UNDERSCORE:
4129           leading_underscore = 1;
4130           break;
4131         case OPTION_IDENTIFY_STRICT:
4132           identify_strict = 1;
4133           break;
4134         case 'x':
4135           no_idata4 = 1;
4136           break;
4137         case 'c':
4138           no_idata5 = 1;
4139           break;
4140         case 'S':
4141           as_name = optarg;
4142           break;
4143         case 't':
4144           tmp_prefix = optarg;
4145           break;
4146         case 'f':
4147           as_flags = optarg;
4148           break;
4149
4150           /* Ignored for compatibility.  */
4151         case 'u':
4152           break;
4153         case 'a':
4154           add_indirect = 1;
4155           break;
4156         case 'z':
4157           output_def = fopen (optarg, FOPEN_WT);
4158           if (!output_def)
4159             /* xgettext:c-format */
4160             fatal (_("Unable to open def-file: %s"), optarg);
4161           break;
4162         case 'D':
4163           dll_name = (char*) lbasename (optarg);
4164           if (dll_name != optarg)
4165             non_fatal (_("Path components stripped from dllname, '%s'."),
4166                          optarg);
4167           break;
4168         case 'l':
4169           imp_name = optarg;
4170           break;
4171         case 'e':
4172           exp_name = optarg;
4173           break;
4174         case 'H':
4175         case 'h':
4176           usage (stdout, 0);
4177           break;
4178         case 'm':
4179           mname = optarg;
4180           break;
4181         case 'I':
4182           identify_imp_name = optarg;
4183           break;
4184         case 'v':
4185           verbose = 1;
4186           break;
4187         case 'V':
4188           print_version (program_name);
4189           break;
4190         case 'U':
4191           add_underscore = 1;
4192           break;
4193         case 'k':
4194           killat = 1;
4195           break;
4196         case 'A':
4197           add_stdcall_alias = 1;
4198           break;
4199         case 'p':
4200           ext_prefix_alias = optarg;
4201           break;
4202         case 'd':
4203           def_file = optarg;
4204           break;
4205         case 'n':
4206           dontdeltemps++;
4207           break;
4208         case 'b':
4209           base_file = fopen (optarg, FOPEN_RB);
4210
4211           if (!base_file)
4212             /* xgettext:c-format */
4213             fatal (_("Unable to open base-file: %s"), optarg);
4214
4215           break;
4216 #ifdef DLLTOOL_MCORE_ELF
4217         case 'M':
4218           mcore_elf_out_file = optarg;
4219           break;
4220         case 'L':
4221           mcore_elf_linker = optarg;
4222           break;
4223         case 'F':
4224           mcore_elf_linker_flags = optarg;
4225           break;
4226 #endif
4227         case 'C':
4228           create_compat_implib = 1;
4229           break;
4230         case 'y':
4231           delayimp_name = optarg;
4232           break;
4233         default:
4234           usage (stderr, 1);
4235           break;
4236         }
4237     }
4238
4239   if (!tmp_prefix)
4240     tmp_prefix = prefix_encode ("d", getpid ());
4241
4242   for (i = 0; mtable[i].type; i++)
4243     if (strcmp (mtable[i].type, mname) == 0)
4244       break;
4245
4246   if (!mtable[i].type)
4247     /* xgettext:c-format */
4248     fatal (_("Machine '%s' not supported"), mname);
4249
4250   machine = i;
4251
4252   /* Check if we generated PE+.  */
4253   create_for_pep = strcmp (mname, "i386:x86-64") == 0;
4254
4255   {
4256     /* Check the default underscore */
4257     int u = leading_underscore; /* Underscoring mode. -1 for use default.  */
4258     if (u == -1)
4259       bfd_get_target_info (mtable[machine].how_bfd_target, NULL,
4260                            NULL, &u, NULL);
4261     if (u != -1)
4262       leading_underscore = (u != 0 ? TRUE : FALSE);
4263   }
4264
4265   if (!dll_name && exp_name)
4266     {
4267       /* If we are inferring dll_name from exp_name,
4268          strip off any path components, without emitting
4269          a warning.  */
4270       const char* exp_basename = lbasename (exp_name);
4271       const int len = strlen (exp_basename) + 5;
4272       dll_name = xmalloc (len);
4273       strcpy (dll_name, exp_basename);
4274       strcat (dll_name, ".dll");
4275       dll_name_set_by_exp_name = 1;
4276     }
4277
4278   if (as_name == NULL)
4279     as_name = deduce_name ("as");
4280
4281   /* Don't use the default exclude list if we're reading only the
4282      symbols in the .drectve section.  The default excludes are meant
4283      to avoid exporting DLL entry point and Cygwin32 impure_ptr.  */
4284   if (! export_all_symbols)
4285     do_default_excludes = FALSE;
4286
4287   if (do_default_excludes)
4288     set_default_excludes ();
4289
4290   if (def_file)
4291     process_def_file (def_file);
4292
4293   while (optind < ac)
4294     {
4295       if (!firstarg)
4296         firstarg = av[optind];
4297       scan_obj_file (av[optind]);
4298       optind++;
4299     }
4300
4301   mangle_defs ();
4302
4303   if (exp_name)
4304     gen_exp_file ();
4305
4306   if (imp_name)
4307     {
4308       /* Make imp_name safe for use as a label.  */
4309       char *p;
4310
4311       imp_name_lab = xstrdup (imp_name);
4312       for (p = imp_name_lab; *p; p++)
4313         {
4314           if (!ISALNUM (*p))
4315             *p = '_';
4316         }
4317       head_label = make_label("_head_", imp_name_lab);
4318       gen_lib_file (0);
4319     }
4320
4321   if (delayimp_name)
4322     {
4323       /* Make delayimp_name safe for use as a label.  */
4324       char *p;
4325
4326       if (mtable[machine].how_dljtab == 0)
4327         {
4328           inform (_("Warning, machine type (%d) not supported for "
4329                         "delayimport."), machine);
4330         }
4331       else
4332         {
4333           killat = 1;
4334           imp_name = delayimp_name;
4335           imp_name_lab = xstrdup (imp_name);
4336           for (p = imp_name_lab; *p; p++)
4337             {
4338               if (!ISALNUM (*p))
4339                 *p = '_';
4340             }
4341           head_label = make_label("__tailMerge_", imp_name_lab);
4342           gen_lib_file (1);
4343         }
4344     }
4345
4346   if (output_def)
4347     gen_def_file ();
4348
4349   if (identify_imp_name)
4350     {
4351       identify_dll_for_implib ();
4352     }
4353
4354 #ifdef DLLTOOL_MCORE_ELF
4355   if (mcore_elf_out_file)
4356     mcore_elf_gen_out_file ();
4357 #endif
4358
4359   return 0;
4360 }
4361
4362 /* Look for the program formed by concatenating PROG_NAME and the
4363    string running from PREFIX to END_PREFIX.  If the concatenated
4364    string contains a '/', try appending EXECUTABLE_SUFFIX if it is
4365    appropriate.  */
4366
4367 static char *
4368 look_for_prog (const char *prog_name, const char *prefix, int end_prefix)
4369 {
4370   struct stat s;
4371   char *cmd;
4372
4373   cmd = xmalloc (strlen (prefix)
4374                  + strlen (prog_name)
4375 #ifdef HAVE_EXECUTABLE_SUFFIX
4376                  + strlen (EXECUTABLE_SUFFIX)
4377 #endif
4378                  + 10);
4379   strcpy (cmd, prefix);
4380
4381   sprintf (cmd + end_prefix, "%s", prog_name);
4382
4383   if (strchr (cmd, '/') != NULL)
4384     {
4385       int found;
4386
4387       found = (stat (cmd, &s) == 0
4388 #ifdef HAVE_EXECUTABLE_SUFFIX
4389                || stat (strcat (cmd, EXECUTABLE_SUFFIX), &s) == 0
4390 #endif
4391                );
4392
4393       if (! found)
4394         {
4395           /* xgettext:c-format */
4396           inform (_("Tried file: %s"), cmd);
4397           free (cmd);
4398           return NULL;
4399         }
4400     }
4401
4402   /* xgettext:c-format */
4403   inform (_("Using file: %s"), cmd);
4404
4405   return cmd;
4406 }
4407
4408 /* Deduce the name of the program we are want to invoke.
4409    PROG_NAME is the basic name of the program we want to run,
4410    eg "as" or "ld".  The catch is that we might want actually
4411    run "i386-pe-as" or "ppc-pe-ld".
4412
4413    If argv[0] contains the full path, then try to find the program
4414    in the same place, with and then without a target-like prefix.
4415
4416    Given, argv[0] = /usr/local/bin/i586-cygwin32-dlltool,
4417    deduce_name("as") uses the following search order:
4418
4419      /usr/local/bin/i586-cygwin32-as
4420      /usr/local/bin/as
4421      as
4422
4423    If there's an EXECUTABLE_SUFFIX, it'll use that as well; for each
4424    name, it'll try without and then with EXECUTABLE_SUFFIX.
4425
4426    Given, argv[0] = i586-cygwin32-dlltool, it will not even try "as"
4427    as the fallback, but rather return i586-cygwin32-as.
4428
4429    Oh, and given, argv[0] = dlltool, it'll return "as".
4430
4431    Returns a dynamically allocated string.  */
4432
4433 static char *
4434 deduce_name (const char *prog_name)
4435 {
4436   char *cmd;
4437   char *dash, *slash, *cp;
4438
4439   dash = NULL;
4440   slash = NULL;
4441   for (cp = program_name; *cp != '\0'; ++cp)
4442     {
4443       if (*cp == '-')
4444         dash = cp;
4445       if (
4446 #if defined(__DJGPP__) || defined (__CYGWIN__) || defined(__WIN32__)
4447           *cp == ':' || *cp == '\\' ||
4448 #endif
4449           *cp == '/')
4450         {
4451           slash = cp;
4452           dash = NULL;
4453         }
4454     }
4455
4456   cmd = NULL;
4457
4458   if (dash != NULL)
4459     {
4460       /* First, try looking for a prefixed PROG_NAME in the
4461          PROGRAM_NAME directory, with the same prefix as PROGRAM_NAME.  */
4462       cmd = look_for_prog (prog_name, program_name, dash - program_name + 1);
4463     }
4464
4465   if (slash != NULL && cmd == NULL)
4466     {
4467       /* Next, try looking for a PROG_NAME in the same directory as
4468          that of this program.  */
4469       cmd = look_for_prog (prog_name, program_name, slash - program_name + 1);
4470     }
4471
4472   if (cmd == NULL)
4473     {
4474       /* Just return PROG_NAME as is.  */
4475       cmd = xstrdup (prog_name);
4476     }
4477
4478   return cmd;
4479 }
4480
4481 #ifdef DLLTOOL_MCORE_ELF
4482 typedef struct fname_cache
4483 {
4484   const char *         filename;
4485   struct fname_cache * next;
4486 }
4487 fname_cache;
4488
4489 static fname_cache fnames;
4490
4491 static void
4492 mcore_elf_cache_filename (const char * filename)
4493 {
4494   fname_cache * ptr;
4495
4496   ptr = & fnames;
4497
4498   while (ptr->next != NULL)
4499     ptr = ptr->next;
4500
4501   ptr->filename = filename;
4502   ptr->next     = (fname_cache *) malloc (sizeof (fname_cache));
4503   if (ptr->next != NULL)
4504     ptr->next->next = NULL;
4505 }
4506
4507 #define MCORE_ELF_TMP_OBJ "mcoreelf.o"
4508 #define MCORE_ELF_TMP_EXP "mcoreelf.exp"
4509 #define MCORE_ELF_TMP_LIB "mcoreelf.lib"
4510
4511 static void
4512 mcore_elf_gen_out_file (void)
4513 {
4514   fname_cache * ptr;
4515   dyn_string_t ds;
4516
4517   /* Step one.  Run 'ld -r' on the input object files in order to resolve
4518      any internal references and to generate a single .exports section.  */
4519   ptr = & fnames;
4520
4521   ds = dyn_string_new (100);
4522   dyn_string_append_cstr (ds, "-r ");
4523
4524   if (mcore_elf_linker_flags != NULL)
4525     dyn_string_append_cstr (ds, mcore_elf_linker_flags);
4526
4527   while (ptr->next != NULL)
4528     {
4529       dyn_string_append_cstr (ds, ptr->filename);
4530       dyn_string_append_cstr (ds, " ");
4531
4532       ptr = ptr->next;
4533     }
4534
4535   dyn_string_append_cstr (ds, "-o ");
4536   dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
4537
4538   if (mcore_elf_linker == NULL)
4539     mcore_elf_linker = deduce_name ("ld");
4540
4541   run (mcore_elf_linker, ds->s);
4542
4543   dyn_string_delete (ds);
4544
4545   /* Step two. Create a .exp file and a .lib file from the temporary file.
4546      Do this by recursively invoking dlltool...  */
4547   ds = dyn_string_new (100);
4548
4549   dyn_string_append_cstr (ds, "-S ");
4550   dyn_string_append_cstr (ds, as_name);
4551
4552   dyn_string_append_cstr (ds, " -e ");
4553   dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP);
4554   dyn_string_append_cstr (ds, " -l ");
4555   dyn_string_append_cstr (ds, MCORE_ELF_TMP_LIB);
4556   dyn_string_append_cstr (ds, " " );
4557   dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
4558
4559   if (verbose)
4560     dyn_string_append_cstr (ds, " -v");
4561
4562   if (dontdeltemps)
4563     {
4564       dyn_string_append_cstr (ds, " -n");
4565
4566       if (dontdeltemps > 1)
4567         dyn_string_append_cstr (ds, " -n");
4568     }
4569
4570   /* XXX - FIME: ought to check/copy other command line options as well.  */
4571   run (program_name, ds->s);
4572
4573   dyn_string_delete (ds);
4574
4575   /* Step four. Feed the .exp and object files to ld -shared to create the dll.  */
4576   ds = dyn_string_new (100);
4577
4578   dyn_string_append_cstr (ds, "-shared ");
4579
4580   if (mcore_elf_linker_flags)
4581     dyn_string_append_cstr (ds, mcore_elf_linker_flags);
4582
4583   dyn_string_append_cstr (ds, " ");
4584   dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP);
4585   dyn_string_append_cstr (ds, " ");
4586   dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
4587   dyn_string_append_cstr (ds, " -o ");
4588   dyn_string_append_cstr (ds, mcore_elf_out_file);
4589
4590   run (mcore_elf_linker, ds->s);
4591
4592   dyn_string_delete (ds);
4593
4594   if (dontdeltemps == 0)
4595     unlink (MCORE_ELF_TMP_EXP);
4596
4597   if (dontdeltemps < 2)
4598     unlink (MCORE_ELF_TMP_OBJ);
4599 }
4600 #endif /* DLLTOOL_MCORE_ELF */