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