binutils/dlltool.c

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