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 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 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 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 *);
697 static char *make_label (const char *, const char *);
698 static char *make_imp_label (const char *, const char *);
699 static bfd *make_one_lib_file (export_type *, int);
700 static bfd *make_head (void);
701 static bfd *make_tail (void);
702 static void gen_lib_file (void);
703 static int pfunc (const void *, const void *);
704 static int nfunc (const void *, const void *);
705 static void remove_null_names (export_type **);
706 static void process_duplicates (export_type **);
707 static void fill_ordinals (export_type **);
708 static int alphafunc (const void *, const void *);
709 static void mangle_defs (void);
710 static void usage (FILE *, int);
711 static void inform (const char *, ...);
712 static void set_dll_name_from_def (const char *);
715 prefix_encode (char *start, unsigned code)
717 static char alpha[26] = "abcdefghijklmnopqrstuvwxyz";
721 p = strchr (buf, '\0');
723 *p++ = alpha[code % sizeof (alpha)];
724 while ((code /= sizeof (alpha)) != 0);
730 dlltmp (char **buf, const char *fmt)
734 *buf = malloc (strlen (tmp_prefix) + 64);
735 sprintf (*buf, fmt, tmp_prefix);
741 inform VPARAMS ((const char * message, ...))
743 VA_OPEN (args, message);
744 VA_FIXEDARG (args, const char *, message);
749 report (message, args);
755 rvaafter (int machine)
771 /* xgettext:c-format */
772 fatal (_("Internal error: Unknown machine type: %d"), machine);
779 rvabefore (int machine)
795 /* xgettext:c-format */
796 fatal (_("Internal error: Unknown machine type: %d"), machine);
803 asm_prefix (int machine, const char *name)
818 /* Symbol names starting with ? do not have a leading underscore. */
819 if (name && *name == '?')
824 /* xgettext:c-format */
825 fatal (_("Internal error: Unknown machine type: %d"), machine);
831 #define ASM_BYTE mtable[machine].how_byte
832 #define ASM_SHORT mtable[machine].how_short
833 #define ASM_LONG mtable[machine].how_long
834 #define ASM_TEXT mtable[machine].how_asciz
835 #define ASM_C mtable[machine].how_comment
836 #define ASM_JUMP mtable[machine].how_jump
837 #define ASM_GLOBAL mtable[machine].how_global
838 #define ASM_SPACE mtable[machine].how_space
839 #define ASM_ALIGN_SHORT mtable[machine].how_align_short
840 #define ASM_RVA_BEFORE rvabefore (machine)
841 #define ASM_RVA_AFTER rvaafter (machine)
842 #define ASM_PREFIX(NAME) asm_prefix (machine, (NAME))
843 #define ASM_ALIGN_LONG mtable[machine].how_align_long
844 #define HOW_BFD_READ_TARGET 0 /* Always default. */
845 #define HOW_BFD_WRITE_TARGET mtable[machine].how_bfd_target
846 #define HOW_BFD_ARCH mtable[machine].how_bfd_arch
847 #define HOW_JTAB mtable[machine].how_jtab
848 #define HOW_JTAB_SIZE mtable[machine].how_jtab_size
849 #define HOW_JTAB_ROFF mtable[machine].how_jtab_roff
850 #define ASM_SWITCHES mtable[machine].how_default_as_switches
855 process_def_file (const char *name)
857 FILE *f = fopen (name, FOPEN_RT);
860 /* xgettext:c-format */
861 fatal (_("Can't open def file: %s"), name);
865 /* xgettext:c-format */
866 inform (_("Processing def file: %s"), name);
870 inform (_("Processed def file"));
873 /**********************************************************************/
875 /* Communications with the parser. */
877 static int d_nfuncs; /* Number of functions exported. */
878 static int d_named_nfuncs; /* Number of named functions exported. */
879 static int d_low_ord; /* Lowest ordinal index. */
880 static int d_high_ord; /* Highest ordinal index. */
881 static export_type *d_exports; /* List of exported functions. */
882 static export_type **d_exports_lexically; /* Vector of exported functions in alpha order. */
883 static dlist_type *d_list; /* Descriptions. */
884 static dlist_type *a_list; /* Stuff to go in directives. */
885 static int d_nforwards = 0; /* Number of forwarded exports. */
891 yyerror (const char * err ATTRIBUTE_UNUSED)
893 /* xgettext:c-format */
894 non_fatal (_("Syntax error in def file %s:%d"), def_file, linenumber);
900 def_exports (const char *name, const char *internal_name, int ordinal,
901 int noname, int constant, int data, int private)
903 struct export *p = (struct export *) xmalloc (sizeof (*p));
906 p->internal_name = internal_name ? internal_name : name;
907 p->import_name = name;
908 p->ordinal = ordinal;
909 p->constant = constant;
911 p->private = private;
917 if ((internal_name != NULL)
918 && (strchr (internal_name, '.') != NULL))
919 p->forward = ++d_nforwards;
921 p->forward = 0; /* no forward */
925 set_dll_name_from_def (const char * name)
927 const char* image_basename = lbasename (name);
928 if (image_basename != name)
929 non_fatal (_("%s: Path components stripped from image name, '%s'."),
931 dll_name = xstrdup (image_basename);
935 def_name (const char *name, int base)
937 /* xgettext:c-format */
938 inform (_("NAME: %s base: %x"), name, base);
941 non_fatal (_("Can't have LIBRARY and NAME"));
943 /* If --dllname not provided, use the one in the DEF file.
944 FIXME: Is this appropriate for executables? */
946 set_dll_name_from_def (name);
951 def_library (const char *name, int base)
953 /* xgettext:c-format */
954 inform (_("LIBRARY: %s base: %x"), name, base);
957 non_fatal (_("Can't have LIBRARY and NAME"));
959 /* If --dllname not provided, use the one in the DEF file. */
961 set_dll_name_from_def (name);
966 def_description (const char *desc)
968 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
969 d->text = xstrdup (desc);
975 new_directive (char *dir)
977 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
978 d->text = xstrdup (dir);
984 def_heapsize (int reserve, int commit)
988 sprintf (b, "-heap 0x%x,0x%x ", reserve, commit);
990 sprintf (b, "-heap 0x%x ", reserve);
991 new_directive (xstrdup (b));
995 def_stacksize (int reserve, int commit)
999 sprintf (b, "-stack 0x%x,0x%x ", reserve, commit);
1001 sprintf (b, "-stack 0x%x ", reserve);
1002 new_directive (xstrdup (b));
1005 /* append_import simply adds the given import definition to the global
1006 import_list. It is used by def_import. */
1009 append_import (const char *symbol_name, const char *dll_name, int func_ordinal)
1014 for (pq = &import_list; *pq != NULL; pq = &(*pq)->next)
1016 if (strcmp ((*pq)->dllname, dll_name) == 0)
1019 q->functail->next = xmalloc (sizeof (ifunctype));
1020 q->functail = q->functail->next;
1021 q->functail->ord = func_ordinal;
1022 q->functail->name = xstrdup (symbol_name);
1023 q->functail->next = NULL;
1029 q = xmalloc (sizeof (iheadtype));
1030 q->dllname = xstrdup (dll_name);
1032 q->funchead = xmalloc (sizeof (ifunctype));
1033 q->functail = q->funchead;
1035 q->functail->name = xstrdup (symbol_name);
1036 q->functail->ord = func_ordinal;
1037 q->functail->next = NULL;
1042 /* def_import is called from within defparse.y when an IMPORT
1043 declaration is encountered. Depending on the form of the
1044 declaration, the module name may or may not need ".dll" to be
1045 appended to it, the name of the function may be stored in internal
1046 or entry, and there may or may not be an ordinal value associated
1049 /* A note regarding the parse modes:
1050 In defparse.y we have to accept import declarations which follow
1051 any one of the following forms:
1052 <func_name_in_app> = <dll_name>.<func_name_in_dll>
1053 <func_name_in_app> = <dll_name>.<number>
1054 <dll_name>.<func_name_in_dll>
1056 Furthermore, the dll's name may or may not end with ".dll", which
1057 complicates the parsing a little. Normally the dll's name is
1058 passed to def_import() in the "module" parameter, but when it ends
1059 with ".dll" it gets passed in "module" sans ".dll" and that needs
1062 def_import gets five parameters:
1063 APP_NAME - the name of the function in the application, if
1064 present, or NULL if not present.
1065 MODULE - the name of the dll, possibly sans extension (ie, '.dll').
1066 DLLEXT - the extension of the dll, if present, NULL if not present.
1067 ENTRY - the name of the function in the dll, if present, or NULL.
1068 ORD_VAL - the numerical tag of the function in the dll, if present,
1069 or NULL. Exactly one of <entry> or <ord_val> must be
1070 present (i.e., not NULL). */
1073 def_import (const char *app_name, const char *module, const char *dllext,
1074 const char *entry, int ord_val)
1076 const char *application_name;
1080 application_name = entry;
1083 if (app_name != NULL)
1084 application_name = app_name;
1086 application_name = "";
1091 buf = (char *) alloca (strlen (module) + strlen (dllext) + 2);
1092 sprintf (buf, "%s.%s", module, dllext);
1096 append_import (application_name, module, ord_val);
1100 def_version (int major, int minor)
1102 printf ("VERSION %d.%d\n", major, minor);
1106 def_section (const char *name, int attr)
1121 sprintf (buf, "-attr %s %s", name, atts);
1122 new_directive (xstrdup (buf));
1129 def_section ("CODE", attr);
1135 def_section ("DATA", attr);
1138 /**********************************************************************/
1141 run (const char *what, char *args)
1144 int pid, wait_status;
1147 char *errmsg_fmt, *errmsg_arg;
1148 char *temp_base = choose_temp_base ();
1150 inform ("run: %s %s", what, args);
1152 /* Count the args */
1154 for (s = args; *s; s++)
1158 argv = alloca (sizeof (char *) * (i + 3));
1167 while (*s != ' ' && *s != 0)
1175 pid = pexecute (argv[0], (char * const *) argv, program_name, temp_base,
1176 &errmsg_fmt, &errmsg_arg, PEXECUTE_ONE | PEXECUTE_SEARCH);
1180 inform (strerror (errno));
1182 fatal (errmsg_fmt, errmsg_arg);
1185 pid = pwait (pid, & wait_status, 0);
1189 /* xgettext:c-format */
1190 fatal (_("wait: %s"), strerror (errno));
1192 else if (WIFSIGNALED (wait_status))
1194 /* xgettext:c-format */
1195 fatal (_("subprocess got fatal signal %d"), WTERMSIG (wait_status));
1197 else if (WIFEXITED (wait_status))
1199 if (WEXITSTATUS (wait_status) != 0)
1200 /* xgettext:c-format */
1201 non_fatal (_("%s exited with status %d"),
1202 what, WEXITSTATUS (wait_status));
1208 /* Look for a list of symbols to export in the .drectve section of
1209 ABFD. Pass each one to def_exports. */
1212 scan_drectve_symbols (bfd *abfd)
1220 /* Look for .drectve's */
1221 s = bfd_get_section_by_name (abfd, DRECTVE_SECTION_NAME);
1226 size = bfd_get_section_size (s);
1227 buf = xmalloc (size);
1229 bfd_get_section_contents (abfd, s, buf, 0, size);
1231 /* xgettext:c-format */
1232 inform (_("Sucking in info from %s section in %s"),
1233 DRECTVE_SECTION_NAME, bfd_get_filename (abfd));
1235 /* Search for -export: strings. The exported symbols can optionally
1236 have type tags (eg., -export:foo,data), so handle those as well.
1237 Currently only data tag is supported. */
1243 && strncmp (p, "-export:", 8) == 0)
1247 flagword flags = BSF_FUNCTION;
1251 while (p < e && *p != ',' && *p != ' ' && *p != '-')
1253 c = xmalloc (p - name + 1);
1254 memcpy (c, name, p - name);
1256 if (p < e && *p == ',') /* found type tag. */
1258 char *tag_start = ++p;
1259 while (p < e && *p != ' ' && *p != '-')
1261 if (strncmp (tag_start, "data", 4) == 0)
1262 flags &= ~BSF_FUNCTION;
1265 /* FIXME: The 5th arg is for the `constant' field.
1266 What should it be? Not that it matters since it's not
1267 currently useful. */
1268 def_exports (c, 0, -1, 0, 0, ! (flags & BSF_FUNCTION), 0);
1270 if (add_stdcall_alias && strchr (c, '@'))
1272 int lead_at = (*c == '@') ;
1273 char *exported_name = xstrdup (c + lead_at);
1274 char *atsym = strchr (exported_name, '@');
1276 /* Note: stdcall alias symbols can never be data. */
1277 def_exports (exported_name, xstrdup (c), -1, 0, 0, 0, 0);
1286 /* Look through the symbols in MINISYMS, and add each one to list of
1287 symbols to export. */
1290 scan_filtered_symbols (bfd *abfd, void *minisyms, long symcount,
1294 bfd_byte *from, *fromend;
1296 store = bfd_make_empty_symbol (abfd);
1298 bfd_fatal (bfd_get_filename (abfd));
1300 from = (bfd_byte *) minisyms;
1301 fromend = from + symcount * size;
1302 for (; from < fromend; from += size)
1305 const char *symbol_name;
1307 sym = bfd_minisymbol_to_symbol (abfd, FALSE, from, store);
1309 bfd_fatal (bfd_get_filename (abfd));
1311 symbol_name = bfd_asymbol_name (sym);
1312 if (bfd_get_symbol_leading_char (abfd) == symbol_name[0])
1315 def_exports (xstrdup (symbol_name) , 0, -1, 0, 0,
1316 ! (sym->flags & BSF_FUNCTION), 0);
1318 if (add_stdcall_alias && strchr (symbol_name, '@'))
1320 int lead_at = (*symbol_name == '@');
1321 char *exported_name = xstrdup (symbol_name + lead_at);
1322 char *atsym = strchr (exported_name, '@');
1324 /* Note: stdcall alias symbols can never be data. */
1325 def_exports (exported_name, xstrdup (symbol_name), -1, 0, 0, 0, 0);
1330 /* Add a list of symbols to exclude. */
1333 add_excludes (const char *new_excludes)
1336 char *exclude_string;
1338 local_copy = xstrdup (new_excludes);
1340 exclude_string = strtok (local_copy, ",:");
1341 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
1343 struct string_list *new_exclude;
1345 new_exclude = ((struct string_list *)
1346 xmalloc (sizeof (struct string_list)));
1347 new_exclude->string = (char *) xmalloc (strlen (exclude_string) + 2);
1348 /* Don't add a leading underscore for fastcall symbols. */
1349 if (*exclude_string == '@')
1350 sprintf (new_exclude->string, "%s", exclude_string);
1352 sprintf (new_exclude->string, "_%s", exclude_string);
1353 new_exclude->next = excludes;
1354 excludes = new_exclude;
1356 /* xgettext:c-format */
1357 inform (_("Excluding symbol: %s"), exclude_string);
1363 /* See if STRING is on the list of symbols to exclude. */
1366 match_exclude (const char *string)
1368 struct string_list *excl_item;
1370 for (excl_item = excludes; excl_item; excl_item = excl_item->next)
1371 if (strcmp (string, excl_item->string) == 0)
1376 /* Add the default list of symbols to exclude. */
1379 set_default_excludes (void)
1381 add_excludes (default_excludes);
1384 /* Choose which symbols to export. */
1387 filter_symbols (bfd *abfd, void *minisyms, long symcount, unsigned int size)
1389 bfd_byte *from, *fromend, *to;
1392 store = bfd_make_empty_symbol (abfd);
1394 bfd_fatal (bfd_get_filename (abfd));
1396 from = (bfd_byte *) minisyms;
1397 fromend = from + symcount * size;
1398 to = (bfd_byte *) minisyms;
1400 for (; from < fromend; from += size)
1405 sym = bfd_minisymbol_to_symbol (abfd, FALSE, (const void *) from, store);
1407 bfd_fatal (bfd_get_filename (abfd));
1409 /* Check for external and defined only symbols. */
1410 keep = (((sym->flags & BSF_GLOBAL) != 0
1411 || (sym->flags & BSF_WEAK) != 0
1412 || bfd_is_com_section (sym->section))
1413 && ! bfd_is_und_section (sym->section));
1415 keep = keep && ! match_exclude (sym->name);
1419 memcpy (to, from, size);
1424 return (to - (bfd_byte *) minisyms) / size;
1427 /* Export all symbols in ABFD, except for ones we were told not to
1431 scan_all_symbols (bfd *abfd)
1437 /* Ignore bfds with an import descriptor table. We assume that any
1438 such BFD contains symbols which are exported from another DLL,
1439 and we don't want to reexport them from here. */
1440 if (bfd_get_section_by_name (abfd, ".idata$4"))
1443 if (! (bfd_get_file_flags (abfd) & HAS_SYMS))
1445 /* xgettext:c-format */
1446 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1450 symcount = bfd_read_minisymbols (abfd, FALSE, &minisyms, &size);
1452 bfd_fatal (bfd_get_filename (abfd));
1456 /* xgettext:c-format */
1457 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1461 /* Discard the symbols we don't want to export. It's OK to do this
1462 in place; we'll free the storage anyway. */
1464 symcount = filter_symbols (abfd, minisyms, symcount, size);
1465 scan_filtered_symbols (abfd, minisyms, symcount, size);
1470 /* Look at the object file to decide which symbols to export. */
1473 scan_open_obj_file (bfd *abfd)
1475 if (export_all_symbols)
1476 scan_all_symbols (abfd);
1478 scan_drectve_symbols (abfd);
1480 /* FIXME: we ought to read in and block out the base relocations. */
1482 /* xgettext:c-format */
1483 inform (_("Done reading %s"), bfd_get_filename (abfd));
1487 scan_obj_file (const char *filename)
1489 bfd * f = bfd_openr (filename, 0);
1492 /* xgettext:c-format */
1493 fatal (_("Unable to open object file: %s"), filename);
1495 /* xgettext:c-format */
1496 inform (_("Scanning object file %s"), filename);
1498 if (bfd_check_format (f, bfd_archive))
1500 bfd *arfile = bfd_openr_next_archived_file (f, 0);
1503 if (bfd_check_format (arfile, bfd_object))
1504 scan_open_obj_file (arfile);
1506 arfile = bfd_openr_next_archived_file (f, arfile);
1509 #ifdef DLLTOOL_MCORE_ELF
1510 if (mcore_elf_out_file)
1511 inform (_("Cannot produce mcore-elf dll from archive file: %s"), filename);
1514 else if (bfd_check_format (f, bfd_object))
1516 scan_open_obj_file (f);
1518 #ifdef DLLTOOL_MCORE_ELF
1519 if (mcore_elf_out_file)
1520 mcore_elf_cache_filename ((char *) filename);
1527 /**********************************************************************/
1530 dump_def_info (FILE *f)
1534 fprintf (f, "%s ", ASM_C);
1535 for (i = 0; oav[i]; i++)
1536 fprintf (f, "%s ", oav[i]);
1538 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1540 fprintf (f, "%s %d = %s %s @ %d %s%s%s%s\n",
1546 exp->noname ? "NONAME " : "",
1547 exp->private ? "PRIVATE " : "",
1548 exp->constant ? "CONSTANT" : "",
1549 exp->data ? "DATA" : "");
1553 /* Generate the .exp file. */
1556 sfunc (const void *a, const void *b)
1558 return *(const long *) a - *(const long *) b;
1562 flush_page (FILE *f, long *need, int page_addr, int on_page)
1566 /* Flush this page. */
1567 fprintf (f, "\t%s\t0x%08x\t%s Starting RVA for chunk\n",
1571 fprintf (f, "\t%s\t0x%x\t%s Size of block\n",
1573 (on_page * 2) + (on_page & 1) * 2 + 8,
1576 for (i = 0; i < on_page; i++)
1578 long needed = need[i];
1581 needed = ((needed - page_addr) | 0x3000) & 0xffff;
1583 fprintf (f, "\t%s\t0x%lx\n", ASM_SHORT, needed);
1588 fprintf (f, "\t%s\t0x%x\n", ASM_SHORT, 0 | 0x0000);
1597 inform (_("Adding exports to output file"));
1599 fprintf (output_def, ";");
1600 for (i = 0; oav[i]; i++)
1601 fprintf (output_def, " %s", oav[i]);
1603 fprintf (output_def, "\nEXPORTS\n");
1605 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1607 char *quote = strchr (exp->name, '.') ? "\"" : "";
1608 char *res = cplus_demangle (exp->internal_name, DMGL_ANSI | DMGL_PARAMS);
1612 fprintf (output_def,";\t%s\n", res);
1616 if (strcmp (exp->name, exp->internal_name) == 0)
1618 fprintf (output_def, "\t%s%s%s @ %d%s%s%s\n",
1623 exp->noname ? " NONAME" : "",
1624 exp->private ? "PRIVATE " : "",
1625 exp->data ? " DATA" : "");
1629 char * quote1 = strchr (exp->internal_name, '.') ? "\"" : "";
1631 fprintf (output_def, "\t%s%s%s = %s%s%s @ %d%s%s%s\n",
1639 exp->noname ? " NONAME" : "",
1640 exp->private ? "PRIVATE " : "",
1641 exp->data ? " DATA" : "");
1645 inform (_("Added exports to output file"));
1648 /* generate_idata_ofile generates the portable assembly source code
1649 for the idata sections. It appends the source code to the end of
1653 generate_idata_ofile (FILE *filvar)
1661 if (import_list == NULL)
1664 fprintf (filvar, "%s Import data sections\n", ASM_C);
1665 fprintf (filvar, "\n\t.section\t.idata$2\n");
1666 fprintf (filvar, "\t%s\tdoi_idata\n", ASM_GLOBAL);
1667 fprintf (filvar, "doi_idata:\n");
1670 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1672 fprintf (filvar, "\t%slistone%d%s\t%s %s\n",
1673 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER,
1674 ASM_C, headptr->dllname);
1675 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1676 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1677 fprintf (filvar, "\t%sdllname%d%s\n",
1678 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1679 fprintf (filvar, "\t%slisttwo%d%s\n\n",
1680 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1684 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL record at */
1685 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* end of idata$2 */
1686 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* section */
1687 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1688 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1690 fprintf (filvar, "\n\t.section\t.idata$4\n");
1692 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1694 fprintf (filvar, "listone%d:\n", headindex);
1695 for ( funcindex = 0; funcindex < headptr->nfuncs; funcindex++ )
1696 fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1697 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1698 fprintf (filvar,"\t%s\t0\n", ASM_LONG); /* NULL terminating list */
1702 fprintf (filvar, "\n\t.section\t.idata$5\n");
1704 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1706 fprintf (filvar, "listtwo%d:\n", headindex);
1707 for ( funcindex = 0; funcindex < headptr->nfuncs; funcindex++ )
1708 fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1709 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1710 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list */
1714 fprintf (filvar, "\n\t.section\t.idata$6\n");
1716 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1719 for (funcptr = headptr->funchead; funcptr != NULL;
1720 funcptr = funcptr->next)
1722 fprintf (filvar,"funcptr%d_%d:\n", headindex, funcindex);
1723 fprintf (filvar,"\t%s\t%d\n", ASM_SHORT,
1724 ((funcptr->ord) & 0xFFFF));
1725 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, funcptr->name);
1726 fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1732 fprintf (filvar, "\n\t.section\t.idata$7\n");
1734 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1736 fprintf (filvar,"dllname%d:\n", headindex);
1737 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, headptr->dllname);
1738 fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1743 /* Assemble the specified file. */
1745 assemble_file (const char * source, const char * dest)
1749 cmd = (char *) alloca (strlen (ASM_SWITCHES) + strlen (as_flags)
1750 + strlen (source) + strlen (dest) + 50);
1752 sprintf (cmd, "%s %s -o %s %s", ASM_SWITCHES, as_flags, dest, source);
1765 /* xgettext:c-format */
1766 inform (_("Generating export file: %s"), exp_name);
1768 f = fopen (TMP_ASM, FOPEN_WT);
1770 /* xgettext:c-format */
1771 fatal (_("Unable to open temporary assembler file: %s"), TMP_ASM);
1773 /* xgettext:c-format */
1774 inform (_("Opened temporary file: %s"), TMP_ASM);
1780 fprintf (f, "\t.section .edata\n\n");
1781 fprintf (f, "\t%s 0 %s Allways 0\n", ASM_LONG, ASM_C);
1782 fprintf (f, "\t%s 0x%lx %s Time and date\n", ASM_LONG, (long) time(0),
1784 fprintf (f, "\t%s 0 %s Major and Minor version\n", ASM_LONG, ASM_C);
1785 fprintf (f, "\t%sname%s %s Ptr to name of dll\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1786 fprintf (f, "\t%s %d %s Starting ordinal of exports\n", ASM_LONG, d_low_ord, ASM_C);
1789 fprintf (f, "\t%s %d %s Number of functions\n", ASM_LONG, d_high_ord - d_low_ord + 1, ASM_C);
1790 fprintf(f,"\t%s named funcs %d, low ord %d, high ord %d\n",
1792 d_named_nfuncs, d_low_ord, d_high_ord);
1793 fprintf (f, "\t%s %d %s Number of names\n", ASM_LONG,
1794 show_allnames ? d_high_ord - d_low_ord + 1 : d_named_nfuncs, ASM_C);
1795 fprintf (f, "\t%safuncs%s %s Address of functions\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1797 fprintf (f, "\t%sanames%s %s Address of Name Pointer Table\n",
1798 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1800 fprintf (f, "\t%sanords%s %s Address of ordinals\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1802 fprintf (f, "name: %s \"%s\"\n", ASM_TEXT, dll_name);
1805 fprintf(f,"%s Export address Table\n", ASM_C);
1806 fprintf(f,"\t%s\n", ASM_ALIGN_LONG);
1807 fprintf (f, "afuncs:\n");
1810 for (exp = d_exports; exp; exp = exp->next)
1812 if (exp->ordinal != i)
1814 while (i < exp->ordinal)
1816 fprintf(f,"\t%s\t0\n", ASM_LONG);
1821 if (exp->forward == 0)
1823 if (exp->internal_name[0] == '@')
1824 fprintf (f, "\t%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
1825 exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1827 fprintf (f, "\t%s%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
1828 ASM_PREFIX (exp->internal_name),
1829 exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1832 fprintf (f, "\t%sf%d%s\t%s %d\n", ASM_RVA_BEFORE,
1833 exp->forward, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1837 fprintf (f,"%s Export Name Pointer Table\n", ASM_C);
1838 fprintf (f, "anames:\n");
1840 for (i = 0; (exp = d_exports_lexically[i]); i++)
1842 if (!exp->noname || show_allnames)
1843 fprintf (f, "\t%sn%d%s\n",
1844 ASM_RVA_BEFORE, exp->ordinal, ASM_RVA_AFTER);
1847 fprintf (f,"%s Export Oridinal Table\n", ASM_C);
1848 fprintf (f, "anords:\n");
1849 for (i = 0; (exp = d_exports_lexically[i]); i++)
1851 if (!exp->noname || show_allnames)
1852 fprintf (f, "\t%s %d\n", ASM_SHORT, exp->ordinal - d_low_ord);
1855 fprintf(f,"%s Export Name Table\n", ASM_C);
1856 for (i = 0; (exp = d_exports_lexically[i]); i++)
1858 if (!exp->noname || show_allnames)
1859 fprintf (f, "n%d: %s \"%s\"\n",
1860 exp->ordinal, ASM_TEXT, xlate (exp->name));
1861 if (exp->forward != 0)
1862 fprintf (f, "f%d: %s \"%s\"\n",
1863 exp->forward, ASM_TEXT, exp->internal_name);
1868 fprintf (f, "\t.section %s\n", DRECTVE_SECTION_NAME);
1869 for (dl = a_list; dl; dl = dl->next)
1871 fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, dl->text);
1877 fprintf (f, "\t.section .rdata\n");
1878 for (dl = d_list; dl; dl = dl->next)
1883 /* We don't output as ascii because there can
1884 be quote characters in the string. */
1886 for (p = dl->text; *p; p++)
1889 fprintf (f, "\t%s\t", ASM_BYTE);
1892 fprintf (f, "%d", *p);
1895 fprintf (f, ",0\n");
1909 /* Add to the output file a way of getting to the exported names
1910 without using the import library. */
1913 fprintf (f, "\t.section\t.rdata\n");
1914 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1915 if (!exp->noname || show_allnames)
1917 /* We use a single underscore for MS compatibility, and a
1918 double underscore for backward compatibility with old
1920 if (create_compat_implib)
1921 fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name);
1922 fprintf (f, "\t%s\t_imp__%s\n", ASM_GLOBAL, exp->name);
1923 if (create_compat_implib)
1924 fprintf (f, "__imp_%s:\n", exp->name);
1925 fprintf (f, "_imp__%s:\n", exp->name);
1926 fprintf (f, "\t%s\t%s\n", ASM_LONG, exp->name);
1930 /* Dump the reloc section if a base file is provided. */
1934 long need[PAGE_SIZE];
1941 fprintf (f, "\t.section\t.init\n");
1942 fprintf (f, "lab:\n");
1944 fseek (base_file, 0, SEEK_END);
1945 numbytes = ftell (base_file);
1946 fseek (base_file, 0, SEEK_SET);
1947 copy = xmalloc (numbytes);
1948 fread (copy, 1, numbytes, base_file);
1949 num_entries = numbytes / sizeof (long);
1952 fprintf (f, "\t.section\t.reloc\n");
1958 qsort (copy, num_entries, sizeof (long), sfunc);
1959 /* Delete duplicates */
1960 for (src = 0; src < num_entries; src++)
1962 if (last != copy[src])
1963 last = copy[dst++] = copy[src];
1967 page_addr = addr & PAGE_MASK; /* work out the page addr */
1969 for (j = 0; j < num_entries; j++)
1972 if ((addr & PAGE_MASK) != page_addr)
1974 flush_page (f, need, page_addr, on_page);
1976 page_addr = addr & PAGE_MASK;
1978 need[on_page++] = addr;
1980 flush_page (f, need, page_addr, on_page);
1982 /* fprintf (f, "\t%s\t0,0\t%s End\n", ASM_LONG, ASM_C);*/
1986 generate_idata_ofile (f);
1990 /* Assemble the file. */
1991 assemble_file (TMP_ASM, exp_name);
1993 if (dontdeltemps == 0)
1996 inform (_("Generated exports file"));
2000 xlate (const char *name)
2002 int lead_at = (*name == '@');
2004 if (add_underscore && !lead_at)
2006 char *copy = xmalloc (strlen (name) + 2);
2009 strcpy (copy + 1, name);
2018 p = strchr (name, '@');
2035 unsigned char *data;
2050 #define TEXT_SEC_FLAGS \
2051 (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY | SEC_HAS_CONTENTS)
2052 #define DATA_SEC_FLAGS (SEC_ALLOC | SEC_LOAD | SEC_DATA)
2053 #define BSS_SEC_FLAGS SEC_ALLOC
2055 #define INIT_SEC_DATA(id, name, flags, align) \
2056 { id, name, flags, align, NULL, NULL, NULL, 0, NULL }
2057 static sinfo secdata[NSECS] =
2059 INIT_SEC_DATA (TEXT, ".text", TEXT_SEC_FLAGS, 2),
2060 INIT_SEC_DATA (DATA, ".data", DATA_SEC_FLAGS, 2),
2061 INIT_SEC_DATA (BSS, ".bss", BSS_SEC_FLAGS, 2),
2062 INIT_SEC_DATA (IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2),
2063 INIT_SEC_DATA (IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2),
2064 INIT_SEC_DATA (IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2),
2065 INIT_SEC_DATA (IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1)
2070 /* Sections numbered to make the order the same as other PowerPC NT
2071 compilers. This also keeps funny alignment thingies from happening. */
2084 static sinfo secdata[NSECS] =
2086 { TEXT, ".text", SEC_CODE | SEC_HAS_CONTENTS, 3},
2087 { PDATA, ".pdata", SEC_HAS_CONTENTS, 2},
2088 { RDATA, ".reldata", SEC_HAS_CONTENTS, 2},
2089 { IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2},
2090 { IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2},
2091 { IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1},
2092 { IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2},
2093 { DATA, ".data", SEC_DATA, 2},
2094 { BSS, ".bss", 0, 2}
2099 /* This is what we're trying to make. We generate the imp symbols with
2100 both single and double underscores, for compatibility.
2103 .global _GetFileVersionInfoSizeW@8
2104 .global __imp_GetFileVersionInfoSizeW@8
2105 _GetFileVersionInfoSizeW@8:
2106 jmp * __imp_GetFileVersionInfoSizeW@8
2107 .section .idata$7 # To force loading of head
2108 .long __version_a_head
2109 # Import Address Table
2111 __imp_GetFileVersionInfoSizeW@8:
2114 # Import Lookup Table
2120 .asciz "GetFileVersionInfoSizeW"
2123 For the PowerPC, here's the variation on the above scheme:
2125 # Rather than a simple "jmp *", the code to get to the dll function
2128 lwz r11,[tocv]__imp_function_name(r2)
2129 # RELOC: 00000000 TOCREL16,TOCDEFN __imp_function_name
2137 make_label (const char *prefix, const char *name)
2139 int len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name);
2140 char *copy = xmalloc (len + 1);
2142 strcpy (copy, ASM_PREFIX (name));
2143 strcat (copy, prefix);
2144 strcat (copy, name);
2149 make_imp_label (const char *prefix, const char *name)
2156 len = strlen (prefix) + strlen (name);
2157 copy = xmalloc (len + 1);
2158 strcpy (copy, prefix);
2159 strcat (copy, name);
2163 len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name);
2164 copy = xmalloc (len + 1);
2165 strcpy (copy, prefix);
2166 strcat (copy, ASM_PREFIX (name));
2167 strcat (copy, name);
2173 make_one_lib_file (export_type *exp, int i)
2176 asymbol * exp_label;
2177 asymbol * iname = 0;
2179 asymbol * iname_lab;
2180 asymbol ** iname_lab_pp;
2181 asymbol ** iname_pp;
2190 asymbol * ptrs[NSECS + 4 + EXTRA + 1];
2191 flagword applicable;
2192 char * outname = xmalloc (strlen (TMP_STUB) + 10);
2196 sprintf (outname, "%s%05d.o", TMP_STUB, i);
2198 abfd = bfd_openw (outname, HOW_BFD_WRITE_TARGET);
2201 /* xgettext:c-format */
2202 fatal (_("bfd_open failed open stub file: %s"), outname);
2204 /* xgettext:c-format */
2205 inform (_("Creating stub file: %s"), outname);
2207 bfd_set_format (abfd, bfd_object);
2208 bfd_set_arch_mach (abfd, HOW_BFD_ARCH, 0);
2211 if (machine == MARM_INTERWORK || machine == MTHUMB)
2212 bfd_set_private_flags (abfd, F_INTERWORK);
2215 applicable = bfd_applicable_section_flags (abfd);
2217 /* First make symbols for the sections. */
2218 for (i = 0; i < NSECS; i++)
2220 sinfo *si = secdata + i;
2224 si->sec = bfd_make_section_old_way (abfd, si->name);
2225 bfd_set_section_flags (abfd,
2227 si->flags & applicable);
2229 bfd_set_section_alignment(abfd, si->sec, si->align);
2230 si->sec->output_section = si->sec;
2231 si->sym = bfd_make_empty_symbol(abfd);
2232 si->sym->name = si->sec->name;
2233 si->sym->section = si->sec;
2234 si->sym->flags = BSF_LOCAL;
2236 ptrs[oidx] = si->sym;
2237 si->sympp = ptrs + oidx;
2246 exp_label = bfd_make_empty_symbol (abfd);
2247 exp_label->name = make_imp_label ("", exp->name);
2249 /* On PowerPC, the function name points to a descriptor in
2250 the rdata section, the first element of which is a
2251 pointer to the code (..function_name), and the second
2252 points to the .toc. */
2254 if (machine == MPPC)
2255 exp_label->section = secdata[RDATA].sec;
2258 exp_label->section = secdata[TEXT].sec;
2260 exp_label->flags = BSF_GLOBAL;
2261 exp_label->value = 0;
2264 if (machine == MTHUMB)
2265 bfd_coff_set_symbol_class (abfd, exp_label, C_THUMBEXTFUNC);
2267 ptrs[oidx++] = exp_label;
2270 /* Generate imp symbols with one underscore for Microsoft
2271 compatibility, and with two underscores for backward
2272 compatibility with old versions of cygwin. */
2273 if (create_compat_implib)
2275 iname = bfd_make_empty_symbol (abfd);
2276 iname->name = make_imp_label ("___imp", exp->name);
2277 iname->section = secdata[IDATA5].sec;
2278 iname->flags = BSF_GLOBAL;
2282 iname2 = bfd_make_empty_symbol (abfd);
2283 iname2->name = make_imp_label ("__imp_", exp->name);
2284 iname2->section = secdata[IDATA5].sec;
2285 iname2->flags = BSF_GLOBAL;
2288 iname_lab = bfd_make_empty_symbol (abfd);
2290 iname_lab->name = head_label;
2291 iname_lab->section = (asection *) &bfd_und_section;
2292 iname_lab->flags = 0;
2293 iname_lab->value = 0;
2295 iname_pp = ptrs + oidx;
2296 if (create_compat_implib)
2297 ptrs[oidx++] = iname;
2298 ptrs[oidx++] = iname2;
2300 iname_lab_pp = ptrs + oidx;
2301 ptrs[oidx++] = iname_lab;
2304 /* The symbol referring to the code (.text). */
2306 asymbol *function_name;
2308 function_name = bfd_make_empty_symbol(abfd);
2309 function_name->name = make_label ("..", exp->name);
2310 function_name->section = secdata[TEXT].sec;
2311 function_name->flags = BSF_GLOBAL;
2312 function_name->value = 0;
2314 fn_pp = ptrs + oidx;
2315 ptrs[oidx++] = function_name;
2318 /* The .toc symbol. */
2320 asymbol *toc_symbol;
2322 toc_symbol = bfd_make_empty_symbol (abfd);
2323 toc_symbol->name = make_label (".", "toc");
2324 toc_symbol->section = (asection *)&bfd_und_section;
2325 toc_symbol->flags = BSF_GLOBAL;
2326 toc_symbol->value = 0;
2328 toc_pp = ptrs + oidx;
2329 ptrs[oidx++] = toc_symbol;
2335 for (i = 0; i < NSECS; i++)
2337 sinfo *si = secdata + i;
2338 asection *sec = si->sec;
2347 si->size = HOW_JTAB_SIZE;
2348 si->data = xmalloc (HOW_JTAB_SIZE);
2349 memcpy (si->data, HOW_JTAB, HOW_JTAB_SIZE);
2351 /* add the reloc into idata$5 */
2352 rel = xmalloc (sizeof (arelent));
2354 rpp = xmalloc (sizeof (arelent *) * 2);
2358 rel->address = HOW_JTAB_ROFF;
2361 if (machine == MPPC)
2363 rel->howto = bfd_reloc_type_lookup (abfd,
2364 BFD_RELOC_16_GOTOFF);
2365 rel->sym_ptr_ptr = iname_pp;
2369 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2370 rel->sym_ptr_ptr = secdata[IDATA5].sympp;
2372 sec->orelocation = rpp;
2373 sec->reloc_count = 1;
2378 /* An idata$4 or idata$5 is one word long, and has an
2381 si->data = xmalloc (4);
2386 si->data[0] = exp->ordinal ;
2387 si->data[1] = exp->ordinal >> 8;
2388 si->data[2] = exp->ordinal >> 16;
2393 sec->reloc_count = 1;
2394 memset (si->data, 0, si->size);
2395 rel = xmalloc (sizeof (arelent));
2396 rpp = xmalloc (sizeof (arelent *) * 2);
2401 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2402 rel->sym_ptr_ptr = secdata[IDATA6].sympp;
2403 sec->orelocation = rpp;
2411 /* This used to add 1 to exp->hint. I don't know
2412 why it did that, and it does not match what I see
2413 in programs compiled with the MS tools. */
2414 int idx = exp->hint;
2415 si->size = strlen (xlate (exp->import_name)) + 3;
2416 si->data = xmalloc (si->size);
2417 si->data[0] = idx & 0xff;
2418 si->data[1] = idx >> 8;
2419 strcpy ((char *) si->data + 2, xlate (exp->import_name));
2424 si->data = xmalloc (4);
2425 memset (si->data, 0, si->size);
2426 rel = xmalloc (sizeof (arelent));
2427 rpp = xmalloc (sizeof (arelent *) * 2);
2431 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2432 rel->sym_ptr_ptr = iname_lab_pp;
2433 sec->orelocation = rpp;
2434 sec->reloc_count = 1;
2440 /* The .pdata section is 5 words long.
2444 bfd_vma BeginAddress, [0x00]
2446 ExceptionHandler, [0x08]
2448 PrologEndAddress; [0x10]
2451 /* So this pdata section setups up this as a glue linkage to
2452 a dll routine. There are a number of house keeping things
2455 1. In the name of glue trickery, the ADDR32 relocs for 0,
2456 4, and 0x10 are set to point to the same place:
2458 2. There is one more reloc needed in the pdata section.
2459 The actual glue instruction to restore the toc on
2460 return is saved as the offset in an IMGLUE reloc.
2461 So we need a total of four relocs for this section.
2463 3. Lastly, the HandlerData field is set to 0x03, to indicate
2464 that this is a glue routine. */
2465 arelent *imglue, *ba_rel, *ea_rel, *pea_rel;
2467 /* Alignment must be set to 2**2 or you get extra stuff. */
2468 bfd_set_section_alignment(abfd, sec, 2);
2471 si->data = xmalloc (si->size);
2472 memset (si->data, 0, si->size);
2473 rpp = xmalloc (sizeof (arelent *) * 5);
2474 rpp[0] = imglue = xmalloc (sizeof (arelent));
2475 rpp[1] = ba_rel = xmalloc (sizeof (arelent));
2476 rpp[2] = ea_rel = xmalloc (sizeof (arelent));
2477 rpp[3] = pea_rel = xmalloc (sizeof (arelent));
2480 /* Stick the toc reload instruction in the glue reloc. */
2481 bfd_put_32(abfd, ppc_glue_insn, (char *) &imglue->address);
2484 imglue->howto = bfd_reloc_type_lookup (abfd,
2485 BFD_RELOC_32_GOTOFF);
2486 imglue->sym_ptr_ptr = fn_pp;
2488 ba_rel->address = 0;
2490 ba_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2491 ba_rel->sym_ptr_ptr = fn_pp;
2493 bfd_put_32 (abfd, 0x18, si->data + 0x04);
2494 ea_rel->address = 4;
2496 ea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2497 ea_rel->sym_ptr_ptr = fn_pp;
2499 /* Mark it as glue. */
2500 bfd_put_32 (abfd, 0x03, si->data + 0x0c);
2502 /* Mark the prolog end address. */
2503 bfd_put_32 (abfd, 0x0D, si->data + 0x10);
2504 pea_rel->address = 0x10;
2505 pea_rel->addend = 0;
2506 pea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2507 pea_rel->sym_ptr_ptr = fn_pp;
2509 sec->orelocation = rpp;
2510 sec->reloc_count = 4;
2514 /* Each external function in a PowerPC PE file has a two word
2515 descriptor consisting of:
2516 1. The address of the code.
2517 2. The address of the appropriate .toc
2518 We use relocs to build this. */
2520 si->data = xmalloc (8);
2521 memset (si->data, 0, si->size);
2523 rpp = xmalloc (sizeof (arelent *) * 3);
2524 rpp[0] = rel = xmalloc (sizeof (arelent));
2525 rpp[1] = xmalloc (sizeof (arelent));
2530 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2531 rel->sym_ptr_ptr = fn_pp;
2537 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2538 rel->sym_ptr_ptr = toc_pp;
2540 sec->orelocation = rpp;
2541 sec->reloc_count = 2;
2543 #endif /* DLLTOOL_PPC */
2549 /* Size up all the sections. */
2550 for (i = 0; i < NSECS; i++)
2552 sinfo *si = secdata + i;
2554 bfd_set_section_size (abfd, si->sec, si->size);
2555 bfd_set_section_vma (abfd, si->sec, vma);
2558 /* Write them out. */
2559 for (i = 0; i < NSECS; i++)
2561 sinfo *si = secdata + i;
2563 if (i == IDATA5 && no_idata5)
2566 if (i == IDATA4 && no_idata4)
2569 bfd_set_section_contents (abfd, si->sec,
2574 bfd_set_symtab (abfd, ptrs, oidx);
2576 abfd = bfd_openr (outname, HOW_BFD_READ_TARGET);
2583 FILE *f = fopen (TMP_HEAD_S, FOPEN_WT);
2587 fatal (_("failed to open temporary head file: %s"), TMP_HEAD_S);
2591 fprintf (f, "%s IMAGE_IMPORT_DESCRIPTOR\n", ASM_C);
2592 fprintf (f, "\t.section .idata$2\n");
2594 fprintf(f,"\t%s\t%s\n", ASM_GLOBAL,head_label);
2596 fprintf (f, "%s:\n", head_label);
2598 fprintf (f, "\t%shname%s\t%sPtr to image import by name list\n",
2599 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
2601 fprintf (f, "\t%sthis should be the timestamp, but NT sometimes\n", ASM_C);
2602 fprintf (f, "\t%sdoesn't load DLLs when this is set.\n", ASM_C);
2603 fprintf (f, "\t%s\t0\t%s loaded time\n", ASM_LONG, ASM_C);
2604 fprintf (f, "\t%s\t0\t%s Forwarder chain\n", ASM_LONG, ASM_C);
2605 fprintf (f, "\t%s__%s_iname%s\t%s imported dll's name\n",
2610 fprintf (f, "\t%sfthunk%s\t%s pointer to firstthunk\n",
2612 ASM_RVA_AFTER, ASM_C);
2614 fprintf (f, "%sStuff for compatibility\n", ASM_C);
2618 fprintf (f, "\t.section\t.idata$5\n");
2619 fprintf (f, "\t%s\t0\n", ASM_LONG);
2620 fprintf (f, "fthunk:\n");
2625 fprintf (f, "\t.section\t.idata$4\n");
2627 fprintf (f, "\t%s\t0\n", ASM_LONG);
2628 fprintf (f, "\t.section .idata$4\n");
2629 fprintf (f, "hname:\n");
2634 assemble_file (TMP_HEAD_S, TMP_HEAD_O);
2636 return bfd_openr (TMP_HEAD_O, HOW_BFD_READ_TARGET);
2642 FILE *f = fopen (TMP_TAIL_S, FOPEN_WT);
2646 fatal (_("failed to open temporary tail file: %s"), TMP_TAIL_S);
2652 fprintf (f, "\t.section .idata$4\n");
2653 fprintf (f, "\t%s\t0\n", ASM_LONG);
2658 fprintf (f, "\t.section .idata$5\n");
2659 fprintf (f, "\t%s\t0\n", ASM_LONG);
2663 /* Normally, we need to see a null descriptor built in idata$3 to
2664 act as the terminator for the list. The ideal way, I suppose,
2665 would be to mark this section as a comdat type 2 section, so
2666 only one would appear in the final .exe (if our linker supported
2667 comdat, that is) or cause it to be inserted by something else (say
2670 fprintf (f, "\t.section .idata$3\n");
2671 fprintf (f, "\t%s\t0\n", ASM_LONG);
2672 fprintf (f, "\t%s\t0\n", ASM_LONG);
2673 fprintf (f, "\t%s\t0\n", ASM_LONG);
2674 fprintf (f, "\t%s\t0\n", ASM_LONG);
2675 fprintf (f, "\t%s\t0\n", ASM_LONG);
2679 /* Other PowerPC NT compilers use idata$6 for the dllname, so I
2680 do too. Original, huh? */
2681 fprintf (f, "\t.section .idata$6\n");
2683 fprintf (f, "\t.section .idata$7\n");
2686 fprintf (f, "\t%s\t__%s_iname\n", ASM_GLOBAL, imp_name_lab);
2687 fprintf (f, "__%s_iname:\t%s\t\"%s\"\n",
2688 imp_name_lab, ASM_TEXT, dll_name);
2692 assemble_file (TMP_TAIL_S, TMP_TAIL_O);
2694 return bfd_openr (TMP_TAIL_O, HOW_BFD_READ_TARGET);
2709 outarch = bfd_openw (imp_name, HOW_BFD_WRITE_TARGET);
2712 /* xgettext:c-format */
2713 fatal (_("Can't open .lib file: %s"), imp_name);
2715 /* xgettext:c-format */
2716 inform (_("Creating library file: %s"), imp_name);
2718 bfd_set_format (outarch, bfd_archive);
2719 outarch->has_armap = 1;
2721 /* Work out a reasonable size of things to put onto one line. */
2722 ar_head = make_head ();
2723 ar_tail = make_tail();
2725 if (ar_head == NULL || ar_tail == NULL)
2728 for (i = 0; (exp = d_exports_lexically[i]); i++)
2731 /* Don't add PRIVATE entries to import lib. */
2734 n = make_one_lib_file (exp, i);
2737 if (ext_prefix_alias)
2739 export_type alias_exp;
2741 assert (i < PREFIX_ALIAS_BASE);
2742 alias_exp.name = make_imp_label (ext_prefix_alias, exp->name);
2743 alias_exp.internal_name = exp->internal_name;
2744 alias_exp.import_name = exp->name;
2745 alias_exp.ordinal = exp->ordinal;
2746 alias_exp.constant = exp->constant;
2747 alias_exp.noname = exp->noname;
2748 alias_exp.private = exp->private;
2749 alias_exp.data = exp->data;
2750 alias_exp.hint = exp->hint;
2751 alias_exp.forward = exp->forward;
2752 alias_exp.next = exp->next;
2753 n = make_one_lib_file (&alias_exp, i + PREFIX_ALIAS_BASE);
2759 /* Now stick them all into the archive. */
2760 ar_head->next = head;
2761 ar_tail->next = ar_head;
2764 if (! bfd_set_archive_head (outarch, head))
2765 bfd_fatal ("bfd_set_archive_head");
2767 if (! bfd_close (outarch))
2768 bfd_fatal (imp_name);
2770 while (head != NULL)
2772 bfd *n = head->next;
2777 /* Delete all the temp files. */
2778 if (dontdeltemps == 0)
2780 unlink (TMP_HEAD_O);
2781 unlink (TMP_HEAD_S);
2782 unlink (TMP_TAIL_O);
2783 unlink (TMP_TAIL_S);
2786 if (dontdeltemps < 2)
2790 name = (char *) alloca (strlen (TMP_STUB) + 10);
2791 for (i = 0; (exp = d_exports_lexically[i]); i++)
2793 /* Don't delete non-existent stubs for PRIVATE entries. */
2796 sprintf (name, "%s%05d.o", TMP_STUB, i);
2797 if (unlink (name) < 0)
2798 /* xgettext:c-format */
2799 non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
2800 if (ext_prefix_alias)
2802 sprintf (name, "%s%05d.o", TMP_STUB, i + PREFIX_ALIAS_BASE);
2803 if (unlink (name) < 0)
2804 /* xgettext:c-format */
2805 non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
2810 inform (_("Created lib file"));
2813 /* Run through the information gathered from the .o files and the
2814 .def file and work out the best stuff. */
2817 pfunc (const void *a, const void *b)
2819 export_type *ap = *(export_type **) a;
2820 export_type *bp = *(export_type **) b;
2821 if (ap->ordinal == bp->ordinal)
2824 /* Unset ordinals go to the bottom. */
2825 if (ap->ordinal == -1)
2827 if (bp->ordinal == -1)
2829 return (ap->ordinal - bp->ordinal);
2833 nfunc (const void *a, const void *b)
2835 export_type *ap = *(export_type **) a;
2836 export_type *bp = *(export_type **) b;
2838 return (strcmp (ap->name, bp->name));
2842 remove_null_names (export_type **ptr)
2847 for (dst = src = 0; src < d_nfuncs; src++)
2851 ptr[dst] = ptr[src];
2859 process_duplicates (export_type **d_export_vec)
2867 /* Remove duplicates. */
2868 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), nfunc);
2870 for (i = 0; i < d_nfuncs - 1; i++)
2872 if (strcmp (d_export_vec[i]->name,
2873 d_export_vec[i + 1]->name) == 0)
2875 export_type *a = d_export_vec[i];
2876 export_type *b = d_export_vec[i + 1];
2880 /* xgettext:c-format */
2881 inform (_("Warning, ignoring duplicate EXPORT %s %d,%d"),
2882 a->name, a->ordinal, b->ordinal);
2884 if (a->ordinal != -1
2885 && b->ordinal != -1)
2886 /* xgettext:c-format */
2887 fatal (_("Error, duplicate EXPORT with oridinals: %s"),
2890 /* Merge attributes. */
2891 b->ordinal = a->ordinal > 0 ? a->ordinal : b->ordinal;
2892 b->constant |= a->constant;
2893 b->noname |= a->noname;
2895 d_export_vec[i] = 0;
2898 remove_null_names (d_export_vec);
2902 /* Count the names. */
2903 for (i = 0; i < d_nfuncs; i++)
2904 if (!d_export_vec[i]->noname)
2909 fill_ordinals (export_type **d_export_vec)
2916 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
2918 /* Fill in the unset ordinals with ones from our range. */
2919 ptr = (char *) xmalloc (size);
2921 memset (ptr, 0, size);
2923 /* Mark in our large vector all the numbers that are taken. */
2924 for (i = 0; i < d_nfuncs; i++)
2926 if (d_export_vec[i]->ordinal != -1)
2928 ptr[d_export_vec[i]->ordinal] = 1;
2930 if (lowest == -1 || d_export_vec[i]->ordinal < lowest)
2931 lowest = d_export_vec[i]->ordinal;
2935 /* Start at 1 for compatibility with MS toolchain. */
2939 /* Now fill in ordinals where the user wants us to choose. */
2940 for (i = 0; i < d_nfuncs; i++)
2942 if (d_export_vec[i]->ordinal == -1)
2946 /* First try within or after any user supplied range. */
2947 for (j = lowest; j < size; j++)
2951 d_export_vec[i]->ordinal = j;
2955 /* Then try before the range. */
2956 for (j = lowest; j >0; j--)
2960 d_export_vec[i]->ordinal = j;
2970 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
2972 /* Work out the lowest and highest ordinal numbers. */
2975 if (d_export_vec[0])
2976 d_low_ord = d_export_vec[0]->ordinal;
2977 if (d_export_vec[d_nfuncs-1])
2978 d_high_ord = d_export_vec[d_nfuncs-1]->ordinal;
2983 alphafunc (const void *av, const void *bv)
2985 const export_type **a = (const export_type **) av;
2986 const export_type **b = (const export_type **) bv;
2988 return strcmp ((*a)->name, (*b)->name);
2994 /* First work out the minimum ordinal chosen. */
2999 export_type **d_export_vec = xmalloc (sizeof (export_type *) * d_nfuncs);
3001 inform (_("Processing definitions"));
3003 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3004 d_export_vec[i] = exp;
3006 process_duplicates (d_export_vec);
3007 fill_ordinals (d_export_vec);
3009 /* Put back the list in the new order. */
3011 for (i = d_nfuncs - 1; i >= 0; i--)
3013 d_export_vec[i]->next = d_exports;
3014 d_exports = d_export_vec[i];
3017 /* Build list in alpha order. */
3018 d_exports_lexically = (export_type **)
3019 xmalloc (sizeof (export_type *) * (d_nfuncs + 1));
3021 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3022 d_exports_lexically[i] = exp;
3024 d_exports_lexically[i] = 0;
3026 qsort (d_exports_lexically, i, sizeof (export_type *), alphafunc);
3028 /* Fill exp entries with their hint values. */
3029 for (i = 0; i < d_nfuncs; i++)
3030 if (!d_exports_lexically[i]->noname || show_allnames)
3031 d_exports_lexically[i]->hint = hint++;
3033 inform (_("Processed definitions"));
3037 usage (FILE *file, int status)
3039 /* xgetext:c-format */
3040 fprintf (file, _("Usage %s <option(s)> <object-file(s)>\n"), program_name);
3041 /* xgetext:c-format */
3042 fprintf (file, _(" -m --machine <machine> Create as DLL for <machine>. [default: %s]\n"), mname);
3043 fprintf (file, _(" possible <machine>: arm[_interwork], i386, mcore[-elf]{-le|-be}, ppc, thumb\n"));
3044 fprintf (file, _(" -e --output-exp <outname> Generate an export file.\n"));
3045 fprintf (file, _(" -l --output-lib <outname> Generate an interface library.\n"));
3046 fprintf (file, _(" -a --add-indirect Add dll indirects to export file.\n"));
3047 fprintf (file, _(" -D --dllname <name> Name of input dll to put into interface lib.\n"));
3048 fprintf (file, _(" -d --input-def <deffile> Name of .def file to be read in.\n"));
3049 fprintf (file, _(" -z --output-def <deffile> Name of .def file to be created.\n"));
3050 fprintf (file, _(" --export-all-symbols Export all symbols to .def\n"));
3051 fprintf (file, _(" --no-export-all-symbols Only export listed symbols\n"));
3052 fprintf (file, _(" --exclude-symbols <list> Don't export <list>\n"));
3053 fprintf (file, _(" --no-default-excludes Clear default exclude symbols\n"));
3054 fprintf (file, _(" -b --base-file <basefile> Read linker generated base file.\n"));
3055 fprintf (file, _(" -x --no-idata4 Don't generate idata$4 section.\n"));
3056 fprintf (file, _(" -c --no-idata5 Don't generate idata$5 section.\n"));
3057 fprintf (file, _(" -U --add-underscore Add underscores to symbols in interface library.\n"));
3058 fprintf (file, _(" -k --kill-at Kill @<n> from exported names.\n"));
3059 fprintf (file, _(" -A --add-stdcall-alias Add aliases without @<n>.\n"));
3060 fprintf (file, _(" -p --ext-prefix-alias <prefix> Add aliases with <prefix>.\n"));
3061 fprintf (file, _(" -S --as <name> Use <name> for assembler.\n"));
3062 fprintf (file, _(" -f --as-flags <flags> Pass <flags> to the assembler.\n"));
3063 fprintf (file, _(" -C --compat-implib Create backward compatible import library.\n"));
3064 fprintf (file, _(" -n --no-delete Keep temp files (repeat for extra preservation).\n"));
3065 fprintf (file, _(" -t --temp-prefix <prefix> Use <prefix> to construct temp file names.\n"));
3066 fprintf (file, _(" -v --verbose Be verbose.\n"));
3067 fprintf (file, _(" -V --version Display the program version.\n"));
3068 fprintf (file, _(" -h --help Display this information.\n"));
3069 #ifdef DLLTOOL_MCORE_ELF
3070 fprintf (file, _(" -M --mcore-elf <outname> Process mcore-elf object files into <outname>.\n"));
3071 fprintf (file, _(" -L --linker <name> Use <name> as the linker.\n"));
3072 fprintf (file, _(" -F --linker-flags <flags> Pass <flags> to the linker.\n"));
3077 #define OPTION_EXPORT_ALL_SYMS 150
3078 #define OPTION_NO_EXPORT_ALL_SYMS (OPTION_EXPORT_ALL_SYMS + 1)
3079 #define OPTION_EXCLUDE_SYMS (OPTION_NO_EXPORT_ALL_SYMS + 1)
3080 #define OPTION_NO_DEFAULT_EXCLUDES (OPTION_EXCLUDE_SYMS + 1)
3082 static const struct option long_options[] =
3084 {"no-delete", no_argument, NULL, 'n'},
3085 {"dllname", required_argument, NULL, 'D'},
3086 {"no-idata4", no_argument, NULL, 'x'},
3087 {"no-idata5", no_argument, NULL, 'c'},
3088 {"output-exp", required_argument, NULL, 'e'},
3089 {"output-def", required_argument, NULL, 'z'},
3090 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL_SYMS},
3091 {"no-export-all-symbols", no_argument, NULL, OPTION_NO_EXPORT_ALL_SYMS},
3092 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMS},
3093 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
3094 {"output-lib", required_argument, NULL, 'l'},
3095 {"def", required_argument, NULL, 'd'}, /* for compatibility with older versions */
3096 {"input-def", required_argument, NULL, 'd'},
3097 {"add-underscore", no_argument, NULL, 'U'},
3098 {"kill-at", no_argument, NULL, 'k'},
3099 {"add-stdcall-alias", no_argument, NULL, 'A'},
3100 {"ext-prefix-alias", required_argument, NULL, 'p'},
3101 {"verbose", no_argument, NULL, 'v'},
3102 {"version", no_argument, NULL, 'V'},
3103 {"help", no_argument, NULL, 'h'},
3104 {"machine", required_argument, NULL, 'm'},
3105 {"add-indirect", no_argument, NULL, 'a'},
3106 {"base-file", required_argument, NULL, 'b'},
3107 {"as", required_argument, NULL, 'S'},
3108 {"as-flags", required_argument, NULL, 'f'},
3109 {"mcore-elf", required_argument, NULL, 'M'},
3110 {"compat-implib", no_argument, NULL, 'C'},
3111 {"temp-prefix", required_argument, NULL, 't'},
3115 int main (int, char **);
3118 main (int ac, char **av)
3123 program_name = av[0];
3126 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
3127 setlocale (LC_MESSAGES, "");
3129 #if defined (HAVE_SETLOCALE)
3130 setlocale (LC_CTYPE, "");
3132 bindtextdomain (PACKAGE, LOCALEDIR);
3133 textdomain (PACKAGE);
3135 while ((c = getopt_long (ac, av,
3136 #ifdef DLLTOOL_MCORE_ELF
3137 "m:e:l:aD:d:z:b:xp:cCuUkAS:f:nvVHhM:L:F:",
3139 "m:e:l:aD:d:z:b:xp:cCuUkAS:f:nvVHh",
3146 case OPTION_EXPORT_ALL_SYMS:
3147 export_all_symbols = TRUE;
3149 case OPTION_NO_EXPORT_ALL_SYMS:
3150 export_all_symbols = FALSE;
3152 case OPTION_EXCLUDE_SYMS:
3153 add_excludes (optarg);
3155 case OPTION_NO_DEFAULT_EXCLUDES:
3156 do_default_excludes = FALSE;
3168 tmp_prefix = optarg;
3174 /* Ignored for compatibility. */
3181 output_def = fopen (optarg, FOPEN_WT);
3184 dll_name = (char*) lbasename (optarg);
3185 if (dll_name != optarg)
3186 non_fatal (_("Path components stripped from dllname, '%s'."),
3206 print_version (program_name);
3215 add_stdcall_alias = 1;
3218 ext_prefix_alias = optarg;
3227 base_file = fopen (optarg, FOPEN_RB);
3230 /* xgettext:c-format */
3231 fatal (_("Unable to open base-file: %s"), optarg);
3234 #ifdef DLLTOOL_MCORE_ELF
3236 mcore_elf_out_file = optarg;
3239 mcore_elf_linker = optarg;
3242 mcore_elf_linker_flags = optarg;
3246 create_compat_implib = 1;
3255 tmp_prefix = prefix_encode ("d", getpid ());
3257 for (i = 0; mtable[i].type; i++)
3258 if (strcmp (mtable[i].type, mname) == 0)
3261 if (!mtable[i].type)
3262 /* xgettext:c-format */
3263 fatal (_("Machine '%s' not supported"), mname);
3267 if (!dll_name && exp_name)
3269 /* If we are inferring dll_name from exp_name,
3270 strip off any path components, without emitting
3272 const char* exp_basename = lbasename (exp_name);
3273 const int len = strlen (exp_basename) + 5;
3274 dll_name = xmalloc (len);
3275 strcpy (dll_name, exp_basename);
3276 strcat (dll_name, ".dll");
3279 if (as_name == NULL)
3280 as_name = deduce_name ("as");
3282 /* Don't use the default exclude list if we're reading only the
3283 symbols in the .drectve section. The default excludes are meant
3284 to avoid exporting DLL entry point and Cygwin32 impure_ptr. */
3285 if (! export_all_symbols)
3286 do_default_excludes = FALSE;
3288 if (do_default_excludes)
3289 set_default_excludes ();
3292 process_def_file (def_file);
3297 firstarg = av[optind];
3298 scan_obj_file (av[optind]);
3309 /* Make imp_name safe for use as a label. */
3312 imp_name_lab = xstrdup (imp_name);
3313 for (p = imp_name_lab; *p; p++)
3318 head_label = make_label("_head_", imp_name_lab);
3325 #ifdef DLLTOOL_MCORE_ELF
3326 if (mcore_elf_out_file)
3327 mcore_elf_gen_out_file ();
3333 /* Look for the program formed by concatenating PROG_NAME and the
3334 string running from PREFIX to END_PREFIX. If the concatenated
3335 string contains a '/', try appending EXECUTABLE_SUFFIX if it is
3339 look_for_prog (const char *prog_name, const char *prefix, int end_prefix)
3344 cmd = xmalloc (strlen (prefix)
3345 + strlen (prog_name)
3346 #ifdef HAVE_EXECUTABLE_SUFFIX
3347 + strlen (EXECUTABLE_SUFFIX)
3350 strcpy (cmd, prefix);
3352 sprintf (cmd + end_prefix, "%s", prog_name);
3354 if (strchr (cmd, '/') != NULL)
3358 found = (stat (cmd, &s) == 0
3359 #ifdef HAVE_EXECUTABLE_SUFFIX
3360 || stat (strcat (cmd, EXECUTABLE_SUFFIX), &s) == 0
3366 /* xgettext:c-format */
3367 inform (_("Tried file: %s"), cmd);
3373 /* xgettext:c-format */
3374 inform (_("Using file: %s"), cmd);
3379 /* Deduce the name of the program we are want to invoke.
3380 PROG_NAME is the basic name of the program we want to run,
3381 eg "as" or "ld". The catch is that we might want actually
3382 run "i386-pe-as" or "ppc-pe-ld".
3384 If argv[0] contains the full path, then try to find the program
3385 in the same place, with and then without a target-like prefix.
3387 Given, argv[0] = /usr/local/bin/i586-cygwin32-dlltool,
3388 deduce_name("as") uses the following search order:
3390 /usr/local/bin/i586-cygwin32-as
3394 If there's an EXECUTABLE_SUFFIX, it'll use that as well; for each
3395 name, it'll try without and then with EXECUTABLE_SUFFIX.
3397 Given, argv[0] = i586-cygwin32-dlltool, it will not even try "as"
3398 as the fallback, but rather return i586-cygwin32-as.
3400 Oh, and given, argv[0] = dlltool, it'll return "as".
3402 Returns a dynamically allocated string. */
3405 deduce_name (const char *prog_name)
3408 char *dash, *slash, *cp;
3412 for (cp = program_name; *cp != '\0'; ++cp)
3417 #if defined(__DJGPP__) || defined (__CYGWIN__) || defined(__WIN32__)
3418 *cp == ':' || *cp == '\\' ||
3431 /* First, try looking for a prefixed PROG_NAME in the
3432 PROGRAM_NAME directory, with the same prefix as PROGRAM_NAME. */
3433 cmd = look_for_prog (prog_name, program_name, dash - program_name + 1);
3436 if (slash != NULL && cmd == NULL)
3438 /* Next, try looking for a PROG_NAME in the same directory as
3439 that of this program. */
3440 cmd = look_for_prog (prog_name, program_name, slash - program_name + 1);
3445 /* Just return PROG_NAME as is. */
3446 cmd = xstrdup (prog_name);
3452 #ifdef DLLTOOL_MCORE_ELF
3453 typedef struct fname_cache
3456 struct fname_cache * next;
3460 static fname_cache fnames;
3463 mcore_elf_cache_filename (char * filename)
3469 while (ptr->next != NULL)
3472 ptr->filename = filename;
3473 ptr->next = (fname_cache *) malloc (sizeof (fname_cache));
3474 if (ptr->next != NULL)
3475 ptr->next->next = NULL;
3478 #define MCORE_ELF_TMP_OBJ "mcoreelf.o"
3479 #define MCORE_ELF_TMP_EXP "mcoreelf.exp"
3480 #define MCORE_ELF_TMP_LIB "mcoreelf.lib"
3483 mcore_elf_gen_out_file (void)
3488 /* Step one. Run 'ld -r' on the input object files in order to resolve
3489 any internal references and to generate a single .exports section. */
3492 ds = dyn_string_new (100);
3493 dyn_string_append_cstr (ds, "-r ");
3495 if (mcore_elf_linker_flags != NULL)
3496 dyn_string_append_cstr (ds, mcore_elf_linker_flags);
3498 while (ptr->next != NULL)
3500 dyn_string_append_cstr (ds, ptr->filename);
3501 dyn_string_append_cstr (ds, " ");
3506 dyn_string_append_cstr (ds, "-o ");
3507 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
3509 if (mcore_elf_linker == NULL)
3510 mcore_elf_linker = deduce_name ("ld");
3512 run (mcore_elf_linker, ds->s);
3514 dyn_string_delete (ds);
3516 /* Step two. Create a .exp file and a .lib file from the temporary file.
3517 Do this by recursively invoking dlltool... */
3518 ds = dyn_string_new (100);
3520 dyn_string_append_cstr (ds, "-S ");
3521 dyn_string_append_cstr (ds, as_name);
3523 dyn_string_append_cstr (ds, " -e ");
3524 dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP);
3525 dyn_string_append_cstr (ds, " -l ");
3526 dyn_string_append_cstr (ds, MCORE_ELF_TMP_LIB);
3527 dyn_string_append_cstr (ds, " " );
3528 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
3531 dyn_string_append_cstr (ds, " -v");
3535 dyn_string_append_cstr (ds, " -n");
3537 if (dontdeltemps > 1)
3538 dyn_string_append_cstr (ds, " -n");
3541 /* XXX - FIME: ought to check/copy other command line options as well. */
3542 run (program_name, ds->s);
3544 dyn_string_delete (ds);
3546 /* Step four. Feed the .exp and object files to ld -shared to create the dll. */
3547 ds = dyn_string_new (100);
3549 dyn_string_append_cstr (ds, "-shared ");
3551 if (mcore_elf_linker_flags)
3552 dyn_string_append_cstr (ds, mcore_elf_linker_flags);
3554 dyn_string_append_cstr (ds, " ");
3555 dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP);
3556 dyn_string_append_cstr (ds, " ");
3557 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
3558 dyn_string_append_cstr (ds, " -o ");
3559 dyn_string_append_cstr (ds, mcore_elf_out_file);
3561 run (mcore_elf_linker, ds->s);
3563 dyn_string_delete (ds);
3565 if (dontdeltemps == 0)
3566 unlink (MCORE_ELF_TMP_EXP);
3568 if (dontdeltemps < 2)
3569 unlink (MCORE_ELF_TMP_OBJ);
3571 #endif /* DLLTOOL_MCORE_ELF */