binutils/dlltool.c

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