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