1 /* dlltool.c -- tool to generate stuff for PE style DLLs
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
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] ) *
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
265 #include "coff/arm.h"
266 #include "coff/internal.h"
269 /* Forward references. */
270 static char *look_for_prog (const char *, const char *, int);
271 static char *deduce_name (const char *);
273 #ifdef DLLTOOL_MCORE_ELF
274 static void mcore_elf_cache_filename (char *);
275 static void mcore_elf_gen_out_file (void);
278 #ifdef HAVE_SYS_WAIT_H
279 #include <sys/wait.h>
280 #else /* ! HAVE_SYS_WAIT_H */
281 #if ! defined (_WIN32) || defined (__CYGWIN32__)
283 #define WIFEXITED(w) (((w) & 0377) == 0)
286 #define WIFSIGNALED(w) (((w) & 0377) != 0177 && ((w) & ~0377) == 0)
289 #define WTERMSIG(w) ((w) & 0177)
292 #define WEXITSTATUS(w) (((w) >> 8) & 0377)
294 #else /* defined (_WIN32) && ! defined (__CYGWIN32__) */
296 #define WIFEXITED(w) (((w) & 0xff) == 0)
299 #define WIFSIGNALED(w) (((w) & 0xff) != 0 && ((w) & 0xff) != 0x7f)
302 #define WTERMSIG(w) ((w) & 0x7f)
305 #define WEXITSTATUS(w) (((w) & 0xff00) >> 8)
307 #endif /* defined (_WIN32) && ! defined (__CYGWIN32__) */
308 #endif /* ! HAVE_SYS_WAIT_H */
310 /* ifunc and ihead data structures: ttk@cygnus.com 1997
312 When IMPORT declarations are encountered in a .def file the
313 function import information is stored in a structure referenced by
314 the global variable IMPORT_LIST. The structure is a linked list
315 containing the names of the dll files each function is imported
316 from and a linked list of functions being imported from that dll
317 file. This roughly parallels the structure of the .idata section
318 in the PE object file.
320 The contents of .def file are interpreted from within the
321 process_def_file function. Every time an IMPORT declaration is
322 encountered, it is broken up into its component parts and passed to
323 def_import. IMPORT_LIST is initialized to NULL in function main. */
325 typedef struct ifunct
327 char * name; /* Name of function being imported. */
328 int ord; /* Two-byte ordinal value associated with function. */
332 typedef struct iheadt
334 char *dllname; /* Name of dll file imported from. */
335 long nfuncs; /* Number of functions in list. */
336 struct ifunct *funchead; /* First function in list. */
337 struct ifunct *functail; /* Last function in list. */
338 struct iheadt *next; /* Next dll file in list. */
341 /* Structure containing all import information as defined in .def file
342 (qv "ihead structure"). */
344 static iheadtype *import_list = NULL;
346 static char *as_name = NULL;
347 static char * as_flags = "";
349 static char *tmp_prefix;
351 static int no_idata4;
352 static int no_idata5;
353 static char *exp_name;
354 static char *imp_name;
355 static char *head_label;
356 static char *imp_name_lab;
357 static char *dll_name;
359 static int add_indirect = 0;
360 static int add_underscore = 0;
361 static int dontdeltemps = 0;
363 /* TRUE if we should export all symbols. Otherwise, we only export
364 symbols listed in .drectve sections or in the def file. */
365 static bfd_boolean export_all_symbols;
367 /* TRUE if we should exclude the symbols in DEFAULT_EXCLUDES when
368 exporting all symbols. */
369 static bfd_boolean do_default_excludes = TRUE;
371 /* Default symbols to exclude when exporting all the symbols. */
372 static const char *default_excludes = "DllMain@12,DllEntryPoint@0,impure_ptr";
374 /* TRUE if we should add __imp_<SYMBOL> to import libraries for backward
375 compatibility to old Cygwin releases. */
376 static bfd_boolean create_compat_implib;
378 static char *def_file;
380 extern char * program_name;
384 static int add_stdcall_alias;
386 static FILE *output_def;
387 static FILE *base_file;
390 #ifdef DLLTOOL_ARM_EPOC
391 static const char *mname = "arm-epoc";
393 static const char *mname = "arm";
398 static const char *mname = "i386";
402 static const char *mname = "ppc";
406 static const char *mname = "sh";
410 static const char *mname = "mips";
414 static const char * mname = "mcore-le";
417 #ifdef DLLTOOL_MCORE_ELF
418 static const char * mname = "mcore-elf";
419 static char * mcore_elf_out_file = NULL;
420 static char * mcore_elf_linker = NULL;
421 static char * mcore_elf_linker_flags = NULL;
423 #define DRECTVE_SECTION_NAME ((machine == MMCORE_ELF || machine == MMCORE_ELF_LE) ? ".exports" : ".drectve")
426 #ifndef DRECTVE_SECTION_NAME
427 #define DRECTVE_SECTION_NAME ".drectve"
430 #define PATHMAX 250 /* What's the right name for this ? */
433 char *tmp_head_s_buf;
434 char *tmp_head_o_buf;
435 char *tmp_tail_s_buf;
436 char *tmp_tail_o_buf;
439 #define TMP_ASM dlltmp (&tmp_asm_buf, "%sc.s")
440 #define TMP_HEAD_S dlltmp (&tmp_head_s_buf, "%sh.s")
441 #define TMP_HEAD_O dlltmp (&tmp_head_o_buf, "%sh.o")
442 #define TMP_TAIL_S dlltmp (&tmp_tail_s_buf, "%st.s")
443 #define TMP_TAIL_O dlltmp (&tmp_tail_o_buf, "%st.o")
444 #define TMP_STUB dlltmp (&tmp_stub_buf, "%ss")
446 /* This bit of assembly does jmp * .... */
447 static const unsigned char i386_jtab[] =
449 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
452 static const unsigned char arm_jtab[] =
454 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
455 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
459 static const unsigned char arm_interwork_jtab[] =
461 0x04, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
462 0x00, 0xc0, 0x9c, 0xe5, /* ldr ip, [ip] */
463 0x1c, 0xff, 0x2f, 0xe1, /* bx ip */
467 static const unsigned char thumb_jtab[] =
469 0x40, 0xb4, /* push {r6} */
470 0x02, 0x4e, /* ldr r6, [pc, #8] */
471 0x36, 0x68, /* ldr r6, [r6] */
472 0xb4, 0x46, /* mov ip, r6 */
473 0x40, 0xbc, /* pop {r6} */
474 0x60, 0x47, /* bx ip */
478 static const unsigned char mcore_be_jtab[] =
480 0x71, 0x02, /* lrw r1,2 */
481 0x81, 0x01, /* ld.w r1,(r1,0) */
482 0x00, 0xC1, /* jmp r1 */
483 0x12, 0x00, /* nop */
484 0x00, 0x00, 0x00, 0x00 /* <address> */
487 static const unsigned char mcore_le_jtab[] =
489 0x02, 0x71, /* lrw r1,2 */
490 0x01, 0x81, /* ld.w r1,(r1,0) */
491 0xC1, 0x00, /* jmp r1 */
492 0x00, 0x12, /* nop */
493 0x00, 0x00, 0x00, 0x00 /* <address> */
496 /* This is the glue sequence for PowerPC PE. There is a
497 tocrel16-tocdefn reloc against the first instruction.
498 We also need a IMGLUE reloc against the glue function
499 to restore the toc saved by the third instruction in
501 static const unsigned char ppc_jtab[] =
503 0x00, 0x00, 0x62, 0x81, /* lwz r11,0(r2) */
504 /* Reloc TOCREL16 __imp_xxx */
505 0x00, 0x00, 0x8B, 0x81, /* lwz r12,0(r11) */
506 0x04, 0x00, 0x41, 0x90, /* stw r2,4(r1) */
507 0xA6, 0x03, 0x89, 0x7D, /* mtctr r12 */
508 0x04, 0x00, 0x4B, 0x80, /* lwz r2,4(r11) */
509 0x20, 0x04, 0x80, 0x4E /* bctr */
513 /* The glue instruction, picks up the toc from the stw in
514 the above code: "lwz r2,4(r1)". */
515 static bfd_vma ppc_glue_insn = 0x80410004;
521 const char *how_byte;
522 const char *how_short;
523 const char *how_long;
524 const char *how_asciz;
525 const char *how_comment;
526 const char *how_jump;
527 const char *how_global;
528 const char *how_space;
529 const char *how_align_short;
530 const char *how_align_long;
531 const char *how_default_as_switches;
532 const char *how_bfd_target;
533 enum bfd_architecture how_bfd_arch;
534 const unsigned char *how_jtab;
535 int how_jtab_size; /* Size of the jtab entry. */
536 int how_jtab_roff; /* Offset into it for the ind 32 reloc into idata 5. */
539 static const struct mac
544 "arm", ".byte", ".short", ".long", ".asciz", "@",
545 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
546 ".global", ".space", ".align\t2",".align\t4", "-mapcs-32",
547 "pe-arm-little", bfd_arch_arm,
548 arm_jtab, sizeof (arm_jtab), 8
553 "i386", ".byte", ".short", ".long", ".asciz", "#",
554 "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
555 "pe-i386",bfd_arch_i386,
556 i386_jtab, sizeof (i386_jtab), 2
561 "ppc", ".byte", ".short", ".long", ".asciz", "#",
562 "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
563 "pe-powerpcle",bfd_arch_powerpc,
564 ppc_jtab, sizeof (ppc_jtab), 0
569 "thumb", ".byte", ".short", ".long", ".asciz", "@",
570 "push\t{r6}\n\tldr\tr6, [pc, #8]\n\tldr\tr6, [r6]\n\tmov\tip, r6\n\tpop\t{r6}\n\tbx\tip",
571 ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
572 "pe-arm-little", bfd_arch_arm,
573 thumb_jtab, sizeof (thumb_jtab), 12
576 #define MARM_INTERWORK 4
578 "arm_interwork", ".byte", ".short", ".long", ".asciz", "@",
579 "ldr\tip,[pc]\n\tldr\tip,[ip]\n\tbx\tip\n\t.long",
580 ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
581 "pe-arm-little", bfd_arch_arm,
582 arm_interwork_jtab, sizeof (arm_interwork_jtab), 12
587 "mcore-be", ".byte", ".short", ".long", ".asciz", "//",
588 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
589 ".global", ".space", ".align\t2",".align\t4", "",
590 "pe-mcore-big", bfd_arch_mcore,
591 mcore_be_jtab, sizeof (mcore_be_jtab), 8
596 "mcore-le", ".byte", ".short", ".long", ".asciz", "//",
597 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
598 ".global", ".space", ".align\t2",".align\t4", "-EL",
599 "pe-mcore-little", bfd_arch_mcore,
600 mcore_le_jtab, sizeof (mcore_le_jtab), 8
605 "mcore-elf-be", ".byte", ".short", ".long", ".asciz", "//",
606 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
607 ".global", ".space", ".align\t2",".align\t4", "",
608 "elf32-mcore-big", bfd_arch_mcore,
609 mcore_be_jtab, sizeof (mcore_be_jtab), 8
613 #define MMCORE_ELF_LE 8
614 "mcore-elf-le", ".byte", ".short", ".long", ".asciz", "//",
615 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
616 ".global", ".space", ".align\t2",".align\t4", "-EL",
617 "elf32-mcore-little", bfd_arch_mcore,
618 mcore_le_jtab, sizeof (mcore_le_jtab), 8
623 "arm-epoc", ".byte", ".short", ".long", ".asciz", "@",
624 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
625 ".global", ".space", ".align\t2",".align\t4", "",
626 "epoc-pe-arm-little", bfd_arch_arm,
627 arm_jtab, sizeof (arm_jtab), 8
630 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
640 typedef struct export
643 const char *internal_name;
649 int forward; /* Number of forward label, 0 means no forward. */
654 /* A list of symbols which we should not export. */
658 struct string_list *next;
662 static struct string_list *excludes;
664 static const char *rvaafter (int);
665 static const char *rvabefore (int);
666 static const char *asm_prefix (int);
667 static void process_def_file (const char *);
668 static void new_directive (char *);
669 static void append_import (const char *, const char *, int);
670 static void run (const char *, char *);
671 static void scan_drectve_symbols (bfd *);
672 static void scan_filtered_symbols (bfd *, void *, long, unsigned int);
673 static void add_excludes (const char *);
674 static bfd_boolean match_exclude (const char *);
675 static void set_default_excludes (void);
676 static long filter_symbols (bfd *, void *, long, unsigned int);
677 static void scan_all_symbols (bfd *);
678 static void scan_open_obj_file (bfd *);
679 static void scan_obj_file (const char *);
680 static void dump_def_info (FILE *);
681 static int sfunc (const void *, const void *);
682 static void flush_page (FILE *, long *, int, int);
683 static void gen_def_file (void);
684 static void generate_idata_ofile (FILE *);
685 static void assemble_file (const char *, const char *);
686 static void gen_exp_file (void);
687 static const char *xlate (const char *);
689 static void dump_iat (FILE *, export_type *);
691 static char *make_label (const char *, const char *);
692 static char *make_imp_label (const char *, const char *);
693 static bfd *make_one_lib_file (export_type *, int);
694 static bfd *make_head (void);
695 static bfd *make_tail (void);
696 static void gen_lib_file (void);
697 static int pfunc (const void *, const void *);
698 static int nfunc (const void *, const void *);
699 static void remove_null_names (export_type **);
700 static void dtab (export_type **);
701 static void process_duplicates (export_type **);
702 static void fill_ordinals (export_type **);
703 static int alphafunc (const void *, const void *);
704 static void mangle_defs (void);
705 static void usage (FILE *, int);
706 static void inform (const char *, ...);
709 prefix_encode (char *start, unsigned code)
711 static char alpha[26] = "abcdefghijklmnopqrstuvwxyz";
715 p = strchr (buf, '\0');
717 *p++ = alpha[code % sizeof (alpha)];
718 while ((code /= sizeof (alpha)) != 0);
724 dlltmp (char **buf, const char *fmt)
728 *buf = malloc (strlen (tmp_prefix) + 64);
729 sprintf (*buf, fmt, tmp_prefix);
735 inform VPARAMS ((const char * message, ...))
737 VA_OPEN (args, message);
738 VA_FIXEDARG (args, const char *, message);
743 report (message, args);
749 rvaafter (int machine)
765 /* xgettext:c-format */
766 fatal (_("Internal error: Unknown machine type: %d"), machine);
773 rvabefore (int machine)
789 /* xgettext:c-format */
790 fatal (_("Internal error: Unknown machine type: %d"), machine);
797 asm_prefix (int machine)
814 /* xgettext:c-format */
815 fatal (_("Internal error: Unknown machine type: %d"), machine);
821 #define ASM_BYTE mtable[machine].how_byte
822 #define ASM_SHORT mtable[machine].how_short
823 #define ASM_LONG mtable[machine].how_long
824 #define ASM_TEXT mtable[machine].how_asciz
825 #define ASM_C mtable[machine].how_comment
826 #define ASM_JUMP mtable[machine].how_jump
827 #define ASM_GLOBAL mtable[machine].how_global
828 #define ASM_SPACE mtable[machine].how_space
829 #define ASM_ALIGN_SHORT mtable[machine].how_align_short
830 #define ASM_RVA_BEFORE rvabefore(machine)
831 #define ASM_RVA_AFTER rvaafter(machine)
832 #define ASM_PREFIX asm_prefix(machine)
833 #define ASM_ALIGN_LONG mtable[machine].how_align_long
834 #define HOW_BFD_READ_TARGET 0 /* always default*/
835 #define HOW_BFD_WRITE_TARGET mtable[machine].how_bfd_target
836 #define HOW_BFD_ARCH mtable[machine].how_bfd_arch
837 #define HOW_JTAB mtable[machine].how_jtab
838 #define HOW_JTAB_SIZE mtable[machine].how_jtab_size
839 #define HOW_JTAB_ROFF mtable[machine].how_jtab_roff
840 #define ASM_SWITCHES mtable[machine].how_default_as_switches
845 process_def_file (const char *name)
847 FILE *f = fopen (name, FOPEN_RT);
850 /* xgettext:c-format */
851 fatal (_("Can't open def file: %s"), name);
855 /* xgettext:c-format */
856 inform (_("Processing def file: %s"), name);
860 inform (_("Processed def file"));
863 /**********************************************************************/
865 /* Communications with the parser. */
867 static const char *d_name; /* Arg to NAME or LIBRARY. */
868 static int d_nfuncs; /* Number of functions exported. */
869 static int d_named_nfuncs; /* Number of named functions exported. */
870 static int d_low_ord; /* Lowest ordinal index. */
871 static int d_high_ord; /* Highest ordinal index. */
872 static export_type *d_exports; /* List of exported functions. */
873 static export_type **d_exports_lexically; /* Vector of exported functions in alpha order. */
874 static dlist_type *d_list; /* Descriptions. */
875 static dlist_type *a_list; /* Stuff to go in directives. */
876 static int d_nforwards = 0; /* Number of forwarded exports. */
882 yyerror (const char * err ATTRIBUTE_UNUSED)
884 /* xgettext:c-format */
885 non_fatal (_("Syntax error in def file %s:%d"), def_file, linenumber);
891 def_exports (const char *name, const char *internal_name, int ordinal,
892 int noname, int constant, int data)
894 struct export *p = (struct export *) xmalloc (sizeof (*p));
897 p->internal_name = internal_name ? internal_name : name;
898 p->ordinal = ordinal;
899 p->constant = constant;
906 if ((internal_name != NULL)
907 && (strchr (internal_name, '.') != NULL))
908 p->forward = ++d_nforwards;
910 p->forward = 0; /* no forward */
914 def_name (const char *name, int base)
916 /* xgettext:c-format */
917 inform (_("NAME: %s base: %x"), name, base);
920 non_fatal (_("Can't have LIBRARY and NAME"));
923 /* If --dllname not provided, use the one in the DEF file.
924 FIXME: Is this appropriate for executables? */
926 dll_name = xstrdup (name);
931 def_library (const char *name, int base)
933 /* xgettext:c-format */
934 inform (_("LIBRARY: %s base: %x"), name, base);
937 non_fatal (_("Can't have LIBRARY and NAME"));
940 /* If --dllname not provided, use the one in the DEF file. */
942 dll_name = xstrdup (name);
947 def_description (const char *desc)
949 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
950 d->text = xstrdup (desc);
956 new_directive (char *dir)
958 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
959 d->text = xstrdup (dir);
965 def_heapsize (int reserve, int commit)
969 sprintf (b, "-heap 0x%x,0x%x ", reserve, commit);
971 sprintf (b, "-heap 0x%x ", reserve);
972 new_directive (xstrdup (b));
976 def_stacksize (int reserve, int commit)
980 sprintf (b, "-stack 0x%x,0x%x ", reserve, commit);
982 sprintf (b, "-stack 0x%x ", reserve);
983 new_directive (xstrdup (b));
986 /* append_import simply adds the given import definition to the global
987 import_list. It is used by def_import. */
990 append_import (const char *symbol_name, const char *dll_name, int func_ordinal)
995 for (pq = &import_list; *pq != NULL; pq = &(*pq)->next)
997 if (strcmp ((*pq)->dllname, dll_name) == 0)
1000 q->functail->next = xmalloc (sizeof (ifunctype));
1001 q->functail = q->functail->next;
1002 q->functail->ord = func_ordinal;
1003 q->functail->name = xstrdup (symbol_name);
1004 q->functail->next = NULL;
1010 q = xmalloc (sizeof (iheadtype));
1011 q->dllname = xstrdup (dll_name);
1013 q->funchead = xmalloc (sizeof (ifunctype));
1014 q->functail = q->funchead;
1016 q->functail->name = xstrdup (symbol_name);
1017 q->functail->ord = func_ordinal;
1018 q->functail->next = NULL;
1023 /* def_import is called from within defparse.y when an IMPORT
1024 declaration is encountered. Depending on the form of the
1025 declaration, the module name may or may not need ".dll" to be
1026 appended to it, the name of the function may be stored in internal
1027 or entry, and there may or may not be an ordinal value associated
1030 /* A note regarding the parse modes:
1031 In defparse.y we have to accept import declarations which follow
1032 any one of the following forms:
1033 <func_name_in_app> = <dll_name>.<func_name_in_dll>
1034 <func_name_in_app> = <dll_name>.<number>
1035 <dll_name>.<func_name_in_dll>
1037 Furthermore, the dll's name may or may not end with ".dll", which
1038 complicates the parsing a little. Normally the dll's name is
1039 passed to def_import() in the "module" parameter, but when it ends
1040 with ".dll" it gets passed in "module" sans ".dll" and that needs
1043 def_import gets five parameters:
1044 APP_NAME - the name of the function in the application, if
1045 present, or NULL if not present.
1046 MODULE - the name of the dll, possibly sans extension (ie, '.dll').
1047 DLLEXT - the extension of the dll, if present, NULL if not present.
1048 ENTRY - the name of the function in the dll, if present, or NULL.
1049 ORD_VAL - the numerical tag of the function in the dll, if present,
1050 or NULL. Exactly one of <entry> or <ord_val> must be
1051 present (i.e., not NULL). */
1054 def_import (const char *app_name, const char *module, const char *dllext,
1055 const char *entry, int ord_val)
1057 const char *application_name;
1061 application_name = entry;
1064 if (app_name != NULL)
1065 application_name = app_name;
1067 application_name = "";
1072 buf = (char *) alloca (strlen (module) + strlen (dllext) + 2);
1073 sprintf (buf, "%s.%s", module, dllext);
1077 append_import (application_name, module, ord_val);
1081 def_version (int major, int minor)
1083 printf ("VERSION %d.%d\n", major, minor);
1087 def_section (const char *name, int attr)
1102 sprintf (buf, "-attr %s %s", name, atts);
1103 new_directive (xstrdup (buf));
1110 def_section ("CODE", attr);
1116 def_section ("DATA", attr);
1119 /**********************************************************************/
1122 run (const char *what, char *args)
1125 int pid, wait_status;
1128 char *errmsg_fmt, *errmsg_arg;
1129 char *temp_base = choose_temp_base ();
1131 inform ("run: %s %s", what, args);
1133 /* Count the args */
1135 for (s = args; *s; s++)
1139 argv = alloca (sizeof (char *) * (i + 3));
1148 while (*s != ' ' && *s != 0)
1156 pid = pexecute (argv[0], (char * const *) argv, program_name, temp_base,
1157 &errmsg_fmt, &errmsg_arg, PEXECUTE_ONE | PEXECUTE_SEARCH);
1161 inform (strerror (errno));
1163 fatal (errmsg_fmt, errmsg_arg);
1166 pid = pwait (pid, & wait_status, 0);
1170 /* xgettext:c-format */
1171 fatal (_("wait: %s"), strerror (errno));
1173 else if (WIFSIGNALED (wait_status))
1175 /* xgettext:c-format */
1176 fatal (_("subprocess got fatal signal %d"), WTERMSIG (wait_status));
1178 else if (WIFEXITED (wait_status))
1180 if (WEXITSTATUS (wait_status) != 0)
1181 /* xgettext:c-format */
1182 non_fatal (_("%s exited with status %d"),
1183 what, WEXITSTATUS (wait_status));
1189 /* Look for a list of symbols to export in the .drectve section of
1190 ABFD. Pass each one to def_exports. */
1193 scan_drectve_symbols (bfd *abfd)
1201 /* Look for .drectve's */
1202 s = bfd_get_section_by_name (abfd, DRECTVE_SECTION_NAME);
1207 size = bfd_get_section_size_before_reloc (s);
1208 buf = xmalloc (size);
1210 bfd_get_section_contents (abfd, s, buf, 0, size);
1212 /* xgettext:c-format */
1213 inform (_("Sucking in info from %s section in %s"),
1214 DRECTVE_SECTION_NAME, bfd_get_filename (abfd));
1216 /* Search for -export: strings. The exported symbols can optionally
1217 have type tags (eg., -export:foo,data), so handle those as well.
1218 Currently only data tag is supported. */
1224 && strncmp (p, "-export:", 8) == 0)
1228 flagword flags = BSF_FUNCTION;
1232 while (p < e && *p != ',' && *p != ' ' && *p != '-')
1234 c = xmalloc (p - name + 1);
1235 memcpy (c, name, p - name);
1237 if (p < e && *p == ',') /* found type tag. */
1239 char *tag_start = ++p;
1240 while (p < e && *p != ' ' && *p != '-')
1242 if (strncmp (tag_start, "data", 4) == 0)
1243 flags &= ~BSF_FUNCTION;
1246 /* FIXME: The 5th arg is for the `constant' field.
1247 What should it be? Not that it matters since it's not
1248 currently useful. */
1249 def_exports (c, 0, -1, 0, 0, ! (flags & BSF_FUNCTION));
1251 if (add_stdcall_alias && strchr (c, '@'))
1253 int lead_at = (*c == '@') ;
1254 char *exported_name = xstrdup (c + lead_at);
1255 char *atsym = strchr (exported_name, '@');
1257 /* Note: stdcall alias symbols can never be data. */
1258 def_exports (exported_name, xstrdup (c), -1, 0, 0, 0);
1267 /* Look through the symbols in MINISYMS, and add each one to list of
1268 symbols to export. */
1271 scan_filtered_symbols (bfd *abfd, void *minisyms, long symcount,
1275 bfd_byte *from, *fromend;
1277 store = bfd_make_empty_symbol (abfd);
1279 bfd_fatal (bfd_get_filename (abfd));
1281 from = (bfd_byte *) minisyms;
1282 fromend = from + symcount * size;
1283 for (; from < fromend; from += size)
1286 const char *symbol_name;
1288 sym = bfd_minisymbol_to_symbol (abfd, FALSE, from, store);
1290 bfd_fatal (bfd_get_filename (abfd));
1292 symbol_name = bfd_asymbol_name (sym);
1293 if (bfd_get_symbol_leading_char (abfd) == symbol_name[0])
1296 def_exports (xstrdup (symbol_name) , 0, -1, 0, 0,
1297 ! (sym->flags & BSF_FUNCTION));
1299 if (add_stdcall_alias && strchr (symbol_name, '@'))
1301 int lead_at = (*symbol_name == '@');
1302 char *exported_name = xstrdup (symbol_name + lead_at);
1303 char *atsym = strchr (exported_name, '@');
1305 /* Note: stdcall alias symbols can never be data. */
1306 def_exports (exported_name, xstrdup (symbol_name), -1, 0, 0, 0);
1311 /* Add a list of symbols to exclude. */
1314 add_excludes (const char *new_excludes)
1317 char *exclude_string;
1319 local_copy = xstrdup (new_excludes);
1321 exclude_string = strtok (local_copy, ",:");
1322 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
1324 struct string_list *new_exclude;
1326 new_exclude = ((struct string_list *)
1327 xmalloc (sizeof (struct string_list)));
1328 new_exclude->string = (char *) xmalloc (strlen (exclude_string) + 2);
1329 /* Don't add a leading underscore for fastcall symbols. */
1330 if (*exclude_string == '@')
1331 sprintf (new_exclude->string, "%s", exclude_string);
1333 sprintf (new_exclude->string, "_%s", exclude_string);
1334 new_exclude->next = excludes;
1335 excludes = new_exclude;
1337 /* xgettext:c-format */
1338 inform (_("Excluding symbol: %s"), exclude_string);
1344 /* See if STRING is on the list of symbols to exclude. */
1347 match_exclude (const char *string)
1349 struct string_list *excl_item;
1351 for (excl_item = excludes; excl_item; excl_item = excl_item->next)
1352 if (strcmp (string, excl_item->string) == 0)
1357 /* Add the default list of symbols to exclude. */
1360 set_default_excludes (void)
1362 add_excludes (default_excludes);
1365 /* Choose which symbols to export. */
1368 filter_symbols (bfd *abfd, void *minisyms, long symcount, unsigned int size)
1370 bfd_byte *from, *fromend, *to;
1373 store = bfd_make_empty_symbol (abfd);
1375 bfd_fatal (bfd_get_filename (abfd));
1377 from = (bfd_byte *) minisyms;
1378 fromend = from + symcount * size;
1379 to = (bfd_byte *) minisyms;
1381 for (; from < fromend; from += size)
1386 sym = bfd_minisymbol_to_symbol (abfd, FALSE, (const void *) from, store);
1388 bfd_fatal (bfd_get_filename (abfd));
1390 /* Check for external and defined only symbols. */
1391 keep = (((sym->flags & BSF_GLOBAL) != 0
1392 || (sym->flags & BSF_WEAK) != 0
1393 || bfd_is_com_section (sym->section))
1394 && ! bfd_is_und_section (sym->section));
1396 keep = keep && ! match_exclude (sym->name);
1400 memcpy (to, from, size);
1405 return (to - (bfd_byte *) minisyms) / size;
1408 /* Export all symbols in ABFD, except for ones we were told not to
1412 scan_all_symbols (bfd *abfd)
1418 /* Ignore bfds with an import descriptor table. We assume that any
1419 such BFD contains symbols which are exported from another DLL,
1420 and we don't want to reexport them from here. */
1421 if (bfd_get_section_by_name (abfd, ".idata$4"))
1424 if (! (bfd_get_file_flags (abfd) & HAS_SYMS))
1426 /* xgettext:c-format */
1427 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1431 symcount = bfd_read_minisymbols (abfd, FALSE, &minisyms, &size);
1433 bfd_fatal (bfd_get_filename (abfd));
1437 /* xgettext:c-format */
1438 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1442 /* Discard the symbols we don't want to export. It's OK to do this
1443 in place; we'll free the storage anyway. */
1445 symcount = filter_symbols (abfd, minisyms, symcount, size);
1446 scan_filtered_symbols (abfd, minisyms, symcount, size);
1451 /* Look at the object file to decide which symbols to export. */
1454 scan_open_obj_file (bfd *abfd)
1456 if (export_all_symbols)
1457 scan_all_symbols (abfd);
1459 scan_drectve_symbols (abfd);
1461 /* FIXME: we ought to read in and block out the base relocations. */
1463 /* xgettext:c-format */
1464 inform (_("Done reading %s"), bfd_get_filename (abfd));
1468 scan_obj_file (const char *filename)
1470 bfd * f = bfd_openr (filename, 0);
1473 /* xgettext:c-format */
1474 fatal (_("Unable to open object file: %s"), filename);
1476 /* xgettext:c-format */
1477 inform (_("Scanning object file %s"), filename);
1479 if (bfd_check_format (f, bfd_archive))
1481 bfd *arfile = bfd_openr_next_archived_file (f, 0);
1484 if (bfd_check_format (arfile, bfd_object))
1485 scan_open_obj_file (arfile);
1487 arfile = bfd_openr_next_archived_file (f, arfile);
1490 #ifdef DLLTOOL_MCORE_ELF
1491 if (mcore_elf_out_file)
1492 inform (_("Cannot produce mcore-elf dll from archive file: %s"), filename);
1495 else if (bfd_check_format (f, bfd_object))
1497 scan_open_obj_file (f);
1499 #ifdef DLLTOOL_MCORE_ELF
1500 if (mcore_elf_out_file)
1501 mcore_elf_cache_filename ((char *) filename);
1508 /**********************************************************************/
1511 dump_def_info (FILE *f)
1515 fprintf (f, "%s ", ASM_C);
1516 for (i = 0; oav[i]; i++)
1517 fprintf (f, "%s ", oav[i]);
1519 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1521 fprintf (f, "%s %d = %s %s @ %d %s%s%s\n",
1527 exp->noname ? "NONAME " : "",
1528 exp->constant ? "CONSTANT" : "",
1529 exp->data ? "DATA" : "");
1533 /* Generate the .exp file. */
1536 sfunc (const void *a, const void *b)
1538 return *(const long *) a - *(const long *) b;
1542 flush_page (FILE *f, long *need, int page_addr, int on_page)
1546 /* Flush this page. */
1547 fprintf (f, "\t%s\t0x%08x\t%s Starting RVA for chunk\n",
1551 fprintf (f, "\t%s\t0x%x\t%s Size of block\n",
1553 (on_page * 2) + (on_page & 1) * 2 + 8,
1556 for (i = 0; i < on_page; i++)
1558 long needed = need[i];
1561 needed = ((needed - page_addr) | 0x3000) & 0xffff;
1563 fprintf (f, "\t%s\t0x%lx\n", ASM_SHORT, needed);
1568 fprintf (f, "\t%s\t0x%x\n", ASM_SHORT, 0 | 0x0000);
1577 inform (_("Adding exports to output file"));
1579 fprintf (output_def, ";");
1580 for (i = 0; oav[i]; i++)
1581 fprintf (output_def, " %s", oav[i]);
1583 fprintf (output_def, "\nEXPORTS\n");
1585 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1587 char *quote = strchr (exp->name, '.') ? "\"" : "";
1588 char *res = cplus_demangle (exp->internal_name, DMGL_ANSI | DMGL_PARAMS);
1592 fprintf (output_def,";\t%s\n", res);
1596 if (strcmp (exp->name, exp->internal_name) == 0)
1599 fprintf (output_def, "\t%s%s%s @ %d%s%s\n",
1604 exp->noname ? " NONAME" : "",
1605 exp->data ? " DATA" : "");
1609 char *quote1 = strchr (exp->internal_name, '.') ? "\"" : "";
1611 fprintf (output_def, "\t%s%s%s = %s%s%s @ %d%s%s\n",
1619 exp->noname ? " NONAME" : "",
1620 exp->data ? " DATA" : "");
1624 inform (_("Added exports to output file"));
1627 /* generate_idata_ofile generates the portable assembly source code
1628 for the idata sections. It appends the source code to the end of
1632 generate_idata_ofile (FILE *filvar)
1640 if (import_list == NULL)
1643 fprintf (filvar, "%s Import data sections\n", ASM_C);
1644 fprintf (filvar, "\n\t.section\t.idata$2\n");
1645 fprintf (filvar, "\t%s\tdoi_idata\n", ASM_GLOBAL);
1646 fprintf (filvar, "doi_idata:\n");
1649 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1651 fprintf (filvar, "\t%slistone%d%s\t%s %s\n",
1652 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER,
1653 ASM_C, headptr->dllname);
1654 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1655 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1656 fprintf (filvar, "\t%sdllname%d%s\n",
1657 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1658 fprintf (filvar, "\t%slisttwo%d%s\n\n",
1659 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1663 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL record at */
1664 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* end of idata$2 */
1665 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* section */
1666 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1667 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1669 fprintf (filvar, "\n\t.section\t.idata$4\n");
1671 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1673 fprintf (filvar, "listone%d:\n", headindex);
1674 for ( funcindex = 0; funcindex < headptr->nfuncs; funcindex++ )
1675 fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1676 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1677 fprintf (filvar,"\t%s\t0\n", ASM_LONG); /* NULL terminating list */
1681 fprintf (filvar, "\n\t.section\t.idata$5\n");
1683 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1685 fprintf (filvar, "listtwo%d:\n", headindex);
1686 for ( funcindex = 0; funcindex < headptr->nfuncs; funcindex++ )
1687 fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1688 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1689 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list */
1693 fprintf (filvar, "\n\t.section\t.idata$6\n");
1695 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1698 for (funcptr = headptr->funchead; funcptr != NULL;
1699 funcptr = funcptr->next)
1701 fprintf (filvar,"funcptr%d_%d:\n", headindex, funcindex);
1702 fprintf (filvar,"\t%s\t%d\n", ASM_SHORT,
1703 ((funcptr->ord) & 0xFFFF));
1704 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, funcptr->name);
1705 fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1711 fprintf (filvar, "\n\t.section\t.idata$7\n");
1713 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1715 fprintf (filvar,"dllname%d:\n", headindex);
1716 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, headptr->dllname);
1717 fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1722 /* Assemble the specified file. */
1724 assemble_file (const char * source, const char * dest)
1728 cmd = (char *) alloca (strlen (ASM_SWITCHES) + strlen (as_flags)
1729 + strlen (source) + strlen (dest) + 50);
1731 sprintf (cmd, "%s %s -o %s %s", ASM_SWITCHES, as_flags, dest, source);
1744 /* xgettext:c-format */
1745 inform (_("Generating export file: %s"), exp_name);
1747 f = fopen (TMP_ASM, FOPEN_WT);
1749 /* xgettext:c-format */
1750 fatal (_("Unable to open temporary assembler file: %s"), TMP_ASM);
1752 /* xgettext:c-format */
1753 inform (_("Opened temporary file: %s"), TMP_ASM);
1759 fprintf (f, "\t.section .edata\n\n");
1760 fprintf (f, "\t%s 0 %s Allways 0\n", ASM_LONG, ASM_C);
1761 fprintf (f, "\t%s 0x%lx %s Time and date\n", ASM_LONG, (long) time(0),
1763 fprintf (f, "\t%s 0 %s Major and Minor version\n", ASM_LONG, ASM_C);
1764 fprintf (f, "\t%sname%s %s Ptr to name of dll\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1765 fprintf (f, "\t%s %d %s Starting ordinal of exports\n", ASM_LONG, d_low_ord, ASM_C);
1768 fprintf (f, "\t%s %d %s Number of functions\n", ASM_LONG, d_high_ord - d_low_ord + 1, ASM_C);
1769 fprintf(f,"\t%s named funcs %d, low ord %d, high ord %d\n",
1771 d_named_nfuncs, d_low_ord, d_high_ord);
1772 fprintf (f, "\t%s %d %s Number of names\n", ASM_LONG,
1773 show_allnames ? d_high_ord - d_low_ord + 1 : d_named_nfuncs, ASM_C);
1774 fprintf (f, "\t%safuncs%s %s Address of functions\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1776 fprintf (f, "\t%sanames%s %s Address of Name Pointer Table\n",
1777 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1779 fprintf (f, "\t%sanords%s %s Address of ordinals\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1781 fprintf (f, "name: %s \"%s\"\n", ASM_TEXT, dll_name);
1784 fprintf(f,"%s Export address Table\n", ASM_C);
1785 fprintf(f,"\t%s\n", ASM_ALIGN_LONG);
1786 fprintf (f, "afuncs:\n");
1789 for (exp = d_exports; exp; exp = exp->next)
1791 if (exp->ordinal != i)
1794 fprintf (f, "\t%s\t%d\t%s %d..%d missing\n",
1796 (exp->ordinal - i) * 4,
1798 i, exp->ordinal - 1);
1801 while (i < exp->ordinal)
1803 fprintf(f,"\t%s\t0\n", ASM_LONG);
1808 if (exp->forward == 0)
1810 if (exp->internal_name[0] == '@')
1811 fprintf (f, "\t%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
1812 exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1814 fprintf (f, "\t%s%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
1816 exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1819 fprintf (f, "\t%sf%d%s\t%s %d\n", ASM_RVA_BEFORE,
1820 exp->forward, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1824 fprintf (f,"%s Export Name Pointer Table\n", ASM_C);
1825 fprintf (f, "anames:\n");
1827 for (i = 0; (exp = d_exports_lexically[i]); i++)
1829 if (!exp->noname || show_allnames)
1830 fprintf (f, "\t%sn%d%s\n",
1831 ASM_RVA_BEFORE, exp->ordinal, ASM_RVA_AFTER);
1834 fprintf (f,"%s Export Oridinal Table\n", ASM_C);
1835 fprintf (f, "anords:\n");
1836 for (i = 0; (exp = d_exports_lexically[i]); i++)
1838 if (!exp->noname || show_allnames)
1839 fprintf (f, "\t%s %d\n", ASM_SHORT, exp->ordinal - d_low_ord);
1842 fprintf(f,"%s Export Name Table\n", ASM_C);
1843 for (i = 0; (exp = d_exports_lexically[i]); i++)
1845 if (!exp->noname || show_allnames)
1846 fprintf (f, "n%d: %s \"%s\"\n",
1847 exp->ordinal, ASM_TEXT, xlate (exp->name));
1848 if (exp->forward != 0)
1849 fprintf (f, "f%d: %s \"%s\"\n",
1850 exp->forward, ASM_TEXT, exp->internal_name);
1855 fprintf (f, "\t.section %s\n", DRECTVE_SECTION_NAME);
1856 for (dl = a_list; dl; dl = dl->next)
1858 fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, dl->text);
1864 fprintf (f, "\t.section .rdata\n");
1865 for (dl = d_list; dl; dl = dl->next)
1870 /* We don't output as ascii because there can
1871 be quote characters in the string. */
1873 for (p = dl->text; *p; p++)
1876 fprintf (f, "\t%s\t", ASM_BYTE);
1879 fprintf (f, "%d", *p);
1882 fprintf (f, ",0\n");
1896 /* Add to the output file a way of getting to the exported names
1897 without using the import library. */
1900 fprintf (f, "\t.section\t.rdata\n");
1901 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1902 if (!exp->noname || show_allnames)
1904 /* We use a single underscore for MS compatibility, and a
1905 double underscore for backward compatibility with old
1907 if (create_compat_implib)
1908 fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name);
1909 fprintf (f, "\t%s\t_imp__%s\n", ASM_GLOBAL, exp->name);
1910 if (create_compat_implib)
1911 fprintf (f, "__imp_%s:\n", exp->name);
1912 fprintf (f, "_imp__%s:\n", exp->name);
1913 fprintf (f, "\t%s\t%s\n", ASM_LONG, exp->name);
1917 /* Dump the reloc section if a base file is provided. */
1921 long need[PAGE_SIZE];
1928 fprintf (f, "\t.section\t.init\n");
1929 fprintf (f, "lab:\n");
1931 fseek (base_file, 0, SEEK_END);
1932 numbytes = ftell (base_file);
1933 fseek (base_file, 0, SEEK_SET);
1934 copy = xmalloc (numbytes);
1935 fread (copy, 1, numbytes, base_file);
1936 num_entries = numbytes / sizeof (long);
1939 fprintf (f, "\t.section\t.reloc\n");
1945 qsort (copy, num_entries, sizeof (long), sfunc);
1946 /* Delete duplicates */
1947 for (src = 0; src < num_entries; src++)
1949 if (last != copy[src])
1950 last = copy[dst++] = copy[src];
1954 page_addr = addr & PAGE_MASK; /* work out the page addr */
1956 for (j = 0; j < num_entries; j++)
1959 if ((addr & PAGE_MASK) != page_addr)
1961 flush_page (f, need, page_addr, on_page);
1963 page_addr = addr & PAGE_MASK;
1965 need[on_page++] = addr;
1967 flush_page (f, need, page_addr, on_page);
1969 /* fprintf (f, "\t%s\t0,0\t%s End\n", ASM_LONG, ASM_C);*/
1973 generate_idata_ofile (f);
1977 /* Assemble the file. */
1978 assemble_file (TMP_ASM, exp_name);
1980 if (dontdeltemps == 0)
1983 inform (_("Generated exports file"));
1987 xlate (const char *name)
1989 int lead_at = (*name == '@');
1991 if (add_underscore && !lead_at)
1993 char *copy = xmalloc (strlen (name) + 2);
1996 strcpy (copy + 1, name);
2005 p = strchr (name, '@');
2012 /**********************************************************************/
2017 dump_iat (FILE *f, export_type *exp)
2019 if (exp->noname && !show_allnames )
2021 fprintf (f, "\t%s\t0x%08x\n",
2023 exp->ordinal | 0x80000000); /* hint or orindal ?? */
2027 fprintf (f, "\t%sID%d%s\n", ASM_RVA_BEFORE,
2045 unsigned char *data;
2060 #define TEXT_SEC_FLAGS \
2061 (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY | SEC_HAS_CONTENTS)
2062 #define DATA_SEC_FLAGS (SEC_ALLOC | SEC_LOAD | SEC_DATA)
2063 #define BSS_SEC_FLAGS SEC_ALLOC
2065 #define INIT_SEC_DATA(id, name, flags, align) \
2066 { id, name, flags, align, NULL, NULL, NULL, 0, NULL }
2067 static sinfo secdata[NSECS] =
2069 INIT_SEC_DATA (TEXT, ".text", TEXT_SEC_FLAGS, 2),
2070 INIT_SEC_DATA (DATA, ".data", DATA_SEC_FLAGS, 2),
2071 INIT_SEC_DATA (BSS, ".bss", BSS_SEC_FLAGS, 2),
2072 INIT_SEC_DATA (IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2),
2073 INIT_SEC_DATA (IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2),
2074 INIT_SEC_DATA (IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2),
2075 INIT_SEC_DATA (IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1)
2080 /* Sections numbered to make the order the same as other PowerPC NT
2081 compilers. This also keeps funny alignment thingies from happening. */
2094 static sinfo secdata[NSECS] =
2096 { TEXT, ".text", SEC_CODE | SEC_HAS_CONTENTS, 3},
2097 { PDATA, ".pdata", SEC_HAS_CONTENTS, 2},
2098 { RDATA, ".reldata", SEC_HAS_CONTENTS, 2},
2099 { IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2},
2100 { IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2},
2101 { IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1},
2102 { IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2},
2103 { DATA, ".data", SEC_DATA, 2},
2104 { BSS, ".bss", 0, 2}
2109 /* This is what we're trying to make. We generate the imp symbols with
2110 both single and double underscores, for compatibility.
2113 .global _GetFileVersionInfoSizeW@8
2114 .global __imp_GetFileVersionInfoSizeW@8
2115 _GetFileVersionInfoSizeW@8:
2116 jmp * __imp_GetFileVersionInfoSizeW@8
2117 .section .idata$7 # To force loading of head
2118 .long __version_a_head
2119 # Import Address Table
2121 __imp_GetFileVersionInfoSizeW@8:
2124 # Import Lookup Table
2130 .asciz "GetFileVersionInfoSizeW"
2133 For the PowerPC, here's the variation on the above scheme:
2135 # Rather than a simple "jmp *", the code to get to the dll function
2138 lwz r11,[tocv]__imp_function_name(r2)
2139 # RELOC: 00000000 TOCREL16,TOCDEFN __imp_function_name
2147 make_label (const char *prefix, const char *name)
2149 int len = strlen (ASM_PREFIX) + strlen (prefix) + strlen (name);
2150 char *copy = xmalloc (len +1 );
2152 strcpy (copy, ASM_PREFIX);
2153 strcat (copy, prefix);
2154 strcat (copy, name);
2159 make_imp_label (const char *prefix, const char *name)
2166 len = strlen (prefix) + strlen (name);
2167 copy = xmalloc (len + 1);
2168 strcpy (copy, prefix);
2169 strcat (copy, name);
2173 len = strlen (ASM_PREFIX) + strlen (prefix) + strlen (name);
2174 copy = xmalloc (len + 1);
2175 strcpy (copy, prefix);
2176 strcat (copy, ASM_PREFIX);
2177 strcat (copy, name);
2183 make_one_lib_file (export_type *exp, int i)
2189 const char *prefix = "d";
2192 name = (char *) alloca (strlen (prefix) + 10);
2193 sprintf (name, "%ss%05d.s", prefix, i);
2194 f = fopen (name, FOPEN_WT);
2195 fprintf (f, "\t.text\n");
2196 fprintf (f, "\t%s\t%s%s\n", ASM_GLOBAL, ASM_PREFIX, exp->name);
2197 if (create_compat_implib)
2198 fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name);
2199 fprintf (f, "\t%s\t_imp__%s\n", ASM_GLOBAL, exp->name);
2200 if (create_compat_implib)
2201 fprintf (f, "%s%s:\n\t%s\t__imp_%s\n", ASM_PREFIX,
2202 exp->name, ASM_JUMP, exp->name);
2204 fprintf (f, "\t.section\t.idata$7\t%s To force loading of head\n", ASM_C);
2205 fprintf (f, "\t%s\t%s\n", ASM_LONG, head_label);
2208 fprintf (f,"%s Import Address Table\n", ASM_C);
2210 fprintf (f, "\t.section .idata$5\n");
2211 if (create_compat_implib)
2212 fprintf (f, "__imp_%s:\n", exp->name);
2213 fprintf (f, "_imp__%s:\n", exp->name);
2217 fprintf (f, "\n%s Import Lookup Table\n", ASM_C);
2218 fprintf (f, "\t.section .idata$4\n");
2222 if(!exp->noname || show_allnames)
2224 fprintf (f, "%s Hint/Name table\n", ASM_C);
2225 fprintf (f, "\t.section .idata$6\n");
2226 fprintf (f, "ID%d:\t%s\t%d\n", exp->ordinal, ASM_SHORT, exp->hint);
2227 fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, xlate (exp->name));
2232 dest = (char *) alloca (strlen (prefix) + 10);
2233 sprintf (dest, "%ss%05d.o", prefix, i);
2234 assemble_file (name, dest);
2239 asymbol * exp_label;
2240 asymbol * iname = 0;
2242 asymbol * iname_lab;
2243 asymbol ** iname_lab_pp;
2244 asymbol ** iname_pp;
2253 asymbol * ptrs[NSECS + 4 + EXTRA + 1];
2254 flagword applicable;
2256 char * outname = xmalloc (strlen (TMP_STUB) + 10);
2260 sprintf (outname, "%s%05d.o", TMP_STUB, i);
2262 abfd = bfd_openw (outname, HOW_BFD_WRITE_TARGET);
2265 /* xgettext:c-format */
2266 fatal (_("bfd_open failed open stub file: %s"), outname);
2268 /* xgettext:c-format */
2269 inform (_("Creating stub file: %s"), outname);
2271 bfd_set_format (abfd, bfd_object);
2272 bfd_set_arch_mach (abfd, HOW_BFD_ARCH, 0);
2275 if (machine == MARM_INTERWORK || machine == MTHUMB)
2276 bfd_set_private_flags (abfd, F_INTERWORK);
2279 applicable = bfd_applicable_section_flags (abfd);
2281 /* First make symbols for the sections. */
2282 for (i = 0; i < NSECS; i++)
2284 sinfo *si = secdata + i;
2287 si->sec = bfd_make_section_old_way (abfd, si->name);
2288 bfd_set_section_flags (abfd,
2290 si->flags & applicable);
2292 bfd_set_section_alignment(abfd, si->sec, si->align);
2293 si->sec->output_section = si->sec;
2294 si->sym = bfd_make_empty_symbol(abfd);
2295 si->sym->name = si->sec->name;
2296 si->sym->section = si->sec;
2297 si->sym->flags = BSF_LOCAL;
2299 ptrs[oidx] = si->sym;
2300 si->sympp = ptrs + oidx;
2309 exp_label = bfd_make_empty_symbol (abfd);
2310 exp_label->name = make_imp_label ("", exp->name);
2312 /* On PowerPC, the function name points to a descriptor in
2313 the rdata section, the first element of which is a
2314 pointer to the code (..function_name), and the second
2315 points to the .toc. */
2317 if (machine == MPPC)
2318 exp_label->section = secdata[RDATA].sec;
2321 exp_label->section = secdata[TEXT].sec;
2323 exp_label->flags = BSF_GLOBAL;
2324 exp_label->value = 0;
2327 if (machine == MTHUMB)
2328 bfd_coff_set_symbol_class (abfd, exp_label, C_THUMBEXTFUNC);
2330 ptrs[oidx++] = exp_label;
2333 /* Generate imp symbols with one underscore for Microsoft
2334 compatibility, and with two underscores for backward
2335 compatibility with old versions of cygwin. */
2336 if (create_compat_implib)
2338 iname = bfd_make_empty_symbol (abfd);
2339 iname->name = make_imp_label ("___imp", exp->name);
2340 iname->section = secdata[IDATA5].sec;
2341 iname->flags = BSF_GLOBAL;
2345 iname2 = bfd_make_empty_symbol (abfd);
2346 iname2->name = make_imp_label ("__imp_", exp->name);
2347 iname2->section = secdata[IDATA5].sec;
2348 iname2->flags = BSF_GLOBAL;
2351 iname_lab = bfd_make_empty_symbol(abfd);
2353 iname_lab->name = head_label;
2354 iname_lab->section = (asection *)&bfd_und_section;
2355 iname_lab->flags = 0;
2356 iname_lab->value = 0;
2358 iname_pp = ptrs + oidx;
2359 if (create_compat_implib)
2360 ptrs[oidx++] = iname;
2361 ptrs[oidx++] = iname2;
2363 iname_lab_pp = ptrs + oidx;
2364 ptrs[oidx++] = iname_lab;
2367 /* The symbol referring to the code (.text). */
2369 asymbol *function_name;
2371 function_name = bfd_make_empty_symbol(abfd);
2372 function_name->name = make_label ("..", exp->name);
2373 function_name->section = secdata[TEXT].sec;
2374 function_name->flags = BSF_GLOBAL;
2375 function_name->value = 0;
2377 fn_pp = ptrs + oidx;
2378 ptrs[oidx++] = function_name;
2381 /* The .toc symbol. */
2383 asymbol *toc_symbol;
2385 toc_symbol = bfd_make_empty_symbol (abfd);
2386 toc_symbol->name = make_label (".", "toc");
2387 toc_symbol->section = (asection *)&bfd_und_section;
2388 toc_symbol->flags = BSF_GLOBAL;
2389 toc_symbol->value = 0;
2391 toc_pp = ptrs + oidx;
2392 ptrs[oidx++] = toc_symbol;
2398 for (i = 0; i < NSECS; i++)
2400 sinfo *si = secdata + i;
2401 asection *sec = si->sec;
2410 si->size = HOW_JTAB_SIZE;
2411 si->data = xmalloc (HOW_JTAB_SIZE);
2412 memcpy (si->data, HOW_JTAB, HOW_JTAB_SIZE);
2414 /* add the reloc into idata$5 */
2415 rel = xmalloc (sizeof (arelent));
2417 rpp = xmalloc (sizeof (arelent *) * 2);
2421 rel->address = HOW_JTAB_ROFF;
2424 if (machine == MPPC)
2426 rel->howto = bfd_reloc_type_lookup (abfd,
2427 BFD_RELOC_16_GOTOFF);
2428 rel->sym_ptr_ptr = iname_pp;
2432 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2433 rel->sym_ptr_ptr = secdata[IDATA5].sympp;
2435 sec->orelocation = rpp;
2436 sec->reloc_count = 1;
2441 /* An idata$4 or idata$5 is one word long, and has an
2444 si->data = xmalloc (4);
2449 si->data[0] = exp->ordinal ;
2450 si->data[1] = exp->ordinal >> 8;
2451 si->data[2] = exp->ordinal >> 16;
2456 sec->reloc_count = 1;
2457 memset (si->data, 0, si->size);
2458 rel = xmalloc (sizeof (arelent));
2459 rpp = xmalloc (sizeof (arelent *) * 2);
2464 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2465 rel->sym_ptr_ptr = secdata[IDATA6].sympp;
2466 sec->orelocation = rpp;
2474 /* This used to add 1 to exp->hint. I don't know
2475 why it did that, and it does not match what I see
2476 in programs compiled with the MS tools. */
2477 int idx = exp->hint;
2478 si->size = strlen (xlate (exp->name)) + 3;
2479 si->data = xmalloc (si->size);
2480 si->data[0] = idx & 0xff;
2481 si->data[1] = idx >> 8;
2482 strcpy (si->data + 2, xlate (exp->name));
2487 si->data =xmalloc (4);
2488 memset (si->data, 0, si->size);
2489 rel = xmalloc (sizeof (arelent));
2490 rpp = xmalloc (sizeof (arelent *) * 2);
2494 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2495 rel->sym_ptr_ptr = iname_lab_pp;
2496 sec->orelocation = rpp;
2497 sec->reloc_count = 1;
2503 /* The .pdata section is 5 words long.
2507 bfd_vma BeginAddress, [0x00]
2509 ExceptionHandler, [0x08]
2511 PrologEndAddress; [0x10]
2514 /* So this pdata section setups up this as a glue linkage to
2515 a dll routine. There are a number of house keeping things
2518 1. In the name of glue trickery, the ADDR32 relocs for 0,
2519 4, and 0x10 are set to point to the same place:
2521 2. There is one more reloc needed in the pdata section.
2522 The actual glue instruction to restore the toc on
2523 return is saved as the offset in an IMGLUE reloc.
2524 So we need a total of four relocs for this section.
2526 3. Lastly, the HandlerData field is set to 0x03, to indicate
2527 that this is a glue routine. */
2528 arelent *imglue, *ba_rel, *ea_rel, *pea_rel;
2530 /* Alignment must be set to 2**2 or you get extra stuff. */
2531 bfd_set_section_alignment(abfd, sec, 2);
2534 si->data = xmalloc (si->size);
2535 memset (si->data, 0, si->size);
2536 rpp = xmalloc (sizeof (arelent *) * 5);
2537 rpp[0] = imglue = xmalloc (sizeof (arelent));
2538 rpp[1] = ba_rel = xmalloc (sizeof (arelent));
2539 rpp[2] = ea_rel = xmalloc (sizeof (arelent));
2540 rpp[3] = pea_rel = xmalloc (sizeof (arelent));
2543 /* Stick the toc reload instruction in the glue reloc. */
2544 bfd_put_32(abfd, ppc_glue_insn, (char *) &imglue->address);
2547 imglue->howto = bfd_reloc_type_lookup (abfd,
2548 BFD_RELOC_32_GOTOFF);
2549 imglue->sym_ptr_ptr = fn_pp;
2551 ba_rel->address = 0;
2553 ba_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2554 ba_rel->sym_ptr_ptr = fn_pp;
2556 bfd_put_32 (abfd, 0x18, si->data + 0x04);
2557 ea_rel->address = 4;
2559 ea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2560 ea_rel->sym_ptr_ptr = fn_pp;
2562 /* Mark it as glue. */
2563 bfd_put_32 (abfd, 0x03, si->data + 0x0c);
2565 /* Mark the prolog end address. */
2566 bfd_put_32 (abfd, 0x0D, si->data + 0x10);
2567 pea_rel->address = 0x10;
2568 pea_rel->addend = 0;
2569 pea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2570 pea_rel->sym_ptr_ptr = fn_pp;
2572 sec->orelocation = rpp;
2573 sec->reloc_count = 4;
2577 /* Each external function in a PowerPC PE file has a two word
2578 descriptor consisting of:
2579 1. The address of the code.
2580 2. The address of the appropriate .toc
2581 We use relocs to build this. */
2583 si->data = xmalloc (8);
2584 memset (si->data, 0, si->size);
2586 rpp = xmalloc (sizeof (arelent *) * 3);
2587 rpp[0] = rel = xmalloc (sizeof (arelent));
2588 rpp[1] = xmalloc (sizeof (arelent));
2593 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2594 rel->sym_ptr_ptr = fn_pp;
2600 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2601 rel->sym_ptr_ptr = toc_pp;
2603 sec->orelocation = rpp;
2604 sec->reloc_count = 2;
2606 #endif /* DLLTOOL_PPC */
2612 /* Size up all the sections. */
2613 for (i = 0; i < NSECS; i++)
2615 sinfo *si = secdata + i;
2617 bfd_set_section_size (abfd, si->sec, si->size);
2618 bfd_set_section_vma (abfd, si->sec, vma);
2620 /* vma += si->size;*/
2623 /* Write them out. */
2624 for (i = 0; i < NSECS; i++)
2626 sinfo *si = secdata + i;
2628 if (i == IDATA5 && no_idata5)
2631 if (i == IDATA4 && no_idata4)
2634 bfd_set_section_contents (abfd, si->sec,
2639 bfd_set_symtab (abfd, ptrs, oidx);
2641 abfd = bfd_openr (outname, HOW_BFD_READ_TARGET);
2650 FILE *f = fopen (TMP_HEAD_S, FOPEN_WT);
2654 fatal (_("failed to open temporary head file: %s"), TMP_HEAD_S);
2658 fprintf (f, "%s IMAGE_IMPORT_DESCRIPTOR\n", ASM_C);
2659 fprintf (f, "\t.section .idata$2\n");
2661 fprintf(f,"\t%s\t%s\n", ASM_GLOBAL,head_label);
2663 fprintf (f, "%s:\n", head_label);
2665 fprintf (f, "\t%shname%s\t%sPtr to image import by name list\n",
2666 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
2668 fprintf (f, "\t%sthis should be the timestamp, but NT sometimes\n", ASM_C);
2669 fprintf (f, "\t%sdoesn't load DLLs when this is set.\n", ASM_C);
2670 fprintf (f, "\t%s\t0\t%s loaded time\n", ASM_LONG, ASM_C);
2671 fprintf (f, "\t%s\t0\t%s Forwarder chain\n", ASM_LONG, ASM_C);
2672 fprintf (f, "\t%s__%s_iname%s\t%s imported dll's name\n",
2677 fprintf (f, "\t%sfthunk%s\t%s pointer to firstthunk\n",
2679 ASM_RVA_AFTER, ASM_C);
2681 fprintf (f, "%sStuff for compatibility\n", ASM_C);
2685 fprintf (f, "\t.section\t.idata$5\n");
2686 fprintf (f, "\t%s\t0\n", ASM_LONG);
2687 fprintf (f, "fthunk:\n");
2692 fprintf (f, "\t.section\t.idata$4\n");
2694 fprintf (f, "\t%s\t0\n", ASM_LONG);
2695 fprintf (f, "\t.section .idata$4\n");
2696 fprintf (f, "hname:\n");
2701 assemble_file (TMP_HEAD_S, TMP_HEAD_O);
2703 return bfd_openr (TMP_HEAD_O, HOW_BFD_READ_TARGET);
2709 FILE *f = fopen (TMP_TAIL_S, FOPEN_WT);
2713 fatal (_("failed to open temporary tail file: %s"), TMP_TAIL_S);
2719 fprintf (f, "\t.section .idata$4\n");
2720 fprintf (f, "\t%s\t0\n", ASM_LONG);
2725 fprintf (f, "\t.section .idata$5\n");
2726 fprintf (f, "\t%s\t0\n", ASM_LONG);
2730 /* Normally, we need to see a null descriptor built in idata$3 to
2731 act as the terminator for the list. The ideal way, I suppose,
2732 would be to mark this section as a comdat type 2 section, so
2733 only one would appear in the final .exe (if our linker supported
2734 comdat, that is) or cause it to be inserted by something else (say
2737 fprintf (f, "\t.section .idata$3\n");
2738 fprintf (f, "\t%s\t0\n", ASM_LONG);
2739 fprintf (f, "\t%s\t0\n", ASM_LONG);
2740 fprintf (f, "\t%s\t0\n", ASM_LONG);
2741 fprintf (f, "\t%s\t0\n", ASM_LONG);
2742 fprintf (f, "\t%s\t0\n", ASM_LONG);
2746 /* Other PowerPC NT compilers use idata$6 for the dllname, so I
2747 do too. Original, huh? */
2748 fprintf (f, "\t.section .idata$6\n");
2750 fprintf (f, "\t.section .idata$7\n");
2753 fprintf (f, "\t%s\t__%s_iname\n", ASM_GLOBAL, imp_name_lab);
2754 fprintf (f, "__%s_iname:\t%s\t\"%s\"\n",
2755 imp_name_lab, ASM_TEXT, dll_name);
2759 assemble_file (TMP_TAIL_S, TMP_TAIL_O);
2761 return bfd_openr (TMP_TAIL_O, HOW_BFD_READ_TARGET);
2776 outarch = bfd_openw (imp_name, HOW_BFD_WRITE_TARGET);
2779 /* xgettext:c-format */
2780 fatal (_("Can't open .lib file: %s"), imp_name);
2782 /* xgettext:c-format */
2783 inform (_("Creating library file: %s"), imp_name);
2785 bfd_set_format (outarch, bfd_archive);
2786 outarch->has_armap = 1;
2788 /* Work out a reasonable size of things to put onto one line. */
2789 ar_head = make_head ();
2790 ar_tail = make_tail();
2792 if (ar_head == NULL || ar_tail == NULL)
2795 for (i = 0; (exp = d_exports_lexically[i]); i++)
2797 bfd *n = make_one_lib_file (exp, i);
2802 /* Now stick them all into the archive. */
2803 ar_head->next = head;
2804 ar_tail->next = ar_head;
2807 if (! bfd_set_archive_head (outarch, head))
2808 bfd_fatal ("bfd_set_archive_head");
2810 if (! bfd_close (outarch))
2811 bfd_fatal (imp_name);
2813 while (head != NULL)
2815 bfd *n = head->next;
2820 /* Delete all the temp files. */
2821 if (dontdeltemps == 0)
2823 unlink (TMP_HEAD_O);
2824 unlink (TMP_HEAD_S);
2825 unlink (TMP_TAIL_O);
2826 unlink (TMP_TAIL_S);
2829 if (dontdeltemps < 2)
2833 name = (char *) alloca (strlen (TMP_STUB) + 10);
2834 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
2836 sprintf (name, "%s%05d.o", TMP_STUB, i);
2837 if (unlink (name) < 0)
2838 /* xgettext:c-format */
2839 non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
2843 inform (_("Created lib file"));
2846 /**********************************************************************/
2848 /* Run through the information gathered from the .o files and the
2849 .def file and work out the best stuff. */
2851 pfunc (const void *a, const void *b)
2853 export_type *ap = *(export_type **) a;
2854 export_type *bp = *(export_type **) b;
2855 if (ap->ordinal == bp->ordinal)
2858 /* Unset ordinals go to the bottom. */
2859 if (ap->ordinal == -1)
2861 if (bp->ordinal == -1)
2863 return (ap->ordinal - bp->ordinal);
2867 nfunc (const void *a, const void *b)
2869 export_type *ap = *(export_type **) a;
2870 export_type *bp = *(export_type **) b;
2872 return (strcmp (ap->name, bp->name));
2876 remove_null_names (export_type **ptr)
2881 for (dst = src = 0; src < d_nfuncs; src++)
2885 ptr[dst] = ptr[src];
2893 dtab (export_type **ptr
2901 for (i = 0; i < d_nfuncs; i++)
2905 printf ("%d %s @ %d %s%s%s\n",
2906 i, ptr[i]->name, ptr[i]->ordinal,
2907 ptr[i]->noname ? "NONAME " : "",
2908 ptr[i]->constant ? "CONSTANT" : "",
2909 ptr[i]->data ? "DATA" : "");
2918 process_duplicates (export_type **d_export_vec)
2927 /* Remove duplicates. */
2928 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), nfunc);
2930 dtab (d_export_vec);
2931 for (i = 0; i < d_nfuncs - 1; i++)
2933 if (strcmp (d_export_vec[i]->name,
2934 d_export_vec[i + 1]->name) == 0)
2937 export_type *a = d_export_vec[i];
2938 export_type *b = d_export_vec[i + 1];
2942 /* xgettext:c-format */
2943 inform (_("Warning, ignoring duplicate EXPORT %s %d,%d"),
2944 a->name, a->ordinal, b->ordinal);
2946 if (a->ordinal != -1
2947 && b->ordinal != -1)
2948 /* xgettext:c-format */
2949 fatal (_("Error, duplicate EXPORT with oridinals: %s"),
2952 /* Merge attributes. */
2953 b->ordinal = a->ordinal > 0 ? a->ordinal : b->ordinal;
2954 b->constant |= a->constant;
2955 b->noname |= a->noname;
2957 d_export_vec[i] = 0;
2960 dtab (d_export_vec);
2961 remove_null_names (d_export_vec);
2962 dtab (d_export_vec);
2967 /* Count the names. */
2968 for (i = 0; i < d_nfuncs; i++)
2970 if (!d_export_vec[i]->noname)
2976 fill_ordinals (export_type **d_export_vec)
2983 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
2985 /* Fill in the unset ordinals with ones from our range. */
2986 ptr = (char *) xmalloc (size);
2988 memset (ptr, 0, size);
2990 /* Mark in our large vector all the numbers that are taken. */
2991 for (i = 0; i < d_nfuncs; i++)
2993 if (d_export_vec[i]->ordinal != -1)
2995 ptr[d_export_vec[i]->ordinal] = 1;
2997 if (lowest == -1 || d_export_vec[i]->ordinal < lowest)
2998 lowest = d_export_vec[i]->ordinal;
3002 /* Start at 1 for compatibility with MS toolchain. */
3006 /* Now fill in ordinals where the user wants us to choose. */
3007 for (i = 0; i < d_nfuncs; i++)
3009 if (d_export_vec[i]->ordinal == -1)
3013 /* First try within or after any user supplied range. */
3014 for (j = lowest; j < size; j++)
3018 d_export_vec[i]->ordinal = j;
3022 /* Then try before the range. */
3023 for (j = lowest; j >0; j--)
3027 d_export_vec[i]->ordinal = j;
3037 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
3039 /* Work out the lowest and highest ordinal numbers. */
3042 if (d_export_vec[0])
3043 d_low_ord = d_export_vec[0]->ordinal;
3044 if (d_export_vec[d_nfuncs-1])
3045 d_high_ord = d_export_vec[d_nfuncs-1]->ordinal;
3050 alphafunc (const void *av, const void *bv)
3052 const export_type **a = (const export_type **) av;
3053 const export_type **b = (const export_type **) bv;
3055 return strcmp ((*a)->name, (*b)->name);
3061 /* First work out the minimum ordinal chosen. */
3066 export_type **d_export_vec
3067 = (export_type **) xmalloc (sizeof (export_type *) * d_nfuncs);
3069 inform (_("Processing definitions"));
3071 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3072 d_export_vec[i] = exp;
3074 process_duplicates (d_export_vec);
3075 fill_ordinals (d_export_vec);
3077 /* Put back the list in the new order. */
3079 for (i = d_nfuncs - 1; i >= 0; i--)
3081 d_export_vec[i]->next = d_exports;
3082 d_exports = d_export_vec[i];
3085 /* Build list in alpha order. */
3086 d_exports_lexically = (export_type **)
3087 xmalloc (sizeof (export_type *) * (d_nfuncs + 1));
3089 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3090 d_exports_lexically[i] = exp;
3092 d_exports_lexically[i] = 0;
3094 qsort (d_exports_lexically, i, sizeof (export_type *), alphafunc);
3096 /* Fill exp entries with their hint values. */
3097 for (i = 0; i < d_nfuncs; i++)
3098 if (!d_exports_lexically[i]->noname || show_allnames)
3099 d_exports_lexically[i]->hint = hint++;
3101 inform (_("Processed definitions"));
3104 /**********************************************************************/
3107 usage (FILE *file, int status)
3109 /* xgetext:c-format */
3110 fprintf (file, _("Usage %s <option(s)> <object-file(s)>\n"), program_name);
3111 /* xgetext:c-format */
3112 fprintf (file, _(" -m --machine <machine> Create as DLL for <machine>. [default: %s]\n"), mname);
3113 fprintf (file, _(" possible <machine>: arm[_interwork], i386, mcore[-elf]{-le|-be}, ppc, thumb\n"));
3114 fprintf (file, _(" -e --output-exp <outname> Generate an export file.\n"));
3115 fprintf (file, _(" -l --output-lib <outname> Generate an interface library.\n"));
3116 fprintf (file, _(" -a --add-indirect Add dll indirects to export file.\n"));
3117 fprintf (file, _(" -D --dllname <name> Name of input dll to put into interface lib.\n"));
3118 fprintf (file, _(" -d --input-def <deffile> Name of .def file to be read in.\n"));
3119 fprintf (file, _(" -z --output-def <deffile> Name of .def file to be created.\n"));
3120 fprintf (file, _(" --export-all-symbols Export all symbols to .def\n"));
3121 fprintf (file, _(" --no-export-all-symbols Only export listed symbols\n"));
3122 fprintf (file, _(" --exclude-symbols <list> Don't export <list>\n"));
3123 fprintf (file, _(" --no-default-excludes Clear default exclude symbols\n"));
3124 fprintf (file, _(" -b --base-file <basefile> Read linker generated base file.\n"));
3125 fprintf (file, _(" -x --no-idata4 Don't generate idata$4 section.\n"));
3126 fprintf (file, _(" -c --no-idata5 Don't generate idata$5 section.\n"));
3127 fprintf (file, _(" -U --add-underscore Add underscores to symbols in interface library.\n"));
3128 fprintf (file, _(" -k --kill-at Kill @<n> from exported names.\n"));
3129 fprintf (file, _(" -A --add-stdcall-alias Add aliases without @<n>.\n"));
3130 fprintf (file, _(" -S --as <name> Use <name> for assembler.\n"));
3131 fprintf (file, _(" -f --as-flags <flags> Pass <flags> to the assembler.\n"));
3132 fprintf (file, _(" -C --compat-implib Create backward compatible import library.\n"));
3133 fprintf (file, _(" -n --no-delete Keep temp files (repeat for extra preservation).\n"));
3134 fprintf (file, _(" -t --temp-prefix <prefix> Use <prefix> to construct temp file names.\n"));
3135 fprintf (file, _(" -v --verbose Be verbose.\n"));
3136 fprintf (file, _(" -V --version Display the program version.\n"));
3137 fprintf (file, _(" -h --help Display this information.\n"));
3138 #ifdef DLLTOOL_MCORE_ELF
3139 fprintf (file, _(" -M --mcore-elf <outname> Process mcore-elf object files into <outname>.\n"));
3140 fprintf (file, _(" -L --linker <name> Use <name> as the linker.\n"));
3141 fprintf (file, _(" -F --linker-flags <flags> Pass <flags> to the linker.\n"));
3146 #define OPTION_EXPORT_ALL_SYMS 150
3147 #define OPTION_NO_EXPORT_ALL_SYMS (OPTION_EXPORT_ALL_SYMS + 1)
3148 #define OPTION_EXCLUDE_SYMS (OPTION_NO_EXPORT_ALL_SYMS + 1)
3149 #define OPTION_NO_DEFAULT_EXCLUDES (OPTION_EXCLUDE_SYMS + 1)
3151 static const struct option long_options[] =
3153 {"no-delete", no_argument, NULL, 'n'},
3154 {"dllname", required_argument, NULL, 'D'},
3155 {"no-idata4", no_argument, NULL, 'x'},
3156 {"no-idata5", no_argument, NULL, 'c'},
3157 {"output-exp", required_argument, NULL, 'e'},
3158 {"output-def", required_argument, NULL, 'z'},
3159 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL_SYMS},
3160 {"no-export-all-symbols", no_argument, NULL, OPTION_NO_EXPORT_ALL_SYMS},
3161 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMS},
3162 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
3163 {"output-lib", required_argument, NULL, 'l'},
3164 {"def", required_argument, NULL, 'd'}, /* for compatibility with older versions */
3165 {"input-def", required_argument, NULL, 'd'},
3166 {"add-underscore", no_argument, NULL, 'U'},
3167 {"kill-at", no_argument, NULL, 'k'},
3168 {"add-stdcall-alias", no_argument, NULL, 'A'},
3169 {"verbose", no_argument, NULL, 'v'},
3170 {"version", no_argument, NULL, 'V'},
3171 {"help", no_argument, NULL, 'h'},
3172 {"machine", required_argument, NULL, 'm'},
3173 {"add-indirect", no_argument, NULL, 'a'},
3174 {"base-file", required_argument, NULL, 'b'},
3175 {"as", required_argument, NULL, 'S'},
3176 {"as-flags", required_argument, NULL, 'f'},
3177 {"mcore-elf", required_argument, NULL, 'M'},
3178 {"compat-implib", no_argument, NULL, 'C'},
3179 {"temp-prefix", required_argument, NULL, 't'},
3183 int main (int, char **);
3186 main (int ac, char **av)
3191 program_name = av[0];
3194 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
3195 setlocale (LC_MESSAGES, "");
3197 #if defined (HAVE_SETLOCALE)
3198 setlocale (LC_CTYPE, "");
3200 bindtextdomain (PACKAGE, LOCALEDIR);
3201 textdomain (PACKAGE);
3203 while ((c = getopt_long (ac, av,
3204 #ifdef DLLTOOL_MCORE_ELF
3205 "m:e:l:aD:d:z:b:xcCuUkAS:f:nvVHhM:L:F:",
3207 "m:e:l:aD:d:z:b:xcCuUkAS:f:nvVHh",
3214 case OPTION_EXPORT_ALL_SYMS:
3215 export_all_symbols = TRUE;
3217 case OPTION_NO_EXPORT_ALL_SYMS:
3218 export_all_symbols = FALSE;
3220 case OPTION_EXCLUDE_SYMS:
3221 add_excludes (optarg);
3223 case OPTION_NO_DEFAULT_EXCLUDES:
3224 do_default_excludes = FALSE;
3236 tmp_prefix = optarg;
3242 /* ignored for compatibility */
3249 output_def = fopen (optarg, FOPEN_WT);
3271 print_version (program_name);
3280 add_stdcall_alias = 1;
3289 base_file = fopen (optarg, FOPEN_RB);
3292 /* xgettext:c-format */
3293 fatal (_("Unable to open base-file: %s"), optarg);
3296 #ifdef DLLTOOL_MCORE_ELF
3298 mcore_elf_out_file = optarg;
3301 mcore_elf_linker = optarg;
3304 mcore_elf_linker_flags = optarg;
3308 create_compat_implib = 1;
3317 tmp_prefix = prefix_encode ("d", getpid ());
3319 for (i = 0; mtable[i].type; i++)
3320 if (strcmp (mtable[i].type, mname) == 0)
3323 if (!mtable[i].type)
3324 /* xgettext:c-format */
3325 fatal (_("Machine '%s' not supported"), mname);
3329 if (!dll_name && exp_name)
3331 int len = strlen (exp_name) + 5;
3332 dll_name = xmalloc (len);
3333 strcpy (dll_name, exp_name);
3334 strcat (dll_name, ".dll");
3337 if (as_name == NULL)
3338 as_name = deduce_name ("as");
3340 /* Don't use the default exclude list if we're reading only the
3341 symbols in the .drectve section. The default excludes are meant
3342 to avoid exporting DLL entry point and Cygwin32 impure_ptr. */
3343 if (! export_all_symbols)
3344 do_default_excludes = FALSE;
3346 if (do_default_excludes)
3347 set_default_excludes ();
3350 process_def_file (def_file);
3355 firstarg = av[optind];
3356 scan_obj_file (av[optind]);
3367 /* Make imp_name safe for use as a label. */
3370 imp_name_lab = xstrdup (imp_name);
3371 for (p = imp_name_lab; *p; p++)
3376 head_label = make_label("_head_", imp_name_lab);
3383 #ifdef DLLTOOL_MCORE_ELF
3384 if (mcore_elf_out_file)
3385 mcore_elf_gen_out_file ();
3391 /* Look for the program formed by concatenating PROG_NAME and the
3392 string running from PREFIX to END_PREFIX. If the concatenated
3393 string contains a '/', try appending EXECUTABLE_SUFFIX if it is
3397 look_for_prog (const char *prog_name, const char *prefix, int end_prefix)
3402 cmd = xmalloc (strlen (prefix)
3403 + strlen (prog_name)
3404 #ifdef HAVE_EXECUTABLE_SUFFIX
3405 + strlen (EXECUTABLE_SUFFIX)
3408 strcpy (cmd, prefix);
3410 sprintf (cmd + end_prefix, "%s", prog_name);
3412 if (strchr (cmd, '/') != NULL)
3416 found = (stat (cmd, &s) == 0
3417 #ifdef HAVE_EXECUTABLE_SUFFIX
3418 || stat (strcat (cmd, EXECUTABLE_SUFFIX), &s) == 0
3424 /* xgettext:c-format */
3425 inform (_("Tried file: %s"), cmd);
3431 /* xgettext:c-format */
3432 inform (_("Using file: %s"), cmd);
3437 /* Deduce the name of the program we are want to invoke.
3438 PROG_NAME is the basic name of the program we want to run,
3439 eg "as" or "ld". The catch is that we might want actually
3440 run "i386-pe-as" or "ppc-pe-ld".
3442 If argv[0] contains the full path, then try to find the program
3443 in the same place, with and then without a target-like prefix.
3445 Given, argv[0] = /usr/local/bin/i586-cygwin32-dlltool,
3446 deduce_name("as") uses the following search order:
3448 /usr/local/bin/i586-cygwin32-as
3452 If there's an EXECUTABLE_SUFFIX, it'll use that as well; for each
3453 name, it'll try without and then with EXECUTABLE_SUFFIX.
3455 Given, argv[0] = i586-cygwin32-dlltool, it will not even try "as"
3456 as the fallback, but rather return i586-cygwin32-as.
3458 Oh, and given, argv[0] = dlltool, it'll return "as".
3460 Returns a dynamically allocated string. */
3463 deduce_name (const char *prog_name)
3466 char *dash, *slash, *cp;
3470 for (cp = program_name; *cp != '\0'; ++cp)
3475 #if defined(__DJGPP__) || defined (__CYGWIN__) || defined(__WIN32__)
3476 *cp == ':' || *cp == '\\' ||
3489 /* First, try looking for a prefixed PROG_NAME in the
3490 PROGRAM_NAME directory, with the same prefix as PROGRAM_NAME. */
3491 cmd = look_for_prog (prog_name, program_name, dash - program_name + 1);
3494 if (slash != NULL && cmd == NULL)
3496 /* Next, try looking for a PROG_NAME in the same directory as
3497 that of this program. */
3498 cmd = look_for_prog (prog_name, program_name, slash - program_name + 1);
3503 /* Just return PROG_NAME as is. */
3504 cmd = xstrdup (prog_name);
3510 #ifdef DLLTOOL_MCORE_ELF
3511 typedef struct fname_cache
3514 struct fname_cache * next;
3518 static fname_cache fnames;
3521 mcore_elf_cache_filename (char * filename)
3527 while (ptr->next != NULL)
3530 ptr->filename = filename;
3531 ptr->next = (fname_cache *) malloc (sizeof (fname_cache));
3532 if (ptr->next != NULL)
3533 ptr->next->next = NULL;
3536 #define MCORE_ELF_TMP_OBJ "mcoreelf.o"
3537 #define MCORE_ELF_TMP_EXP "mcoreelf.exp"
3538 #define MCORE_ELF_TMP_LIB "mcoreelf.lib"
3541 mcore_elf_gen_out_file (void)
3546 /* Step one. Run 'ld -r' on the input object files in order to resolve
3547 any internal references and to generate a single .exports section. */
3550 ds = dyn_string_new (100);
3551 dyn_string_append_cstr (ds, "-r ");
3553 if (mcore_elf_linker_flags != NULL)
3554 dyn_string_append_cstr (ds, mcore_elf_linker_flags);
3556 while (ptr->next != NULL)
3558 dyn_string_append_cstr (ds, ptr->filename);
3559 dyn_string_append_cstr (ds, " ");
3564 dyn_string_append_cstr (ds, "-o ");
3565 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
3567 if (mcore_elf_linker == NULL)
3568 mcore_elf_linker = deduce_name ("ld");
3570 run (mcore_elf_linker, ds->s);
3572 dyn_string_delete (ds);
3574 /* Step two. Create a .exp file and a .lib file from the temporary file.
3575 Do this by recursively invoking dlltool... */
3576 ds = dyn_string_new (100);
3578 dyn_string_append_cstr (ds, "-S ");
3579 dyn_string_append_cstr (ds, as_name);
3581 dyn_string_append_cstr (ds, " -e ");
3582 dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP);
3583 dyn_string_append_cstr (ds, " -l ");
3584 dyn_string_append_cstr (ds, MCORE_ELF_TMP_LIB);
3585 dyn_string_append_cstr (ds, " " );
3586 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
3589 dyn_string_append_cstr (ds, " -v");
3593 dyn_string_append_cstr (ds, " -n");
3595 if (dontdeltemps > 1)
3596 dyn_string_append_cstr (ds, " -n");
3599 /* XXX - FIME: ought to check/copy other command line options as well. */
3600 run (program_name, ds->s);
3602 dyn_string_delete (ds);
3604 /* Step four. Feed the .exp and object files to ld -shared to create the dll. */
3605 ds = dyn_string_new (100);
3607 dyn_string_append_cstr (ds, "-shared ");
3609 if (mcore_elf_linker_flags)
3610 dyn_string_append_cstr (ds, mcore_elf_linker_flags);
3612 dyn_string_append_cstr (ds, " ");
3613 dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP);
3614 dyn_string_append_cstr (ds, " ");
3615 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
3616 dyn_string_append_cstr (ds, " -o ");
3617 dyn_string_append_cstr (ds, mcore_elf_out_file);
3619 run (mcore_elf_linker, ds->s);
3621 dyn_string_delete (ds);
3623 if (dontdeltemps == 0)
3624 unlink (MCORE_ELF_TMP_EXP);
3626 if (dontdeltemps < 2)
3627 unlink (MCORE_ELF_TMP_OBJ);
3629 #endif /* DLLTOOL_MCORE_ELF */