1 /* dlltool.c -- tool to generate stuff for PE style DLLs
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
3 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 2 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., 59 Temple Place - Suite 330, 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 whoes 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 4096
245 #define PAGE_MASK (-PAGE_SIZE)
247 #include "libiberty.h"
250 #include "demangle.h"
251 #include "dyn-string.h"
253 #include "safe-ctype.h"
256 #include <sys/stat.h>
258 #ifdef ANSI_PROTOTYPES
267 #include "coff/arm.h"
268 #include "coff/internal.h"
271 /* Forward references. */
272 static char *look_for_prog (const char *, const char *, int);
273 static char *deduce_name (const char *);
275 #ifdef DLLTOOL_MCORE_ELF
276 static void mcore_elf_cache_filename (char *);
277 static void mcore_elf_gen_out_file (void);
280 #ifdef HAVE_SYS_WAIT_H
281 #include <sys/wait.h>
282 #else /* ! HAVE_SYS_WAIT_H */
283 #if ! defined (_WIN32) || defined (__CYGWIN32__)
285 #define WIFEXITED(w) (((w) & 0377) == 0)
288 #define WIFSIGNALED(w) (((w) & 0377) != 0177 && ((w) & ~0377) == 0)
291 #define WTERMSIG(w) ((w) & 0177)
294 #define WEXITSTATUS(w) (((w) >> 8) & 0377)
296 #else /* defined (_WIN32) && ! defined (__CYGWIN32__) */
298 #define WIFEXITED(w) (((w) & 0xff) == 0)
301 #define WIFSIGNALED(w) (((w) & 0xff) != 0 && ((w) & 0xff) != 0x7f)
304 #define WTERMSIG(w) ((w) & 0x7f)
307 #define WEXITSTATUS(w) (((w) & 0xff00) >> 8)
309 #endif /* defined (_WIN32) && ! defined (__CYGWIN32__) */
310 #endif /* ! HAVE_SYS_WAIT_H */
312 /* ifunc and ihead data structures: ttk@cygnus.com 1997
314 When IMPORT declarations are encountered in a .def file the
315 function import information is stored in a structure referenced by
316 the global variable IMPORT_LIST. The structure is a linked list
317 containing the names of the dll files each function is imported
318 from and a linked list of functions being imported from that dll
319 file. This roughly parallels the structure of the .idata section
320 in the PE object file.
322 The contents of .def file are interpreted from within the
323 process_def_file function. Every time an IMPORT declaration is
324 encountered, it is broken up into its component parts and passed to
325 def_import. IMPORT_LIST is initialized to NULL in function main. */
327 typedef struct ifunct
329 char * name; /* Name of function being imported. */
330 int ord; /* Two-byte ordinal value associated with function. */
334 typedef struct iheadt
336 char *dllname; /* Name of dll file imported from. */
337 long nfuncs; /* Number of functions in list. */
338 struct ifunct *funchead; /* First function in list. */
339 struct ifunct *functail; /* Last function in list. */
340 struct iheadt *next; /* Next dll file in list. */
343 /* Structure containing all import information as defined in .def file
344 (qv "ihead structure"). */
346 static iheadtype *import_list = NULL;
348 static char *as_name = NULL;
349 static char * as_flags = "";
351 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 *head_label;
358 static char *imp_name_lab;
359 static char *dll_name;
361 static int add_indirect = 0;
362 static int add_underscore = 0;
363 static int dontdeltemps = 0;
365 /* TRUE if we should export all symbols. Otherwise, we only export
366 symbols listed in .drectve sections or in the def file. */
367 static bfd_boolean export_all_symbols;
369 /* TRUE if we should exclude the symbols in DEFAULT_EXCLUDES when
370 exporting all symbols. */
371 static bfd_boolean do_default_excludes = TRUE;
373 /* Default symbols to exclude when exporting all the symbols. */
374 static const char *default_excludes = "DllMain@12,DllEntryPoint@0,impure_ptr";
376 /* TRUE if we should add __imp_<SYMBOL> to import libraries for backward
377 compatibility to old Cygwin releases. */
378 static bfd_boolean create_compat_implib;
380 static char *def_file;
382 extern char * program_name;
386 static int add_stdcall_alias;
387 static const char *ext_prefix_alias;
389 static FILE *output_def;
390 static FILE *base_file;
393 #ifdef DLLTOOL_ARM_EPOC
394 static const char *mname = "arm-epoc";
396 static const char *mname = "arm";
401 static const char *mname = "i386";
405 static const char *mname = "ppc";
409 static const char *mname = "sh";
413 static const char *mname = "mips";
417 static const char * mname = "mcore-le";
420 #ifdef DLLTOOL_MCORE_ELF
421 static const char * mname = "mcore-elf";
422 static char * mcore_elf_out_file = NULL;
423 static char * mcore_elf_linker = NULL;
424 static char * mcore_elf_linker_flags = NULL;
426 #define DRECTVE_SECTION_NAME ((machine == MMCORE_ELF || machine == MMCORE_ELF_LE) ? ".exports" : ".drectve")
429 #ifndef DRECTVE_SECTION_NAME
430 #define DRECTVE_SECTION_NAME ".drectve"
433 /* What's the right name for this ? */
436 /* External name alias numbering starts here. */
437 #define PREFIX_ALIAS_BASE 20000
440 char *tmp_head_s_buf;
441 char *tmp_head_o_buf;
442 char *tmp_tail_s_buf;
443 char *tmp_tail_o_buf;
446 #define TMP_ASM dlltmp (&tmp_asm_buf, "%sc.s")
447 #define TMP_HEAD_S dlltmp (&tmp_head_s_buf, "%sh.s")
448 #define TMP_HEAD_O dlltmp (&tmp_head_o_buf, "%sh.o")
449 #define TMP_TAIL_S dlltmp (&tmp_tail_s_buf, "%st.s")
450 #define TMP_TAIL_O dlltmp (&tmp_tail_o_buf, "%st.o")
451 #define TMP_STUB dlltmp (&tmp_stub_buf, "%ss")
453 /* This bit of assembly does jmp * .... */
454 static const unsigned char i386_jtab[] =
456 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
459 static const unsigned char arm_jtab[] =
461 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
462 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
466 static const unsigned char arm_interwork_jtab[] =
468 0x04, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
469 0x00, 0xc0, 0x9c, 0xe5, /* ldr ip, [ip] */
470 0x1c, 0xff, 0x2f, 0xe1, /* bx ip */
474 static const unsigned char thumb_jtab[] =
476 0x40, 0xb4, /* push {r6} */
477 0x02, 0x4e, /* ldr r6, [pc, #8] */
478 0x36, 0x68, /* ldr r6, [r6] */
479 0xb4, 0x46, /* mov ip, r6 */
480 0x40, 0xbc, /* pop {r6} */
481 0x60, 0x47, /* bx ip */
485 static const unsigned char mcore_be_jtab[] =
487 0x71, 0x02, /* lrw r1,2 */
488 0x81, 0x01, /* ld.w r1,(r1,0) */
489 0x00, 0xC1, /* jmp r1 */
490 0x12, 0x00, /* nop */
491 0x00, 0x00, 0x00, 0x00 /* <address> */
494 static const unsigned char mcore_le_jtab[] =
496 0x02, 0x71, /* lrw r1,2 */
497 0x01, 0x81, /* ld.w r1,(r1,0) */
498 0xC1, 0x00, /* jmp r1 */
499 0x00, 0x12, /* nop */
500 0x00, 0x00, 0x00, 0x00 /* <address> */
503 /* This is the glue sequence for PowerPC PE. There is a
504 tocrel16-tocdefn reloc against the first instruction.
505 We also need a IMGLUE reloc against the glue function
506 to restore the toc saved by the third instruction in
508 static const unsigned char ppc_jtab[] =
510 0x00, 0x00, 0x62, 0x81, /* lwz r11,0(r2) */
511 /* Reloc TOCREL16 __imp_xxx */
512 0x00, 0x00, 0x8B, 0x81, /* lwz r12,0(r11) */
513 0x04, 0x00, 0x41, 0x90, /* stw r2,4(r1) */
514 0xA6, 0x03, 0x89, 0x7D, /* mtctr r12 */
515 0x04, 0x00, 0x4B, 0x80, /* lwz r2,4(r11) */
516 0x20, 0x04, 0x80, 0x4E /* bctr */
520 /* The glue instruction, picks up the toc from the stw in
521 the above code: "lwz r2,4(r1)". */
522 static bfd_vma ppc_glue_insn = 0x80410004;
528 const char *how_byte;
529 const char *how_short;
530 const char *how_long;
531 const char *how_asciz;
532 const char *how_comment;
533 const char *how_jump;
534 const char *how_global;
535 const char *how_space;
536 const char *how_align_short;
537 const char *how_align_long;
538 const char *how_default_as_switches;
539 const char *how_bfd_target;
540 enum bfd_architecture how_bfd_arch;
541 const unsigned char *how_jtab;
542 int how_jtab_size; /* Size of the jtab entry. */
543 int how_jtab_roff; /* Offset into it for the ind 32 reloc into idata 5. */
546 static const struct mac
551 "arm", ".byte", ".short", ".long", ".asciz", "@",
552 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
553 ".global", ".space", ".align\t2",".align\t4", "-mapcs-32",
554 "pe-arm-little", bfd_arch_arm,
555 arm_jtab, sizeof (arm_jtab), 8
560 "i386", ".byte", ".short", ".long", ".asciz", "#",
561 "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
562 "pe-i386",bfd_arch_i386,
563 i386_jtab, sizeof (i386_jtab), 2
568 "ppc", ".byte", ".short", ".long", ".asciz", "#",
569 "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
570 "pe-powerpcle",bfd_arch_powerpc,
571 ppc_jtab, sizeof (ppc_jtab), 0
576 "thumb", ".byte", ".short", ".long", ".asciz", "@",
577 "push\t{r6}\n\tldr\tr6, [pc, #8]\n\tldr\tr6, [r6]\n\tmov\tip, r6\n\tpop\t{r6}\n\tbx\tip",
578 ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
579 "pe-arm-little", bfd_arch_arm,
580 thumb_jtab, sizeof (thumb_jtab), 12
583 #define MARM_INTERWORK 4
585 "arm_interwork", ".byte", ".short", ".long", ".asciz", "@",
586 "ldr\tip,[pc]\n\tldr\tip,[ip]\n\tbx\tip\n\t.long",
587 ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
588 "pe-arm-little", bfd_arch_arm,
589 arm_interwork_jtab, sizeof (arm_interwork_jtab), 12
594 "mcore-be", ".byte", ".short", ".long", ".asciz", "//",
595 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
596 ".global", ".space", ".align\t2",".align\t4", "",
597 "pe-mcore-big", bfd_arch_mcore,
598 mcore_be_jtab, sizeof (mcore_be_jtab), 8
603 "mcore-le", ".byte", ".short", ".long", ".asciz", "//",
604 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
605 ".global", ".space", ".align\t2",".align\t4", "-EL",
606 "pe-mcore-little", bfd_arch_mcore,
607 mcore_le_jtab, sizeof (mcore_le_jtab), 8
612 "mcore-elf-be", ".byte", ".short", ".long", ".asciz", "//",
613 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
614 ".global", ".space", ".align\t2",".align\t4", "",
615 "elf32-mcore-big", bfd_arch_mcore,
616 mcore_be_jtab, sizeof (mcore_be_jtab), 8
620 #define MMCORE_ELF_LE 8
621 "mcore-elf-le", ".byte", ".short", ".long", ".asciz", "//",
622 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
623 ".global", ".space", ".align\t2",".align\t4", "-EL",
624 "elf32-mcore-little", bfd_arch_mcore,
625 mcore_le_jtab, sizeof (mcore_le_jtab), 8
630 "arm-epoc", ".byte", ".short", ".long", ".asciz", "@",
631 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
632 ".global", ".space", ".align\t2",".align\t4", "",
633 "epoc-pe-arm-little", bfd_arch_arm,
634 arm_jtab, sizeof (arm_jtab), 8
637 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
647 typedef struct export
650 const char *internal_name;
651 const char *import_name;
654 int noname; /* Don't put name in image file. */
655 int private; /* Don't put reference in import lib. */
658 int forward; /* Number of forward label, 0 means no forward. */
663 /* A list of symbols which we should not export. */
667 struct string_list *next;
671 static struct string_list *excludes;
673 static const char *rvaafter (int);
674 static const char *rvabefore (int);
675 static const char *asm_prefix (int, const char *);
676 static void process_def_file (const char *);
677 static void new_directive (char *);
678 static void append_import (const char *, const char *, int);
679 static void run (const char *, char *);
680 static void scan_drectve_symbols (bfd *);
681 static void scan_filtered_symbols (bfd *, void *, long, unsigned int);
682 static void add_excludes (const char *);
683 static bfd_boolean match_exclude (const char *);
684 static void set_default_excludes (void);
685 static long filter_symbols (bfd *, void *, long, unsigned int);
686 static void scan_all_symbols (bfd *);
687 static void scan_open_obj_file (bfd *);
688 static void scan_obj_file (const char *);
689 static void dump_def_info (FILE *);
690 static int sfunc (const void *, const void *);
691 static void flush_page (FILE *, long *, int, int);
692 static void gen_def_file (void);
693 static void generate_idata_ofile (FILE *);
694 static void assemble_file (const char *, const char *);
695 static void gen_exp_file (void);
696 static const char *xlate (const char *);
698 static void dump_iat (FILE *, export_type *);
700 static char *make_label (const char *, const char *);
701 static char *make_imp_label (const char *, const char *);
702 static bfd *make_one_lib_file (export_type *, int);
703 static bfd *make_head (void);
704 static bfd *make_tail (void);
705 static void gen_lib_file (void);
706 static int pfunc (const void *, const void *);
707 static int nfunc (const void *, const void *);
708 static void remove_null_names (export_type **);
709 static void dtab (export_type **);
710 static void process_duplicates (export_type **);
711 static void fill_ordinals (export_type **);
712 static int alphafunc (const void *, const void *);
713 static void mangle_defs (void);
714 static void usage (FILE *, int);
715 static void inform (const char *, ...);
718 prefix_encode (char *start, unsigned code)
720 static char alpha[26] = "abcdefghijklmnopqrstuvwxyz";
724 p = strchr (buf, '\0');
726 *p++ = alpha[code % sizeof (alpha)];
727 while ((code /= sizeof (alpha)) != 0);
733 dlltmp (char **buf, const char *fmt)
737 *buf = malloc (strlen (tmp_prefix) + 64);
738 sprintf (*buf, fmt, tmp_prefix);
744 inform VPARAMS ((const char * message, ...))
746 VA_OPEN (args, message);
747 VA_FIXEDARG (args, const char *, message);
752 report (message, args);
758 rvaafter (int machine)
774 /* xgettext:c-format */
775 fatal (_("Internal error: Unknown machine type: %d"), machine);
782 rvabefore (int machine)
798 /* xgettext:c-format */
799 fatal (_("Internal error: Unknown machine type: %d"), machine);
806 asm_prefix (int machine, const char *name)
821 /* Symbol names starting with ? do not have a leading underscore. */
822 if (name && *name == '?')
827 /* xgettext:c-format */
828 fatal (_("Internal error: Unknown machine type: %d"), machine);
834 #define ASM_BYTE mtable[machine].how_byte
835 #define ASM_SHORT mtable[machine].how_short
836 #define ASM_LONG mtable[machine].how_long
837 #define ASM_TEXT mtable[machine].how_asciz
838 #define ASM_C mtable[machine].how_comment
839 #define ASM_JUMP mtable[machine].how_jump
840 #define ASM_GLOBAL mtable[machine].how_global
841 #define ASM_SPACE mtable[machine].how_space
842 #define ASM_ALIGN_SHORT mtable[machine].how_align_short
843 #define ASM_RVA_BEFORE rvabefore (machine)
844 #define ASM_RVA_AFTER rvaafter (machine)
845 #define ASM_PREFIX(NAME) asm_prefix (machine, (NAME))
846 #define ASM_ALIGN_LONG mtable[machine].how_align_long
847 #define HOW_BFD_READ_TARGET 0 /* Always default. */
848 #define HOW_BFD_WRITE_TARGET mtable[machine].how_bfd_target
849 #define HOW_BFD_ARCH mtable[machine].how_bfd_arch
850 #define HOW_JTAB mtable[machine].how_jtab
851 #define HOW_JTAB_SIZE mtable[machine].how_jtab_size
852 #define HOW_JTAB_ROFF mtable[machine].how_jtab_roff
853 #define ASM_SWITCHES mtable[machine].how_default_as_switches
858 process_def_file (const char *name)
860 FILE *f = fopen (name, FOPEN_RT);
863 /* xgettext:c-format */
864 fatal (_("Can't open def file: %s"), name);
868 /* xgettext:c-format */
869 inform (_("Processing def file: %s"), name);
873 inform (_("Processed def file"));
876 /**********************************************************************/
878 /* Communications with the parser. */
880 static const char *d_name; /* Arg to NAME or LIBRARY. */
881 static int d_nfuncs; /* Number of functions exported. */
882 static int d_named_nfuncs; /* Number of named functions exported. */
883 static int d_low_ord; /* Lowest ordinal index. */
884 static int d_high_ord; /* Highest ordinal index. */
885 static export_type *d_exports; /* List of exported functions. */
886 static export_type **d_exports_lexically; /* Vector of exported functions in alpha order. */
887 static dlist_type *d_list; /* Descriptions. */
888 static dlist_type *a_list; /* Stuff to go in directives. */
889 static int d_nforwards = 0; /* Number of forwarded exports. */
895 yyerror (const char * err ATTRIBUTE_UNUSED)
897 /* xgettext:c-format */
898 non_fatal (_("Syntax error in def file %s:%d"), def_file, linenumber);
904 def_exports (const char *name, const char *internal_name, int ordinal,
905 int noname, int constant, int data, int private)
907 struct export *p = (struct export *) xmalloc (sizeof (*p));
910 p->internal_name = internal_name ? internal_name : name;
911 p->import_name = name;
912 p->ordinal = ordinal;
913 p->constant = constant;
915 p->private = private;
921 if ((internal_name != NULL)
922 && (strchr (internal_name, '.') != NULL))
923 p->forward = ++d_nforwards;
925 p->forward = 0; /* no forward */
929 def_name (const char *name, int base)
931 /* xgettext:c-format */
932 inform (_("NAME: %s base: %x"), name, base);
935 non_fatal (_("Can't have LIBRARY and NAME"));
938 /* If --dllname not provided, use the one in the DEF file.
939 FIXME: Is this appropriate for executables? */
941 dll_name = xstrdup (name);
946 def_library (const char *name, int base)
948 /* xgettext:c-format */
949 inform (_("LIBRARY: %s base: %x"), name, base);
952 non_fatal (_("Can't have LIBRARY and NAME"));
955 /* If --dllname not provided, use the one in the DEF file. */
957 dll_name = xstrdup (name);
962 def_description (const char *desc)
964 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
965 d->text = xstrdup (desc);
971 new_directive (char *dir)
973 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
974 d->text = xstrdup (dir);
980 def_heapsize (int reserve, int commit)
984 sprintf (b, "-heap 0x%x,0x%x ", reserve, commit);
986 sprintf (b, "-heap 0x%x ", reserve);
987 new_directive (xstrdup (b));
991 def_stacksize (int reserve, int commit)
995 sprintf (b, "-stack 0x%x,0x%x ", reserve, commit);
997 sprintf (b, "-stack 0x%x ", reserve);
998 new_directive (xstrdup (b));
1001 /* append_import simply adds the given import definition to the global
1002 import_list. It is used by def_import. */
1005 append_import (const char *symbol_name, const char *dll_name, int func_ordinal)
1010 for (pq = &import_list; *pq != NULL; pq = &(*pq)->next)
1012 if (strcmp ((*pq)->dllname, dll_name) == 0)
1015 q->functail->next = xmalloc (sizeof (ifunctype));
1016 q->functail = q->functail->next;
1017 q->functail->ord = func_ordinal;
1018 q->functail->name = xstrdup (symbol_name);
1019 q->functail->next = NULL;
1025 q = xmalloc (sizeof (iheadtype));
1026 q->dllname = xstrdup (dll_name);
1028 q->funchead = xmalloc (sizeof (ifunctype));
1029 q->functail = q->funchead;
1031 q->functail->name = xstrdup (symbol_name);
1032 q->functail->ord = func_ordinal;
1033 q->functail->next = NULL;
1038 /* def_import is called from within defparse.y when an IMPORT
1039 declaration is encountered. Depending on the form of the
1040 declaration, the module name may or may not need ".dll" to be
1041 appended to it, the name of the function may be stored in internal
1042 or entry, and there may or may not be an ordinal value associated
1045 /* A note regarding the parse modes:
1046 In defparse.y we have to accept import declarations which follow
1047 any one of the following forms:
1048 <func_name_in_app> = <dll_name>.<func_name_in_dll>
1049 <func_name_in_app> = <dll_name>.<number>
1050 <dll_name>.<func_name_in_dll>
1052 Furthermore, the dll's name may or may not end with ".dll", which
1053 complicates the parsing a little. Normally the dll's name is
1054 passed to def_import() in the "module" parameter, but when it ends
1055 with ".dll" it gets passed in "module" sans ".dll" and that needs
1058 def_import gets five parameters:
1059 APP_NAME - the name of the function in the application, if
1060 present, or NULL if not present.
1061 MODULE - the name of the dll, possibly sans extension (ie, '.dll').
1062 DLLEXT - the extension of the dll, if present, NULL if not present.
1063 ENTRY - the name of the function in the dll, if present, or NULL.
1064 ORD_VAL - the numerical tag of the function in the dll, if present,
1065 or NULL. Exactly one of <entry> or <ord_val> must be
1066 present (i.e., not NULL). */
1069 def_import (const char *app_name, const char *module, const char *dllext,
1070 const char *entry, int ord_val)
1072 const char *application_name;
1076 application_name = entry;
1079 if (app_name != NULL)
1080 application_name = app_name;
1082 application_name = "";
1087 buf = (char *) alloca (strlen (module) + strlen (dllext) + 2);
1088 sprintf (buf, "%s.%s", module, dllext);
1092 append_import (application_name, module, ord_val);
1096 def_version (int major, int minor)
1098 printf ("VERSION %d.%d\n", major, minor);
1102 def_section (const char *name, int attr)
1117 sprintf (buf, "-attr %s %s", name, atts);
1118 new_directive (xstrdup (buf));
1125 def_section ("CODE", attr);
1131 def_section ("DATA", attr);
1134 /**********************************************************************/
1137 run (const char *what, char *args)
1140 int pid, wait_status;
1143 char *errmsg_fmt, *errmsg_arg;
1144 char *temp_base = choose_temp_base ();
1146 inform ("run: %s %s", what, args);
1148 /* Count the args */
1150 for (s = args; *s; s++)
1154 argv = alloca (sizeof (char *) * (i + 3));
1163 while (*s != ' ' && *s != 0)
1171 pid = pexecute (argv[0], (char * const *) argv, program_name, temp_base,
1172 &errmsg_fmt, &errmsg_arg, PEXECUTE_ONE | PEXECUTE_SEARCH);
1176 inform (strerror (errno));
1178 fatal (errmsg_fmt, errmsg_arg);
1181 pid = pwait (pid, & wait_status, 0);
1185 /* xgettext:c-format */
1186 fatal (_("wait: %s"), strerror (errno));
1188 else if (WIFSIGNALED (wait_status))
1190 /* xgettext:c-format */
1191 fatal (_("subprocess got fatal signal %d"), WTERMSIG (wait_status));
1193 else if (WIFEXITED (wait_status))
1195 if (WEXITSTATUS (wait_status) != 0)
1196 /* xgettext:c-format */
1197 non_fatal (_("%s exited with status %d"),
1198 what, WEXITSTATUS (wait_status));
1204 /* Look for a list of symbols to export in the .drectve section of
1205 ABFD. Pass each one to def_exports. */
1208 scan_drectve_symbols (bfd *abfd)
1216 /* Look for .drectve's */
1217 s = bfd_get_section_by_name (abfd, DRECTVE_SECTION_NAME);
1222 size = bfd_get_section_size (s);
1223 buf = xmalloc (size);
1225 bfd_get_section_contents (abfd, s, buf, 0, size);
1227 /* xgettext:c-format */
1228 inform (_("Sucking in info from %s section in %s"),
1229 DRECTVE_SECTION_NAME, bfd_get_filename (abfd));
1231 /* Search for -export: strings. The exported symbols can optionally
1232 have type tags (eg., -export:foo,data), so handle those as well.
1233 Currently only data tag is supported. */
1239 && strncmp (p, "-export:", 8) == 0)
1243 flagword flags = BSF_FUNCTION;
1247 while (p < e && *p != ',' && *p != ' ' && *p != '-')
1249 c = xmalloc (p - name + 1);
1250 memcpy (c, name, p - name);
1252 if (p < e && *p == ',') /* found type tag. */
1254 char *tag_start = ++p;
1255 while (p < e && *p != ' ' && *p != '-')
1257 if (strncmp (tag_start, "data", 4) == 0)
1258 flags &= ~BSF_FUNCTION;
1261 /* FIXME: The 5th arg is for the `constant' field.
1262 What should it be? Not that it matters since it's not
1263 currently useful. */
1264 def_exports (c, 0, -1, 0, 0, ! (flags & BSF_FUNCTION), 0);
1266 if (add_stdcall_alias && strchr (c, '@'))
1268 int lead_at = (*c == '@') ;
1269 char *exported_name = xstrdup (c + lead_at);
1270 char *atsym = strchr (exported_name, '@');
1272 /* Note: stdcall alias symbols can never be data. */
1273 def_exports (exported_name, xstrdup (c), -1, 0, 0, 0, 0);
1282 /* Look through the symbols in MINISYMS, and add each one to list of
1283 symbols to export. */
1286 scan_filtered_symbols (bfd *abfd, void *minisyms, long symcount,
1290 bfd_byte *from, *fromend;
1292 store = bfd_make_empty_symbol (abfd);
1294 bfd_fatal (bfd_get_filename (abfd));
1296 from = (bfd_byte *) minisyms;
1297 fromend = from + symcount * size;
1298 for (; from < fromend; from += size)
1301 const char *symbol_name;
1303 sym = bfd_minisymbol_to_symbol (abfd, FALSE, from, store);
1305 bfd_fatal (bfd_get_filename (abfd));
1307 symbol_name = bfd_asymbol_name (sym);
1308 if (bfd_get_symbol_leading_char (abfd) == symbol_name[0])
1311 def_exports (xstrdup (symbol_name) , 0, -1, 0, 0,
1312 ! (sym->flags & BSF_FUNCTION), 0);
1314 if (add_stdcall_alias && strchr (symbol_name, '@'))
1316 int lead_at = (*symbol_name == '@');
1317 char *exported_name = xstrdup (symbol_name + lead_at);
1318 char *atsym = strchr (exported_name, '@');
1320 /* Note: stdcall alias symbols can never be data. */
1321 def_exports (exported_name, xstrdup (symbol_name), -1, 0, 0, 0, 0);
1326 /* Add a list of symbols to exclude. */
1329 add_excludes (const char *new_excludes)
1332 char *exclude_string;
1334 local_copy = xstrdup (new_excludes);
1336 exclude_string = strtok (local_copy, ",:");
1337 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
1339 struct string_list *new_exclude;
1341 new_exclude = ((struct string_list *)
1342 xmalloc (sizeof (struct string_list)));
1343 new_exclude->string = (char *) xmalloc (strlen (exclude_string) + 2);
1344 /* Don't add a leading underscore for fastcall symbols. */
1345 if (*exclude_string == '@')
1346 sprintf (new_exclude->string, "%s", exclude_string);
1348 sprintf (new_exclude->string, "_%s", exclude_string);
1349 new_exclude->next = excludes;
1350 excludes = new_exclude;
1352 /* xgettext:c-format */
1353 inform (_("Excluding symbol: %s"), exclude_string);
1359 /* See if STRING is on the list of symbols to exclude. */
1362 match_exclude (const char *string)
1364 struct string_list *excl_item;
1366 for (excl_item = excludes; excl_item; excl_item = excl_item->next)
1367 if (strcmp (string, excl_item->string) == 0)
1372 /* Add the default list of symbols to exclude. */
1375 set_default_excludes (void)
1377 add_excludes (default_excludes);
1380 /* Choose which symbols to export. */
1383 filter_symbols (bfd *abfd, void *minisyms, long symcount, unsigned int size)
1385 bfd_byte *from, *fromend, *to;
1388 store = bfd_make_empty_symbol (abfd);
1390 bfd_fatal (bfd_get_filename (abfd));
1392 from = (bfd_byte *) minisyms;
1393 fromend = from + symcount * size;
1394 to = (bfd_byte *) minisyms;
1396 for (; from < fromend; from += size)
1401 sym = bfd_minisymbol_to_symbol (abfd, FALSE, (const void *) from, store);
1403 bfd_fatal (bfd_get_filename (abfd));
1405 /* Check for external and defined only symbols. */
1406 keep = (((sym->flags & BSF_GLOBAL) != 0
1407 || (sym->flags & BSF_WEAK) != 0
1408 || bfd_is_com_section (sym->section))
1409 && ! bfd_is_und_section (sym->section));
1411 keep = keep && ! match_exclude (sym->name);
1415 memcpy (to, from, size);
1420 return (to - (bfd_byte *) minisyms) / size;
1423 /* Export all symbols in ABFD, except for ones we were told not to
1427 scan_all_symbols (bfd *abfd)
1433 /* Ignore bfds with an import descriptor table. We assume that any
1434 such BFD contains symbols which are exported from another DLL,
1435 and we don't want to reexport them from here. */
1436 if (bfd_get_section_by_name (abfd, ".idata$4"))
1439 if (! (bfd_get_file_flags (abfd) & HAS_SYMS))
1441 /* xgettext:c-format */
1442 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1446 symcount = bfd_read_minisymbols (abfd, FALSE, &minisyms, &size);
1448 bfd_fatal (bfd_get_filename (abfd));
1452 /* xgettext:c-format */
1453 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1457 /* Discard the symbols we don't want to export. It's OK to do this
1458 in place; we'll free the storage anyway. */
1460 symcount = filter_symbols (abfd, minisyms, symcount, size);
1461 scan_filtered_symbols (abfd, minisyms, symcount, size);
1466 /* Look at the object file to decide which symbols to export. */
1469 scan_open_obj_file (bfd *abfd)
1471 if (export_all_symbols)
1472 scan_all_symbols (abfd);
1474 scan_drectve_symbols (abfd);
1476 /* FIXME: we ought to read in and block out the base relocations. */
1478 /* xgettext:c-format */
1479 inform (_("Done reading %s"), bfd_get_filename (abfd));
1483 scan_obj_file (const char *filename)
1485 bfd * f = bfd_openr (filename, 0);
1488 /* xgettext:c-format */
1489 fatal (_("Unable to open object file: %s"), filename);
1491 /* xgettext:c-format */
1492 inform (_("Scanning object file %s"), filename);
1494 if (bfd_check_format (f, bfd_archive))
1496 bfd *arfile = bfd_openr_next_archived_file (f, 0);
1499 if (bfd_check_format (arfile, bfd_object))
1500 scan_open_obj_file (arfile);
1502 arfile = bfd_openr_next_archived_file (f, arfile);
1505 #ifdef DLLTOOL_MCORE_ELF
1506 if (mcore_elf_out_file)
1507 inform (_("Cannot produce mcore-elf dll from archive file: %s"), filename);
1510 else if (bfd_check_format (f, bfd_object))
1512 scan_open_obj_file (f);
1514 #ifdef DLLTOOL_MCORE_ELF
1515 if (mcore_elf_out_file)
1516 mcore_elf_cache_filename ((char *) filename);
1523 /**********************************************************************/
1526 dump_def_info (FILE *f)
1530 fprintf (f, "%s ", ASM_C);
1531 for (i = 0; oav[i]; i++)
1532 fprintf (f, "%s ", oav[i]);
1534 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1536 fprintf (f, "%s %d = %s %s @ %d %s%s%s%s\n",
1542 exp->noname ? "NONAME " : "",
1543 exp->private ? "PRIVATE " : "",
1544 exp->constant ? "CONSTANT" : "",
1545 exp->data ? "DATA" : "");
1549 /* Generate the .exp file. */
1552 sfunc (const void *a, const void *b)
1554 return *(const long *) a - *(const long *) b;
1558 flush_page (FILE *f, long *need, int page_addr, int on_page)
1562 /* Flush this page. */
1563 fprintf (f, "\t%s\t0x%08x\t%s Starting RVA for chunk\n",
1567 fprintf (f, "\t%s\t0x%x\t%s Size of block\n",
1569 (on_page * 2) + (on_page & 1) * 2 + 8,
1572 for (i = 0; i < on_page; i++)
1574 long needed = need[i];
1577 needed = ((needed - page_addr) | 0x3000) & 0xffff;
1579 fprintf (f, "\t%s\t0x%lx\n", ASM_SHORT, needed);
1584 fprintf (f, "\t%s\t0x%x\n", ASM_SHORT, 0 | 0x0000);
1593 inform (_("Adding exports to output file"));
1595 fprintf (output_def, ";");
1596 for (i = 0; oav[i]; i++)
1597 fprintf (output_def, " %s", oav[i]);
1599 fprintf (output_def, "\nEXPORTS\n");
1601 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1603 char *quote = strchr (exp->name, '.') ? "\"" : "";
1604 char *res = cplus_demangle (exp->internal_name, DMGL_ANSI | DMGL_PARAMS);
1608 fprintf (output_def,";\t%s\n", res);
1612 if (strcmp (exp->name, exp->internal_name) == 0)
1614 fprintf (output_def, "\t%s%s%s @ %d%s%s%s\n",
1619 exp->noname ? " NONAME" : "",
1620 exp->private ? "PRIVATE " : "",
1621 exp->data ? " DATA" : "");
1625 char * quote1 = strchr (exp->internal_name, '.') ? "\"" : "";
1627 fprintf (output_def, "\t%s%s%s = %s%s%s @ %d%s%s%s\n",
1635 exp->noname ? " NONAME" : "",
1636 exp->private ? "PRIVATE " : "",
1637 exp->data ? " DATA" : "");
1641 inform (_("Added exports to output file"));
1644 /* generate_idata_ofile generates the portable assembly source code
1645 for the idata sections. It appends the source code to the end of
1649 generate_idata_ofile (FILE *filvar)
1657 if (import_list == NULL)
1660 fprintf (filvar, "%s Import data sections\n", ASM_C);
1661 fprintf (filvar, "\n\t.section\t.idata$2\n");
1662 fprintf (filvar, "\t%s\tdoi_idata\n", ASM_GLOBAL);
1663 fprintf (filvar, "doi_idata:\n");
1666 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1668 fprintf (filvar, "\t%slistone%d%s\t%s %s\n",
1669 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER,
1670 ASM_C, headptr->dllname);
1671 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1672 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1673 fprintf (filvar, "\t%sdllname%d%s\n",
1674 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1675 fprintf (filvar, "\t%slisttwo%d%s\n\n",
1676 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1680 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL record at */
1681 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* end of idata$2 */
1682 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* section */
1683 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1684 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1686 fprintf (filvar, "\n\t.section\t.idata$4\n");
1688 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1690 fprintf (filvar, "listone%d:\n", headindex);
1691 for ( funcindex = 0; funcindex < headptr->nfuncs; funcindex++ )
1692 fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1693 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1694 fprintf (filvar,"\t%s\t0\n", ASM_LONG); /* NULL terminating list */
1698 fprintf (filvar, "\n\t.section\t.idata$5\n");
1700 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1702 fprintf (filvar, "listtwo%d:\n", headindex);
1703 for ( funcindex = 0; funcindex < headptr->nfuncs; funcindex++ )
1704 fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1705 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1706 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list */
1710 fprintf (filvar, "\n\t.section\t.idata$6\n");
1712 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1715 for (funcptr = headptr->funchead; funcptr != NULL;
1716 funcptr = funcptr->next)
1718 fprintf (filvar,"funcptr%d_%d:\n", headindex, funcindex);
1719 fprintf (filvar,"\t%s\t%d\n", ASM_SHORT,
1720 ((funcptr->ord) & 0xFFFF));
1721 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, funcptr->name);
1722 fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1728 fprintf (filvar, "\n\t.section\t.idata$7\n");
1730 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1732 fprintf (filvar,"dllname%d:\n", headindex);
1733 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, headptr->dllname);
1734 fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1739 /* Assemble the specified file. */
1741 assemble_file (const char * source, const char * dest)
1745 cmd = (char *) alloca (strlen (ASM_SWITCHES) + strlen (as_flags)
1746 + strlen (source) + strlen (dest) + 50);
1748 sprintf (cmd, "%s %s -o %s %s", ASM_SWITCHES, as_flags, dest, source);
1761 /* xgettext:c-format */
1762 inform (_("Generating export file: %s"), exp_name);
1764 f = fopen (TMP_ASM, FOPEN_WT);
1766 /* xgettext:c-format */
1767 fatal (_("Unable to open temporary assembler file: %s"), TMP_ASM);
1769 /* xgettext:c-format */
1770 inform (_("Opened temporary file: %s"), TMP_ASM);
1776 fprintf (f, "\t.section .edata\n\n");
1777 fprintf (f, "\t%s 0 %s Allways 0\n", ASM_LONG, ASM_C);
1778 fprintf (f, "\t%s 0x%lx %s Time and date\n", ASM_LONG, (long) time(0),
1780 fprintf (f, "\t%s 0 %s Major and Minor version\n", ASM_LONG, ASM_C);
1781 fprintf (f, "\t%sname%s %s Ptr to name of dll\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1782 fprintf (f, "\t%s %d %s Starting ordinal of exports\n", ASM_LONG, d_low_ord, ASM_C);
1785 fprintf (f, "\t%s %d %s Number of functions\n", ASM_LONG, d_high_ord - d_low_ord + 1, ASM_C);
1786 fprintf(f,"\t%s named funcs %d, low ord %d, high ord %d\n",
1788 d_named_nfuncs, d_low_ord, d_high_ord);
1789 fprintf (f, "\t%s %d %s Number of names\n", ASM_LONG,
1790 show_allnames ? d_high_ord - d_low_ord + 1 : d_named_nfuncs, ASM_C);
1791 fprintf (f, "\t%safuncs%s %s Address of functions\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1793 fprintf (f, "\t%sanames%s %s Address of Name Pointer Table\n",
1794 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1796 fprintf (f, "\t%sanords%s %s Address of ordinals\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1798 fprintf (f, "name: %s \"%s\"\n", ASM_TEXT, dll_name);
1801 fprintf(f,"%s Export address Table\n", ASM_C);
1802 fprintf(f,"\t%s\n", ASM_ALIGN_LONG);
1803 fprintf (f, "afuncs:\n");
1806 for (exp = d_exports; exp; exp = exp->next)
1808 if (exp->ordinal != i)
1811 fprintf (f, "\t%s\t%d\t%s %d..%d missing\n",
1813 (exp->ordinal - i) * 4,
1815 i, exp->ordinal - 1);
1818 while (i < exp->ordinal)
1820 fprintf(f,"\t%s\t0\n", ASM_LONG);
1825 if (exp->forward == 0)
1827 if (exp->internal_name[0] == '@')
1828 fprintf (f, "\t%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
1829 exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1831 fprintf (f, "\t%s%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
1832 ASM_PREFIX (exp->internal_name),
1833 exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1836 fprintf (f, "\t%sf%d%s\t%s %d\n", ASM_RVA_BEFORE,
1837 exp->forward, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1841 fprintf (f,"%s Export Name Pointer Table\n", ASM_C);
1842 fprintf (f, "anames:\n");
1844 for (i = 0; (exp = d_exports_lexically[i]); i++)
1846 if (!exp->noname || show_allnames)
1847 fprintf (f, "\t%sn%d%s\n",
1848 ASM_RVA_BEFORE, exp->ordinal, ASM_RVA_AFTER);
1851 fprintf (f,"%s Export Oridinal Table\n", ASM_C);
1852 fprintf (f, "anords:\n");
1853 for (i = 0; (exp = d_exports_lexically[i]); i++)
1855 if (!exp->noname || show_allnames)
1856 fprintf (f, "\t%s %d\n", ASM_SHORT, exp->ordinal - d_low_ord);
1859 fprintf(f,"%s Export Name Table\n", ASM_C);
1860 for (i = 0; (exp = d_exports_lexically[i]); i++)
1862 if (!exp->noname || show_allnames)
1863 fprintf (f, "n%d: %s \"%s\"\n",
1864 exp->ordinal, ASM_TEXT, xlate (exp->name));
1865 if (exp->forward != 0)
1866 fprintf (f, "f%d: %s \"%s\"\n",
1867 exp->forward, ASM_TEXT, exp->internal_name);
1872 fprintf (f, "\t.section %s\n", DRECTVE_SECTION_NAME);
1873 for (dl = a_list; dl; dl = dl->next)
1875 fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, dl->text);
1881 fprintf (f, "\t.section .rdata\n");
1882 for (dl = d_list; dl; dl = dl->next)
1887 /* We don't output as ascii because there can
1888 be quote characters in the string. */
1890 for (p = dl->text; *p; p++)
1893 fprintf (f, "\t%s\t", ASM_BYTE);
1896 fprintf (f, "%d", *p);
1899 fprintf (f, ",0\n");
1913 /* Add to the output file a way of getting to the exported names
1914 without using the import library. */
1917 fprintf (f, "\t.section\t.rdata\n");
1918 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1919 if (!exp->noname || show_allnames)
1921 /* We use a single underscore for MS compatibility, and a
1922 double underscore for backward compatibility with old
1924 if (create_compat_implib)
1925 fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name);
1926 fprintf (f, "\t%s\t_imp__%s\n", ASM_GLOBAL, exp->name);
1927 if (create_compat_implib)
1928 fprintf (f, "__imp_%s:\n", exp->name);
1929 fprintf (f, "_imp__%s:\n", exp->name);
1930 fprintf (f, "\t%s\t%s\n", ASM_LONG, exp->name);
1934 /* Dump the reloc section if a base file is provided. */
1938 long need[PAGE_SIZE];
1945 fprintf (f, "\t.section\t.init\n");
1946 fprintf (f, "lab:\n");
1948 fseek (base_file, 0, SEEK_END);
1949 numbytes = ftell (base_file);
1950 fseek (base_file, 0, SEEK_SET);
1951 copy = xmalloc (numbytes);
1952 fread (copy, 1, numbytes, base_file);
1953 num_entries = numbytes / sizeof (long);
1956 fprintf (f, "\t.section\t.reloc\n");
1962 qsort (copy, num_entries, sizeof (long), sfunc);
1963 /* Delete duplicates */
1964 for (src = 0; src < num_entries; src++)
1966 if (last != copy[src])
1967 last = copy[dst++] = copy[src];
1971 page_addr = addr & PAGE_MASK; /* work out the page addr */
1973 for (j = 0; j < num_entries; j++)
1976 if ((addr & PAGE_MASK) != page_addr)
1978 flush_page (f, need, page_addr, on_page);
1980 page_addr = addr & PAGE_MASK;
1982 need[on_page++] = addr;
1984 flush_page (f, need, page_addr, on_page);
1986 /* fprintf (f, "\t%s\t0,0\t%s End\n", ASM_LONG, ASM_C);*/
1990 generate_idata_ofile (f);
1994 /* Assemble the file. */
1995 assemble_file (TMP_ASM, exp_name);
1997 if (dontdeltemps == 0)
2000 inform (_("Generated exports file"));
2004 xlate (const char *name)
2006 int lead_at = (*name == '@');
2008 if (add_underscore && !lead_at)
2010 char *copy = xmalloc (strlen (name) + 2);
2013 strcpy (copy + 1, name);
2022 p = strchr (name, '@');
2029 /**********************************************************************/
2034 dump_iat (FILE *f, export_type *exp)
2036 if (exp->noname && !show_allnames )
2038 fprintf (f, "\t%s\t0x%08x\n",
2040 exp->ordinal | 0x80000000); /* hint or orindal ?? */
2044 fprintf (f, "\t%sID%d%s\n", ASM_RVA_BEFORE,
2062 unsigned char *data;
2077 #define TEXT_SEC_FLAGS \
2078 (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY | SEC_HAS_CONTENTS)
2079 #define DATA_SEC_FLAGS (SEC_ALLOC | SEC_LOAD | SEC_DATA)
2080 #define BSS_SEC_FLAGS SEC_ALLOC
2082 #define INIT_SEC_DATA(id, name, flags, align) \
2083 { id, name, flags, align, NULL, NULL, NULL, 0, NULL }
2084 static sinfo secdata[NSECS] =
2086 INIT_SEC_DATA (TEXT, ".text", TEXT_SEC_FLAGS, 2),
2087 INIT_SEC_DATA (DATA, ".data", DATA_SEC_FLAGS, 2),
2088 INIT_SEC_DATA (BSS, ".bss", BSS_SEC_FLAGS, 2),
2089 INIT_SEC_DATA (IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2),
2090 INIT_SEC_DATA (IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2),
2091 INIT_SEC_DATA (IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2),
2092 INIT_SEC_DATA (IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1)
2097 /* Sections numbered to make the order the same as other PowerPC NT
2098 compilers. This also keeps funny alignment thingies from happening. */
2111 static sinfo secdata[NSECS] =
2113 { TEXT, ".text", SEC_CODE | SEC_HAS_CONTENTS, 3},
2114 { PDATA, ".pdata", SEC_HAS_CONTENTS, 2},
2115 { RDATA, ".reldata", SEC_HAS_CONTENTS, 2},
2116 { IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2},
2117 { IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2},
2118 { IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1},
2119 { IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2},
2120 { DATA, ".data", SEC_DATA, 2},
2121 { BSS, ".bss", 0, 2}
2126 /* This is what we're trying to make. We generate the imp symbols with
2127 both single and double underscores, for compatibility.
2130 .global _GetFileVersionInfoSizeW@8
2131 .global __imp_GetFileVersionInfoSizeW@8
2132 _GetFileVersionInfoSizeW@8:
2133 jmp * __imp_GetFileVersionInfoSizeW@8
2134 .section .idata$7 # To force loading of head
2135 .long __version_a_head
2136 # Import Address Table
2138 __imp_GetFileVersionInfoSizeW@8:
2141 # Import Lookup Table
2147 .asciz "GetFileVersionInfoSizeW"
2150 For the PowerPC, here's the variation on the above scheme:
2152 # Rather than a simple "jmp *", the code to get to the dll function
2155 lwz r11,[tocv]__imp_function_name(r2)
2156 # RELOC: 00000000 TOCREL16,TOCDEFN __imp_function_name
2164 make_label (const char *prefix, const char *name)
2166 int len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name);
2167 char *copy = xmalloc (len + 1);
2169 strcpy (copy, ASM_PREFIX (name));
2170 strcat (copy, prefix);
2171 strcat (copy, name);
2176 make_imp_label (const char *prefix, const char *name)
2183 len = strlen (prefix) + strlen (name);
2184 copy = xmalloc (len + 1);
2185 strcpy (copy, prefix);
2186 strcat (copy, name);
2190 len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name);
2191 copy = xmalloc (len + 1);
2192 strcpy (copy, prefix);
2193 strcat (copy, ASM_PREFIX (name));
2194 strcat (copy, name);
2200 make_one_lib_file (export_type *exp, int i)
2206 const char *prefix = "d";
2209 name = (char *) alloca (strlen (prefix) + 10);
2210 sprintf (name, "%ss%05d.s", prefix, i);
2211 f = fopen (name, FOPEN_WT);
2212 fprintf (f, "\t.text\n");
2213 fprintf (f, "\t%s\t%s%s\n", ASM_GLOBAL, ASM_PREFIX (exp->name), exp->name);
2214 if (create_compat_implib)
2215 fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name);
2216 fprintf (f, "\t%s\t_imp__%s\n", ASM_GLOBAL, exp->name);
2217 if (create_compat_implib)
2218 fprintf (f, "%s%s:\n\t%s\t__imp_%s\n", ASM_PREFIX (exp->name),
2219 exp->name, ASM_JUMP, exp->name);
2221 fprintf (f, "\t.section\t.idata$7\t%s To force loading of head\n", ASM_C);
2222 fprintf (f, "\t%s\t%s\n", ASM_LONG, head_label);
2225 fprintf (f,"%s Import Address Table\n", ASM_C);
2227 fprintf (f, "\t.section .idata$5\n");
2228 if (create_compat_implib)
2229 fprintf (f, "__imp_%s:\n", exp->name);
2230 fprintf (f, "_imp__%s:\n", exp->name);
2234 fprintf (f, "\n%s Import Lookup Table\n", ASM_C);
2235 fprintf (f, "\t.section .idata$4\n");
2239 if(!exp->noname || show_allnames)
2241 fprintf (f, "%s Hint/Name table\n", ASM_C);
2242 fprintf (f, "\t.section .idata$6\n");
2243 fprintf (f, "ID%d:\t%s\t%d\n", exp->ordinal, ASM_SHORT, exp->hint);
2244 fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, xlate (exp->name));
2249 dest = (char *) alloca (strlen (prefix) + 10);
2250 sprintf (dest, "%ss%05d.o", prefix, i);
2251 assemble_file (name, dest);
2256 asymbol * exp_label;
2257 asymbol * iname = 0;
2259 asymbol * iname_lab;
2260 asymbol ** iname_lab_pp;
2261 asymbol ** iname_pp;
2270 asymbol * ptrs[NSECS + 4 + EXTRA + 1];
2271 flagword applicable;
2272 char * outname = xmalloc (strlen (TMP_STUB) + 10);
2276 sprintf (outname, "%s%05d.o", TMP_STUB, i);
2278 abfd = bfd_openw (outname, HOW_BFD_WRITE_TARGET);
2281 /* xgettext:c-format */
2282 fatal (_("bfd_open failed open stub file: %s"), outname);
2284 /* xgettext:c-format */
2285 inform (_("Creating stub file: %s"), outname);
2287 bfd_set_format (abfd, bfd_object);
2288 bfd_set_arch_mach (abfd, HOW_BFD_ARCH, 0);
2291 if (machine == MARM_INTERWORK || machine == MTHUMB)
2292 bfd_set_private_flags (abfd, F_INTERWORK);
2295 applicable = bfd_applicable_section_flags (abfd);
2297 /* First make symbols for the sections. */
2298 for (i = 0; i < NSECS; i++)
2300 sinfo *si = secdata + i;
2304 si->sec = bfd_make_section_old_way (abfd, si->name);
2305 bfd_set_section_flags (abfd,
2307 si->flags & applicable);
2309 bfd_set_section_alignment(abfd, si->sec, si->align);
2310 si->sec->output_section = si->sec;
2311 si->sym = bfd_make_empty_symbol(abfd);
2312 si->sym->name = si->sec->name;
2313 si->sym->section = si->sec;
2314 si->sym->flags = BSF_LOCAL;
2316 ptrs[oidx] = si->sym;
2317 si->sympp = ptrs + oidx;
2326 exp_label = bfd_make_empty_symbol (abfd);
2327 exp_label->name = make_imp_label ("", exp->name);
2329 /* On PowerPC, the function name points to a descriptor in
2330 the rdata section, the first element of which is a
2331 pointer to the code (..function_name), and the second
2332 points to the .toc. */
2334 if (machine == MPPC)
2335 exp_label->section = secdata[RDATA].sec;
2338 exp_label->section = secdata[TEXT].sec;
2340 exp_label->flags = BSF_GLOBAL;
2341 exp_label->value = 0;
2344 if (machine == MTHUMB)
2345 bfd_coff_set_symbol_class (abfd, exp_label, C_THUMBEXTFUNC);
2347 ptrs[oidx++] = exp_label;
2350 /* Generate imp symbols with one underscore for Microsoft
2351 compatibility, and with two underscores for backward
2352 compatibility with old versions of cygwin. */
2353 if (create_compat_implib)
2355 iname = bfd_make_empty_symbol (abfd);
2356 iname->name = make_imp_label ("___imp", exp->name);
2357 iname->section = secdata[IDATA5].sec;
2358 iname->flags = BSF_GLOBAL;
2362 iname2 = bfd_make_empty_symbol (abfd);
2363 iname2->name = make_imp_label ("__imp_", exp->name);
2364 iname2->section = secdata[IDATA5].sec;
2365 iname2->flags = BSF_GLOBAL;
2368 iname_lab = bfd_make_empty_symbol (abfd);
2370 iname_lab->name = head_label;
2371 iname_lab->section = (asection *) &bfd_und_section;
2372 iname_lab->flags = 0;
2373 iname_lab->value = 0;
2375 iname_pp = ptrs + oidx;
2376 if (create_compat_implib)
2377 ptrs[oidx++] = iname;
2378 ptrs[oidx++] = iname2;
2380 iname_lab_pp = ptrs + oidx;
2381 ptrs[oidx++] = iname_lab;
2384 /* The symbol referring to the code (.text). */
2386 asymbol *function_name;
2388 function_name = bfd_make_empty_symbol(abfd);
2389 function_name->name = make_label ("..", exp->name);
2390 function_name->section = secdata[TEXT].sec;
2391 function_name->flags = BSF_GLOBAL;
2392 function_name->value = 0;
2394 fn_pp = ptrs + oidx;
2395 ptrs[oidx++] = function_name;
2398 /* The .toc symbol. */
2400 asymbol *toc_symbol;
2402 toc_symbol = bfd_make_empty_symbol (abfd);
2403 toc_symbol->name = make_label (".", "toc");
2404 toc_symbol->section = (asection *)&bfd_und_section;
2405 toc_symbol->flags = BSF_GLOBAL;
2406 toc_symbol->value = 0;
2408 toc_pp = ptrs + oidx;
2409 ptrs[oidx++] = toc_symbol;
2415 for (i = 0; i < NSECS; i++)
2417 sinfo *si = secdata + i;
2418 asection *sec = si->sec;
2427 si->size = HOW_JTAB_SIZE;
2428 si->data = xmalloc (HOW_JTAB_SIZE);
2429 memcpy (si->data, HOW_JTAB, HOW_JTAB_SIZE);
2431 /* add the reloc into idata$5 */
2432 rel = xmalloc (sizeof (arelent));
2434 rpp = xmalloc (sizeof (arelent *) * 2);
2438 rel->address = HOW_JTAB_ROFF;
2441 if (machine == MPPC)
2443 rel->howto = bfd_reloc_type_lookup (abfd,
2444 BFD_RELOC_16_GOTOFF);
2445 rel->sym_ptr_ptr = iname_pp;
2449 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2450 rel->sym_ptr_ptr = secdata[IDATA5].sympp;
2452 sec->orelocation = rpp;
2453 sec->reloc_count = 1;
2458 /* An idata$4 or idata$5 is one word long, and has an
2461 si->data = xmalloc (4);
2466 si->data[0] = exp->ordinal ;
2467 si->data[1] = exp->ordinal >> 8;
2468 si->data[2] = exp->ordinal >> 16;
2473 sec->reloc_count = 1;
2474 memset (si->data, 0, si->size);
2475 rel = xmalloc (sizeof (arelent));
2476 rpp = xmalloc (sizeof (arelent *) * 2);
2481 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2482 rel->sym_ptr_ptr = secdata[IDATA6].sympp;
2483 sec->orelocation = rpp;
2491 /* This used to add 1 to exp->hint. I don't know
2492 why it did that, and it does not match what I see
2493 in programs compiled with the MS tools. */
2494 int idx = exp->hint;
2495 si->size = strlen (xlate (exp->import_name)) + 3;
2496 si->data = xmalloc (si->size);
2497 si->data[0] = idx & 0xff;
2498 si->data[1] = idx >> 8;
2499 strcpy (si->data + 2, xlate (exp->import_name));
2504 si->data = xmalloc (4);
2505 memset (si->data, 0, si->size);
2506 rel = xmalloc (sizeof (arelent));
2507 rpp = xmalloc (sizeof (arelent *) * 2);
2511 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2512 rel->sym_ptr_ptr = iname_lab_pp;
2513 sec->orelocation = rpp;
2514 sec->reloc_count = 1;
2520 /* The .pdata section is 5 words long.
2524 bfd_vma BeginAddress, [0x00]
2526 ExceptionHandler, [0x08]
2528 PrologEndAddress; [0x10]
2531 /* So this pdata section setups up this as a glue linkage to
2532 a dll routine. There are a number of house keeping things
2535 1. In the name of glue trickery, the ADDR32 relocs for 0,
2536 4, and 0x10 are set to point to the same place:
2538 2. There is one more reloc needed in the pdata section.
2539 The actual glue instruction to restore the toc on
2540 return is saved as the offset in an IMGLUE reloc.
2541 So we need a total of four relocs for this section.
2543 3. Lastly, the HandlerData field is set to 0x03, to indicate
2544 that this is a glue routine. */
2545 arelent *imglue, *ba_rel, *ea_rel, *pea_rel;
2547 /* Alignment must be set to 2**2 or you get extra stuff. */
2548 bfd_set_section_alignment(abfd, sec, 2);
2551 si->data = xmalloc (si->size);
2552 memset (si->data, 0, si->size);
2553 rpp = xmalloc (sizeof (arelent *) * 5);
2554 rpp[0] = imglue = xmalloc (sizeof (arelent));
2555 rpp[1] = ba_rel = xmalloc (sizeof (arelent));
2556 rpp[2] = ea_rel = xmalloc (sizeof (arelent));
2557 rpp[3] = pea_rel = xmalloc (sizeof (arelent));
2560 /* Stick the toc reload instruction in the glue reloc. */
2561 bfd_put_32(abfd, ppc_glue_insn, (char *) &imglue->address);
2564 imglue->howto = bfd_reloc_type_lookup (abfd,
2565 BFD_RELOC_32_GOTOFF);
2566 imglue->sym_ptr_ptr = fn_pp;
2568 ba_rel->address = 0;
2570 ba_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2571 ba_rel->sym_ptr_ptr = fn_pp;
2573 bfd_put_32 (abfd, 0x18, si->data + 0x04);
2574 ea_rel->address = 4;
2576 ea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2577 ea_rel->sym_ptr_ptr = fn_pp;
2579 /* Mark it as glue. */
2580 bfd_put_32 (abfd, 0x03, si->data + 0x0c);
2582 /* Mark the prolog end address. */
2583 bfd_put_32 (abfd, 0x0D, si->data + 0x10);
2584 pea_rel->address = 0x10;
2585 pea_rel->addend = 0;
2586 pea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2587 pea_rel->sym_ptr_ptr = fn_pp;
2589 sec->orelocation = rpp;
2590 sec->reloc_count = 4;
2594 /* Each external function in a PowerPC PE file has a two word
2595 descriptor consisting of:
2596 1. The address of the code.
2597 2. The address of the appropriate .toc
2598 We use relocs to build this. */
2600 si->data = xmalloc (8);
2601 memset (si->data, 0, si->size);
2603 rpp = xmalloc (sizeof (arelent *) * 3);
2604 rpp[0] = rel = xmalloc (sizeof (arelent));
2605 rpp[1] = xmalloc (sizeof (arelent));
2610 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2611 rel->sym_ptr_ptr = fn_pp;
2617 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2618 rel->sym_ptr_ptr = toc_pp;
2620 sec->orelocation = rpp;
2621 sec->reloc_count = 2;
2623 #endif /* DLLTOOL_PPC */
2629 /* Size up all the sections. */
2630 for (i = 0; i < NSECS; i++)
2632 sinfo *si = secdata + i;
2634 bfd_set_section_size (abfd, si->sec, si->size);
2635 bfd_set_section_vma (abfd, si->sec, vma);
2637 /* vma += si->size;*/
2640 /* Write them out. */
2641 for (i = 0; i < NSECS; i++)
2643 sinfo *si = secdata + i;
2645 if (i == IDATA5 && no_idata5)
2648 if (i == IDATA4 && no_idata4)
2651 bfd_set_section_contents (abfd, si->sec,
2656 bfd_set_symtab (abfd, ptrs, oidx);
2658 abfd = bfd_openr (outname, HOW_BFD_READ_TARGET);
2667 FILE *f = fopen (TMP_HEAD_S, FOPEN_WT);
2671 fatal (_("failed to open temporary head file: %s"), TMP_HEAD_S);
2675 fprintf (f, "%s IMAGE_IMPORT_DESCRIPTOR\n", ASM_C);
2676 fprintf (f, "\t.section .idata$2\n");
2678 fprintf(f,"\t%s\t%s\n", ASM_GLOBAL,head_label);
2680 fprintf (f, "%s:\n", head_label);
2682 fprintf (f, "\t%shname%s\t%sPtr to image import by name list\n",
2683 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
2685 fprintf (f, "\t%sthis should be the timestamp, but NT sometimes\n", ASM_C);
2686 fprintf (f, "\t%sdoesn't load DLLs when this is set.\n", ASM_C);
2687 fprintf (f, "\t%s\t0\t%s loaded time\n", ASM_LONG, ASM_C);
2688 fprintf (f, "\t%s\t0\t%s Forwarder chain\n", ASM_LONG, ASM_C);
2689 fprintf (f, "\t%s__%s_iname%s\t%s imported dll's name\n",
2694 fprintf (f, "\t%sfthunk%s\t%s pointer to firstthunk\n",
2696 ASM_RVA_AFTER, ASM_C);
2698 fprintf (f, "%sStuff for compatibility\n", ASM_C);
2702 fprintf (f, "\t.section\t.idata$5\n");
2703 fprintf (f, "\t%s\t0\n", ASM_LONG);
2704 fprintf (f, "fthunk:\n");
2709 fprintf (f, "\t.section\t.idata$4\n");
2711 fprintf (f, "\t%s\t0\n", ASM_LONG);
2712 fprintf (f, "\t.section .idata$4\n");
2713 fprintf (f, "hname:\n");
2718 assemble_file (TMP_HEAD_S, TMP_HEAD_O);
2720 return bfd_openr (TMP_HEAD_O, HOW_BFD_READ_TARGET);
2726 FILE *f = fopen (TMP_TAIL_S, FOPEN_WT);
2730 fatal (_("failed to open temporary tail file: %s"), TMP_TAIL_S);
2736 fprintf (f, "\t.section .idata$4\n");
2737 fprintf (f, "\t%s\t0\n", ASM_LONG);
2742 fprintf (f, "\t.section .idata$5\n");
2743 fprintf (f, "\t%s\t0\n", ASM_LONG);
2747 /* Normally, we need to see a null descriptor built in idata$3 to
2748 act as the terminator for the list. The ideal way, I suppose,
2749 would be to mark this section as a comdat type 2 section, so
2750 only one would appear in the final .exe (if our linker supported
2751 comdat, that is) or cause it to be inserted by something else (say
2754 fprintf (f, "\t.section .idata$3\n");
2755 fprintf (f, "\t%s\t0\n", ASM_LONG);
2756 fprintf (f, "\t%s\t0\n", ASM_LONG);
2757 fprintf (f, "\t%s\t0\n", ASM_LONG);
2758 fprintf (f, "\t%s\t0\n", ASM_LONG);
2759 fprintf (f, "\t%s\t0\n", ASM_LONG);
2763 /* Other PowerPC NT compilers use idata$6 for the dllname, so I
2764 do too. Original, huh? */
2765 fprintf (f, "\t.section .idata$6\n");
2767 fprintf (f, "\t.section .idata$7\n");
2770 fprintf (f, "\t%s\t__%s_iname\n", ASM_GLOBAL, imp_name_lab);
2771 fprintf (f, "__%s_iname:\t%s\t\"%s\"\n",
2772 imp_name_lab, ASM_TEXT, dll_name);
2776 assemble_file (TMP_TAIL_S, TMP_TAIL_O);
2778 return bfd_openr (TMP_TAIL_O, HOW_BFD_READ_TARGET);
2793 outarch = bfd_openw (imp_name, HOW_BFD_WRITE_TARGET);
2796 /* xgettext:c-format */
2797 fatal (_("Can't open .lib file: %s"), imp_name);
2799 /* xgettext:c-format */
2800 inform (_("Creating library file: %s"), imp_name);
2802 bfd_set_format (outarch, bfd_archive);
2803 outarch->has_armap = 1;
2805 /* Work out a reasonable size of things to put onto one line. */
2806 ar_head = make_head ();
2807 ar_tail = make_tail();
2809 if (ar_head == NULL || ar_tail == NULL)
2812 for (i = 0; (exp = d_exports_lexically[i]); i++)
2815 /* Don't add PRIVATE entries to import lib. */
2818 n = make_one_lib_file (exp, i);
2821 if (ext_prefix_alias)
2823 export_type alias_exp;
2825 assert (i < PREFIX_ALIAS_BASE);
2826 alias_exp.name = make_imp_label (ext_prefix_alias, exp->name);
2827 alias_exp.internal_name = exp->internal_name;
2828 alias_exp.import_name = exp->name;
2829 alias_exp.ordinal = exp->ordinal;
2830 alias_exp.constant = exp->constant;
2831 alias_exp.noname = exp->noname;
2832 alias_exp.private = exp->private;
2833 alias_exp.data = exp->data;
2834 alias_exp.hint = exp->hint;
2835 alias_exp.forward = exp->forward;
2836 alias_exp.next = exp->next;
2837 n = make_one_lib_file (&alias_exp, i + PREFIX_ALIAS_BASE);
2843 /* Now stick them all into the archive. */
2844 ar_head->next = head;
2845 ar_tail->next = ar_head;
2848 if (! bfd_set_archive_head (outarch, head))
2849 bfd_fatal ("bfd_set_archive_head");
2851 if (! bfd_close (outarch))
2852 bfd_fatal (imp_name);
2854 while (head != NULL)
2856 bfd *n = head->next;
2861 /* Delete all the temp files. */
2862 if (dontdeltemps == 0)
2864 unlink (TMP_HEAD_O);
2865 unlink (TMP_HEAD_S);
2866 unlink (TMP_TAIL_O);
2867 unlink (TMP_TAIL_S);
2870 if (dontdeltemps < 2)
2874 name = (char *) alloca (strlen (TMP_STUB) + 10);
2875 for (i = 0; (exp = d_exports_lexically[i]); i++)
2877 /* Don't delete non-existent stubs for PRIVATE entries. */
2880 sprintf (name, "%s%05d.o", TMP_STUB, i);
2881 if (unlink (name) < 0)
2882 /* xgettext:c-format */
2883 non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
2884 if (ext_prefix_alias)
2886 sprintf (name, "%s%05d.o", TMP_STUB, i + PREFIX_ALIAS_BASE);
2887 if (unlink (name) < 0)
2888 /* xgettext:c-format */
2889 non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
2894 inform (_("Created lib file"));
2897 /* Run through the information gathered from the .o files and the
2898 .def file and work out the best stuff. */
2901 pfunc (const void *a, const void *b)
2903 export_type *ap = *(export_type **) a;
2904 export_type *bp = *(export_type **) b;
2905 if (ap->ordinal == bp->ordinal)
2908 /* Unset ordinals go to the bottom. */
2909 if (ap->ordinal == -1)
2911 if (bp->ordinal == -1)
2913 return (ap->ordinal - bp->ordinal);
2917 nfunc (const void *a, const void *b)
2919 export_type *ap = *(export_type **) a;
2920 export_type *bp = *(export_type **) b;
2922 return (strcmp (ap->name, bp->name));
2926 remove_null_names (export_type **ptr)
2931 for (dst = src = 0; src < d_nfuncs; src++)
2935 ptr[dst] = ptr[src];
2943 dtab (export_type **ptr ATTRIBUTE_UNUSED)
2947 for (i = 0; i < d_nfuncs; i++)
2951 printf ("%d %s @ %d %s%s%s\n",
2952 i, ptr[i]->name, ptr[i]->ordinal,
2953 ptr[i]->noname ? "NONAME " : "",
2954 ptr[i]->constant ? "CONSTANT" : "",
2955 ptr[i]->data ? "DATA" : "");
2964 process_duplicates (export_type **d_export_vec)
2972 /* Remove duplicates. */
2973 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), nfunc);
2975 dtab (d_export_vec);
2976 for (i = 0; i < d_nfuncs - 1; i++)
2978 if (strcmp (d_export_vec[i]->name,
2979 d_export_vec[i + 1]->name) == 0)
2981 export_type *a = d_export_vec[i];
2982 export_type *b = d_export_vec[i + 1];
2986 /* xgettext:c-format */
2987 inform (_("Warning, ignoring duplicate EXPORT %s %d,%d"),
2988 a->name, a->ordinal, b->ordinal);
2990 if (a->ordinal != -1
2991 && b->ordinal != -1)
2992 /* xgettext:c-format */
2993 fatal (_("Error, duplicate EXPORT with oridinals: %s"),
2996 /* Merge attributes. */
2997 b->ordinal = a->ordinal > 0 ? a->ordinal : b->ordinal;
2998 b->constant |= a->constant;
2999 b->noname |= a->noname;
3001 d_export_vec[i] = 0;
3004 dtab (d_export_vec);
3005 remove_null_names (d_export_vec);
3006 dtab (d_export_vec);
3010 /* Count the names. */
3011 for (i = 0; i < d_nfuncs; i++)
3012 if (!d_export_vec[i]->noname)
3017 fill_ordinals (export_type **d_export_vec)
3024 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
3026 /* Fill in the unset ordinals with ones from our range. */
3027 ptr = (char *) xmalloc (size);
3029 memset (ptr, 0, size);
3031 /* Mark in our large vector all the numbers that are taken. */
3032 for (i = 0; i < d_nfuncs; i++)
3034 if (d_export_vec[i]->ordinal != -1)
3036 ptr[d_export_vec[i]->ordinal] = 1;
3038 if (lowest == -1 || d_export_vec[i]->ordinal < lowest)
3039 lowest = d_export_vec[i]->ordinal;
3043 /* Start at 1 for compatibility with MS toolchain. */
3047 /* Now fill in ordinals where the user wants us to choose. */
3048 for (i = 0; i < d_nfuncs; i++)
3050 if (d_export_vec[i]->ordinal == -1)
3054 /* First try within or after any user supplied range. */
3055 for (j = lowest; j < size; j++)
3059 d_export_vec[i]->ordinal = j;
3063 /* Then try before the range. */
3064 for (j = lowest; j >0; j--)
3068 d_export_vec[i]->ordinal = j;
3078 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
3080 /* Work out the lowest and highest ordinal numbers. */
3083 if (d_export_vec[0])
3084 d_low_ord = d_export_vec[0]->ordinal;
3085 if (d_export_vec[d_nfuncs-1])
3086 d_high_ord = d_export_vec[d_nfuncs-1]->ordinal;
3091 alphafunc (const void *av, const void *bv)
3093 const export_type **a = (const export_type **) av;
3094 const export_type **b = (const export_type **) bv;
3096 return strcmp ((*a)->name, (*b)->name);
3102 /* First work out the minimum ordinal chosen. */
3107 export_type **d_export_vec = xmalloc (sizeof (export_type *) * d_nfuncs);
3109 inform (_("Processing definitions"));
3111 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3112 d_export_vec[i] = exp;
3114 process_duplicates (d_export_vec);
3115 fill_ordinals (d_export_vec);
3117 /* Put back the list in the new order. */
3119 for (i = d_nfuncs - 1; i >= 0; i--)
3121 d_export_vec[i]->next = d_exports;
3122 d_exports = d_export_vec[i];
3125 /* Build list in alpha order. */
3126 d_exports_lexically = (export_type **)
3127 xmalloc (sizeof (export_type *) * (d_nfuncs + 1));
3129 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3130 d_exports_lexically[i] = exp;
3132 d_exports_lexically[i] = 0;
3134 qsort (d_exports_lexically, i, sizeof (export_type *), alphafunc);
3136 /* Fill exp entries with their hint values. */
3137 for (i = 0; i < d_nfuncs; i++)
3138 if (!d_exports_lexically[i]->noname || show_allnames)
3139 d_exports_lexically[i]->hint = hint++;
3141 inform (_("Processed definitions"));
3145 usage (FILE *file, int status)
3147 /* xgetext:c-format */
3148 fprintf (file, _("Usage %s <option(s)> <object-file(s)>\n"), program_name);
3149 /* xgetext:c-format */
3150 fprintf (file, _(" -m --machine <machine> Create as DLL for <machine>. [default: %s]\n"), mname);
3151 fprintf (file, _(" possible <machine>: arm[_interwork], i386, mcore[-elf]{-le|-be}, ppc, thumb\n"));
3152 fprintf (file, _(" -e --output-exp <outname> Generate an export file.\n"));
3153 fprintf (file, _(" -l --output-lib <outname> Generate an interface library.\n"));
3154 fprintf (file, _(" -a --add-indirect Add dll indirects to export file.\n"));
3155 fprintf (file, _(" -D --dllname <name> Name of input dll to put into interface lib.\n"));
3156 fprintf (file, _(" -d --input-def <deffile> Name of .def file to be read in.\n"));
3157 fprintf (file, _(" -z --output-def <deffile> Name of .def file to be created.\n"));
3158 fprintf (file, _(" --export-all-symbols Export all symbols to .def\n"));
3159 fprintf (file, _(" --no-export-all-symbols Only export listed symbols\n"));
3160 fprintf (file, _(" --exclude-symbols <list> Don't export <list>\n"));
3161 fprintf (file, _(" --no-default-excludes Clear default exclude symbols\n"));
3162 fprintf (file, _(" -b --base-file <basefile> Read linker generated base file.\n"));
3163 fprintf (file, _(" -x --no-idata4 Don't generate idata$4 section.\n"));
3164 fprintf (file, _(" -c --no-idata5 Don't generate idata$5 section.\n"));
3165 fprintf (file, _(" -U --add-underscore Add underscores to symbols in interface library.\n"));
3166 fprintf (file, _(" -k --kill-at Kill @<n> from exported names.\n"));
3167 fprintf (file, _(" -A --add-stdcall-alias Add aliases without @<n>.\n"));
3168 fprintf (file, _(" -p --ext-prefix-alias <prefix> Add aliases with <prefix>.\n"));
3169 fprintf (file, _(" -S --as <name> Use <name> for assembler.\n"));
3170 fprintf (file, _(" -f --as-flags <flags> Pass <flags> to the assembler.\n"));
3171 fprintf (file, _(" -C --compat-implib Create backward compatible import library.\n"));
3172 fprintf (file, _(" -n --no-delete Keep temp files (repeat for extra preservation).\n"));
3173 fprintf (file, _(" -t --temp-prefix <prefix> Use <prefix> to construct temp file names.\n"));
3174 fprintf (file, _(" -v --verbose Be verbose.\n"));
3175 fprintf (file, _(" -V --version Display the program version.\n"));
3176 fprintf (file, _(" -h --help Display this information.\n"));
3177 #ifdef DLLTOOL_MCORE_ELF
3178 fprintf (file, _(" -M --mcore-elf <outname> Process mcore-elf object files into <outname>.\n"));
3179 fprintf (file, _(" -L --linker <name> Use <name> as the linker.\n"));
3180 fprintf (file, _(" -F --linker-flags <flags> Pass <flags> to the linker.\n"));
3185 #define OPTION_EXPORT_ALL_SYMS 150
3186 #define OPTION_NO_EXPORT_ALL_SYMS (OPTION_EXPORT_ALL_SYMS + 1)
3187 #define OPTION_EXCLUDE_SYMS (OPTION_NO_EXPORT_ALL_SYMS + 1)
3188 #define OPTION_NO_DEFAULT_EXCLUDES (OPTION_EXCLUDE_SYMS + 1)
3190 static const struct option long_options[] =
3192 {"no-delete", no_argument, NULL, 'n'},
3193 {"dllname", required_argument, NULL, 'D'},
3194 {"no-idata4", no_argument, NULL, 'x'},
3195 {"no-idata5", no_argument, NULL, 'c'},
3196 {"output-exp", required_argument, NULL, 'e'},
3197 {"output-def", required_argument, NULL, 'z'},
3198 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL_SYMS},
3199 {"no-export-all-symbols", no_argument, NULL, OPTION_NO_EXPORT_ALL_SYMS},
3200 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMS},
3201 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
3202 {"output-lib", required_argument, NULL, 'l'},
3203 {"def", required_argument, NULL, 'd'}, /* for compatibility with older versions */
3204 {"input-def", required_argument, NULL, 'd'},
3205 {"add-underscore", no_argument, NULL, 'U'},
3206 {"kill-at", no_argument, NULL, 'k'},
3207 {"add-stdcall-alias", no_argument, NULL, 'A'},
3208 {"ext-prefix-alias", required_argument, NULL, 'p'},
3209 {"verbose", no_argument, NULL, 'v'},
3210 {"version", no_argument, NULL, 'V'},
3211 {"help", no_argument, NULL, 'h'},
3212 {"machine", required_argument, NULL, 'm'},
3213 {"add-indirect", no_argument, NULL, 'a'},
3214 {"base-file", required_argument, NULL, 'b'},
3215 {"as", required_argument, NULL, 'S'},
3216 {"as-flags", required_argument, NULL, 'f'},
3217 {"mcore-elf", required_argument, NULL, 'M'},
3218 {"compat-implib", no_argument, NULL, 'C'},
3219 {"temp-prefix", required_argument, NULL, 't'},
3223 int main (int, char **);
3226 main (int ac, char **av)
3231 program_name = av[0];
3234 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
3235 setlocale (LC_MESSAGES, "");
3237 #if defined (HAVE_SETLOCALE)
3238 setlocale (LC_CTYPE, "");
3240 bindtextdomain (PACKAGE, LOCALEDIR);
3241 textdomain (PACKAGE);
3243 while ((c = getopt_long (ac, av,
3244 #ifdef DLLTOOL_MCORE_ELF
3245 "m:e:l:aD:d:z:b:xp:cCuUkAS:f:nvVHhM:L:F:",
3247 "m:e:l:aD:d:z:b:xp:cCuUkAS:f:nvVHh",
3254 case OPTION_EXPORT_ALL_SYMS:
3255 export_all_symbols = TRUE;
3257 case OPTION_NO_EXPORT_ALL_SYMS:
3258 export_all_symbols = FALSE;
3260 case OPTION_EXCLUDE_SYMS:
3261 add_excludes (optarg);
3263 case OPTION_NO_DEFAULT_EXCLUDES:
3264 do_default_excludes = FALSE;
3276 tmp_prefix = optarg;
3282 /* Ignored for compatibility. */
3289 output_def = fopen (optarg, FOPEN_WT);
3311 print_version (program_name);
3320 add_stdcall_alias = 1;
3323 ext_prefix_alias = optarg;
3332 base_file = fopen (optarg, FOPEN_RB);
3335 /* xgettext:c-format */
3336 fatal (_("Unable to open base-file: %s"), optarg);
3339 #ifdef DLLTOOL_MCORE_ELF
3341 mcore_elf_out_file = optarg;
3344 mcore_elf_linker = optarg;
3347 mcore_elf_linker_flags = optarg;
3351 create_compat_implib = 1;
3360 tmp_prefix = prefix_encode ("d", getpid ());
3362 for (i = 0; mtable[i].type; i++)
3363 if (strcmp (mtable[i].type, mname) == 0)
3366 if (!mtable[i].type)
3367 /* xgettext:c-format */
3368 fatal (_("Machine '%s' not supported"), mname);
3372 if (!dll_name && exp_name)
3374 int len = strlen (exp_name) + 5;
3375 dll_name = xmalloc (len);
3376 strcpy (dll_name, exp_name);
3377 strcat (dll_name, ".dll");
3380 if (as_name == NULL)
3381 as_name = deduce_name ("as");
3383 /* Don't use the default exclude list if we're reading only the
3384 symbols in the .drectve section. The default excludes are meant
3385 to avoid exporting DLL entry point and Cygwin32 impure_ptr. */
3386 if (! export_all_symbols)
3387 do_default_excludes = FALSE;
3389 if (do_default_excludes)
3390 set_default_excludes ();
3393 process_def_file (def_file);
3398 firstarg = av[optind];
3399 scan_obj_file (av[optind]);
3410 /* Make imp_name safe for use as a label. */
3413 imp_name_lab = xstrdup (imp_name);
3414 for (p = imp_name_lab; *p; p++)
3419 head_label = make_label("_head_", imp_name_lab);
3426 #ifdef DLLTOOL_MCORE_ELF
3427 if (mcore_elf_out_file)
3428 mcore_elf_gen_out_file ();
3434 /* Look for the program formed by concatenating PROG_NAME and the
3435 string running from PREFIX to END_PREFIX. If the concatenated
3436 string contains a '/', try appending EXECUTABLE_SUFFIX if it is
3440 look_for_prog (const char *prog_name, const char *prefix, int end_prefix)
3445 cmd = xmalloc (strlen (prefix)
3446 + strlen (prog_name)
3447 #ifdef HAVE_EXECUTABLE_SUFFIX
3448 + strlen (EXECUTABLE_SUFFIX)
3451 strcpy (cmd, prefix);
3453 sprintf (cmd + end_prefix, "%s", prog_name);
3455 if (strchr (cmd, '/') != NULL)
3459 found = (stat (cmd, &s) == 0
3460 #ifdef HAVE_EXECUTABLE_SUFFIX
3461 || stat (strcat (cmd, EXECUTABLE_SUFFIX), &s) == 0
3467 /* xgettext:c-format */
3468 inform (_("Tried file: %s"), cmd);
3474 /* xgettext:c-format */
3475 inform (_("Using file: %s"), cmd);
3480 /* Deduce the name of the program we are want to invoke.
3481 PROG_NAME is the basic name of the program we want to run,
3482 eg "as" or "ld". The catch is that we might want actually
3483 run "i386-pe-as" or "ppc-pe-ld".
3485 If argv[0] contains the full path, then try to find the program
3486 in the same place, with and then without a target-like prefix.
3488 Given, argv[0] = /usr/local/bin/i586-cygwin32-dlltool,
3489 deduce_name("as") uses the following search order:
3491 /usr/local/bin/i586-cygwin32-as
3495 If there's an EXECUTABLE_SUFFIX, it'll use that as well; for each
3496 name, it'll try without and then with EXECUTABLE_SUFFIX.
3498 Given, argv[0] = i586-cygwin32-dlltool, it will not even try "as"
3499 as the fallback, but rather return i586-cygwin32-as.
3501 Oh, and given, argv[0] = dlltool, it'll return "as".
3503 Returns a dynamically allocated string. */
3506 deduce_name (const char *prog_name)
3509 char *dash, *slash, *cp;
3513 for (cp = program_name; *cp != '\0'; ++cp)
3518 #if defined(__DJGPP__) || defined (__CYGWIN__) || defined(__WIN32__)
3519 *cp == ':' || *cp == '\\' ||
3532 /* First, try looking for a prefixed PROG_NAME in the
3533 PROGRAM_NAME directory, with the same prefix as PROGRAM_NAME. */
3534 cmd = look_for_prog (prog_name, program_name, dash - program_name + 1);
3537 if (slash != NULL && cmd == NULL)
3539 /* Next, try looking for a PROG_NAME in the same directory as
3540 that of this program. */
3541 cmd = look_for_prog (prog_name, program_name, slash - program_name + 1);
3546 /* Just return PROG_NAME as is. */
3547 cmd = xstrdup (prog_name);
3553 #ifdef DLLTOOL_MCORE_ELF
3554 typedef struct fname_cache
3557 struct fname_cache * next;
3561 static fname_cache fnames;
3564 mcore_elf_cache_filename (char * filename)
3570 while (ptr->next != NULL)
3573 ptr->filename = filename;
3574 ptr->next = (fname_cache *) malloc (sizeof (fname_cache));
3575 if (ptr->next != NULL)
3576 ptr->next->next = NULL;
3579 #define MCORE_ELF_TMP_OBJ "mcoreelf.o"
3580 #define MCORE_ELF_TMP_EXP "mcoreelf.exp"
3581 #define MCORE_ELF_TMP_LIB "mcoreelf.lib"
3584 mcore_elf_gen_out_file (void)
3589 /* Step one. Run 'ld -r' on the input object files in order to resolve
3590 any internal references and to generate a single .exports section. */
3593 ds = dyn_string_new (100);
3594 dyn_string_append_cstr (ds, "-r ");
3596 if (mcore_elf_linker_flags != NULL)
3597 dyn_string_append_cstr (ds, mcore_elf_linker_flags);
3599 while (ptr->next != NULL)
3601 dyn_string_append_cstr (ds, ptr->filename);
3602 dyn_string_append_cstr (ds, " ");
3607 dyn_string_append_cstr (ds, "-o ");
3608 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
3610 if (mcore_elf_linker == NULL)
3611 mcore_elf_linker = deduce_name ("ld");
3613 run (mcore_elf_linker, ds->s);
3615 dyn_string_delete (ds);
3617 /* Step two. Create a .exp file and a .lib file from the temporary file.
3618 Do this by recursively invoking dlltool... */
3619 ds = dyn_string_new (100);
3621 dyn_string_append_cstr (ds, "-S ");
3622 dyn_string_append_cstr (ds, as_name);
3624 dyn_string_append_cstr (ds, " -e ");
3625 dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP);
3626 dyn_string_append_cstr (ds, " -l ");
3627 dyn_string_append_cstr (ds, MCORE_ELF_TMP_LIB);
3628 dyn_string_append_cstr (ds, " " );
3629 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
3632 dyn_string_append_cstr (ds, " -v");
3636 dyn_string_append_cstr (ds, " -n");
3638 if (dontdeltemps > 1)
3639 dyn_string_append_cstr (ds, " -n");
3642 /* XXX - FIME: ought to check/copy other command line options as well. */
3643 run (program_name, ds->s);
3645 dyn_string_delete (ds);
3647 /* Step four. Feed the .exp and object files to ld -shared to create the dll. */
3648 ds = dyn_string_new (100);
3650 dyn_string_append_cstr (ds, "-shared ");
3652 if (mcore_elf_linker_flags)
3653 dyn_string_append_cstr (ds, mcore_elf_linker_flags);
3655 dyn_string_append_cstr (ds, " ");
3656 dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP);
3657 dyn_string_append_cstr (ds, " ");
3658 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
3659 dyn_string_append_cstr (ds, " -o ");
3660 dyn_string_append_cstr (ds, mcore_elf_out_file);
3662 run (mcore_elf_linker, ds->s);
3664 dyn_string_delete (ds);
3666 if (dontdeltemps == 0)
3667 unlink (MCORE_ELF_TMP_EXP);
3669 if (dontdeltemps < 2)
3670 unlink (MCORE_ELF_TMP_OBJ);
3672 #endif /* DLLTOOL_MCORE_ELF */