1 /* dlltool.c -- tool to generate stuff for PE style DLLs
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
23 /* This program allows you to build the files necessary to create
24 DLLs to run on a system which understands PE format image files.
27 See "Peering Inside the PE: A Tour of the Win32 Portable Executable
28 File Format", MSJ 1994, Volume 9 for more information.
29 Also see "Microsoft Portable Executable and Common Object File Format,
30 Specification 4.1" for more information.
32 A DLL contains an export table which contains the information
33 which the runtime loader needs to tie up references from a
36 The export table is generated by this program by reading
37 in a .DEF file or scanning the .a and .o files which will be in the
38 DLL. A .o file can contain information in special ".drectve" sections
39 with export information.
41 A DEF file contains any number of the following commands:
44 NAME <name> [ , <base> ]
45 The result is going to be <name>.EXE
47 LIBRARY <name> [ , <base> ]
48 The result is going to be <name>.DLL
50 EXPORTS ( ( ( <name1> [ = <name2> ] )
51 | ( <name1> = <module-name> . <external-name>))
52 [ @ <integer> ] [ NONAME ] [CONSTANT] [DATA] [PRIVATE] ) *
53 Declares name1 as an exported symbol from the
54 DLL, with optional ordinal number <integer>.
55 Or declares name1 as an alias (forward) of the function <external-name>
56 in the DLL <module-name>.
58 IMPORTS ( ( <internal-name> = <module-name> . <integer> )
59 | ( [ <internal-name> = ] <module-name> . <external-name> )) *
60 Declares that <external-name> or the exported function whose ordinal number
61 is <integer> is to be imported from the file <module-name>. If
62 <internal-name> is specified then this is the name that the imported
63 function will be refereed to in the body of the DLL.
66 Puts <string> into output .exp file in the .rdata section
68 [STACKSIZE|HEAPSIZE] <number-reserve> [ , <number-commit> ]
69 Generates --stack|--heap <number-reserve>,<number-commit>
70 in the output .drectve section. The linker will
71 see this and act upon it.
74 SECTIONS ( <sectionname> <attr>+ )*
75 <attr> = READ | WRITE | EXECUTE | SHARED
76 Generates --attr <sectionname> <attr> in the output
77 .drectve section. The linker will see this and act
81 A -export:<name> in a .drectve section in an input .o or .a
82 file to this program is equivalent to a EXPORTS <name>
87 The program generates output files with the prefix supplied
88 on the command line, or in the def file, or taken from the first
91 The .exp.s file contains the information necessary to export
92 the routines in the DLL. The .lib.s file contains the information
93 necessary to use the DLL's routines from a referencing program.
100 asm (".section .drectve");
101 asm (".ascii \"-export:adef\"");
105 printf ("hello from the dll %s\n", s);
110 printf ("hello from the dll and the other entry point %s\n", s);
114 asm (".section .drectve");
115 asm (".ascii \"-export:cdef\"");
116 asm (".ascii \"-export:ddef\"");
120 printf ("hello from the dll %s\n", s);
125 printf ("hello from the dll and the other entry point %s\n", s);
143 HEAPSIZE 0x40000, 0x2000
147 SECTIONS donkey READ WRITE
150 # Compile up the parts of the dll and the program
152 gcc -c file1.c file2.c themain.c
154 # Optional: put the dll objects into a library
155 # (you don't have to, you could name all the object
156 # files on the dlltool line)
158 ar qcv thedll.in file1.o file2.o
161 # Run this tool over the DLL's .def file and generate an exports
162 # file (thedll.o) and an imports file (thedll.a).
163 # (You may have to use -S to tell dlltool where to find the assembler).
165 dlltool --def thedll.def --output-exp thedll.o --output-lib thedll.a
167 # Build the dll with the library and the export table
169 ld -o thedll.dll thedll.o thedll.in
171 # Link the executable with the import library
173 gcc -o themain.exe themain.o thedll.a
175 This example can be extended if relocations are needed in the DLL:
177 # Compile up the parts of the dll and the program
179 gcc -c file1.c file2.c themain.c
181 # Run this tool over the DLL's .def file and generate an imports file.
183 dlltool --def thedll.def --output-lib thedll.lib
185 # Link the executable with the import library and generate a base file
188 gcc -o themain.exe themain.o thedll.lib -Wl,--base-file -Wl,themain.base
190 # Run this tool over the DLL's .def file and generate an exports file
191 # which includes the relocations from the base file.
193 dlltool --def thedll.def --base-file themain.base --output-exp thedll.exp
195 # Build the dll with file1.o, file2.o and the export table
197 ld -o thedll.dll thedll.exp file1.o file2.o */
199 /* .idata section description
201 The .idata section is the import table. It is a collection of several
202 subsections used to keep the pieces for each dll together: .idata$[234567].
203 IE: Each dll's .idata$2's are catenated together, each .idata$3's, etc.
205 .idata$2 = Import Directory Table
206 = array of IMAGE_IMPORT_DESCRIPTOR's.
208 DWORD Import Lookup Table; - pointer to .idata$4
209 DWORD TimeDateStamp; - currently always 0
210 DWORD ForwarderChain; - currently always 0
211 DWORD Name; - pointer to dll's name
212 PIMAGE_THUNK_DATA FirstThunk; - pointer to .idata$5
214 .idata$3 = null terminating entry for .idata$2.
216 .idata$4 = Import Lookup Table
217 = array of array of pointers to hint name table.
218 There is one for each dll being imported from, and each dll's set is
219 terminated by a trailing NULL.
221 .idata$5 = Import Address Table
222 = array of array of pointers to hint name table.
223 There is one for each dll being imported from, and each dll's set is
224 terminated by a trailing NULL.
225 Initially, this table is identical to the Import Lookup Table. However,
226 at load time, the loader overwrites the entries with the address of the
229 .idata$6 = Hint Name Table
230 = Array of { short, asciz } entries, one for each imported function.
231 The `short' is the function's ordinal number.
233 .idata$7 = dll name (eg: "kernel32.dll"). (.idata$6 for ppc). */
235 /* AIX requires this to be the first thing in the file. */
242 #define show_allnames 0
244 #define PAGE_SIZE ((bfd_vma) 4096)
245 #define PAGE_MASK ((bfd_vma) (-4096))
249 #include "libiberty.h"
251 #include "demangle.h"
252 #include "dyn-string.h"
255 #include "safe-ctype.h"
258 #include <sys/stat.h>
263 #include "coff/arm.h"
264 #include "coff/internal.h"
266 #ifdef DLLTOOL_MX86_64
267 #include "coff/x86_64.h"
270 /* get current BFD error message */
271 #define bfd_get_errmsg() (bfd_errmsg (bfd_get_error ()))
273 /* Forward references. */
274 static char *look_for_prog (const char *, const char *, int);
275 static char *deduce_name (const char *);
277 #ifdef DLLTOOL_MCORE_ELF
278 static void mcore_elf_cache_filename (const char *);
279 static void mcore_elf_gen_out_file (void);
282 #ifdef HAVE_SYS_WAIT_H
283 #include <sys/wait.h>
284 #else /* ! HAVE_SYS_WAIT_H */
285 #if ! defined (_WIN32) || defined (__CYGWIN32__)
287 #define WIFEXITED(w) (((w) & 0377) == 0)
290 #define WIFSIGNALED(w) (((w) & 0377) != 0177 && ((w) & ~0377) == 0)
293 #define WTERMSIG(w) ((w) & 0177)
296 #define WEXITSTATUS(w) (((w) >> 8) & 0377)
298 #else /* defined (_WIN32) && ! defined (__CYGWIN32__) */
300 #define WIFEXITED(w) (((w) & 0xff) == 0)
303 #define WIFSIGNALED(w) (((w) & 0xff) != 0 && ((w) & 0xff) != 0x7f)
306 #define WTERMSIG(w) ((w) & 0x7f)
309 #define WEXITSTATUS(w) (((w) & 0xff00) >> 8)
311 #endif /* defined (_WIN32) && ! defined (__CYGWIN32__) */
312 #endif /* ! HAVE_SYS_WAIT_H */
314 /* ifunc and ihead data structures: ttk@cygnus.com 1997
316 When IMPORT declarations are encountered in a .def file the
317 function import information is stored in a structure referenced by
318 the global variable IMPORT_LIST. The structure is a linked list
319 containing the names of the dll files each function is imported
320 from and a linked list of functions being imported from that dll
321 file. This roughly parallels the structure of the .idata section
322 in the PE object file.
324 The contents of .def file are interpreted from within the
325 process_def_file function. Every time an IMPORT declaration is
326 encountered, it is broken up into its component parts and passed to
327 def_import. IMPORT_LIST is initialized to NULL in function main. */
329 typedef struct ifunct
331 char * name; /* Name of function being imported. */
332 char * its_name; /* Optional import table symbol name. */
333 int ord; /* Two-byte ordinal value associated with function. */
337 typedef struct iheadt
339 char * dllname; /* Name of dll file imported from. */
340 long nfuncs; /* Number of functions in list. */
341 struct ifunct *funchead; /* First function in list. */
342 struct ifunct *functail; /* Last function in list. */
343 struct iheadt *next; /* Next dll file in list. */
346 /* Structure containing all import information as defined in .def file
347 (qv "ihead structure"). */
349 static iheadtype *import_list = NULL;
350 static char *as_name = NULL;
351 static char * as_flags = "";
352 static char *tmp_prefix;
353 static int no_idata4;
354 static int no_idata5;
355 static char *exp_name;
356 static char *imp_name;
357 static char *delayimp_name;
358 static char *identify_imp_name;
359 static bfd_boolean identify_strict;
361 /* Types used to implement a linked list of dllnames associated
362 with the specified import lib. Used by the identify_* code.
363 The head entry is acts as a sentinal node and is always empty
364 (head->dllname is NULL). */
365 typedef struct dll_name_list_node_t
368 struct dll_name_list_node_t * next;
369 } dll_name_list_node_type;
371 typedef struct dll_name_list_t
373 dll_name_list_node_type * head;
374 dll_name_list_node_type * tail;
375 } dll_name_list_type;
377 /* Types used to pass data to iterator functions. */
378 typedef struct symname_search_data_t
380 const char * symname;
382 } symname_search_data_type;
384 typedef struct identify_data_t
386 dll_name_list_type * list;
387 bfd_boolean ms_style_implib;
388 } identify_data_type;
391 static char *head_label;
392 static char *imp_name_lab;
393 static char *dll_name;
394 static int add_indirect = 0;
395 static int add_underscore = 0;
396 static int add_stdcall_underscore = 0;
397 static int dontdeltemps = 0;
399 /* TRUE if we should export all symbols. Otherwise, we only export
400 symbols listed in .drectve sections or in the def file. */
401 static bfd_boolean export_all_symbols;
403 /* TRUE if we should exclude the symbols in DEFAULT_EXCLUDES when
404 exporting all symbols. */
405 static bfd_boolean do_default_excludes = TRUE;
407 static bfd_boolean use_nul_prefixed_import_tables = FALSE;
409 /* Default symbols to exclude when exporting all the symbols. */
410 static const char *default_excludes = "DllMain@12,DllEntryPoint@0,impure_ptr";
412 /* TRUE if we should add __imp_<SYMBOL> to import libraries for backward
413 compatibility to old Cygwin releases. */
414 static bfd_boolean create_compat_implib;
416 /* TRUE if we have to write PE+ import libraries. */
417 static bfd_boolean create_for_pep;
419 static char *def_file;
421 extern char * program_name;
425 static int add_stdcall_alias;
426 static const char *ext_prefix_alias;
428 static FILE *output_def;
429 static FILE *base_file;
431 #ifdef DLLTOOL_DEFAULT_ARM
432 static const char *mname = "arm";
435 #ifdef DLLTOOL_DEFAULT_ARM_EPOC
436 static const char *mname = "arm-epoc";
439 #ifdef DLLTOOL_DEFAULT_ARM_WINCE
440 static const char *mname = "arm-wince";
443 #ifdef DLLTOOL_DEFAULT_I386
444 static const char *mname = "i386";
447 #ifdef DLLTOOL_DEFAULT_MX86_64
448 static const char *mname = "i386:x86-64";
451 #ifdef DLLTOOL_DEFAULT_PPC
452 static const char *mname = "ppc";
455 #ifdef DLLTOOL_DEFAULT_SH
456 static const char *mname = "sh";
459 #ifdef DLLTOOL_DEFAULT_MIPS
460 static const char *mname = "mips";
463 #ifdef DLLTOOL_DEFAULT_MCORE
464 static const char * mname = "mcore-le";
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;
473 #define DRECTVE_SECTION_NAME ((machine == MMCORE_ELF || machine == MMCORE_ELF_LE) ? ".exports" : ".drectve")
476 #ifndef DRECTVE_SECTION_NAME
477 #define DRECTVE_SECTION_NAME ".drectve"
480 /* What's the right name for this ? */
483 /* External name alias numbering starts here. */
484 #define PREFIX_ALIAS_BASE 20000
487 char *tmp_head_s_buf;
488 char *tmp_head_o_buf;
489 char *tmp_tail_s_buf;
490 char *tmp_tail_o_buf;
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")
500 /* This bit of assembly does jmp * .... */
501 static const unsigned char i386_jtab[] =
503 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
506 static const unsigned char i386_dljtab[] =
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 */
513 static const unsigned char arm_jtab[] =
515 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
516 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
520 static const unsigned char arm_interwork_jtab[] =
522 0x04, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
523 0x00, 0xc0, 0x9c, 0xe5, /* ldr ip, [ip] */
524 0x1c, 0xff, 0x2f, 0xe1, /* bx ip */
528 static const unsigned char thumb_jtab[] =
530 0x40, 0xb4, /* push {r6} */
531 0x02, 0x4e, /* ldr r6, [pc, #8] */
532 0x36, 0x68, /* ldr r6, [r6] */
533 0xb4, 0x46, /* mov ip, r6 */
534 0x40, 0xbc, /* pop {r6} */
535 0x60, 0x47, /* bx ip */
539 static const unsigned char mcore_be_jtab[] =
541 0x71, 0x02, /* lrw r1,2 */
542 0x81, 0x01, /* ld.w r1,(r1,0) */
543 0x00, 0xC1, /* jmp r1 */
544 0x12, 0x00, /* nop */
545 0x00, 0x00, 0x00, 0x00 /* <address> */
548 static const unsigned char mcore_le_jtab[] =
550 0x02, 0x71, /* lrw r1,2 */
551 0x01, 0x81, /* ld.w r1,(r1,0) */
552 0xC1, 0x00, /* jmp r1 */
553 0x00, 0x12, /* nop */
554 0x00, 0x00, 0x00, 0x00 /* <address> */
557 /* This is the glue sequence for PowerPC PE. There is a
558 tocrel16-tocdefn reloc against the first instruction.
559 We also need a IMGLUE reloc against the glue function
560 to restore the toc saved by the third instruction in
562 static const unsigned char ppc_jtab[] =
564 0x00, 0x00, 0x62, 0x81, /* lwz r11,0(r2) */
565 /* Reloc TOCREL16 __imp_xxx */
566 0x00, 0x00, 0x8B, 0x81, /* lwz r12,0(r11) */
567 0x04, 0x00, 0x41, 0x90, /* stw r2,4(r1) */
568 0xA6, 0x03, 0x89, 0x7D, /* mtctr r12 */
569 0x04, 0x00, 0x4B, 0x80, /* lwz r2,4(r11) */
570 0x20, 0x04, 0x80, 0x4E /* bctr */
574 /* The glue instruction, picks up the toc from the stw in
575 the above code: "lwz r2,4(r1)". */
576 static bfd_vma ppc_glue_insn = 0x80410004;
579 static const char i386_trampoline[] =
583 "\tpushl $__DELAY_IMPORT_DESCRIPTOR_%s\n"
584 "\tcall ___delayLoadHelper2@8\n"
592 const char *how_byte;
593 const char *how_short;
594 const char *how_long;
595 const char *how_asciz;
596 const char *how_comment;
597 const char *how_jump;
598 const char *how_global;
599 const char *how_space;
600 const char *how_align_short;
601 const char *how_align_long;
602 const char *how_default_as_switches;
603 const char *how_bfd_target;
604 enum bfd_architecture how_bfd_arch;
605 const unsigned char *how_jtab;
606 int how_jtab_size; /* Size of the jtab entry. */
607 int how_jtab_roff; /* Offset into it for the ind 32 reloc into idata 5. */
608 const unsigned char *how_dljtab;
609 int how_dljtab_size; /* Size of the dljtab entry. */
610 int how_dljtab_roff1; /* Offset for the ind 32 reloc into idata 5. */
611 int how_dljtab_roff2; /* Offset for the ind 32 reloc into idata 5. */
612 int how_dljtab_roff3; /* Offset for the ind 32 reloc into idata 5. */
613 const char *trampoline;
616 static const struct mac
621 "arm", ".byte", ".short", ".long", ".asciz", "@",
622 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
623 ".global", ".space", ".align\t2",".align\t4", "-mapcs-32",
624 "pe-arm-little", bfd_arch_arm,
625 arm_jtab, sizeof (arm_jtab), 8,
631 "i386", ".byte", ".short", ".long", ".asciz", "#",
632 "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
633 "pe-i386",bfd_arch_i386,
634 i386_jtab, sizeof (i386_jtab), 2,
635 i386_dljtab, sizeof (i386_dljtab), 2, 7, 12, i386_trampoline
640 "ppc", ".byte", ".short", ".long", ".asciz", "#",
641 "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
642 "pe-powerpcle",bfd_arch_powerpc,
643 ppc_jtab, sizeof (ppc_jtab), 0,
649 "thumb", ".byte", ".short", ".long", ".asciz", "@",
650 "push\t{r6}\n\tldr\tr6, [pc, #8]\n\tldr\tr6, [r6]\n\tmov\tip, r6\n\tpop\t{r6}\n\tbx\tip",
651 ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
652 "pe-arm-little", bfd_arch_arm,
653 thumb_jtab, sizeof (thumb_jtab), 12,
657 #define MARM_INTERWORK 4
659 "arm_interwork", ".byte", ".short", ".long", ".asciz", "@",
660 "ldr\tip,[pc]\n\tldr\tip,[ip]\n\tbx\tip\n\t.long",
661 ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
662 "pe-arm-little", bfd_arch_arm,
663 arm_interwork_jtab, sizeof (arm_interwork_jtab), 12,
669 "mcore-be", ".byte", ".short", ".long", ".asciz", "//",
670 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
671 ".global", ".space", ".align\t2",".align\t4", "",
672 "pe-mcore-big", bfd_arch_mcore,
673 mcore_be_jtab, sizeof (mcore_be_jtab), 8,
679 "mcore-le", ".byte", ".short", ".long", ".asciz", "//",
680 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
681 ".global", ".space", ".align\t2",".align\t4", "-EL",
682 "pe-mcore-little", bfd_arch_mcore,
683 mcore_le_jtab, sizeof (mcore_le_jtab), 8,
689 "mcore-elf-be", ".byte", ".short", ".long", ".asciz", "//",
690 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
691 ".global", ".space", ".align\t2",".align\t4", "",
692 "elf32-mcore-big", bfd_arch_mcore,
693 mcore_be_jtab, sizeof (mcore_be_jtab), 8,
698 #define MMCORE_ELF_LE 8
699 "mcore-elf-le", ".byte", ".short", ".long", ".asciz", "//",
700 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
701 ".global", ".space", ".align\t2",".align\t4", "-EL",
702 "elf32-mcore-little", bfd_arch_mcore,
703 mcore_le_jtab, sizeof (mcore_le_jtab), 8,
709 "arm-epoc", ".byte", ".short", ".long", ".asciz", "@",
710 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
711 ".global", ".space", ".align\t2",".align\t4", "",
712 "epoc-pe-arm-little", bfd_arch_arm,
713 arm_jtab, sizeof (arm_jtab), 8,
718 #define MARM_WINCE 10
719 "arm-wince", ".byte", ".short", ".long", ".asciz", "@",
720 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
721 ".global", ".space", ".align\t2",".align\t4", "-mapcs-32",
722 "pe-arm-wince-little", bfd_arch_arm,
723 arm_jtab, sizeof (arm_jtab), 8,
729 "i386:x86-64", ".byte", ".short", ".long", ".asciz", "#",
730 "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
731 "pe-x86-64",bfd_arch_i386,
732 i386_jtab, sizeof (i386_jtab), 2,
733 i386_dljtab, sizeof (i386_dljtab), 2, 7, 12, i386_trampoline
736 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
746 typedef struct export
749 const char *internal_name;
750 const char *import_name;
751 const char *its_name;
754 int noname; /* Don't put name in image file. */
755 int private; /* Don't put reference in import lib. */
758 int forward; /* Number of forward label, 0 means no forward. */
763 /* A list of symbols which we should not export. */
767 struct string_list *next;
771 static struct string_list *excludes;
773 static const char *rvaafter (int);
774 static const char *rvabefore (int);
775 static const char *asm_prefix (int, const char *);
776 static void process_def_file (const char *);
777 static void new_directive (char *);
778 static void append_import (const char *, const char *, int, const char *);
779 static void run (const char *, char *);
780 static void scan_drectve_symbols (bfd *);
781 static void scan_filtered_symbols (bfd *, void *, long, unsigned int);
782 static void add_excludes (const char *);
783 static bfd_boolean match_exclude (const char *);
784 static void set_default_excludes (void);
785 static long filter_symbols (bfd *, void *, long, unsigned int);
786 static void scan_all_symbols (bfd *);
787 static void scan_open_obj_file (bfd *);
788 static void scan_obj_file (const char *);
789 static void dump_def_info (FILE *);
790 static int sfunc (const void *, const void *);
791 static void flush_page (FILE *, bfd_vma *, bfd_vma, int);
792 static void gen_def_file (void);
793 static void generate_idata_ofile (FILE *);
794 static void assemble_file (const char *, const char *);
795 static void gen_exp_file (void);
796 static const char *xlate (const char *);
797 static char *make_label (const char *, const char *);
798 static char *make_imp_label (const char *, const char *);
799 static bfd *make_one_lib_file (export_type *, int, int);
800 static bfd *make_head (void);
801 static bfd *make_tail (void);
802 static bfd *make_delay_head (void);
803 static void gen_lib_file (int);
804 static void dll_name_list_append (dll_name_list_type *, bfd_byte *);
805 static int dll_name_list_count (dll_name_list_type *);
806 static void dll_name_list_print (dll_name_list_type *);
807 static void dll_name_list_free_contents (dll_name_list_node_type *);
808 static void dll_name_list_free (dll_name_list_type *);
809 static dll_name_list_type * dll_name_list_create (void);
810 static void identify_dll_for_implib (void);
811 static void identify_search_archive
812 (bfd *, void (*) (bfd *, bfd *, void *), void *);
813 static void identify_search_member (bfd *, bfd *, void *);
814 static bfd_boolean identify_process_section_p (asection *, bfd_boolean);
815 static void identify_search_section (bfd *, asection *, void *);
816 static void identify_member_contains_symname (bfd *, bfd *, void *);
818 static int pfunc (const void *, const void *);
819 static int nfunc (const void *, const void *);
820 static void remove_null_names (export_type **);
821 static void process_duplicates (export_type **);
822 static void fill_ordinals (export_type **);
823 static void mangle_defs (void);
824 static void usage (FILE *, int);
825 static void inform (const char *, ...) ATTRIBUTE_PRINTF_1;
826 static void set_dll_name_from_def (const char *name, char is_dll);
829 prefix_encode (char *start, unsigned code)
831 static char alpha[26] = "abcdefghijklmnopqrstuvwxyz";
835 p = strchr (buf, '\0');
837 *p++ = alpha[code % sizeof (alpha)];
838 while ((code /= sizeof (alpha)) != 0);
844 dlltmp (char **buf, const char *fmt)
848 *buf = malloc (strlen (tmp_prefix) + 64);
849 sprintf (*buf, fmt, tmp_prefix);
855 inform VPARAMS ((const char * message, ...))
857 VA_OPEN (args, message);
858 VA_FIXEDARG (args, const char *, message);
863 report (message, args);
869 rvaafter (int machine)
887 /* xgettext:c-format */
888 fatal (_("Internal error: Unknown machine type: %d"), machine);
895 rvabefore (int machine)
913 /* xgettext:c-format */
914 fatal (_("Internal error: Unknown machine type: %d"), machine);
921 asm_prefix (int machine, const char *name)
938 /* Symbol names starting with ? do not have a leading underscore. */
939 if (name && *name == '?')
944 /* xgettext:c-format */
945 fatal (_("Internal error: Unknown machine type: %d"), machine);
951 #define ASM_BYTE mtable[machine].how_byte
952 #define ASM_SHORT mtable[machine].how_short
953 #define ASM_LONG mtable[machine].how_long
954 #define ASM_TEXT mtable[machine].how_asciz
955 #define ASM_C mtable[machine].how_comment
956 #define ASM_JUMP mtable[machine].how_jump
957 #define ASM_GLOBAL mtable[machine].how_global
958 #define ASM_SPACE mtable[machine].how_space
959 #define ASM_ALIGN_SHORT mtable[machine].how_align_short
960 #define ASM_RVA_BEFORE rvabefore (machine)
961 #define ASM_RVA_AFTER rvaafter (machine)
962 #define ASM_PREFIX(NAME) asm_prefix (machine, (NAME))
963 #define ASM_ALIGN_LONG mtable[machine].how_align_long
964 #define HOW_BFD_READ_TARGET 0 /* Always default. */
965 #define HOW_BFD_WRITE_TARGET mtable[machine].how_bfd_target
966 #define HOW_BFD_ARCH mtable[machine].how_bfd_arch
967 #define HOW_JTAB (delay ? mtable[machine].how_dljtab \
968 : mtable[machine].how_jtab)
969 #define HOW_JTAB_SIZE (delay ? mtable[machine].how_dljtab_size \
970 : mtable[machine].how_jtab_size)
971 #define HOW_JTAB_ROFF (delay ? mtable[machine].how_dljtab_roff1 \
972 : mtable[machine].how_jtab_roff)
973 #define HOW_JTAB_ROFF2 (delay ? mtable[machine].how_dljtab_roff2 : 0)
974 #define HOW_JTAB_ROFF3 (delay ? mtable[machine].how_dljtab_roff3 : 0)
975 #define ASM_SWITCHES mtable[machine].how_default_as_switches
980 process_def_file (const char *name)
982 FILE *f = fopen (name, FOPEN_RT);
985 /* xgettext:c-format */
986 fatal (_("Can't open def file: %s"), name);
990 /* xgettext:c-format */
991 inform (_("Processing def file: %s"), name);
995 inform (_("Processed def file"));
998 /**********************************************************************/
1000 /* Communications with the parser. */
1002 static int d_nfuncs; /* Number of functions exported. */
1003 static int d_named_nfuncs; /* Number of named functions exported. */
1004 static int d_low_ord; /* Lowest ordinal index. */
1005 static int d_high_ord; /* Highest ordinal index. */
1006 static export_type *d_exports; /* List of exported functions. */
1007 static export_type **d_exports_lexically; /* Vector of exported functions in alpha order. */
1008 static dlist_type *d_list; /* Descriptions. */
1009 static dlist_type *a_list; /* Stuff to go in directives. */
1010 static int d_nforwards = 0; /* Number of forwarded exports. */
1012 static int d_is_dll;
1013 static int d_is_exe;
1016 yyerror (const char * err ATTRIBUTE_UNUSED)
1018 /* xgettext:c-format */
1019 non_fatal (_("Syntax error in def file %s:%d"), def_file, linenumber);
1025 def_exports (const char *name, const char *internal_name, int ordinal,
1026 int noname, int constant, int data, int private,
1027 const char *its_name)
1029 struct export *p = (struct export *) xmalloc (sizeof (*p));
1032 p->internal_name = internal_name ? internal_name : name;
1033 p->its_name = its_name;
1034 p->import_name = name;
1035 p->ordinal = ordinal;
1036 p->constant = constant;
1038 p->private = private;
1040 p->next = d_exports;
1044 if ((internal_name != NULL)
1045 && (strchr (internal_name, '.') != NULL))
1046 p->forward = ++d_nforwards;
1048 p->forward = 0; /* no forward */
1052 set_dll_name_from_def (const char *name, char is_dll)
1054 const char *image_basename = lbasename (name);
1055 if (image_basename != name)
1056 non_fatal (_("%s: Path components stripped from image name, '%s'."),
1058 /* Append the default suffix, if none specified. */
1059 if (strchr (image_basename, '.') == 0)
1061 const char * suffix = is_dll ? ".dll" : ".exe";
1063 dll_name = xmalloc (strlen (image_basename) + strlen (suffix) + 1);
1064 sprintf (dll_name, "%s%s", image_basename, suffix);
1067 dll_name = xstrdup (image_basename);
1071 def_name (const char *name, int base)
1073 /* xgettext:c-format */
1074 inform (_("NAME: %s base: %x"), name, base);
1077 non_fatal (_("Can't have LIBRARY and NAME"));
1079 /* If --dllname not provided, use the one in the DEF file.
1080 FIXME: Is this appropriate for executables? */
1082 set_dll_name_from_def (name, 0);
1087 def_library (const char *name, int base)
1089 /* xgettext:c-format */
1090 inform (_("LIBRARY: %s base: %x"), name, base);
1093 non_fatal (_("Can't have LIBRARY and NAME"));
1095 /* If --dllname not provided, use the one in the DEF file. */
1097 set_dll_name_from_def (name, 1);
1102 def_description (const char *desc)
1104 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
1105 d->text = xstrdup (desc);
1111 new_directive (char *dir)
1113 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
1114 d->text = xstrdup (dir);
1120 def_heapsize (int reserve, int commit)
1124 sprintf (b, "-heap 0x%x,0x%x ", reserve, commit);
1126 sprintf (b, "-heap 0x%x ", reserve);
1127 new_directive (xstrdup (b));
1131 def_stacksize (int reserve, int commit)
1135 sprintf (b, "-stack 0x%x,0x%x ", reserve, commit);
1137 sprintf (b, "-stack 0x%x ", reserve);
1138 new_directive (xstrdup (b));
1141 /* append_import simply adds the given import definition to the global
1142 import_list. It is used by def_import. */
1145 append_import (const char *symbol_name, const char *dll_name, int func_ordinal,
1146 const char *its_name)
1151 for (pq = &import_list; *pq != NULL; pq = &(*pq)->next)
1153 if (strcmp ((*pq)->dllname, dll_name) == 0)
1156 q->functail->next = xmalloc (sizeof (ifunctype));
1157 q->functail = q->functail->next;
1158 q->functail->ord = func_ordinal;
1159 q->functail->name = xstrdup (symbol_name);
1160 q->functail->its_name = (its_name ? xstrdup (its_name) : NULL);
1161 q->functail->next = NULL;
1167 q = xmalloc (sizeof (iheadtype));
1168 q->dllname = xstrdup (dll_name);
1170 q->funchead = xmalloc (sizeof (ifunctype));
1171 q->functail = q->funchead;
1173 q->functail->name = xstrdup (symbol_name);
1174 q->functail->its_name = (its_name ? xstrdup (its_name) : NULL);
1175 q->functail->ord = func_ordinal;
1176 q->functail->next = NULL;
1181 /* def_import is called from within defparse.y when an IMPORT
1182 declaration is encountered. Depending on the form of the
1183 declaration, the module name may or may not need ".dll" to be
1184 appended to it, the name of the function may be stored in internal
1185 or entry, and there may or may not be an ordinal value associated
1188 /* A note regarding the parse modes:
1189 In defparse.y we have to accept import declarations which follow
1190 any one of the following forms:
1191 <func_name_in_app> = <dll_name>.<func_name_in_dll>
1192 <func_name_in_app> = <dll_name>.<number>
1193 <dll_name>.<func_name_in_dll>
1195 Furthermore, the dll's name may or may not end with ".dll", which
1196 complicates the parsing a little. Normally the dll's name is
1197 passed to def_import() in the "module" parameter, but when it ends
1198 with ".dll" it gets passed in "module" sans ".dll" and that needs
1201 def_import gets five parameters:
1202 APP_NAME - the name of the function in the application, if
1203 present, or NULL if not present.
1204 MODULE - the name of the dll, possibly sans extension (ie, '.dll').
1205 DLLEXT - the extension of the dll, if present, NULL if not present.
1206 ENTRY - the name of the function in the dll, if present, or NULL.
1207 ORD_VAL - the numerical tag of the function in the dll, if present,
1208 or NULL. Exactly one of <entry> or <ord_val> must be
1209 present (i.e., not NULL). */
1212 def_import (const char *app_name, const char *module, const char *dllext,
1213 const char *entry, int ord_val, const char *its_name)
1215 const char *application_name;
1219 application_name = entry;
1222 if (app_name != NULL)
1223 application_name = app_name;
1225 application_name = "";
1230 buf = (char *) alloca (strlen (module) + strlen (dllext) + 2);
1231 sprintf (buf, "%s.%s", module, dllext);
1235 append_import (application_name, module, ord_val, its_name);
1239 def_version (int major, int minor)
1241 printf ("VERSION %d.%d\n", major, minor);
1245 def_section (const char *name, int attr)
1260 sprintf (buf, "-attr %s %s", name, atts);
1261 new_directive (xstrdup (buf));
1268 def_section ("CODE", attr);
1274 def_section ("DATA", attr);
1277 /**********************************************************************/
1280 run (const char *what, char *args)
1283 int pid, wait_status;
1286 char *errmsg_fmt, *errmsg_arg;
1287 char *temp_base = choose_temp_base ();
1289 inform ("run: %s %s", what, args);
1291 /* Count the args */
1293 for (s = args; *s; s++)
1297 argv = alloca (sizeof (char *) * (i + 3));
1306 while (*s != ' ' && *s != 0)
1314 pid = pexecute (argv[0], (char * const *) argv, program_name, temp_base,
1315 &errmsg_fmt, &errmsg_arg, PEXECUTE_ONE | PEXECUTE_SEARCH);
1319 inform ("%s", strerror (errno));
1321 fatal (errmsg_fmt, errmsg_arg);
1324 pid = pwait (pid, & wait_status, 0);
1328 /* xgettext:c-format */
1329 fatal (_("wait: %s"), strerror (errno));
1331 else if (WIFSIGNALED (wait_status))
1333 /* xgettext:c-format */
1334 fatal (_("subprocess got fatal signal %d"), WTERMSIG (wait_status));
1336 else if (WIFEXITED (wait_status))
1338 if (WEXITSTATUS (wait_status) != 0)
1339 /* xgettext:c-format */
1340 non_fatal (_("%s exited with status %d"),
1341 what, WEXITSTATUS (wait_status));
1347 /* Look for a list of symbols to export in the .drectve section of
1348 ABFD. Pass each one to def_exports. */
1351 scan_drectve_symbols (bfd *abfd)
1359 /* Look for .drectve's */
1360 s = bfd_get_section_by_name (abfd, DRECTVE_SECTION_NAME);
1365 size = bfd_get_section_size (s);
1366 buf = xmalloc (size);
1368 bfd_get_section_contents (abfd, s, buf, 0, size);
1370 /* xgettext:c-format */
1371 inform (_("Sucking in info from %s section in %s"),
1372 DRECTVE_SECTION_NAME, bfd_get_filename (abfd));
1374 /* Search for -export: strings. The exported symbols can optionally
1375 have type tags (eg., -export:foo,data), so handle those as well.
1376 Currently only data tag is supported. */
1382 && CONST_STRNEQ (p, "-export:"))
1386 flagword flags = BSF_FUNCTION;
1390 while (p < e && *p != ',' && *p != ' ' && *p != '-')
1392 c = xmalloc (p - name + 1);
1393 memcpy (c, name, p - name);
1395 if (p < e && *p == ',') /* found type tag. */
1397 char *tag_start = ++p;
1398 while (p < e && *p != ' ' && *p != '-')
1400 if (CONST_STRNEQ (tag_start, "data"))
1401 flags &= ~BSF_FUNCTION;
1404 /* FIXME: The 5th arg is for the `constant' field.
1405 What should it be? Not that it matters since it's not
1406 currently useful. */
1407 def_exports (c, 0, -1, 0, 0, ! (flags & BSF_FUNCTION), 0, NULL);
1409 if (add_stdcall_alias && strchr (c, '@'))
1411 int lead_at = (*c == '@') ;
1412 char *exported_name = xstrdup (c + lead_at);
1413 char *atsym = strchr (exported_name, '@');
1415 /* Note: stdcall alias symbols can never be data. */
1416 def_exports (exported_name, xstrdup (c), -1, 0, 0, 0, 0, NULL);
1425 /* Look through the symbols in MINISYMS, and add each one to list of
1426 symbols to export. */
1429 scan_filtered_symbols (bfd *abfd, void *minisyms, long symcount,
1433 bfd_byte *from, *fromend;
1435 store = bfd_make_empty_symbol (abfd);
1437 bfd_fatal (bfd_get_filename (abfd));
1439 from = (bfd_byte *) minisyms;
1440 fromend = from + symcount * size;
1441 for (; from < fromend; from += size)
1444 const char *symbol_name;
1446 sym = bfd_minisymbol_to_symbol (abfd, FALSE, from, store);
1448 bfd_fatal (bfd_get_filename (abfd));
1450 symbol_name = bfd_asymbol_name (sym);
1451 if (bfd_get_symbol_leading_char (abfd) == symbol_name[0])
1454 def_exports (xstrdup (symbol_name) , 0, -1, 0, 0,
1455 ! (sym->flags & BSF_FUNCTION), 0, NULL);
1457 if (add_stdcall_alias && strchr (symbol_name, '@'))
1459 int lead_at = (*symbol_name == '@');
1460 char *exported_name = xstrdup (symbol_name + lead_at);
1461 char *atsym = strchr (exported_name, '@');
1463 /* Note: stdcall alias symbols can never be data. */
1464 def_exports (exported_name, xstrdup (symbol_name), -1, 0, 0, 0, 0, NULL);
1469 /* Add a list of symbols to exclude. */
1472 add_excludes (const char *new_excludes)
1475 char *exclude_string;
1477 local_copy = xstrdup (new_excludes);
1479 exclude_string = strtok (local_copy, ",:");
1480 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
1482 struct string_list *new_exclude;
1484 new_exclude = ((struct string_list *)
1485 xmalloc (sizeof (struct string_list)));
1486 new_exclude->string = (char *) xmalloc (strlen (exclude_string) + 2);
1487 /* Don't add a leading underscore for fastcall symbols. */
1488 if (*exclude_string == '@')
1489 sprintf (new_exclude->string, "%s", exclude_string);
1491 sprintf (new_exclude->string, "_%s", exclude_string);
1492 new_exclude->next = excludes;
1493 excludes = new_exclude;
1495 /* xgettext:c-format */
1496 inform (_("Excluding symbol: %s"), exclude_string);
1502 /* See if STRING is on the list of symbols to exclude. */
1505 match_exclude (const char *string)
1507 struct string_list *excl_item;
1509 for (excl_item = excludes; excl_item; excl_item = excl_item->next)
1510 if (strcmp (string, excl_item->string) == 0)
1515 /* Add the default list of symbols to exclude. */
1518 set_default_excludes (void)
1520 add_excludes (default_excludes);
1523 /* Choose which symbols to export. */
1526 filter_symbols (bfd *abfd, void *minisyms, long symcount, unsigned int size)
1528 bfd_byte *from, *fromend, *to;
1531 store = bfd_make_empty_symbol (abfd);
1533 bfd_fatal (bfd_get_filename (abfd));
1535 from = (bfd_byte *) minisyms;
1536 fromend = from + symcount * size;
1537 to = (bfd_byte *) minisyms;
1539 for (; from < fromend; from += size)
1544 sym = bfd_minisymbol_to_symbol (abfd, FALSE, (const void *) from, store);
1546 bfd_fatal (bfd_get_filename (abfd));
1548 /* Check for external and defined only symbols. */
1549 keep = (((sym->flags & BSF_GLOBAL) != 0
1550 || (sym->flags & BSF_WEAK) != 0
1551 || bfd_is_com_section (sym->section))
1552 && ! bfd_is_und_section (sym->section));
1554 keep = keep && ! match_exclude (sym->name);
1558 memcpy (to, from, size);
1563 return (to - (bfd_byte *) minisyms) / size;
1566 /* Export all symbols in ABFD, except for ones we were told not to
1570 scan_all_symbols (bfd *abfd)
1576 /* Ignore bfds with an import descriptor table. We assume that any
1577 such BFD contains symbols which are exported from another DLL,
1578 and we don't want to reexport them from here. */
1579 if (bfd_get_section_by_name (abfd, ".idata$4"))
1582 if (! (bfd_get_file_flags (abfd) & HAS_SYMS))
1584 /* xgettext:c-format */
1585 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1589 symcount = bfd_read_minisymbols (abfd, FALSE, &minisyms, &size);
1591 bfd_fatal (bfd_get_filename (abfd));
1595 /* xgettext:c-format */
1596 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1600 /* Discard the symbols we don't want to export. It's OK to do this
1601 in place; we'll free the storage anyway. */
1603 symcount = filter_symbols (abfd, minisyms, symcount, size);
1604 scan_filtered_symbols (abfd, minisyms, symcount, size);
1609 /* Look at the object file to decide which symbols to export. */
1612 scan_open_obj_file (bfd *abfd)
1614 if (export_all_symbols)
1615 scan_all_symbols (abfd);
1617 scan_drectve_symbols (abfd);
1619 /* FIXME: we ought to read in and block out the base relocations. */
1621 /* xgettext:c-format */
1622 inform (_("Done reading %s"), bfd_get_filename (abfd));
1626 scan_obj_file (const char *filename)
1628 bfd * f = bfd_openr (filename, 0);
1631 /* xgettext:c-format */
1632 fatal (_("Unable to open object file: %s: %s"), filename, bfd_get_errmsg ());
1634 /* xgettext:c-format */
1635 inform (_("Scanning object file %s"), filename);
1637 if (bfd_check_format (f, bfd_archive))
1639 bfd *arfile = bfd_openr_next_archived_file (f, 0);
1642 if (bfd_check_format (arfile, bfd_object))
1643 scan_open_obj_file (arfile);
1645 arfile = bfd_openr_next_archived_file (f, arfile);
1648 #ifdef DLLTOOL_MCORE_ELF
1649 if (mcore_elf_out_file)
1650 inform (_("Cannot produce mcore-elf dll from archive file: %s"), filename);
1653 else if (bfd_check_format (f, bfd_object))
1655 scan_open_obj_file (f);
1657 #ifdef DLLTOOL_MCORE_ELF
1658 if (mcore_elf_out_file)
1659 mcore_elf_cache_filename (filename);
1669 dump_def_info (FILE *f)
1673 fprintf (f, "%s ", ASM_C);
1674 for (i = 0; oav[i]; i++)
1675 fprintf (f, "%s ", oav[i]);
1677 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1679 fprintf (f, "%s %d = %s %s @ %d %s%s%s%s%s%s\n",
1685 exp->noname ? "NONAME " : "",
1686 exp->private ? "PRIVATE " : "",
1687 exp->constant ? "CONSTANT" : "",
1688 exp->data ? "DATA" : "",
1689 exp->its_name ? " ==" : "",
1690 exp->its_name ? exp->its_name : "");
1694 /* Generate the .exp file. */
1697 sfunc (const void *a, const void *b)
1699 if (*(const bfd_vma *) a == *(const bfd_vma *) b)
1702 return ((*(const bfd_vma *) a > *(const bfd_vma *) b) ? 1 : -1);
1706 flush_page (FILE *f, bfd_vma *need, bfd_vma page_addr, int on_page)
1710 /* Flush this page. */
1711 fprintf (f, "\t%s\t0x%08x\t%s Starting RVA for chunk\n",
1715 fprintf (f, "\t%s\t0x%x\t%s Size of block\n",
1717 (on_page * 2) + (on_page & 1) * 2 + 8,
1720 for (i = 0; i < on_page; i++)
1722 bfd_vma needed = need[i];
1726 if (!create_for_pep)
1728 /* Relocation via HIGHLOW. */
1729 needed = ((needed - page_addr) | 0x3000) & 0xffff;
1733 /* Relocation via DIR64. */
1734 needed = ((needed - page_addr) | 0xa000) & 0xffff;
1738 fprintf (f, "\t%s\t0x%lx\n", ASM_SHORT, (long) needed);
1743 fprintf (f, "\t%s\t0x%x\n", ASM_SHORT, 0 | 0x0000);
1752 inform (_("Adding exports to output file"));
1754 fprintf (output_def, ";");
1755 for (i = 0; oav[i]; i++)
1756 fprintf (output_def, " %s", oav[i]);
1758 fprintf (output_def, "\nEXPORTS\n");
1760 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1762 char *quote = strchr (exp->name, '.') ? "\"" : "";
1763 char *res = cplus_demangle (exp->internal_name, DMGL_ANSI | DMGL_PARAMS);
1767 fprintf (output_def,";\t%s\n", res);
1771 if (strcmp (exp->name, exp->internal_name) == 0)
1773 fprintf (output_def, "\t%s%s%s @ %d%s%s%s%s%s\n",
1778 exp->noname ? " NONAME" : "",
1779 exp->private ? "PRIVATE " : "",
1780 exp->data ? " DATA" : "",
1781 exp->its_name ? " ==" : "",
1782 exp->its_name ? exp->its_name : "");
1786 char * quote1 = strchr (exp->internal_name, '.') ? "\"" : "";
1788 fprintf (output_def, "\t%s%s%s = %s%s%s @ %d%s%s%s%s%s\n",
1796 exp->noname ? " NONAME" : "",
1797 exp->private ? "PRIVATE " : "",
1798 exp->data ? " DATA" : "",
1799 exp->its_name ? " ==" : "",
1800 exp->its_name ? exp->its_name : "");
1804 inform (_("Added exports to output file"));
1807 /* generate_idata_ofile generates the portable assembly source code
1808 for the idata sections. It appends the source code to the end of
1812 generate_idata_ofile (FILE *filvar)
1820 if (import_list == NULL)
1823 fprintf (filvar, "%s Import data sections\n", ASM_C);
1824 fprintf (filvar, "\n\t.section\t.idata$2\n");
1825 fprintf (filvar, "\t%s\tdoi_idata\n", ASM_GLOBAL);
1826 fprintf (filvar, "doi_idata:\n");
1829 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1831 fprintf (filvar, "\t%slistone%d%s\t%s %s\n",
1832 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER,
1833 ASM_C, headptr->dllname);
1834 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1835 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1836 fprintf (filvar, "\t%sdllname%d%s\n",
1837 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1838 fprintf (filvar, "\t%slisttwo%d%s\n\n",
1839 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1843 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL record at */
1844 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* end of idata$2 */
1845 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* section */
1846 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1847 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1849 fprintf (filvar, "\n\t.section\t.idata$4\n");
1851 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1853 fprintf (filvar, "listone%d:\n", headindex);
1854 for (funcindex = 0; funcindex < headptr->nfuncs; funcindex++)
1857 fprintf (filvar, "\t%sfuncptr%d_%d%s\n%s\t0\n",
1858 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER,
1861 fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1862 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1865 fprintf (filvar, "\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
1867 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list. */
1871 fprintf (filvar, "\n\t.section\t.idata$5\n");
1873 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1875 fprintf (filvar, "listtwo%d:\n", headindex);
1876 for (funcindex = 0; funcindex < headptr->nfuncs; funcindex++)
1879 fprintf (filvar, "\t%sfuncptr%d_%d%s\n%s\t0\n",
1880 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER,
1883 fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1884 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1887 fprintf (filvar, "\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
1889 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list. */
1893 fprintf (filvar, "\n\t.section\t.idata$6\n");
1895 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1898 for (funcptr = headptr->funchead; funcptr != NULL;
1899 funcptr = funcptr->next)
1901 fprintf (filvar,"funcptr%d_%d:\n", headindex, funcindex);
1902 fprintf (filvar,"\t%s\t%d\n", ASM_SHORT,
1903 ((funcptr->ord) & 0xFFFF));
1904 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT,
1905 (funcptr->its_name ? funcptr->its_name : funcptr->name));
1906 fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1912 fprintf (filvar, "\n\t.section\t.idata$7\n");
1914 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1916 fprintf (filvar,"dllname%d:\n", headindex);
1917 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, headptr->dllname);
1918 fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1923 /* Assemble the specified file. */
1925 assemble_file (const char * source, const char * dest)
1929 cmd = (char *) alloca (strlen (ASM_SWITCHES) + strlen (as_flags)
1930 + strlen (source) + strlen (dest) + 50);
1932 sprintf (cmd, "%s %s -o %s %s", ASM_SWITCHES, as_flags, dest, source);
1945 /* xgettext:c-format */
1946 inform (_("Generating export file: %s"), exp_name);
1948 f = fopen (TMP_ASM, FOPEN_WT);
1950 /* xgettext:c-format */
1951 fatal (_("Unable to open temporary assembler file: %s"), TMP_ASM);
1953 /* xgettext:c-format */
1954 inform (_("Opened temporary file: %s"), TMP_ASM);
1960 fprintf (f, "\t.section .edata\n\n");
1961 fprintf (f, "\t%s 0 %s Allways 0\n", ASM_LONG, ASM_C);
1962 fprintf (f, "\t%s 0x%lx %s Time and date\n", ASM_LONG,
1963 (unsigned long) time(0), ASM_C);
1964 fprintf (f, "\t%s 0 %s Major and Minor version\n", ASM_LONG, ASM_C);
1965 fprintf (f, "\t%sname%s %s Ptr to name of dll\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1966 fprintf (f, "\t%s %d %s Starting ordinal of exports\n", ASM_LONG, d_low_ord, ASM_C);
1969 fprintf (f, "\t%s %d %s Number of functions\n", ASM_LONG, d_high_ord - d_low_ord + 1, ASM_C);
1970 fprintf(f,"\t%s named funcs %d, low ord %d, high ord %d\n",
1972 d_named_nfuncs, d_low_ord, d_high_ord);
1973 fprintf (f, "\t%s %d %s Number of names\n", ASM_LONG,
1974 show_allnames ? d_high_ord - d_low_ord + 1 : d_named_nfuncs, ASM_C);
1975 fprintf (f, "\t%safuncs%s %s Address of functions\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1977 fprintf (f, "\t%sanames%s %s Address of Name Pointer Table\n",
1978 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1980 fprintf (f, "\t%sanords%s %s Address of ordinals\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1982 fprintf (f, "name: %s \"%s\"\n", ASM_TEXT, dll_name);
1985 fprintf(f,"%s Export address Table\n", ASM_C);
1986 fprintf(f,"\t%s\n", ASM_ALIGN_LONG);
1987 fprintf (f, "afuncs:\n");
1990 for (exp = d_exports; exp; exp = exp->next)
1992 if (exp->ordinal != i)
1994 while (i < exp->ordinal)
1996 fprintf(f,"\t%s\t0\n", ASM_LONG);
2001 if (exp->forward == 0)
2003 if (exp->internal_name[0] == '@')
2004 fprintf (f, "\t%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
2005 exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
2007 fprintf (f, "\t%s%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
2008 ASM_PREFIX (exp->internal_name),
2009 exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
2012 fprintf (f, "\t%sf%d%s\t%s %d\n", ASM_RVA_BEFORE,
2013 exp->forward, ASM_RVA_AFTER, ASM_C, exp->ordinal);
2017 fprintf (f,"%s Export Name Pointer Table\n", ASM_C);
2018 fprintf (f, "anames:\n");
2020 for (i = 0; (exp = d_exports_lexically[i]); i++)
2022 if (!exp->noname || show_allnames)
2023 fprintf (f, "\t%sn%d%s\n",
2024 ASM_RVA_BEFORE, exp->ordinal, ASM_RVA_AFTER);
2027 fprintf (f,"%s Export Ordinal Table\n", ASM_C);
2028 fprintf (f, "anords:\n");
2029 for (i = 0; (exp = d_exports_lexically[i]); i++)
2031 if (!exp->noname || show_allnames)
2032 fprintf (f, "\t%s %d\n", ASM_SHORT, exp->ordinal - d_low_ord);
2035 fprintf(f,"%s Export Name Table\n", ASM_C);
2036 for (i = 0; (exp = d_exports_lexically[i]); i++)
2038 if (!exp->noname || show_allnames)
2039 fprintf (f, "n%d: %s \"%s\"\n",
2040 exp->ordinal, ASM_TEXT,
2041 (exp->its_name ? exp->its_name : xlate (exp->name)));
2042 if (exp->forward != 0)
2043 fprintf (f, "f%d: %s \"%s\"\n",
2044 exp->forward, ASM_TEXT, exp->internal_name);
2049 fprintf (f, "\t.section %s\n", DRECTVE_SECTION_NAME);
2050 for (dl = a_list; dl; dl = dl->next)
2052 fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, dl->text);
2058 fprintf (f, "\t.section .rdata\n");
2059 for (dl = d_list; dl; dl = dl->next)
2064 /* We don't output as ascii because there can
2065 be quote characters in the string. */
2067 for (p = dl->text; *p; p++)
2070 fprintf (f, "\t%s\t", ASM_BYTE);
2073 fprintf (f, "%d", *p);
2076 fprintf (f, ",0\n");
2090 /* Add to the output file a way of getting to the exported names
2091 without using the import library. */
2094 fprintf (f, "\t.section\t.rdata\n");
2095 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
2096 if (!exp->noname || show_allnames)
2098 /* We use a single underscore for MS compatibility, and a
2099 double underscore for backward compatibility with old
2101 if (create_compat_implib)
2102 fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name);
2103 fprintf (f, "\t%s\t_imp__%s\n", ASM_GLOBAL, exp->name);
2104 if (create_compat_implib)
2105 fprintf (f, "__imp_%s:\n", exp->name);
2106 fprintf (f, "_imp__%s:\n", exp->name);
2107 fprintf (f, "\t%s\t%s\n", ASM_LONG, exp->name);
2111 /* Dump the reloc section if a base file is provided. */
2115 bfd_vma need[PAGE_SIZE];
2117 bfd_size_type numbytes;
2122 fprintf (f, "\t.section\t.init\n");
2123 fprintf (f, "lab:\n");
2125 fseek (base_file, 0, SEEK_END);
2126 numbytes = ftell (base_file);
2127 fseek (base_file, 0, SEEK_SET);
2128 copy = xmalloc (numbytes);
2129 if (fread (copy, 1, numbytes, base_file) < numbytes)
2130 fatal (_("failed to read the number of entries from base file"));
2131 num_entries = numbytes / sizeof (bfd_vma);
2134 fprintf (f, "\t.section\t.reloc\n");
2139 bfd_vma last = (bfd_vma) -1;
2140 qsort (copy, num_entries, sizeof (bfd_vma), sfunc);
2141 /* Delete duplicates */
2142 for (src = 0; src < num_entries; src++)
2144 if (last != copy[src])
2145 last = copy[dst++] = copy[src];
2149 page_addr = addr & PAGE_MASK; /* work out the page addr */
2151 for (j = 0; j < num_entries; j++)
2154 if ((addr & PAGE_MASK) != page_addr)
2156 flush_page (f, need, page_addr, on_page);
2158 page_addr = addr & PAGE_MASK;
2160 need[on_page++] = addr;
2162 flush_page (f, need, page_addr, on_page);
2164 /* fprintf (f, "\t%s\t0,0\t%s End\n", ASM_LONG, ASM_C);*/
2168 generate_idata_ofile (f);
2172 /* Assemble the file. */
2173 assemble_file (TMP_ASM, exp_name);
2175 if (dontdeltemps == 0)
2178 inform (_("Generated exports file"));
2182 xlate (const char *name)
2184 int lead_at = (*name == '@');
2186 if (!lead_at && (add_underscore
2187 || (add_stdcall_underscore
2188 && strchr (name, '@'))))
2190 char *copy = xmalloc (strlen (name) + 2);
2193 strcpy (copy + 1, name);
2202 /* PR 9766: Look for the last @ sign in the name. */
2203 p = strrchr (name, '@');
2204 if (p && ISDIGIT (p[1]))
2220 unsigned char *data;
2235 #define TEXT_SEC_FLAGS \
2236 (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY | SEC_HAS_CONTENTS)
2237 #define DATA_SEC_FLAGS (SEC_ALLOC | SEC_LOAD | SEC_DATA)
2238 #define BSS_SEC_FLAGS SEC_ALLOC
2240 #define INIT_SEC_DATA(id, name, flags, align) \
2241 { id, name, flags, align, NULL, NULL, NULL, 0, NULL }
2242 static sinfo secdata[NSECS] =
2244 INIT_SEC_DATA (TEXT, ".text", TEXT_SEC_FLAGS, 2),
2245 INIT_SEC_DATA (DATA, ".data", DATA_SEC_FLAGS, 2),
2246 INIT_SEC_DATA (BSS, ".bss", BSS_SEC_FLAGS, 2),
2247 INIT_SEC_DATA (IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2),
2248 INIT_SEC_DATA (IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2),
2249 INIT_SEC_DATA (IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2),
2250 INIT_SEC_DATA (IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1)
2255 /* Sections numbered to make the order the same as other PowerPC NT
2256 compilers. This also keeps funny alignment thingies from happening. */
2269 static sinfo secdata[NSECS] =
2271 { TEXT, ".text", SEC_CODE | SEC_HAS_CONTENTS, 3},
2272 { PDATA, ".pdata", SEC_HAS_CONTENTS, 2},
2273 { RDATA, ".reldata", SEC_HAS_CONTENTS, 2},
2274 { IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2},
2275 { IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2},
2276 { IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1},
2277 { IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2},
2278 { DATA, ".data", SEC_DATA, 2},
2279 { BSS, ".bss", 0, 2}
2284 /* This is what we're trying to make. We generate the imp symbols with
2285 both single and double underscores, for compatibility.
2288 .global _GetFileVersionInfoSizeW@8
2289 .global __imp_GetFileVersionInfoSizeW@8
2290 _GetFileVersionInfoSizeW@8:
2291 jmp * __imp_GetFileVersionInfoSizeW@8
2292 .section .idata$7 # To force loading of head
2293 .long __version_a_head
2294 # Import Address Table
2296 __imp_GetFileVersionInfoSizeW@8:
2299 # Import Lookup Table
2305 .asciz "GetFileVersionInfoSizeW"
2308 For the PowerPC, here's the variation on the above scheme:
2310 # Rather than a simple "jmp *", the code to get to the dll function
2313 lwz r11,[tocv]__imp_function_name(r2)
2314 # RELOC: 00000000 TOCREL16,TOCDEFN __imp_function_name
2322 make_label (const char *prefix, const char *name)
2324 int len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name);
2325 char *copy = xmalloc (len + 1);
2327 strcpy (copy, ASM_PREFIX (name));
2328 strcat (copy, prefix);
2329 strcat (copy, name);
2334 make_imp_label (const char *prefix, const char *name)
2341 len = strlen (prefix) + strlen (name);
2342 copy = xmalloc (len + 1);
2343 strcpy (copy, prefix);
2344 strcat (copy, name);
2348 len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name);
2349 copy = xmalloc (len + 1);
2350 strcpy (copy, prefix);
2351 strcat (copy, ASM_PREFIX (name));
2352 strcat (copy, name);
2358 make_one_lib_file (export_type *exp, int i, int delay)
2361 asymbol * exp_label;
2362 asymbol * iname = 0;
2364 asymbol * iname_lab;
2365 asymbol ** iname_lab_pp;
2366 asymbol ** iname_pp;
2375 asymbol * ptrs[NSECS + 4 + EXTRA + 1];
2376 flagword applicable;
2377 char * outname = xmalloc (strlen (TMP_STUB) + 10);
2381 sprintf (outname, "%s%05d.o", TMP_STUB, i);
2383 abfd = bfd_openw (outname, HOW_BFD_WRITE_TARGET);
2386 /* xgettext:c-format */
2387 fatal (_("bfd_open failed open stub file: %s: %s"),
2388 outname, bfd_get_errmsg ());
2390 /* xgettext:c-format */
2391 inform (_("Creating stub file: %s"), outname);
2393 bfd_set_format (abfd, bfd_object);
2394 bfd_set_arch_mach (abfd, HOW_BFD_ARCH, 0);
2397 if (machine == MARM_INTERWORK || machine == MTHUMB)
2398 bfd_set_private_flags (abfd, F_INTERWORK);
2401 applicable = bfd_applicable_section_flags (abfd);
2403 /* First make symbols for the sections. */
2404 for (i = 0; i < NSECS; i++)
2406 sinfo *si = secdata + i;
2410 si->sec = bfd_make_section_old_way (abfd, si->name);
2411 bfd_set_section_flags (abfd,
2413 si->flags & applicable);
2415 bfd_set_section_alignment(abfd, si->sec, si->align);
2416 si->sec->output_section = si->sec;
2417 si->sym = bfd_make_empty_symbol(abfd);
2418 si->sym->name = si->sec->name;
2419 si->sym->section = si->sec;
2420 si->sym->flags = BSF_LOCAL;
2422 ptrs[oidx] = si->sym;
2423 si->sympp = ptrs + oidx;
2432 exp_label = bfd_make_empty_symbol (abfd);
2433 exp_label->name = make_imp_label ("", exp->name);
2435 /* On PowerPC, the function name points to a descriptor in
2436 the rdata section, the first element of which is a
2437 pointer to the code (..function_name), and the second
2438 points to the .toc. */
2440 if (machine == MPPC)
2441 exp_label->section = secdata[RDATA].sec;
2444 exp_label->section = secdata[TEXT].sec;
2446 exp_label->flags = BSF_GLOBAL;
2447 exp_label->value = 0;
2450 if (machine == MTHUMB)
2451 bfd_coff_set_symbol_class (abfd, exp_label, C_THUMBEXTFUNC);
2453 ptrs[oidx++] = exp_label;
2456 /* Generate imp symbols with one underscore for Microsoft
2457 compatibility, and with two underscores for backward
2458 compatibility with old versions of cygwin. */
2459 if (create_compat_implib)
2461 iname = bfd_make_empty_symbol (abfd);
2462 iname->name = make_imp_label ("___imp", exp->name);
2463 iname->section = secdata[IDATA5].sec;
2464 iname->flags = BSF_GLOBAL;
2468 iname2 = bfd_make_empty_symbol (abfd);
2469 iname2->name = make_imp_label ("__imp_", exp->name);
2470 iname2->section = secdata[IDATA5].sec;
2471 iname2->flags = BSF_GLOBAL;
2474 iname_lab = bfd_make_empty_symbol (abfd);
2476 iname_lab->name = head_label;
2477 iname_lab->section = (asection *) &bfd_und_section;
2478 iname_lab->flags = 0;
2479 iname_lab->value = 0;
2481 iname_pp = ptrs + oidx;
2482 if (create_compat_implib)
2483 ptrs[oidx++] = iname;
2484 ptrs[oidx++] = iname2;
2486 iname_lab_pp = ptrs + oidx;
2487 ptrs[oidx++] = iname_lab;
2490 /* The symbol referring to the code (.text). */
2492 asymbol *function_name;
2494 function_name = bfd_make_empty_symbol(abfd);
2495 function_name->name = make_label ("..", exp->name);
2496 function_name->section = secdata[TEXT].sec;
2497 function_name->flags = BSF_GLOBAL;
2498 function_name->value = 0;
2500 fn_pp = ptrs + oidx;
2501 ptrs[oidx++] = function_name;
2504 /* The .toc symbol. */
2506 asymbol *toc_symbol;
2508 toc_symbol = bfd_make_empty_symbol (abfd);
2509 toc_symbol->name = make_label (".", "toc");
2510 toc_symbol->section = (asection *)&bfd_und_section;
2511 toc_symbol->flags = BSF_GLOBAL;
2512 toc_symbol->value = 0;
2514 toc_pp = ptrs + oidx;
2515 ptrs[oidx++] = toc_symbol;
2521 for (i = 0; i < NSECS; i++)
2523 sinfo *si = secdata + i;
2524 asection *sec = si->sec;
2525 arelent *rel, *rel2 = 0, *rel3 = 0;
2533 si->size = HOW_JTAB_SIZE;
2534 si->data = xmalloc (HOW_JTAB_SIZE);
2535 memcpy (si->data, HOW_JTAB, HOW_JTAB_SIZE);
2537 /* Add the reloc into idata$5. */
2538 rel = xmalloc (sizeof (arelent));
2540 rpp = xmalloc (sizeof (arelent *) * (delay ? 4 : 2));
2544 rel->address = HOW_JTAB_ROFF;
2549 rel2 = xmalloc (sizeof (arelent));
2551 rel2->address = HOW_JTAB_ROFF2;
2553 rel3 = xmalloc (sizeof (arelent));
2555 rel3->address = HOW_JTAB_ROFF3;
2560 if (machine == MPPC)
2562 rel->howto = bfd_reloc_type_lookup (abfd,
2563 BFD_RELOC_16_GOTOFF);
2564 rel->sym_ptr_ptr = iname_pp;
2566 else if (machine == MX86)
2568 rel->howto = bfd_reloc_type_lookup (abfd,
2569 BFD_RELOC_32_PCREL);
2570 rel->sym_ptr_ptr = iname_pp;
2574 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2575 rel->sym_ptr_ptr = secdata[IDATA5].sympp;
2580 rel2->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2581 rel2->sym_ptr_ptr = rel->sym_ptr_ptr;
2582 rel3->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32_PCREL);
2583 rel3->sym_ptr_ptr = iname_lab_pp;
2586 sec->orelocation = rpp;
2587 sec->reloc_count = delay ? 3 : 1;
2594 si->data = xmalloc (4);
2596 sec->reloc_count = 1;
2597 memset (si->data, 0, si->size);
2599 rel = xmalloc (sizeof (arelent));
2600 rpp = xmalloc (sizeof (arelent *) * 2);
2605 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2606 rel->sym_ptr_ptr = secdata[TEXT].sympp;
2607 sec->orelocation = rpp;
2610 /* else fall through */
2612 /* An idata$4 or idata$5 is one word long, and has an
2617 si->data = xmalloc (8);
2621 si->data[0] = exp->ordinal ;
2622 si->data[1] = exp->ordinal >> 8;
2623 si->data[2] = exp->ordinal >> 16;
2624 si->data[3] = exp->ordinal >> 24;
2632 sec->reloc_count = 1;
2633 memset (si->data, 0, si->size);
2634 rel = xmalloc (sizeof (arelent));
2635 rpp = xmalloc (sizeof (arelent *) * 2);
2640 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2641 rel->sym_ptr_ptr = secdata[IDATA6].sympp;
2642 sec->orelocation = rpp;
2647 si->data = xmalloc (4);
2652 si->data[0] = exp->ordinal ;
2653 si->data[1] = exp->ordinal >> 8;
2654 si->data[2] = exp->ordinal >> 16;
2659 sec->reloc_count = 1;
2660 memset (si->data, 0, si->size);
2661 rel = xmalloc (sizeof (arelent));
2662 rpp = xmalloc (sizeof (arelent *) * 2);
2667 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2668 rel->sym_ptr_ptr = secdata[IDATA6].sympp;
2669 sec->orelocation = rpp;
2677 /* This used to add 1 to exp->hint. I don't know
2678 why it did that, and it does not match what I see
2679 in programs compiled with the MS tools. */
2680 int idx = exp->hint;
2682 si->size = strlen (exp->its_name) + 3;
2684 si->size = strlen (xlate (exp->import_name)) + 3;
2685 si->data = xmalloc (si->size);
2686 si->data[0] = idx & 0xff;
2687 si->data[1] = idx >> 8;
2689 strcpy ((char *) si->data + 2, exp->its_name);
2691 strcpy ((char *) si->data + 2, xlate (exp->import_name));
2698 si->data = xmalloc (4);
2699 memset (si->data, 0, si->size);
2700 rel = xmalloc (sizeof (arelent));
2701 rpp = xmalloc (sizeof (arelent *) * 2);
2705 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2706 rel->sym_ptr_ptr = iname_lab_pp;
2707 sec->orelocation = rpp;
2708 sec->reloc_count = 1;
2714 /* The .pdata section is 5 words long.
2718 bfd_vma BeginAddress, [0x00]
2720 ExceptionHandler, [0x08]
2722 PrologEndAddress; [0x10]
2725 /* So this pdata section setups up this as a glue linkage to
2726 a dll routine. There are a number of house keeping things
2729 1. In the name of glue trickery, the ADDR32 relocs for 0,
2730 4, and 0x10 are set to point to the same place:
2732 2. There is one more reloc needed in the pdata section.
2733 The actual glue instruction to restore the toc on
2734 return is saved as the offset in an IMGLUE reloc.
2735 So we need a total of four relocs for this section.
2737 3. Lastly, the HandlerData field is set to 0x03, to indicate
2738 that this is a glue routine. */
2739 arelent *imglue, *ba_rel, *ea_rel, *pea_rel;
2741 /* Alignment must be set to 2**2 or you get extra stuff. */
2742 bfd_set_section_alignment(abfd, sec, 2);
2745 si->data = xmalloc (si->size);
2746 memset (si->data, 0, si->size);
2747 rpp = xmalloc (sizeof (arelent *) * 5);
2748 rpp[0] = imglue = xmalloc (sizeof (arelent));
2749 rpp[1] = ba_rel = xmalloc (sizeof (arelent));
2750 rpp[2] = ea_rel = xmalloc (sizeof (arelent));
2751 rpp[3] = pea_rel = xmalloc (sizeof (arelent));
2754 /* Stick the toc reload instruction in the glue reloc. */
2755 bfd_put_32(abfd, ppc_glue_insn, (char *) &imglue->address);
2758 imglue->howto = bfd_reloc_type_lookup (abfd,
2759 BFD_RELOC_32_GOTOFF);
2760 imglue->sym_ptr_ptr = fn_pp;
2762 ba_rel->address = 0;
2764 ba_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2765 ba_rel->sym_ptr_ptr = fn_pp;
2767 bfd_put_32 (abfd, 0x18, si->data + 0x04);
2768 ea_rel->address = 4;
2770 ea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2771 ea_rel->sym_ptr_ptr = fn_pp;
2773 /* Mark it as glue. */
2774 bfd_put_32 (abfd, 0x03, si->data + 0x0c);
2776 /* Mark the prolog end address. */
2777 bfd_put_32 (abfd, 0x0D, si->data + 0x10);
2778 pea_rel->address = 0x10;
2779 pea_rel->addend = 0;
2780 pea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2781 pea_rel->sym_ptr_ptr = fn_pp;
2783 sec->orelocation = rpp;
2784 sec->reloc_count = 4;
2788 /* Each external function in a PowerPC PE file has a two word
2789 descriptor consisting of:
2790 1. The address of the code.
2791 2. The address of the appropriate .toc
2792 We use relocs to build this. */
2794 si->data = xmalloc (8);
2795 memset (si->data, 0, si->size);
2797 rpp = xmalloc (sizeof (arelent *) * 3);
2798 rpp[0] = rel = xmalloc (sizeof (arelent));
2799 rpp[1] = xmalloc (sizeof (arelent));
2804 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2805 rel->sym_ptr_ptr = fn_pp;
2811 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2812 rel->sym_ptr_ptr = toc_pp;
2814 sec->orelocation = rpp;
2815 sec->reloc_count = 2;
2817 #endif /* DLLTOOL_PPC */
2823 /* Size up all the sections. */
2824 for (i = 0; i < NSECS; i++)
2826 sinfo *si = secdata + i;
2828 bfd_set_section_size (abfd, si->sec, si->size);
2829 bfd_set_section_vma (abfd, si->sec, vma);
2832 /* Write them out. */
2833 for (i = 0; i < NSECS; i++)
2835 sinfo *si = secdata + i;
2837 if (i == IDATA5 && no_idata5)
2840 if (i == IDATA4 && no_idata4)
2843 bfd_set_section_contents (abfd, si->sec,
2848 bfd_set_symtab (abfd, ptrs, oidx);
2850 abfd = bfd_openr (outname, HOW_BFD_READ_TARGET);
2852 /* xgettext:c-format */
2853 fatal (_("bfd_open failed reopen stub file: %s: %s"),
2854 outname, bfd_get_errmsg ());
2862 FILE *f = fopen (TMP_HEAD_S, FOPEN_WT);
2867 fatal (_("failed to open temporary head file: %s"), TMP_HEAD_S);
2871 fprintf (f, "%s IMAGE_IMPORT_DESCRIPTOR\n", ASM_C);
2872 fprintf (f, "\t.section\t.idata$2\n");
2874 fprintf (f,"\t%s\t%s\n", ASM_GLOBAL, head_label);
2876 fprintf (f, "%s:\n", head_label);
2878 fprintf (f, "\t%shname%s\t%sPtr to image import by name list\n",
2879 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
2881 fprintf (f, "\t%sthis should be the timestamp, but NT sometimes\n", ASM_C);
2882 fprintf (f, "\t%sdoesn't load DLLs when this is set.\n", ASM_C);
2883 fprintf (f, "\t%s\t0\t%s loaded time\n", ASM_LONG, ASM_C);
2884 fprintf (f, "\t%s\t0\t%s Forwarder chain\n", ASM_LONG, ASM_C);
2885 fprintf (f, "\t%s__%s_iname%s\t%s imported dll's name\n",
2890 fprintf (f, "\t%sfthunk%s\t%s pointer to firstthunk\n",
2892 ASM_RVA_AFTER, ASM_C);
2894 fprintf (f, "%sStuff for compatibility\n", ASM_C);
2898 fprintf (f, "\t.section\t.idata$5\n");
2899 if (use_nul_prefixed_import_tables)
2902 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
2904 fprintf (f,"\t%s\t0\n", ASM_LONG);
2906 fprintf (f, "fthunk:\n");
2911 fprintf (f, "\t.section\t.idata$4\n");
2912 if (use_nul_prefixed_import_tables)
2915 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
2917 fprintf (f,"\t%s\t0\n", ASM_LONG);
2919 fprintf (f, "hname:\n");
2924 assemble_file (TMP_HEAD_S, TMP_HEAD_O);
2926 abfd = bfd_openr (TMP_HEAD_O, HOW_BFD_READ_TARGET);
2928 /* xgettext:c-format */
2929 fatal (_("failed to open temporary head file: %s: %s"),
2930 TMP_HEAD_O, bfd_get_errmsg ());
2936 make_delay_head (void)
2938 FILE *f = fopen (TMP_HEAD_S, FOPEN_WT);
2943 fatal (_("failed to open temporary head file: %s"), TMP_HEAD_S);
2947 /* Output the __tailMerge__xxx function */
2948 fprintf (f, "%s Import trampoline\n", ASM_C);
2949 fprintf (f, "\t.section\t.text\n");
2950 fprintf(f,"\t%s\t%s\n", ASM_GLOBAL, head_label);
2951 fprintf (f, "%s:\n", head_label);
2952 fprintf (f, mtable[machine].trampoline, imp_name_lab);
2954 /* Output the delay import descriptor */
2955 fprintf (f, "\n%s DELAY_IMPORT_DESCRIPTOR\n", ASM_C);
2956 fprintf (f, ".section\t.text$2\n");
2957 fprintf (f,"%s __DELAY_IMPORT_DESCRIPTOR_%s\n", ASM_GLOBAL,imp_name_lab);
2958 fprintf (f, "__DELAY_IMPORT_DESCRIPTOR_%s:\n", imp_name_lab);
2959 fprintf (f, "\t%s 1\t%s grAttrs\n", ASM_LONG, ASM_C);
2960 fprintf (f, "\t%s__%s_iname%s\t%s rvaDLLName\n",
2961 ASM_RVA_BEFORE, imp_name_lab, ASM_RVA_AFTER, ASM_C);
2962 fprintf (f, "\t%s__DLL_HANDLE_%s%s\t%s rvaHmod\n",
2963 ASM_RVA_BEFORE, imp_name_lab, ASM_RVA_AFTER, ASM_C);
2964 fprintf (f, "\t%s__IAT_%s%s\t%s rvaIAT\n",
2965 ASM_RVA_BEFORE, imp_name_lab, ASM_RVA_AFTER, ASM_C);
2966 fprintf (f, "\t%s__INT_%s%s\t%s rvaINT\n",
2967 ASM_RVA_BEFORE, imp_name_lab, ASM_RVA_AFTER, ASM_C);
2968 fprintf (f, "\t%s\t0\t%s rvaBoundIAT\n", ASM_LONG, ASM_C);
2969 fprintf (f, "\t%s\t0\t%s rvaUnloadIAT\n", ASM_LONG, ASM_C);
2970 fprintf (f, "\t%s\t0\t%s dwTimeStamp\n", ASM_LONG, ASM_C);
2972 /* Output the dll_handle */
2973 fprintf (f, "\n.section .data\n");
2974 fprintf (f, "__DLL_HANDLE_%s:\n", imp_name_lab);
2975 fprintf (f, "\t%s\t0\t%s Handle\n", ASM_LONG, ASM_C);
2978 fprintf (f, "%sStuff for compatibility\n", ASM_C);
2982 fprintf (f, "\t.section\t.idata$5\n");
2983 /* NULL terminating list. */
2984 #ifdef DLLTOOL_MX86_64
2985 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
2987 fprintf (f,"\t%s\t0\n", ASM_LONG);
2989 fprintf (f, "__IAT_%s:\n", imp_name_lab);
2994 fprintf (f, "\t.section\t.idata$4\n");
2995 fprintf (f, "\t%s\t0\n", ASM_LONG);
2996 fprintf (f, "\t.section\t.idata$4\n");
2997 fprintf (f, "__INT_%s:\n", imp_name_lab);
3000 fprintf (f, "\t.section\t.idata$2\n");
3004 assemble_file (TMP_HEAD_S, TMP_HEAD_O);
3006 abfd = bfd_openr (TMP_HEAD_O, HOW_BFD_READ_TARGET);
3008 /* xgettext:c-format */
3009 fatal (_("failed to open temporary head file: %s: %s"),
3010 TMP_HEAD_O, bfd_get_errmsg ());
3018 FILE *f = fopen (TMP_TAIL_S, FOPEN_WT);
3023 fatal (_("failed to open temporary tail file: %s"), TMP_TAIL_S);
3029 fprintf (f, "\t.section\t.idata$4\n");
3031 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
3033 fprintf (f,"\t%s\t0\n", ASM_LONG); /* NULL terminating list. */
3038 fprintf (f, "\t.section\t.idata$5\n");
3040 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
3042 fprintf (f,"\t%s\t0\n", ASM_LONG); /* NULL terminating list. */
3046 /* Normally, we need to see a null descriptor built in idata$3 to
3047 act as the terminator for the list. The ideal way, I suppose,
3048 would be to mark this section as a comdat type 2 section, so
3049 only one would appear in the final .exe (if our linker supported
3050 comdat, that is) or cause it to be inserted by something else (say
3053 fprintf (f, "\t.section\t.idata$3\n");
3054 fprintf (f, "\t%s\t0\n", ASM_LONG);
3055 fprintf (f, "\t%s\t0\n", ASM_LONG);
3056 fprintf (f, "\t%s\t0\n", ASM_LONG);
3057 fprintf (f, "\t%s\t0\n", ASM_LONG);
3058 fprintf (f, "\t%s\t0\n", ASM_LONG);
3062 /* Other PowerPC NT compilers use idata$6 for the dllname, so I
3063 do too. Original, huh? */
3064 fprintf (f, "\t.section\t.idata$6\n");
3066 fprintf (f, "\t.section\t.idata$7\n");
3069 fprintf (f, "\t%s\t__%s_iname\n", ASM_GLOBAL, imp_name_lab);
3070 fprintf (f, "__%s_iname:\t%s\t\"%s\"\n",
3071 imp_name_lab, ASM_TEXT, dll_name);
3075 assemble_file (TMP_TAIL_S, TMP_TAIL_O);
3077 abfd = bfd_openr (TMP_TAIL_O, HOW_BFD_READ_TARGET);
3079 /* xgettext:c-format */
3080 fatal (_("failed to open temporary tail file: %s: %s"),
3081 TMP_TAIL_O, bfd_get_errmsg ());
3087 gen_lib_file (int delay)
3098 outarch = bfd_openw (imp_name, HOW_BFD_WRITE_TARGET);
3101 /* xgettext:c-format */
3102 fatal (_("Can't create .lib file: %s: %s"),
3103 imp_name, bfd_get_errmsg ());
3105 /* xgettext:c-format */
3106 inform (_("Creating library file: %s"), imp_name);
3108 bfd_set_format (outarch, bfd_archive);
3109 outarch->has_armap = 1;
3110 outarch->is_thin_archive = 0;
3112 /* Work out a reasonable size of things to put onto one line. */
3115 ar_head = make_delay_head ();
3119 ar_head = make_head ();
3121 ar_tail = make_tail();
3123 if (ar_head == NULL || ar_tail == NULL)
3126 for (i = 0; (exp = d_exports_lexically[i]); i++)
3129 /* Don't add PRIVATE entries to import lib. */
3132 n = make_one_lib_file (exp, i, delay);
3133 n->archive_next = head;
3135 if (ext_prefix_alias)
3137 export_type alias_exp;
3139 assert (i < PREFIX_ALIAS_BASE);
3140 alias_exp.name = make_imp_label (ext_prefix_alias, exp->name);
3141 alias_exp.internal_name = exp->internal_name;
3142 alias_exp.its_name = exp->its_name;
3143 alias_exp.import_name = exp->name;
3144 alias_exp.ordinal = exp->ordinal;
3145 alias_exp.constant = exp->constant;
3146 alias_exp.noname = exp->noname;
3147 alias_exp.private = exp->private;
3148 alias_exp.data = exp->data;
3149 alias_exp.hint = exp->hint;
3150 alias_exp.forward = exp->forward;
3151 alias_exp.next = exp->next;
3152 n = make_one_lib_file (&alias_exp, i + PREFIX_ALIAS_BASE, delay);
3153 n->archive_next = head;
3158 /* Now stick them all into the archive. */
3159 ar_head->archive_next = head;
3160 ar_tail->archive_next = ar_head;
3163 if (! bfd_set_archive_head (outarch, head))
3164 bfd_fatal ("bfd_set_archive_head");
3166 if (! bfd_close (outarch))
3167 bfd_fatal (imp_name);
3169 while (head != NULL)
3171 bfd *n = head->archive_next;
3176 /* Delete all the temp files. */
3177 if (dontdeltemps == 0)
3179 unlink (TMP_HEAD_O);
3180 unlink (TMP_HEAD_S);
3181 unlink (TMP_TAIL_O);
3182 unlink (TMP_TAIL_S);
3185 if (dontdeltemps < 2)
3189 name = (char *) alloca (strlen (TMP_STUB) + 10);
3190 for (i = 0; (exp = d_exports_lexically[i]); i++)
3192 /* Don't delete non-existent stubs for PRIVATE entries. */
3195 sprintf (name, "%s%05d.o", TMP_STUB, i);
3196 if (unlink (name) < 0)
3197 /* xgettext:c-format */
3198 non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
3199 if (ext_prefix_alias)
3201 sprintf (name, "%s%05d.o", TMP_STUB, i + PREFIX_ALIAS_BASE);
3202 if (unlink (name) < 0)
3203 /* xgettext:c-format */
3204 non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
3209 inform (_("Created lib file"));
3212 /* Append a copy of data (cast to char *) to list. */
3215 dll_name_list_append (dll_name_list_type * list, bfd_byte * data)
3217 dll_name_list_node_type * entry;
3219 /* Error checking. */
3220 if (! list || ! list->tail)
3223 /* Allocate new node. */
3224 entry = ((dll_name_list_node_type *)
3225 xmalloc (sizeof (dll_name_list_node_type)));
3227 /* Initialize its values. */
3228 entry->dllname = xstrdup ((char *) data);
3231 /* Add to tail, and move tail. */
3232 list->tail->next = entry;
3236 /* Count the number of entries in list. */
3239 dll_name_list_count (dll_name_list_type * list)
3241 dll_name_list_node_type * p;
3244 /* Error checking. */
3245 if (! list || ! list->head)
3250 while (p && p->next)
3258 /* Print each entry in list to stdout. */
3261 dll_name_list_print (dll_name_list_type * list)
3263 dll_name_list_node_type * p;
3265 /* Error checking. */
3266 if (! list || ! list->head)
3271 while (p && p->next && p->next->dllname && *(p->next->dllname))
3273 printf ("%s\n", p->next->dllname);
3278 /* Free all entries in list, and list itself. */
3281 dll_name_list_free (dll_name_list_type * list)
3285 dll_name_list_free_contents (list->head);
3292 /* Recursive function to free all nodes entry->next->next...
3293 as well as entry itself. */
3296 dll_name_list_free_contents (dll_name_list_node_type * entry)
3302 dll_name_list_free_contents (entry->next);
3307 free (entry->dllname);
3308 entry->dllname = NULL;
3314 /* Allocate and initialize a dll_name_list_type object,
3315 including its sentinel node. Caller is responsible
3316 for calling dll_name_list_free when finished with
3319 static dll_name_list_type *
3320 dll_name_list_create (void)
3322 /* Allocate list. */
3323 dll_name_list_type * list = xmalloc (sizeof (dll_name_list_type));
3325 /* Allocate and initialize sentinel node. */
3326 list->head = xmalloc (sizeof (dll_name_list_node_type));
3327 list->head->dllname = NULL;
3328 list->head->next = NULL;
3330 /* Bookkeeping for empty list. */
3331 list->tail = list->head;
3336 /* Search the symbol table of the suppled BFD for a symbol whose name matches
3337 OBJ (where obj is cast to const char *). If found, set global variable
3338 identify_member_contains_symname_result TRUE. It is the caller's
3339 responsibility to set the result variable FALSE before iterating with
3343 identify_member_contains_symname (bfd * abfd,
3344 bfd * archive_bfd ATTRIBUTE_UNUSED,
3347 long storage_needed;
3348 asymbol ** symbol_table;
3349 long number_of_symbols;
3351 symname_search_data_type * search_data = (symname_search_data_type *) obj;
3353 /* If we already found the symbol in a different member,
3355 if (search_data->found)
3358 storage_needed = bfd_get_symtab_upper_bound (abfd);
3359 if (storage_needed <= 0)
3362 symbol_table = xmalloc (storage_needed);
3363 number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
3364 if (number_of_symbols < 0)
3366 free (symbol_table);
3370 for (i = 0; i < number_of_symbols; i++)
3372 if (strncmp (symbol_table[i]->name,
3373 search_data->symname,
3374 strlen (search_data->symname)) == 0)
3376 search_data->found = TRUE;
3380 free (symbol_table);
3383 /* This is the main implementation for the --identify option.
3384 Given the name of an import library in identify_imp_name, first determine
3385 if the import library is a GNU binutils-style one (where the DLL name is
3386 stored in an .idata$7 (.idata$6 on PPC) section, or if it is a MS-style
3387 one (where the DLL name, along with much other data, is stored in the
3388 .idata$6 section). We determine the style of import library by searching
3389 for the DLL-structure symbol inserted by MS tools:
3390 __NULL_IMPORT_DESCRIPTOR.
3392 Once we know which section to search, evaluate each section for the
3393 appropriate properties that indicate it may contain the name of the
3394 associated DLL (this differs depending on the style). Add the contents
3395 of all sections which meet the criteria to a linked list of dll names.
3397 Finally, print them all to stdout. (If --identify-strict, an error is
3398 reported if more than one match was found). */
3401 identify_dll_for_implib (void)
3405 identify_data_type identify_data;
3406 symname_search_data_type search_data;
3408 /* Initialize identify_data. */
3409 identify_data.list = dll_name_list_create ();
3410 identify_data.ms_style_implib = FALSE;
3412 /* Initialize search_data. */
3413 search_data.symname = "__NULL_IMPORT_DESCRIPTOR";
3414 search_data.found = FALSE;
3418 abfd = bfd_openr (identify_imp_name, 0);
3420 /* xgettext:c-format */
3421 fatal (_("Can't open .lib file: %s: %s"),
3422 identify_imp_name, bfd_get_errmsg ());
3424 if (! bfd_check_format (abfd, bfd_archive))
3426 if (! bfd_close (abfd))
3427 bfd_fatal (identify_imp_name);
3429 fatal (_("%s is not a library"), identify_imp_name);
3432 /* Detect if this a Microsoft import library. */
3433 identify_search_archive (abfd,
3434 identify_member_contains_symname,
3435 (void *)(& search_data));
3436 if (search_data.found)
3437 identify_data.ms_style_implib = TRUE;
3439 /* Rewind the bfd. */
3440 if (! bfd_close (abfd))
3441 bfd_fatal (identify_imp_name);
3442 abfd = bfd_openr (identify_imp_name, 0);
3444 bfd_fatal (identify_imp_name);
3446 if (!bfd_check_format (abfd, bfd_archive))
3448 if (!bfd_close (abfd))
3449 bfd_fatal (identify_imp_name);
3451 fatal (_("%s is not a library"), identify_imp_name);
3454 /* Now search for the dll name. */
3455 identify_search_archive (abfd,
3456 identify_search_member,
3457 (void *)(& identify_data));
3459 if (! bfd_close (abfd))
3460 bfd_fatal (identify_imp_name);
3462 count = dll_name_list_count (identify_data.list);
3465 if (identify_strict && count > 1)
3467 dll_name_list_free (identify_data.list);
3468 identify_data.list = NULL;
3469 fatal (_("Import library `%s' specifies two or more dlls"),
3472 dll_name_list_print (identify_data.list);
3473 dll_name_list_free (identify_data.list);
3474 identify_data.list = NULL;
3478 dll_name_list_free (identify_data.list);
3479 identify_data.list = NULL;
3480 fatal (_("Unable to determine dll name for `%s' (not an import library?)"),
3485 /* Loop over all members of the archive, applying the supplied function to
3486 each member that is a bfd_object. The function will be called as if:
3487 func (member_bfd, abfd, user_storage) */
3490 identify_search_archive (bfd * abfd,
3491 void (* operation) (bfd *, bfd *, void *),
3492 void * user_storage)
3494 bfd * arfile = NULL;
3495 bfd * last_arfile = NULL;
3500 arfile = bfd_openr_next_archived_file (abfd, arfile);
3504 if (bfd_get_error () != bfd_error_no_more_archived_files)
3505 bfd_fatal (bfd_get_filename (abfd));
3509 if (bfd_check_format_matches (arfile, bfd_object, &matching))
3510 (*operation) (arfile, abfd, user_storage);
3513 bfd_nonfatal (bfd_get_filename (arfile));
3517 if (last_arfile != NULL)
3518 bfd_close (last_arfile);
3520 last_arfile = arfile;
3523 if (last_arfile != NULL)
3525 bfd_close (last_arfile);
3529 /* Call the identify_search_section() function for each section of this
3533 identify_search_member (bfd *abfd,
3534 bfd *archive_bfd ATTRIBUTE_UNUSED,
3537 bfd_map_over_sections (abfd, identify_search_section, obj);
3540 /* This predicate returns true if section->name matches the desired value.
3541 By default, this is .idata$7 (.idata$6 on PPC, or if the import
3542 library is ms-style). */
3545 identify_process_section_p (asection * section, bfd_boolean ms_style_implib)
3547 static const char * SECTION_NAME =
3549 /* dllname is stored in idata$6 on PPC */
3554 static const char * MS_SECTION_NAME = ".idata$6";
3556 const char * section_name =
3557 (ms_style_implib ? MS_SECTION_NAME : SECTION_NAME);
3559 if (strcmp (section_name, section->name) == 0)
3564 /* If *section has contents and its name is .idata$7 (.data$6 on PPC or if
3565 import lib ms-generated) -- and it satisfies several other constraints
3566 -- then add the contents of the section to obj->list. */
3569 identify_search_section (bfd * abfd, asection * section, void * obj)
3572 bfd_size_type datasize;
3573 identify_data_type * identify_data = (identify_data_type *)obj;
3574 bfd_boolean ms_style = identify_data->ms_style_implib;
3576 if ((section->flags & SEC_HAS_CONTENTS) == 0)
3579 if (! identify_process_section_p (section, ms_style))
3582 /* Binutils import libs seem distinguish the .idata$7 section that contains
3583 the DLL name from other .idata$7 sections by the absence of the
3585 if (!ms_style && ((section->flags & SEC_RELOC) == SEC_RELOC))
3588 /* MS import libs seem to distinguish the .idata$6 section
3589 that contains the DLL name from other .idata$6 sections
3590 by the presence of the SEC_DATA flag. */
3591 if (ms_style && ((section->flags & SEC_DATA) == 0))
3594 if ((datasize = bfd_section_size (abfd, section)) == 0)
3597 data = (bfd_byte *) xmalloc (datasize + 1);
3600 bfd_get_section_contents (abfd, section, data, 0, datasize);
3601 data[datasize] = '\0';
3603 /* Use a heuristic to determine if data is a dll name.
3604 Possible to defeat this if (a) the library has MANY
3605 (more than 0x302f) imports, (b) it is an ms-style
3606 import library, but (c) it is buggy, in that the SEC_DATA
3607 flag is set on the "wrong" sections. This heuristic might
3608 also fail to record a valid dll name if the dllname uses
3609 a multibyte or unicode character set (is that valid?).
3611 This heuristic is based on the fact that symbols names in
3612 the chosen section -- as opposed to the dll name -- begin
3613 at offset 2 in the data. The first two bytes are a 16bit
3614 little-endian count, and start at 0x0000. However, the dll
3615 name begins at offset 0 in the data. We assume that the
3616 dll name does not contain unprintable characters. */
3617 if (data[0] != '\0' && ISPRINT (data[0])
3618 && ((datasize < 2) || ISPRINT (data[1])))
3619 dll_name_list_append (identify_data->list, data);
3624 /* Run through the information gathered from the .o files and the
3625 .def file and work out the best stuff. */
3628 pfunc (const void *a, const void *b)
3630 export_type *ap = *(export_type **) a;
3631 export_type *bp = *(export_type **) b;
3633 if (ap->ordinal == bp->ordinal)
3636 /* Unset ordinals go to the bottom. */
3637 if (ap->ordinal == -1)
3639 if (bp->ordinal == -1)
3641 return (ap->ordinal - bp->ordinal);
3645 nfunc (const void *a, const void *b)
3647 export_type *ap = *(export_type **) a;
3648 export_type *bp = *(export_type **) b;
3649 const char *an = ap->name;
3650 const char *bn = bp->name;
3657 an = (an[0] == '@') ? an + 1 : an;
3658 bn = (bn[0] == '@') ? bn + 1 : bn;
3661 return (strcmp (an, bn));
3665 remove_null_names (export_type **ptr)
3670 for (dst = src = 0; src < d_nfuncs; src++)
3674 ptr[dst] = ptr[src];
3682 process_duplicates (export_type **d_export_vec)
3690 /* Remove duplicates. */
3691 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), nfunc);
3693 for (i = 0; i < d_nfuncs - 1; i++)
3695 if (strcmp (d_export_vec[i]->name,
3696 d_export_vec[i + 1]->name) == 0)
3698 export_type *a = d_export_vec[i];
3699 export_type *b = d_export_vec[i + 1];
3703 /* xgettext:c-format */
3704 inform (_("Warning, ignoring duplicate EXPORT %s %d,%d"),
3705 a->name, a->ordinal, b->ordinal);
3707 if (a->ordinal != -1
3708 && b->ordinal != -1)
3709 /* xgettext:c-format */
3710 fatal (_("Error, duplicate EXPORT with ordinals: %s"),
3713 /* Merge attributes. */
3714 b->ordinal = a->ordinal > 0 ? a->ordinal : b->ordinal;
3715 b->constant |= a->constant;
3716 b->noname |= a->noname;
3718 d_export_vec[i] = 0;
3721 remove_null_names (d_export_vec);
3725 /* Count the names. */
3726 for (i = 0; i < d_nfuncs; i++)
3727 if (!d_export_vec[i]->noname)
3732 fill_ordinals (export_type **d_export_vec)
3739 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
3741 /* Fill in the unset ordinals with ones from our range. */
3742 ptr = (char *) xmalloc (size);
3744 memset (ptr, 0, size);
3746 /* Mark in our large vector all the numbers that are taken. */
3747 for (i = 0; i < d_nfuncs; i++)
3749 if (d_export_vec[i]->ordinal != -1)
3751 ptr[d_export_vec[i]->ordinal] = 1;
3753 if (lowest == -1 || d_export_vec[i]->ordinal < lowest)
3754 lowest = d_export_vec[i]->ordinal;
3758 /* Start at 1 for compatibility with MS toolchain. */
3762 /* Now fill in ordinals where the user wants us to choose. */
3763 for (i = 0; i < d_nfuncs; i++)
3765 if (d_export_vec[i]->ordinal == -1)
3769 /* First try within or after any user supplied range. */
3770 for (j = lowest; j < size; j++)
3774 d_export_vec[i]->ordinal = j;
3778 /* Then try before the range. */
3779 for (j = lowest; j >0; j--)
3783 d_export_vec[i]->ordinal = j;
3793 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
3795 /* Work out the lowest and highest ordinal numbers. */
3798 if (d_export_vec[0])
3799 d_low_ord = d_export_vec[0]->ordinal;
3800 if (d_export_vec[d_nfuncs-1])
3801 d_high_ord = d_export_vec[d_nfuncs-1]->ordinal;
3808 /* First work out the minimum ordinal chosen. */
3813 export_type **d_export_vec = xmalloc (sizeof (export_type *) * d_nfuncs);
3815 inform (_("Processing definitions"));
3817 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3818 d_export_vec[i] = exp;
3820 process_duplicates (d_export_vec);
3821 fill_ordinals (d_export_vec);
3823 /* Put back the list in the new order. */
3825 for (i = d_nfuncs - 1; i >= 0; i--)
3827 d_export_vec[i]->next = d_exports;
3828 d_exports = d_export_vec[i];
3831 /* Build list in alpha order. */
3832 d_exports_lexically = (export_type **)
3833 xmalloc (sizeof (export_type *) * (d_nfuncs + 1));
3835 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3836 d_exports_lexically[i] = exp;
3838 d_exports_lexically[i] = 0;
3840 qsort (d_exports_lexically, i, sizeof (export_type *), nfunc);
3842 /* Fill exp entries with their hint values. */
3843 for (i = 0; i < d_nfuncs; i++)
3844 if (!d_exports_lexically[i]->noname || show_allnames)
3845 d_exports_lexically[i]->hint = hint++;
3847 inform (_("Processed definitions"));
3851 usage (FILE *file, int status)
3853 /* xgetext:c-format */
3854 fprintf (file, _("Usage %s <option(s)> <object-file(s)>\n"), program_name);
3855 /* xgetext:c-format */
3856 fprintf (file, _(" -m --machine <machine> Create as DLL for <machine>. [default: %s]\n"), mname);
3857 fprintf (file, _(" possible <machine>: arm[_interwork], i386, mcore[-elf]{-le|-be}, ppc, thumb\n"));
3858 fprintf (file, _(" -e --output-exp <outname> Generate an export file.\n"));
3859 fprintf (file, _(" -l --output-lib <outname> Generate an interface library.\n"));
3860 fprintf (file, _(" -y --output-delaylib <outname> Create a delay-import library.\n"));
3861 fprintf (file, _(" -a --add-indirect Add dll indirects to export file.\n"));
3862 fprintf (file, _(" -D --dllname <name> Name of input dll to put into interface lib.\n"));
3863 fprintf (file, _(" -d --input-def <deffile> Name of .def file to be read in.\n"));
3864 fprintf (file, _(" -z --output-def <deffile> Name of .def file to be created.\n"));
3865 fprintf (file, _(" --export-all-symbols Export all symbols to .def\n"));
3866 fprintf (file, _(" --no-export-all-symbols Only export listed symbols\n"));
3867 fprintf (file, _(" --exclude-symbols <list> Don't export <list>\n"));
3868 fprintf (file, _(" --no-default-excludes Clear default exclude symbols\n"));
3869 fprintf (file, _(" -b --base-file <basefile> Read linker generated base file.\n"));
3870 fprintf (file, _(" -x --no-idata4 Don't generate idata$4 section.\n"));
3871 fprintf (file, _(" -c --no-idata5 Don't generate idata$5 section.\n"));
3872 fprintf (file, _(" --use-nul-prefixed-import-tables Use zero prefixed idata$4 and idata$5.\n"));
3873 fprintf (file, _(" -U --add-underscore Add underscores to all symbols in interface library.\n"));
3874 fprintf (file, _(" --add-stdcall-underscore Add underscores to stdcall symbols in interface library.\n"));
3875 fprintf (file, _(" -k --kill-at Kill @<n> from exported names.\n"));
3876 fprintf (file, _(" -A --add-stdcall-alias Add aliases without @<n>.\n"));
3877 fprintf (file, _(" -p --ext-prefix-alias <prefix> Add aliases with <prefix>.\n"));
3878 fprintf (file, _(" -S --as <name> Use <name> for assembler.\n"));
3879 fprintf (file, _(" -f --as-flags <flags> Pass <flags> to the assembler.\n"));
3880 fprintf (file, _(" -C --compat-implib Create backward compatible import library.\n"));
3881 fprintf (file, _(" -n --no-delete Keep temp files (repeat for extra preservation).\n"));
3882 fprintf (file, _(" -t --temp-prefix <prefix> Use <prefix> to construct temp file names.\n"));
3883 fprintf (file, _(" -I --identify <implib> Report the name of the DLL associated with <implib>.\n"));
3884 fprintf (file, _(" --identify-strict Causes --identify to report error when multiple DLLs.\n"));
3885 fprintf (file, _(" -v --verbose Be verbose.\n"));
3886 fprintf (file, _(" -V --version Display the program version.\n"));
3887 fprintf (file, _(" -h --help Display this information.\n"));
3888 fprintf (file, _(" @<file> Read options from <file>.\n"));
3889 #ifdef DLLTOOL_MCORE_ELF
3890 fprintf (file, _(" -M --mcore-elf <outname> Process mcore-elf object files into <outname>.\n"));
3891 fprintf (file, _(" -L --linker <name> Use <name> as the linker.\n"));
3892 fprintf (file, _(" -F --linker-flags <flags> Pass <flags> to the linker.\n"));
3894 if (REPORT_BUGS_TO[0] && status == 0)
3895 fprintf (file, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3899 #define OPTION_EXPORT_ALL_SYMS 150
3900 #define OPTION_NO_EXPORT_ALL_SYMS (OPTION_EXPORT_ALL_SYMS + 1)
3901 #define OPTION_EXCLUDE_SYMS (OPTION_NO_EXPORT_ALL_SYMS + 1)
3902 #define OPTION_NO_DEFAULT_EXCLUDES (OPTION_EXCLUDE_SYMS + 1)
3903 #define OPTION_ADD_STDCALL_UNDERSCORE (OPTION_NO_DEFAULT_EXCLUDES + 1)
3904 #define OPTION_USE_NUL_PREFIXED_IMPORT_TABLES \
3905 (OPTION_ADD_STDCALL_UNDERSCORE + 1)
3906 #define OPTION_IDENTIFY_STRICT (OPTION_USE_NUL_PREFIXED_IMPORT_TABLES + 1)
3908 static const struct option long_options[] =
3910 {"no-delete", no_argument, NULL, 'n'},
3911 {"dllname", required_argument, NULL, 'D'},
3912 {"no-idata4", no_argument, NULL, 'x'},
3913 {"no-idata5", no_argument, NULL, 'c'},
3914 {"use-nul-prefixed-import-tables", no_argument, NULL,
3915 OPTION_USE_NUL_PREFIXED_IMPORT_TABLES},
3916 {"output-exp", required_argument, NULL, 'e'},
3917 {"output-def", required_argument, NULL, 'z'},
3918 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL_SYMS},
3919 {"no-export-all-symbols", no_argument, NULL, OPTION_NO_EXPORT_ALL_SYMS},
3920 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMS},
3921 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
3922 {"output-lib", required_argument, NULL, 'l'},
3923 {"def", required_argument, NULL, 'd'}, /* for compatibility with older versions */
3924 {"input-def", required_argument, NULL, 'd'},
3925 {"add-underscore", no_argument, NULL, 'U'},
3926 {"add-stdcall-underscore", no_argument, NULL, OPTION_ADD_STDCALL_UNDERSCORE},
3927 {"kill-at", no_argument, NULL, 'k'},
3928 {"add-stdcall-alias", no_argument, NULL, 'A'},
3929 {"ext-prefix-alias", required_argument, NULL, 'p'},
3930 {"identify", required_argument, NULL, 'I'},
3931 {"identify-strict", no_argument, NULL, OPTION_IDENTIFY_STRICT},
3932 {"verbose", no_argument, NULL, 'v'},
3933 {"version", no_argument, NULL, 'V'},
3934 {"help", no_argument, NULL, 'h'},
3935 {"machine", required_argument, NULL, 'm'},
3936 {"add-indirect", no_argument, NULL, 'a'},
3937 {"base-file", required_argument, NULL, 'b'},
3938 {"as", required_argument, NULL, 'S'},
3939 {"as-flags", required_argument, NULL, 'f'},
3940 {"mcore-elf", required_argument, NULL, 'M'},
3941 {"compat-implib", no_argument, NULL, 'C'},
3942 {"temp-prefix", required_argument, NULL, 't'},
3943 {"output-delaylib", required_argument, NULL, 'y'},
3947 int main (int, char **);
3950 main (int ac, char **av)
3955 program_name = av[0];
3958 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
3959 setlocale (LC_MESSAGES, "");
3961 #if defined (HAVE_SETLOCALE)
3962 setlocale (LC_CTYPE, "");
3964 bindtextdomain (PACKAGE, LOCALEDIR);
3965 textdomain (PACKAGE);
3967 expandargv (&ac, &av);
3969 while ((c = getopt_long (ac, av,
3970 #ifdef DLLTOOL_MCORE_ELF
3971 "m:e:l:aD:d:z:b:xp:cCuUkAS:f:nI:vVHhM:L:F:",
3973 "m:e:l:y:aD:d:z:b:xp:cCuUkAS:f:nI:vVHh",
3980 case OPTION_EXPORT_ALL_SYMS:
3981 export_all_symbols = TRUE;
3983 case OPTION_NO_EXPORT_ALL_SYMS:
3984 export_all_symbols = FALSE;
3986 case OPTION_EXCLUDE_SYMS:
3987 add_excludes (optarg);
3989 case OPTION_NO_DEFAULT_EXCLUDES:
3990 do_default_excludes = FALSE;
3992 case OPTION_USE_NUL_PREFIXED_IMPORT_TABLES:
3993 use_nul_prefixed_import_tables = TRUE;
3995 case OPTION_ADD_STDCALL_UNDERSCORE:
3996 add_stdcall_underscore = 1;
3998 case OPTION_IDENTIFY_STRICT:
3999 identify_strict = 1;
4011 tmp_prefix = optarg;
4017 /* Ignored for compatibility. */
4024 output_def = fopen (optarg, FOPEN_WT);
4027 dll_name = (char*) lbasename (optarg);
4028 if (dll_name != optarg)
4029 non_fatal (_("Path components stripped from dllname, '%s'."),
4046 identify_imp_name = optarg;
4052 print_version (program_name);
4061 add_stdcall_alias = 1;
4064 ext_prefix_alias = optarg;
4073 base_file = fopen (optarg, FOPEN_RB);
4076 /* xgettext:c-format */
4077 fatal (_("Unable to open base-file: %s"), optarg);
4080 #ifdef DLLTOOL_MCORE_ELF
4082 mcore_elf_out_file = optarg;
4085 mcore_elf_linker = optarg;
4088 mcore_elf_linker_flags = optarg;
4092 create_compat_implib = 1;
4095 delayimp_name = optarg;
4104 tmp_prefix = prefix_encode ("d", getpid ());
4106 for (i = 0; mtable[i].type; i++)
4107 if (strcmp (mtable[i].type, mname) == 0)
4110 if (!mtable[i].type)
4111 /* xgettext:c-format */
4112 fatal (_("Machine '%s' not supported"), mname);
4116 /* Check if we generated PE+. */
4117 create_for_pep = strcmp (mname, "i386:x86-64") == 0;
4119 if (!dll_name && exp_name)
4121 /* If we are inferring dll_name from exp_name,
4122 strip off any path components, without emitting
4124 const char* exp_basename = lbasename (exp_name);
4125 const int len = strlen (exp_basename) + 5;
4126 dll_name = xmalloc (len);
4127 strcpy (dll_name, exp_basename);
4128 strcat (dll_name, ".dll");
4131 if (as_name == NULL)
4132 as_name = deduce_name ("as");
4134 /* Don't use the default exclude list if we're reading only the
4135 symbols in the .drectve section. The default excludes are meant
4136 to avoid exporting DLL entry point and Cygwin32 impure_ptr. */
4137 if (! export_all_symbols)
4138 do_default_excludes = FALSE;
4140 if (do_default_excludes)
4141 set_default_excludes ();
4144 process_def_file (def_file);
4149 firstarg = av[optind];
4150 scan_obj_file (av[optind]);
4161 /* Make imp_name safe for use as a label. */
4164 imp_name_lab = xstrdup (imp_name);
4165 for (p = imp_name_lab; *p; p++)
4170 head_label = make_label("_head_", imp_name_lab);
4176 /* Make delayimp_name safe for use as a label. */
4179 if (mtable[machine].how_dljtab == 0)
4181 inform (_("Warning, machine type (%d) not supported for "
4182 "delayimport."), machine);
4187 imp_name = delayimp_name;
4188 imp_name_lab = xstrdup (imp_name);
4189 for (p = imp_name_lab; *p; p++)
4194 head_label = make_label("__tailMerge_", imp_name_lab);
4202 if (identify_imp_name)
4204 identify_dll_for_implib ();
4207 #ifdef DLLTOOL_MCORE_ELF
4208 if (mcore_elf_out_file)
4209 mcore_elf_gen_out_file ();
4215 /* Look for the program formed by concatenating PROG_NAME and the
4216 string running from PREFIX to END_PREFIX. If the concatenated
4217 string contains a '/', try appending EXECUTABLE_SUFFIX if it is
4221 look_for_prog (const char *prog_name, const char *prefix, int end_prefix)
4226 cmd = xmalloc (strlen (prefix)
4227 + strlen (prog_name)
4228 #ifdef HAVE_EXECUTABLE_SUFFIX
4229 + strlen (EXECUTABLE_SUFFIX)
4232 strcpy (cmd, prefix);
4234 sprintf (cmd + end_prefix, "%s", prog_name);
4236 if (strchr (cmd, '/') != NULL)
4240 found = (stat (cmd, &s) == 0
4241 #ifdef HAVE_EXECUTABLE_SUFFIX
4242 || stat (strcat (cmd, EXECUTABLE_SUFFIX), &s) == 0
4248 /* xgettext:c-format */
4249 inform (_("Tried file: %s"), cmd);
4255 /* xgettext:c-format */
4256 inform (_("Using file: %s"), cmd);
4261 /* Deduce the name of the program we are want to invoke.
4262 PROG_NAME is the basic name of the program we want to run,
4263 eg "as" or "ld". The catch is that we might want actually
4264 run "i386-pe-as" or "ppc-pe-ld".
4266 If argv[0] contains the full path, then try to find the program
4267 in the same place, with and then without a target-like prefix.
4269 Given, argv[0] = /usr/local/bin/i586-cygwin32-dlltool,
4270 deduce_name("as") uses the following search order:
4272 /usr/local/bin/i586-cygwin32-as
4276 If there's an EXECUTABLE_SUFFIX, it'll use that as well; for each
4277 name, it'll try without and then with EXECUTABLE_SUFFIX.
4279 Given, argv[0] = i586-cygwin32-dlltool, it will not even try "as"
4280 as the fallback, but rather return i586-cygwin32-as.
4282 Oh, and given, argv[0] = dlltool, it'll return "as".
4284 Returns a dynamically allocated string. */
4287 deduce_name (const char *prog_name)
4290 char *dash, *slash, *cp;
4294 for (cp = program_name; *cp != '\0'; ++cp)
4299 #if defined(__DJGPP__) || defined (__CYGWIN__) || defined(__WIN32__)
4300 *cp == ':' || *cp == '\\' ||
4313 /* First, try looking for a prefixed PROG_NAME in the
4314 PROGRAM_NAME directory, with the same prefix as PROGRAM_NAME. */
4315 cmd = look_for_prog (prog_name, program_name, dash - program_name + 1);
4318 if (slash != NULL && cmd == NULL)
4320 /* Next, try looking for a PROG_NAME in the same directory as
4321 that of this program. */
4322 cmd = look_for_prog (prog_name, program_name, slash - program_name + 1);
4327 /* Just return PROG_NAME as is. */
4328 cmd = xstrdup (prog_name);
4334 #ifdef DLLTOOL_MCORE_ELF
4335 typedef struct fname_cache
4337 const char * filename;
4338 struct fname_cache * next;
4342 static fname_cache fnames;
4345 mcore_elf_cache_filename (const char * filename)
4351 while (ptr->next != NULL)
4354 ptr->filename = filename;
4355 ptr->next = (fname_cache *) malloc (sizeof (fname_cache));
4356 if (ptr->next != NULL)
4357 ptr->next->next = NULL;
4360 #define MCORE_ELF_TMP_OBJ "mcoreelf.o"
4361 #define MCORE_ELF_TMP_EXP "mcoreelf.exp"
4362 #define MCORE_ELF_TMP_LIB "mcoreelf.lib"
4365 mcore_elf_gen_out_file (void)
4370 /* Step one. Run 'ld -r' on the input object files in order to resolve
4371 any internal references and to generate a single .exports section. */
4374 ds = dyn_string_new (100);
4375 dyn_string_append_cstr (ds, "-r ");
4377 if (mcore_elf_linker_flags != NULL)
4378 dyn_string_append_cstr (ds, mcore_elf_linker_flags);
4380 while (ptr->next != NULL)
4382 dyn_string_append_cstr (ds, ptr->filename);
4383 dyn_string_append_cstr (ds, " ");
4388 dyn_string_append_cstr (ds, "-o ");
4389 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
4391 if (mcore_elf_linker == NULL)
4392 mcore_elf_linker = deduce_name ("ld");
4394 run (mcore_elf_linker, ds->s);
4396 dyn_string_delete (ds);
4398 /* Step two. Create a .exp file and a .lib file from the temporary file.
4399 Do this by recursively invoking dlltool... */
4400 ds = dyn_string_new (100);
4402 dyn_string_append_cstr (ds, "-S ");
4403 dyn_string_append_cstr (ds, as_name);
4405 dyn_string_append_cstr (ds, " -e ");
4406 dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP);
4407 dyn_string_append_cstr (ds, " -l ");
4408 dyn_string_append_cstr (ds, MCORE_ELF_TMP_LIB);
4409 dyn_string_append_cstr (ds, " " );
4410 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
4413 dyn_string_append_cstr (ds, " -v");
4417 dyn_string_append_cstr (ds, " -n");
4419 if (dontdeltemps > 1)
4420 dyn_string_append_cstr (ds, " -n");
4423 /* XXX - FIME: ought to check/copy other command line options as well. */
4424 run (program_name, ds->s);
4426 dyn_string_delete (ds);
4428 /* Step four. Feed the .exp and object files to ld -shared to create the dll. */
4429 ds = dyn_string_new (100);
4431 dyn_string_append_cstr (ds, "-shared ");
4433 if (mcore_elf_linker_flags)
4434 dyn_string_append_cstr (ds, mcore_elf_linker_flags);
4436 dyn_string_append_cstr (ds, " ");
4437 dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP);
4438 dyn_string_append_cstr (ds, " ");
4439 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
4440 dyn_string_append_cstr (ds, " -o ");
4441 dyn_string_append_cstr (ds, mcore_elf_out_file);
4443 run (mcore_elf_linker, ds->s);
4445 dyn_string_delete (ds);
4447 if (dontdeltemps == 0)
4448 unlink (MCORE_ELF_TMP_EXP);
4450 if (dontdeltemps < 2)
4451 unlink (MCORE_ELF_TMP_OBJ);
4453 #endif /* DLLTOOL_MCORE_ELF */