1 /* dlltool.c -- tool to generate stuff for PE style DLLs
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
23 /* This program allows you to build the files necessary to create
24 DLLs to run on a system which understands PE format image files.
27 See "Peering Inside the PE: A Tour of the Win32 Portable Executable
28 File Format", MSJ 1994, Volume 9 for more information.
29 Also see "Microsoft Portable Executable and Common Object File Format,
30 Specification 4.1" for more information.
32 A DLL contains an export table which contains the information
33 which the runtime loader needs to tie up references from a
36 The export table is generated by this program by reading
37 in a .DEF file or scanning the .a and .o files which will be in the
38 DLL. A .o file can contain information in special ".drectve" sections
39 with export information.
41 A DEF file contains any number of the following commands:
44 NAME <name> [ , <base> ]
45 The result is going to be <name>.EXE
47 LIBRARY <name> [ , <base> ]
48 The result is going to be <name>.DLL
50 EXPORTS ( ( ( <name1> [ = <name2> ] )
51 | ( <name1> = <module-name> . <external-name>))
52 [ @ <integer> ] [ NONAME ] [CONSTANT] [DATA] [PRIVATE] ) *
53 Declares name1 as an exported symbol from the
54 DLL, with optional ordinal number <integer>.
55 Or declares name1 as an alias (forward) of the function <external-name>
56 in the DLL <module-name>.
58 IMPORTS ( ( <internal-name> = <module-name> . <integer> )
59 | ( [ <internal-name> = ] <module-name> . <external-name> )) *
60 Declares that <external-name> or the exported function whose ordinal number
61 is <integer> is to be imported from the file <module-name>. If
62 <internal-name> is specified then this is the name that the imported
63 function will be refereed to in the body of the DLL.
66 Puts <string> into output .exp file in the .rdata section
68 [STACKSIZE|HEAPSIZE] <number-reserve> [ , <number-commit> ]
69 Generates --stack|--heap <number-reserve>,<number-commit>
70 in the output .drectve section. The linker will
71 see this and act upon it.
74 SECTIONS ( <sectionname> <attr>+ )*
75 <attr> = READ | WRITE | EXECUTE | SHARED
76 Generates --attr <sectionname> <attr> in the output
77 .drectve section. The linker will see this and act
81 A -export:<name> in a .drectve section in an input .o or .a
82 file to this program is equivalent to a EXPORTS <name>
87 The program generates output files with the prefix supplied
88 on the command line, or in the def file, or taken from the first
91 The .exp.s file contains the information necessary to export
92 the routines in the DLL. The .lib.s file contains the information
93 necessary to use the DLL's routines from a referencing program.
100 asm (".section .drectve");
101 asm (".ascii \"-export:adef\"");
105 printf ("hello from the dll %s\n", s);
110 printf ("hello from the dll and the other entry point %s\n", s);
114 asm (".section .drectve");
115 asm (".ascii \"-export:cdef\"");
116 asm (".ascii \"-export:ddef\"");
120 printf ("hello from the dll %s\n", s);
125 printf ("hello from the dll and the other entry point %s\n", s);
143 HEAPSIZE 0x40000, 0x2000
147 SECTIONS donkey READ WRITE
150 # Compile up the parts of the dll and the program
152 gcc -c file1.c file2.c themain.c
154 # Optional: put the dll objects into a library
155 # (you don't have to, you could name all the object
156 # files on the dlltool line)
158 ar qcv thedll.in file1.o file2.o
161 # Run this tool over the DLL's .def file and generate an exports
162 # file (thedll.o) and an imports file (thedll.a).
163 # (You may have to use -S to tell dlltool where to find the assembler).
165 dlltool --def thedll.def --output-exp thedll.o --output-lib thedll.a
167 # Build the dll with the library and the export table
169 ld -o thedll.dll thedll.o thedll.in
171 # Link the executable with the import library
173 gcc -o themain.exe themain.o thedll.a
175 This example can be extended if relocations are needed in the DLL:
177 # Compile up the parts of the dll and the program
179 gcc -c file1.c file2.c themain.c
181 # Run this tool over the DLL's .def file and generate an imports file.
183 dlltool --def thedll.def --output-lib thedll.lib
185 # Link the executable with the import library and generate a base file
188 gcc -o themain.exe themain.o thedll.lib -Wl,--base-file -Wl,themain.base
190 # Run this tool over the DLL's .def file and generate an exports file
191 # which includes the relocations from the base file.
193 dlltool --def thedll.def --base-file themain.base --output-exp thedll.exp
195 # Build the dll with file1.o, file2.o and the export table
197 ld -o thedll.dll thedll.exp file1.o file2.o */
199 /* .idata section description
201 The .idata section is the import table. It is a collection of several
202 subsections used to keep the pieces for each dll together: .idata$[234567].
203 IE: Each dll's .idata$2's are catenated together, each .idata$3's, etc.
205 .idata$2 = Import Directory Table
206 = array of IMAGE_IMPORT_DESCRIPTOR's.
208 DWORD Import Lookup Table; - pointer to .idata$4
209 DWORD TimeDateStamp; - currently always 0
210 DWORD ForwarderChain; - currently always 0
211 DWORD Name; - pointer to dll's name
212 PIMAGE_THUNK_DATA FirstThunk; - pointer to .idata$5
214 .idata$3 = null terminating entry for .idata$2.
216 .idata$4 = Import Lookup Table
217 = array of array of pointers to hint name table.
218 There is one for each dll being imported from, and each dll's set is
219 terminated by a trailing NULL.
221 .idata$5 = Import Address Table
222 = array of array of pointers to hint name table.
223 There is one for each dll being imported from, and each dll's set is
224 terminated by a trailing NULL.
225 Initially, this table is identical to the Import Lookup Table. However,
226 at load time, the loader overwrites the entries with the address of the
229 .idata$6 = Hint Name Table
230 = Array of { short, asciz } entries, one for each imported function.
231 The `short' is the function's ordinal number.
233 .idata$7 = dll name (eg: "kernel32.dll"). (.idata$6 for ppc). */
235 /* AIX requires this to be the first thing in the file. */
242 #define show_allnames 0
244 #define PAGE_SIZE ((bfd_vma) 4096)
245 #define PAGE_MASK ((bfd_vma) (-4096))
248 #include "libiberty.h"
250 #include "demangle.h"
251 #include "dyn-string.h"
254 #include "safe-ctype.h"
257 #include <sys/stat.h>
262 #include "coff/arm.h"
263 #include "coff/internal.h"
265 #ifdef DLLTOOL_MX86_64
266 #include "coff/x86_64.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 (const 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 *identify_imp_name;
356 static char *identify_dll_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 add_stdcall_underscore = 0;
364 static int dontdeltemps = 0;
366 /* TRUE if we should export all symbols. Otherwise, we only export
367 symbols listed in .drectve sections or in the def file. */
368 static bfd_boolean export_all_symbols;
370 /* TRUE if we should exclude the symbols in DEFAULT_EXCLUDES when
371 exporting all symbols. */
372 static bfd_boolean do_default_excludes = TRUE;
374 static bfd_boolean use_nul_prefixed_import_tables = FALSE;
376 /* Default symbols to exclude when exporting all the symbols. */
377 static const char *default_excludes = "DllMain@12,DllEntryPoint@0,impure_ptr";
379 /* TRUE if we should add __imp_<SYMBOL> to import libraries for backward
380 compatibility to old Cygwin releases. */
381 static bfd_boolean create_compat_implib;
383 /* TRUE if we have to write PE+ import libraries. */
384 static bfd_boolean create_for_pep;
386 static char *def_file;
388 extern char * program_name;
392 static int add_stdcall_alias;
393 static const char *ext_prefix_alias;
395 static FILE *output_def;
396 static FILE *base_file;
398 #ifdef DLLTOOL_DEFAULT_ARM
399 static const char *mname = "arm";
402 #ifdef DLLTOOL_DEFAULT_ARM_EPOC
403 static const char *mname = "arm-epoc";
406 #ifdef DLLTOOL_DEFAULT_ARM_WINCE
407 static const char *mname = "arm-wince";
410 #ifdef DLLTOOL_DEFAULT_I386
411 static const char *mname = "i386";
414 #ifdef DLLTOOL_DEFAULT_MX86_64
415 static const char *mname = "i386:x86-64";
418 #ifdef DLLTOOL_DEFAULT_PPC
419 static const char *mname = "ppc";
422 #ifdef DLLTOOL_DEFAULT_SH
423 static const char *mname = "sh";
426 #ifdef DLLTOOL_DEFAULT_MIPS
427 static const char *mname = "mips";
430 #ifdef DLLTOOL_DEFAULT_MCORE
431 static const char * mname = "mcore-le";
434 #ifdef DLLTOOL_DEFAULT_MCORE_ELF
435 static const char * mname = "mcore-elf";
436 static char * mcore_elf_out_file = NULL;
437 static char * mcore_elf_linker = NULL;
438 static char * mcore_elf_linker_flags = NULL;
440 #define DRECTVE_SECTION_NAME ((machine == MMCORE_ELF || machine == MMCORE_ELF_LE) ? ".exports" : ".drectve")
443 #ifndef DRECTVE_SECTION_NAME
444 #define DRECTVE_SECTION_NAME ".drectve"
447 /* What's the right name for this ? */
450 /* External name alias numbering starts here. */
451 #define PREFIX_ALIAS_BASE 20000
454 char *tmp_head_s_buf;
455 char *tmp_head_o_buf;
456 char *tmp_tail_s_buf;
457 char *tmp_tail_o_buf;
460 #define TMP_ASM dlltmp (&tmp_asm_buf, "%sc.s")
461 #define TMP_HEAD_S dlltmp (&tmp_head_s_buf, "%sh.s")
462 #define TMP_HEAD_O dlltmp (&tmp_head_o_buf, "%sh.o")
463 #define TMP_TAIL_S dlltmp (&tmp_tail_s_buf, "%st.s")
464 #define TMP_TAIL_O dlltmp (&tmp_tail_o_buf, "%st.o")
465 #define TMP_STUB dlltmp (&tmp_stub_buf, "%ss")
467 /* This bit of assembly does jmp * .... */
468 static const unsigned char i386_jtab[] =
470 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
473 static const unsigned char arm_jtab[] =
475 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
476 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
480 static const unsigned char arm_interwork_jtab[] =
482 0x04, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
483 0x00, 0xc0, 0x9c, 0xe5, /* ldr ip, [ip] */
484 0x1c, 0xff, 0x2f, 0xe1, /* bx ip */
488 static const unsigned char thumb_jtab[] =
490 0x40, 0xb4, /* push {r6} */
491 0x02, 0x4e, /* ldr r6, [pc, #8] */
492 0x36, 0x68, /* ldr r6, [r6] */
493 0xb4, 0x46, /* mov ip, r6 */
494 0x40, 0xbc, /* pop {r6} */
495 0x60, 0x47, /* bx ip */
499 static const unsigned char mcore_be_jtab[] =
501 0x71, 0x02, /* lrw r1,2 */
502 0x81, 0x01, /* ld.w r1,(r1,0) */
503 0x00, 0xC1, /* jmp r1 */
504 0x12, 0x00, /* nop */
505 0x00, 0x00, 0x00, 0x00 /* <address> */
508 static const unsigned char mcore_le_jtab[] =
510 0x02, 0x71, /* lrw r1,2 */
511 0x01, 0x81, /* ld.w r1,(r1,0) */
512 0xC1, 0x00, /* jmp r1 */
513 0x00, 0x12, /* nop */
514 0x00, 0x00, 0x00, 0x00 /* <address> */
517 /* This is the glue sequence for PowerPC PE. There is a
518 tocrel16-tocdefn reloc against the first instruction.
519 We also need a IMGLUE reloc against the glue function
520 to restore the toc saved by the third instruction in
522 static const unsigned char ppc_jtab[] =
524 0x00, 0x00, 0x62, 0x81, /* lwz r11,0(r2) */
525 /* Reloc TOCREL16 __imp_xxx */
526 0x00, 0x00, 0x8B, 0x81, /* lwz r12,0(r11) */
527 0x04, 0x00, 0x41, 0x90, /* stw r2,4(r1) */
528 0xA6, 0x03, 0x89, 0x7D, /* mtctr r12 */
529 0x04, 0x00, 0x4B, 0x80, /* lwz r2,4(r11) */
530 0x20, 0x04, 0x80, 0x4E /* bctr */
534 /* The glue instruction, picks up the toc from the stw in
535 the above code: "lwz r2,4(r1)". */
536 static bfd_vma ppc_glue_insn = 0x80410004;
542 const char *how_byte;
543 const char *how_short;
544 const char *how_long;
545 const char *how_asciz;
546 const char *how_comment;
547 const char *how_jump;
548 const char *how_global;
549 const char *how_space;
550 const char *how_align_short;
551 const char *how_align_long;
552 const char *how_default_as_switches;
553 const char *how_bfd_target;
554 enum bfd_architecture how_bfd_arch;
555 const unsigned char *how_jtab;
556 int how_jtab_size; /* Size of the jtab entry. */
557 int how_jtab_roff; /* Offset into it for the ind 32 reloc into idata 5. */
560 static const struct mac
565 "arm", ".byte", ".short", ".long", ".asciz", "@",
566 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
567 ".global", ".space", ".align\t2",".align\t4", "-mapcs-32",
568 "pe-arm-little", bfd_arch_arm,
569 arm_jtab, sizeof (arm_jtab), 8
574 "i386", ".byte", ".short", ".long", ".asciz", "#",
575 "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
576 "pe-i386",bfd_arch_i386,
577 i386_jtab, sizeof (i386_jtab), 2
582 "ppc", ".byte", ".short", ".long", ".asciz", "#",
583 "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
584 "pe-powerpcle",bfd_arch_powerpc,
585 ppc_jtab, sizeof (ppc_jtab), 0
590 "thumb", ".byte", ".short", ".long", ".asciz", "@",
591 "push\t{r6}\n\tldr\tr6, [pc, #8]\n\tldr\tr6, [r6]\n\tmov\tip, r6\n\tpop\t{r6}\n\tbx\tip",
592 ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
593 "pe-arm-little", bfd_arch_arm,
594 thumb_jtab, sizeof (thumb_jtab), 12
597 #define MARM_INTERWORK 4
599 "arm_interwork", ".byte", ".short", ".long", ".asciz", "@",
600 "ldr\tip,[pc]\n\tldr\tip,[ip]\n\tbx\tip\n\t.long",
601 ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
602 "pe-arm-little", bfd_arch_arm,
603 arm_interwork_jtab, sizeof (arm_interwork_jtab), 12
608 "mcore-be", ".byte", ".short", ".long", ".asciz", "//",
609 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
610 ".global", ".space", ".align\t2",".align\t4", "",
611 "pe-mcore-big", bfd_arch_mcore,
612 mcore_be_jtab, sizeof (mcore_be_jtab), 8
617 "mcore-le", ".byte", ".short", ".long", ".asciz", "//",
618 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
619 ".global", ".space", ".align\t2",".align\t4", "-EL",
620 "pe-mcore-little", bfd_arch_mcore,
621 mcore_le_jtab, sizeof (mcore_le_jtab), 8
626 "mcore-elf-be", ".byte", ".short", ".long", ".asciz", "//",
627 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
628 ".global", ".space", ".align\t2",".align\t4", "",
629 "elf32-mcore-big", bfd_arch_mcore,
630 mcore_be_jtab, sizeof (mcore_be_jtab), 8
634 #define MMCORE_ELF_LE 8
635 "mcore-elf-le", ".byte", ".short", ".long", ".asciz", "//",
636 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
637 ".global", ".space", ".align\t2",".align\t4", "-EL",
638 "elf32-mcore-little", bfd_arch_mcore,
639 mcore_le_jtab, sizeof (mcore_le_jtab), 8
644 "arm-epoc", ".byte", ".short", ".long", ".asciz", "@",
645 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
646 ".global", ".space", ".align\t2",".align\t4", "",
647 "epoc-pe-arm-little", bfd_arch_arm,
648 arm_jtab, sizeof (arm_jtab), 8
652 #define MARM_WINCE 10
653 "arm-wince", ".byte", ".short", ".long", ".asciz", "@",
654 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
655 ".global", ".space", ".align\t2",".align\t4", "-mapcs-32",
656 "pe-arm-wince-little", bfd_arch_arm,
657 arm_jtab, sizeof (arm_jtab), 8
662 "i386:x86-64", ".byte", ".short", ".long", ".asciz", "#",
663 "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
664 "pe-x86-64",bfd_arch_i386,
665 i386_jtab, sizeof (i386_jtab), 2
668 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
678 typedef struct export
681 const char *internal_name;
682 const char *import_name;
685 int noname; /* Don't put name in image file. */
686 int private; /* Don't put reference in import lib. */
689 int forward; /* Number of forward label, 0 means no forward. */
694 /* A list of symbols which we should not export. */
698 struct string_list *next;
702 static struct string_list *excludes;
704 static const char *rvaafter (int);
705 static const char *rvabefore (int);
706 static const char *asm_prefix (int, const char *);
707 static void process_def_file (const char *);
708 static void new_directive (char *);
709 static void append_import (const char *, const char *, int);
710 static void run (const char *, char *);
711 static void scan_drectve_symbols (bfd *);
712 static void scan_filtered_symbols (bfd *, void *, long, unsigned int);
713 static void add_excludes (const char *);
714 static bfd_boolean match_exclude (const char *);
715 static void set_default_excludes (void);
716 static long filter_symbols (bfd *, void *, long, unsigned int);
717 static void scan_all_symbols (bfd *);
718 static void scan_open_obj_file (bfd *);
719 static void scan_obj_file (const char *);
720 static void dump_def_info (FILE *);
721 static int sfunc (const void *, const void *);
722 static void flush_page (FILE *, bfd_vma *, bfd_vma, int);
723 static void gen_def_file (void);
724 static void generate_idata_ofile (FILE *);
725 static void assemble_file (const char *, const char *);
726 static void gen_exp_file (void);
727 static const char *xlate (const char *);
728 static char *make_label (const char *, const char *);
729 static char *make_imp_label (const char *, const char *);
730 static bfd *make_one_lib_file (export_type *, int);
731 static bfd *make_head (void);
732 static bfd *make_tail (void);
733 static void gen_lib_file (void);
734 static void identify_dll_for_implib (void);
735 static void identify_search_archive (bfd*);
736 static void identify_search_member (bfd*, bfd*);
737 static bfd_boolean identify_process_section_p (asection *);
738 static void identify_search_section (bfd *, asection *, void *);
739 static int pfunc (const void *, const void *);
740 static int nfunc (const void *, const void *);
741 static void remove_null_names (export_type **);
742 static void process_duplicates (export_type **);
743 static void fill_ordinals (export_type **);
744 static void mangle_defs (void);
745 static void usage (FILE *, int);
746 static void inform (const char *, ...) ATTRIBUTE_PRINTF_1;
747 static void set_dll_name_from_def (const char *);
750 prefix_encode (char *start, unsigned code)
752 static char alpha[26] = "abcdefghijklmnopqrstuvwxyz";
756 p = strchr (buf, '\0');
758 *p++ = alpha[code % sizeof (alpha)];
759 while ((code /= sizeof (alpha)) != 0);
765 dlltmp (char **buf, const char *fmt)
769 *buf = malloc (strlen (tmp_prefix) + 64);
770 sprintf (*buf, fmt, tmp_prefix);
776 inform VPARAMS ((const char * message, ...))
778 VA_OPEN (args, message);
779 VA_FIXEDARG (args, const char *, message);
784 report (message, args);
790 rvaafter (int machine)
808 /* xgettext:c-format */
809 fatal (_("Internal error: Unknown machine type: %d"), machine);
816 rvabefore (int machine)
834 /* xgettext:c-format */
835 fatal (_("Internal error: Unknown machine type: %d"), machine);
842 asm_prefix (int machine, const char *name)
859 /* Symbol names starting with ? do not have a leading underscore. */
860 if (name && *name == '?')
865 /* xgettext:c-format */
866 fatal (_("Internal error: Unknown machine type: %d"), machine);
872 #define ASM_BYTE mtable[machine].how_byte
873 #define ASM_SHORT mtable[machine].how_short
874 #define ASM_LONG mtable[machine].how_long
875 #define ASM_TEXT mtable[machine].how_asciz
876 #define ASM_C mtable[machine].how_comment
877 #define ASM_JUMP mtable[machine].how_jump
878 #define ASM_GLOBAL mtable[machine].how_global
879 #define ASM_SPACE mtable[machine].how_space
880 #define ASM_ALIGN_SHORT mtable[machine].how_align_short
881 #define ASM_RVA_BEFORE rvabefore (machine)
882 #define ASM_RVA_AFTER rvaafter (machine)
883 #define ASM_PREFIX(NAME) asm_prefix (machine, (NAME))
884 #define ASM_ALIGN_LONG mtable[machine].how_align_long
885 #define HOW_BFD_READ_TARGET 0 /* Always default. */
886 #define HOW_BFD_WRITE_TARGET mtable[machine].how_bfd_target
887 #define HOW_BFD_ARCH mtable[machine].how_bfd_arch
888 #define HOW_JTAB mtable[machine].how_jtab
889 #define HOW_JTAB_SIZE mtable[machine].how_jtab_size
890 #define HOW_JTAB_ROFF mtable[machine].how_jtab_roff
891 #define ASM_SWITCHES mtable[machine].how_default_as_switches
896 process_def_file (const char *name)
898 FILE *f = fopen (name, FOPEN_RT);
901 /* xgettext:c-format */
902 fatal (_("Can't open def file: %s"), name);
906 /* xgettext:c-format */
907 inform (_("Processing def file: %s"), name);
911 inform (_("Processed def file"));
914 /**********************************************************************/
916 /* Communications with the parser. */
918 static int d_nfuncs; /* Number of functions exported. */
919 static int d_named_nfuncs; /* Number of named functions exported. */
920 static int d_low_ord; /* Lowest ordinal index. */
921 static int d_high_ord; /* Highest ordinal index. */
922 static export_type *d_exports; /* List of exported functions. */
923 static export_type **d_exports_lexically; /* Vector of exported functions in alpha order. */
924 static dlist_type *d_list; /* Descriptions. */
925 static dlist_type *a_list; /* Stuff to go in directives. */
926 static int d_nforwards = 0; /* Number of forwarded exports. */
932 yyerror (const char * err ATTRIBUTE_UNUSED)
934 /* xgettext:c-format */
935 non_fatal (_("Syntax error in def file %s:%d"), def_file, linenumber);
941 def_exports (const char *name, const char *internal_name, int ordinal,
942 int noname, int constant, int data, int private)
944 struct export *p = (struct export *) xmalloc (sizeof (*p));
947 p->internal_name = internal_name ? internal_name : name;
948 p->import_name = name;
949 p->ordinal = ordinal;
950 p->constant = constant;
952 p->private = private;
958 if ((internal_name != NULL)
959 && (strchr (internal_name, '.') != NULL))
960 p->forward = ++d_nforwards;
962 p->forward = 0; /* no forward */
966 set_dll_name_from_def (const char * name)
968 const char* image_basename = lbasename (name);
969 if (image_basename != name)
970 non_fatal (_("%s: Path components stripped from image name, '%s'."),
972 dll_name = xstrdup (image_basename);
976 def_name (const char *name, int base)
978 /* xgettext:c-format */
979 inform (_("NAME: %s base: %x"), name, base);
982 non_fatal (_("Can't have LIBRARY and NAME"));
984 /* If --dllname not provided, use the one in the DEF file.
985 FIXME: Is this appropriate for executables? */
987 set_dll_name_from_def (name);
992 def_library (const char *name, int base)
994 /* xgettext:c-format */
995 inform (_("LIBRARY: %s base: %x"), name, base);
998 non_fatal (_("Can't have LIBRARY and NAME"));
1000 /* If --dllname not provided, use the one in the DEF file. */
1002 set_dll_name_from_def (name);
1007 def_description (const char *desc)
1009 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
1010 d->text = xstrdup (desc);
1016 new_directive (char *dir)
1018 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
1019 d->text = xstrdup (dir);
1025 def_heapsize (int reserve, int commit)
1029 sprintf (b, "-heap 0x%x,0x%x ", reserve, commit);
1031 sprintf (b, "-heap 0x%x ", reserve);
1032 new_directive (xstrdup (b));
1036 def_stacksize (int reserve, int commit)
1040 sprintf (b, "-stack 0x%x,0x%x ", reserve, commit);
1042 sprintf (b, "-stack 0x%x ", reserve);
1043 new_directive (xstrdup (b));
1046 /* append_import simply adds the given import definition to the global
1047 import_list. It is used by def_import. */
1050 append_import (const char *symbol_name, const char *dll_name, int func_ordinal)
1055 for (pq = &import_list; *pq != NULL; pq = &(*pq)->next)
1057 if (strcmp ((*pq)->dllname, dll_name) == 0)
1060 q->functail->next = xmalloc (sizeof (ifunctype));
1061 q->functail = q->functail->next;
1062 q->functail->ord = func_ordinal;
1063 q->functail->name = xstrdup (symbol_name);
1064 q->functail->next = NULL;
1070 q = xmalloc (sizeof (iheadtype));
1071 q->dllname = xstrdup (dll_name);
1073 q->funchead = xmalloc (sizeof (ifunctype));
1074 q->functail = q->funchead;
1076 q->functail->name = xstrdup (symbol_name);
1077 q->functail->ord = func_ordinal;
1078 q->functail->next = NULL;
1083 /* def_import is called from within defparse.y when an IMPORT
1084 declaration is encountered. Depending on the form of the
1085 declaration, the module name may or may not need ".dll" to be
1086 appended to it, the name of the function may be stored in internal
1087 or entry, and there may or may not be an ordinal value associated
1090 /* A note regarding the parse modes:
1091 In defparse.y we have to accept import declarations which follow
1092 any one of the following forms:
1093 <func_name_in_app> = <dll_name>.<func_name_in_dll>
1094 <func_name_in_app> = <dll_name>.<number>
1095 <dll_name>.<func_name_in_dll>
1097 Furthermore, the dll's name may or may not end with ".dll", which
1098 complicates the parsing a little. Normally the dll's name is
1099 passed to def_import() in the "module" parameter, but when it ends
1100 with ".dll" it gets passed in "module" sans ".dll" and that needs
1103 def_import gets five parameters:
1104 APP_NAME - the name of the function in the application, if
1105 present, or NULL if not present.
1106 MODULE - the name of the dll, possibly sans extension (ie, '.dll').
1107 DLLEXT - the extension of the dll, if present, NULL if not present.
1108 ENTRY - the name of the function in the dll, if present, or NULL.
1109 ORD_VAL - the numerical tag of the function in the dll, if present,
1110 or NULL. Exactly one of <entry> or <ord_val> must be
1111 present (i.e., not NULL). */
1114 def_import (const char *app_name, const char *module, const char *dllext,
1115 const char *entry, int ord_val)
1117 const char *application_name;
1121 application_name = entry;
1124 if (app_name != NULL)
1125 application_name = app_name;
1127 application_name = "";
1132 buf = (char *) alloca (strlen (module) + strlen (dllext) + 2);
1133 sprintf (buf, "%s.%s", module, dllext);
1137 append_import (application_name, module, ord_val);
1141 def_version (int major, int minor)
1143 printf ("VERSION %d.%d\n", major, minor);
1147 def_section (const char *name, int attr)
1162 sprintf (buf, "-attr %s %s", name, atts);
1163 new_directive (xstrdup (buf));
1170 def_section ("CODE", attr);
1176 def_section ("DATA", attr);
1179 /**********************************************************************/
1182 run (const char *what, char *args)
1185 int pid, wait_status;
1188 char *errmsg_fmt, *errmsg_arg;
1189 char *temp_base = choose_temp_base ();
1191 inform ("run: %s %s", what, args);
1193 /* Count the args */
1195 for (s = args; *s; s++)
1199 argv = alloca (sizeof (char *) * (i + 3));
1208 while (*s != ' ' && *s != 0)
1216 pid = pexecute (argv[0], (char * const *) argv, program_name, temp_base,
1217 &errmsg_fmt, &errmsg_arg, PEXECUTE_ONE | PEXECUTE_SEARCH);
1221 inform ("%s", strerror (errno));
1223 fatal (errmsg_fmt, errmsg_arg);
1226 pid = pwait (pid, & wait_status, 0);
1230 /* xgettext:c-format */
1231 fatal (_("wait: %s"), strerror (errno));
1233 else if (WIFSIGNALED (wait_status))
1235 /* xgettext:c-format */
1236 fatal (_("subprocess got fatal signal %d"), WTERMSIG (wait_status));
1238 else if (WIFEXITED (wait_status))
1240 if (WEXITSTATUS (wait_status) != 0)
1241 /* xgettext:c-format */
1242 non_fatal (_("%s exited with status %d"),
1243 what, WEXITSTATUS (wait_status));
1249 /* Look for a list of symbols to export in the .drectve section of
1250 ABFD. Pass each one to def_exports. */
1253 scan_drectve_symbols (bfd *abfd)
1261 /* Look for .drectve's */
1262 s = bfd_get_section_by_name (abfd, DRECTVE_SECTION_NAME);
1267 size = bfd_get_section_size (s);
1268 buf = xmalloc (size);
1270 bfd_get_section_contents (abfd, s, buf, 0, size);
1272 /* xgettext:c-format */
1273 inform (_("Sucking in info from %s section in %s"),
1274 DRECTVE_SECTION_NAME, bfd_get_filename (abfd));
1276 /* Search for -export: strings. The exported symbols can optionally
1277 have type tags (eg., -export:foo,data), so handle those as well.
1278 Currently only data tag is supported. */
1284 && CONST_STRNEQ (p, "-export:"))
1288 flagword flags = BSF_FUNCTION;
1292 while (p < e && *p != ',' && *p != ' ' && *p != '-')
1294 c = xmalloc (p - name + 1);
1295 memcpy (c, name, p - name);
1297 if (p < e && *p == ',') /* found type tag. */
1299 char *tag_start = ++p;
1300 while (p < e && *p != ' ' && *p != '-')
1302 if (CONST_STRNEQ (tag_start, "data"))
1303 flags &= ~BSF_FUNCTION;
1306 /* FIXME: The 5th arg is for the `constant' field.
1307 What should it be? Not that it matters since it's not
1308 currently useful. */
1309 def_exports (c, 0, -1, 0, 0, ! (flags & BSF_FUNCTION), 0);
1311 if (add_stdcall_alias && strchr (c, '@'))
1313 int lead_at = (*c == '@') ;
1314 char *exported_name = xstrdup (c + lead_at);
1315 char *atsym = strchr (exported_name, '@');
1317 /* Note: stdcall alias symbols can never be data. */
1318 def_exports (exported_name, xstrdup (c), -1, 0, 0, 0, 0);
1327 /* Look through the symbols in MINISYMS, and add each one to list of
1328 symbols to export. */
1331 scan_filtered_symbols (bfd *abfd, void *minisyms, long symcount,
1335 bfd_byte *from, *fromend;
1337 store = bfd_make_empty_symbol (abfd);
1339 bfd_fatal (bfd_get_filename (abfd));
1341 from = (bfd_byte *) minisyms;
1342 fromend = from + symcount * size;
1343 for (; from < fromend; from += size)
1346 const char *symbol_name;
1348 sym = bfd_minisymbol_to_symbol (abfd, FALSE, from, store);
1350 bfd_fatal (bfd_get_filename (abfd));
1352 symbol_name = bfd_asymbol_name (sym);
1353 if (bfd_get_symbol_leading_char (abfd) == symbol_name[0])
1356 def_exports (xstrdup (symbol_name) , 0, -1, 0, 0,
1357 ! (sym->flags & BSF_FUNCTION), 0);
1359 if (add_stdcall_alias && strchr (symbol_name, '@'))
1361 int lead_at = (*symbol_name == '@');
1362 char *exported_name = xstrdup (symbol_name + lead_at);
1363 char *atsym = strchr (exported_name, '@');
1365 /* Note: stdcall alias symbols can never be data. */
1366 def_exports (exported_name, xstrdup (symbol_name), -1, 0, 0, 0, 0);
1371 /* Add a list of symbols to exclude. */
1374 add_excludes (const char *new_excludes)
1377 char *exclude_string;
1379 local_copy = xstrdup (new_excludes);
1381 exclude_string = strtok (local_copy, ",:");
1382 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
1384 struct string_list *new_exclude;
1386 new_exclude = ((struct string_list *)
1387 xmalloc (sizeof (struct string_list)));
1388 new_exclude->string = (char *) xmalloc (strlen (exclude_string) + 2);
1389 /* Don't add a leading underscore for fastcall symbols. */
1390 if (*exclude_string == '@')
1391 sprintf (new_exclude->string, "%s", exclude_string);
1393 sprintf (new_exclude->string, "_%s", exclude_string);
1394 new_exclude->next = excludes;
1395 excludes = new_exclude;
1397 /* xgettext:c-format */
1398 inform (_("Excluding symbol: %s"), exclude_string);
1404 /* See if STRING is on the list of symbols to exclude. */
1407 match_exclude (const char *string)
1409 struct string_list *excl_item;
1411 for (excl_item = excludes; excl_item; excl_item = excl_item->next)
1412 if (strcmp (string, excl_item->string) == 0)
1417 /* Add the default list of symbols to exclude. */
1420 set_default_excludes (void)
1422 add_excludes (default_excludes);
1425 /* Choose which symbols to export. */
1428 filter_symbols (bfd *abfd, void *minisyms, long symcount, unsigned int size)
1430 bfd_byte *from, *fromend, *to;
1433 store = bfd_make_empty_symbol (abfd);
1435 bfd_fatal (bfd_get_filename (abfd));
1437 from = (bfd_byte *) minisyms;
1438 fromend = from + symcount * size;
1439 to = (bfd_byte *) minisyms;
1441 for (; from < fromend; from += size)
1446 sym = bfd_minisymbol_to_symbol (abfd, FALSE, (const void *) from, store);
1448 bfd_fatal (bfd_get_filename (abfd));
1450 /* Check for external and defined only symbols. */
1451 keep = (((sym->flags & BSF_GLOBAL) != 0
1452 || (sym->flags & BSF_WEAK) != 0
1453 || bfd_is_com_section (sym->section))
1454 && ! bfd_is_und_section (sym->section));
1456 keep = keep && ! match_exclude (sym->name);
1460 memcpy (to, from, size);
1465 return (to - (bfd_byte *) minisyms) / size;
1468 /* Export all symbols in ABFD, except for ones we were told not to
1472 scan_all_symbols (bfd *abfd)
1478 /* Ignore bfds with an import descriptor table. We assume that any
1479 such BFD contains symbols which are exported from another DLL,
1480 and we don't want to reexport them from here. */
1481 if (bfd_get_section_by_name (abfd, ".idata$4"))
1484 if (! (bfd_get_file_flags (abfd) & HAS_SYMS))
1486 /* xgettext:c-format */
1487 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1491 symcount = bfd_read_minisymbols (abfd, FALSE, &minisyms, &size);
1493 bfd_fatal (bfd_get_filename (abfd));
1497 /* xgettext:c-format */
1498 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1502 /* Discard the symbols we don't want to export. It's OK to do this
1503 in place; we'll free the storage anyway. */
1505 symcount = filter_symbols (abfd, minisyms, symcount, size);
1506 scan_filtered_symbols (abfd, minisyms, symcount, size);
1511 /* Look at the object file to decide which symbols to export. */
1514 scan_open_obj_file (bfd *abfd)
1516 if (export_all_symbols)
1517 scan_all_symbols (abfd);
1519 scan_drectve_symbols (abfd);
1521 /* FIXME: we ought to read in and block out the base relocations. */
1523 /* xgettext:c-format */
1524 inform (_("Done reading %s"), bfd_get_filename (abfd));
1528 scan_obj_file (const char *filename)
1530 bfd * f = bfd_openr (filename, 0);
1533 /* xgettext:c-format */
1534 fatal (_("Unable to open object file: %s"), filename);
1536 /* xgettext:c-format */
1537 inform (_("Scanning object file %s"), filename);
1539 if (bfd_check_format (f, bfd_archive))
1541 bfd *arfile = bfd_openr_next_archived_file (f, 0);
1544 if (bfd_check_format (arfile, bfd_object))
1545 scan_open_obj_file (arfile);
1547 arfile = bfd_openr_next_archived_file (f, arfile);
1550 #ifdef DLLTOOL_MCORE_ELF
1551 if (mcore_elf_out_file)
1552 inform (_("Cannot produce mcore-elf dll from archive file: %s"), filename);
1555 else if (bfd_check_format (f, bfd_object))
1557 scan_open_obj_file (f);
1559 #ifdef DLLTOOL_MCORE_ELF
1560 if (mcore_elf_out_file)
1561 mcore_elf_cache_filename (filename);
1568 /**********************************************************************/
1571 dump_def_info (FILE *f)
1575 fprintf (f, "%s ", ASM_C);
1576 for (i = 0; oav[i]; i++)
1577 fprintf (f, "%s ", oav[i]);
1579 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1581 fprintf (f, "%s %d = %s %s @ %d %s%s%s%s\n",
1587 exp->noname ? "NONAME " : "",
1588 exp->private ? "PRIVATE " : "",
1589 exp->constant ? "CONSTANT" : "",
1590 exp->data ? "DATA" : "");
1594 /* Generate the .exp file. */
1597 sfunc (const void *a, const void *b)
1599 if (*(const bfd_vma *) a == *(const bfd_vma *) b)
1602 return ((*(const bfd_vma *) a > *(const bfd_vma *) b) ? 1 : -1);
1606 flush_page (FILE *f, bfd_vma *need, bfd_vma page_addr, int on_page)
1610 /* Flush this page. */
1611 fprintf (f, "\t%s\t0x%08x\t%s Starting RVA for chunk\n",
1615 fprintf (f, "\t%s\t0x%x\t%s Size of block\n",
1617 (on_page * 2) + (on_page & 1) * 2 + 8,
1620 for (i = 0; i < on_page; i++)
1622 bfd_vma needed = need[i];
1626 if (!create_for_pep)
1628 /* Relocation via HIGHLOW. */
1629 needed = ((needed - page_addr) | 0x3000) & 0xffff;
1633 /* Relocation via DIR64. */
1634 needed = ((needed - page_addr) | 0xa000) & 0xffff;
1638 fprintf (f, "\t%s\t0x%lx\n", ASM_SHORT, (long) needed);
1643 fprintf (f, "\t%s\t0x%x\n", ASM_SHORT, 0 | 0x0000);
1652 inform (_("Adding exports to output file"));
1654 fprintf (output_def, ";");
1655 for (i = 0; oav[i]; i++)
1656 fprintf (output_def, " %s", oav[i]);
1658 fprintf (output_def, "\nEXPORTS\n");
1660 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1662 char *quote = strchr (exp->name, '.') ? "\"" : "";
1663 char *res = cplus_demangle (exp->internal_name, DMGL_ANSI | DMGL_PARAMS);
1667 fprintf (output_def,";\t%s\n", res);
1671 if (strcmp (exp->name, exp->internal_name) == 0)
1673 fprintf (output_def, "\t%s%s%s @ %d%s%s%s\n",
1678 exp->noname ? " NONAME" : "",
1679 exp->private ? "PRIVATE " : "",
1680 exp->data ? " DATA" : "");
1684 char * quote1 = strchr (exp->internal_name, '.') ? "\"" : "";
1686 fprintf (output_def, "\t%s%s%s = %s%s%s @ %d%s%s%s\n",
1694 exp->noname ? " NONAME" : "",
1695 exp->private ? "PRIVATE " : "",
1696 exp->data ? " DATA" : "");
1700 inform (_("Added exports to output file"));
1703 /* generate_idata_ofile generates the portable assembly source code
1704 for the idata sections. It appends the source code to the end of
1708 generate_idata_ofile (FILE *filvar)
1716 if (import_list == NULL)
1719 fprintf (filvar, "%s Import data sections\n", ASM_C);
1720 fprintf (filvar, "\n\t.section\t.idata$2\n");
1721 fprintf (filvar, "\t%s\tdoi_idata\n", ASM_GLOBAL);
1722 fprintf (filvar, "doi_idata:\n");
1725 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1727 fprintf (filvar, "\t%slistone%d%s\t%s %s\n",
1728 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER,
1729 ASM_C, headptr->dllname);
1730 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1731 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1732 fprintf (filvar, "\t%sdllname%d%s\n",
1733 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1734 fprintf (filvar, "\t%slisttwo%d%s\n\n",
1735 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1739 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL record at */
1740 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* end of idata$2 */
1741 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* section */
1742 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1743 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1745 fprintf (filvar, "\n\t.section\t.idata$4\n");
1747 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1749 fprintf (filvar, "listone%d:\n", headindex);
1750 for (funcindex = 0; funcindex < headptr->nfuncs; funcindex++)
1753 fprintf (filvar, "\t%sfuncptr%d_%d%s\n%s\t0\n",
1754 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER,
1757 fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1758 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1761 fprintf (filvar, "\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
1763 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list. */
1767 fprintf (filvar, "\n\t.section\t.idata$5\n");
1769 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1771 fprintf (filvar, "listtwo%d:\n", headindex);
1772 for (funcindex = 0; funcindex < headptr->nfuncs; funcindex++)
1775 fprintf (filvar, "\t%sfuncptr%d_%d%s\n%s\t0\n",
1776 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER,
1779 fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1780 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1783 fprintf (filvar, "\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
1785 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list. */
1789 fprintf (filvar, "\n\t.section\t.idata$6\n");
1791 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1794 for (funcptr = headptr->funchead; funcptr != NULL;
1795 funcptr = funcptr->next)
1797 fprintf (filvar,"funcptr%d_%d:\n", headindex, funcindex);
1798 fprintf (filvar,"\t%s\t%d\n", ASM_SHORT,
1799 ((funcptr->ord) & 0xFFFF));
1800 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, funcptr->name);
1801 fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1807 fprintf (filvar, "\n\t.section\t.idata$7\n");
1809 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1811 fprintf (filvar,"dllname%d:\n", headindex);
1812 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, headptr->dllname);
1813 fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1818 /* Assemble the specified file. */
1820 assemble_file (const char * source, const char * dest)
1824 cmd = (char *) alloca (strlen (ASM_SWITCHES) + strlen (as_flags)
1825 + strlen (source) + strlen (dest) + 50);
1827 sprintf (cmd, "%s %s -o %s %s", ASM_SWITCHES, as_flags, dest, source);
1840 /* xgettext:c-format */
1841 inform (_("Generating export file: %s"), exp_name);
1843 f = fopen (TMP_ASM, FOPEN_WT);
1845 /* xgettext:c-format */
1846 fatal (_("Unable to open temporary assembler file: %s"), TMP_ASM);
1848 /* xgettext:c-format */
1849 inform (_("Opened temporary file: %s"), TMP_ASM);
1855 fprintf (f, "\t.section .edata\n\n");
1856 fprintf (f, "\t%s 0 %s Allways 0\n", ASM_LONG, ASM_C);
1857 fprintf (f, "\t%s 0x%lx %s Time and date\n", ASM_LONG,
1858 (unsigned long) time(0), ASM_C);
1859 fprintf (f, "\t%s 0 %s Major and Minor version\n", ASM_LONG, ASM_C);
1860 fprintf (f, "\t%sname%s %s Ptr to name of dll\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1861 fprintf (f, "\t%s %d %s Starting ordinal of exports\n", ASM_LONG, d_low_ord, ASM_C);
1864 fprintf (f, "\t%s %d %s Number of functions\n", ASM_LONG, d_high_ord - d_low_ord + 1, ASM_C);
1865 fprintf(f,"\t%s named funcs %d, low ord %d, high ord %d\n",
1867 d_named_nfuncs, d_low_ord, d_high_ord);
1868 fprintf (f, "\t%s %d %s Number of names\n", ASM_LONG,
1869 show_allnames ? d_high_ord - d_low_ord + 1 : d_named_nfuncs, ASM_C);
1870 fprintf (f, "\t%safuncs%s %s Address of functions\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1872 fprintf (f, "\t%sanames%s %s Address of Name Pointer Table\n",
1873 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1875 fprintf (f, "\t%sanords%s %s Address of ordinals\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1877 fprintf (f, "name: %s \"%s\"\n", ASM_TEXT, dll_name);
1880 fprintf(f,"%s Export address Table\n", ASM_C);
1881 fprintf(f,"\t%s\n", ASM_ALIGN_LONG);
1882 fprintf (f, "afuncs:\n");
1885 for (exp = d_exports; exp; exp = exp->next)
1887 if (exp->ordinal != i)
1889 while (i < exp->ordinal)
1891 fprintf(f,"\t%s\t0\n", ASM_LONG);
1896 if (exp->forward == 0)
1898 if (exp->internal_name[0] == '@')
1899 fprintf (f, "\t%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
1900 exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1902 fprintf (f, "\t%s%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
1903 ASM_PREFIX (exp->internal_name),
1904 exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1907 fprintf (f, "\t%sf%d%s\t%s %d\n", ASM_RVA_BEFORE,
1908 exp->forward, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1912 fprintf (f,"%s Export Name Pointer Table\n", ASM_C);
1913 fprintf (f, "anames:\n");
1915 for (i = 0; (exp = d_exports_lexically[i]); i++)
1917 if (!exp->noname || show_allnames)
1918 fprintf (f, "\t%sn%d%s\n",
1919 ASM_RVA_BEFORE, exp->ordinal, ASM_RVA_AFTER);
1922 fprintf (f,"%s Export Ordinal Table\n", ASM_C);
1923 fprintf (f, "anords:\n");
1924 for (i = 0; (exp = d_exports_lexically[i]); i++)
1926 if (!exp->noname || show_allnames)
1927 fprintf (f, "\t%s %d\n", ASM_SHORT, exp->ordinal - d_low_ord);
1930 fprintf(f,"%s Export Name Table\n", ASM_C);
1931 for (i = 0; (exp = d_exports_lexically[i]); i++)
1933 if (!exp->noname || show_allnames)
1934 fprintf (f, "n%d: %s \"%s\"\n",
1935 exp->ordinal, ASM_TEXT, xlate (exp->name));
1936 if (exp->forward != 0)
1937 fprintf (f, "f%d: %s \"%s\"\n",
1938 exp->forward, ASM_TEXT, exp->internal_name);
1943 fprintf (f, "\t.section %s\n", DRECTVE_SECTION_NAME);
1944 for (dl = a_list; dl; dl = dl->next)
1946 fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, dl->text);
1952 fprintf (f, "\t.section .rdata\n");
1953 for (dl = d_list; dl; dl = dl->next)
1958 /* We don't output as ascii because there can
1959 be quote characters in the string. */
1961 for (p = dl->text; *p; p++)
1964 fprintf (f, "\t%s\t", ASM_BYTE);
1967 fprintf (f, "%d", *p);
1970 fprintf (f, ",0\n");
1984 /* Add to the output file a way of getting to the exported names
1985 without using the import library. */
1988 fprintf (f, "\t.section\t.rdata\n");
1989 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1990 if (!exp->noname || show_allnames)
1992 /* We use a single underscore for MS compatibility, and a
1993 double underscore for backward compatibility with old
1995 if (create_compat_implib)
1996 fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name);
1997 fprintf (f, "\t%s\t_imp__%s\n", ASM_GLOBAL, exp->name);
1998 if (create_compat_implib)
1999 fprintf (f, "__imp_%s:\n", exp->name);
2000 fprintf (f, "_imp__%s:\n", exp->name);
2001 fprintf (f, "\t%s\t%s\n", ASM_LONG, exp->name);
2005 /* Dump the reloc section if a base file is provided. */
2009 bfd_vma need[PAGE_SIZE];
2011 bfd_size_type numbytes;
2016 fprintf (f, "\t.section\t.init\n");
2017 fprintf (f, "lab:\n");
2019 fseek (base_file, 0, SEEK_END);
2020 numbytes = ftell (base_file);
2021 fseek (base_file, 0, SEEK_SET);
2022 copy = xmalloc (numbytes);
2023 if (fread (copy, 1, numbytes, base_file) < numbytes)
2024 fatal (_("failed to read the number of entries from base file"));
2025 num_entries = numbytes / sizeof (bfd_vma);
2028 fprintf (f, "\t.section\t.reloc\n");
2033 bfd_vma last = (bfd_vma) -1;
2034 qsort (copy, num_entries, sizeof (bfd_vma), sfunc);
2035 /* Delete duplicates */
2036 for (src = 0; src < num_entries; src++)
2038 if (last != copy[src])
2039 last = copy[dst++] = copy[src];
2043 page_addr = addr & PAGE_MASK; /* work out the page addr */
2045 for (j = 0; j < num_entries; j++)
2048 if ((addr & PAGE_MASK) != page_addr)
2050 flush_page (f, need, page_addr, on_page);
2052 page_addr = addr & PAGE_MASK;
2054 need[on_page++] = addr;
2056 flush_page (f, need, page_addr, on_page);
2058 /* fprintf (f, "\t%s\t0,0\t%s End\n", ASM_LONG, ASM_C);*/
2062 generate_idata_ofile (f);
2066 /* Assemble the file. */
2067 assemble_file (TMP_ASM, exp_name);
2069 if (dontdeltemps == 0)
2072 inform (_("Generated exports file"));
2076 xlate (const char *name)
2078 int lead_at = (*name == '@');
2080 if (!lead_at && (add_underscore
2081 || (add_stdcall_underscore
2082 && strchr (name, '@'))))
2084 char *copy = xmalloc (strlen (name) + 2);
2087 strcpy (copy + 1, name);
2096 p = strchr (name, '@');
2113 unsigned char *data;
2128 #define TEXT_SEC_FLAGS \
2129 (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY | SEC_HAS_CONTENTS)
2130 #define DATA_SEC_FLAGS (SEC_ALLOC | SEC_LOAD | SEC_DATA)
2131 #define BSS_SEC_FLAGS SEC_ALLOC
2133 #define INIT_SEC_DATA(id, name, flags, align) \
2134 { id, name, flags, align, NULL, NULL, NULL, 0, NULL }
2135 static sinfo secdata[NSECS] =
2137 INIT_SEC_DATA (TEXT, ".text", TEXT_SEC_FLAGS, 2),
2138 INIT_SEC_DATA (DATA, ".data", DATA_SEC_FLAGS, 2),
2139 INIT_SEC_DATA (BSS, ".bss", BSS_SEC_FLAGS, 2),
2140 INIT_SEC_DATA (IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2),
2141 INIT_SEC_DATA (IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2),
2142 INIT_SEC_DATA (IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2),
2143 INIT_SEC_DATA (IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1)
2148 /* Sections numbered to make the order the same as other PowerPC NT
2149 compilers. This also keeps funny alignment thingies from happening. */
2162 static sinfo secdata[NSECS] =
2164 { TEXT, ".text", SEC_CODE | SEC_HAS_CONTENTS, 3},
2165 { PDATA, ".pdata", SEC_HAS_CONTENTS, 2},
2166 { RDATA, ".reldata", SEC_HAS_CONTENTS, 2},
2167 { IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2},
2168 { IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2},
2169 { IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1},
2170 { IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2},
2171 { DATA, ".data", SEC_DATA, 2},
2172 { BSS, ".bss", 0, 2}
2177 /* This is what we're trying to make. We generate the imp symbols with
2178 both single and double underscores, for compatibility.
2181 .global _GetFileVersionInfoSizeW@8
2182 .global __imp_GetFileVersionInfoSizeW@8
2183 _GetFileVersionInfoSizeW@8:
2184 jmp * __imp_GetFileVersionInfoSizeW@8
2185 .section .idata$7 # To force loading of head
2186 .long __version_a_head
2187 # Import Address Table
2189 __imp_GetFileVersionInfoSizeW@8:
2192 # Import Lookup Table
2198 .asciz "GetFileVersionInfoSizeW"
2201 For the PowerPC, here's the variation on the above scheme:
2203 # Rather than a simple "jmp *", the code to get to the dll function
2206 lwz r11,[tocv]__imp_function_name(r2)
2207 # RELOC: 00000000 TOCREL16,TOCDEFN __imp_function_name
2215 make_label (const char *prefix, const char *name)
2217 int len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name);
2218 char *copy = xmalloc (len + 1);
2220 strcpy (copy, ASM_PREFIX (name));
2221 strcat (copy, prefix);
2222 strcat (copy, name);
2227 make_imp_label (const char *prefix, const char *name)
2234 len = strlen (prefix) + strlen (name);
2235 copy = xmalloc (len + 1);
2236 strcpy (copy, prefix);
2237 strcat (copy, name);
2241 len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name);
2242 copy = xmalloc (len + 1);
2243 strcpy (copy, prefix);
2244 strcat (copy, ASM_PREFIX (name));
2245 strcat (copy, name);
2251 make_one_lib_file (export_type *exp, int i)
2254 asymbol * exp_label;
2255 asymbol * iname = 0;
2257 asymbol * iname_lab;
2258 asymbol ** iname_lab_pp;
2259 asymbol ** iname_pp;
2268 asymbol * ptrs[NSECS + 4 + EXTRA + 1];
2269 flagword applicable;
2270 char * outname = xmalloc (strlen (TMP_STUB) + 10);
2274 sprintf (outname, "%s%05d.o", TMP_STUB, i);
2276 abfd = bfd_openw (outname, HOW_BFD_WRITE_TARGET);
2279 /* xgettext:c-format */
2280 fatal (_("bfd_open failed open stub file: %s"), outname);
2282 /* xgettext:c-format */
2283 inform (_("Creating stub file: %s"), outname);
2285 bfd_set_format (abfd, bfd_object);
2286 bfd_set_arch_mach (abfd, HOW_BFD_ARCH, 0);
2289 if (machine == MARM_INTERWORK || machine == MTHUMB)
2290 bfd_set_private_flags (abfd, F_INTERWORK);
2293 applicable = bfd_applicable_section_flags (abfd);
2295 /* First make symbols for the sections. */
2296 for (i = 0; i < NSECS; i++)
2298 sinfo *si = secdata + i;
2302 si->sec = bfd_make_section_old_way (abfd, si->name);
2303 bfd_set_section_flags (abfd,
2305 si->flags & applicable);
2307 bfd_set_section_alignment(abfd, si->sec, si->align);
2308 si->sec->output_section = si->sec;
2309 si->sym = bfd_make_empty_symbol(abfd);
2310 si->sym->name = si->sec->name;
2311 si->sym->section = si->sec;
2312 si->sym->flags = BSF_LOCAL;
2314 ptrs[oidx] = si->sym;
2315 si->sympp = ptrs + oidx;
2324 exp_label = bfd_make_empty_symbol (abfd);
2325 exp_label->name = make_imp_label ("", exp->name);
2327 /* On PowerPC, the function name points to a descriptor in
2328 the rdata section, the first element of which is a
2329 pointer to the code (..function_name), and the second
2330 points to the .toc. */
2332 if (machine == MPPC)
2333 exp_label->section = secdata[RDATA].sec;
2336 exp_label->section = secdata[TEXT].sec;
2338 exp_label->flags = BSF_GLOBAL;
2339 exp_label->value = 0;
2342 if (machine == MTHUMB)
2343 bfd_coff_set_symbol_class (abfd, exp_label, C_THUMBEXTFUNC);
2345 ptrs[oidx++] = exp_label;
2348 /* Generate imp symbols with one underscore for Microsoft
2349 compatibility, and with two underscores for backward
2350 compatibility with old versions of cygwin. */
2351 if (create_compat_implib)
2353 iname = bfd_make_empty_symbol (abfd);
2354 iname->name = make_imp_label ("___imp", exp->name);
2355 iname->section = secdata[IDATA5].sec;
2356 iname->flags = BSF_GLOBAL;
2360 iname2 = bfd_make_empty_symbol (abfd);
2361 iname2->name = make_imp_label ("__imp_", exp->name);
2362 iname2->section = secdata[IDATA5].sec;
2363 iname2->flags = BSF_GLOBAL;
2366 iname_lab = bfd_make_empty_symbol (abfd);
2368 iname_lab->name = head_label;
2369 iname_lab->section = (asection *) &bfd_und_section;
2370 iname_lab->flags = 0;
2371 iname_lab->value = 0;
2373 iname_pp = ptrs + oidx;
2374 if (create_compat_implib)
2375 ptrs[oidx++] = iname;
2376 ptrs[oidx++] = iname2;
2378 iname_lab_pp = ptrs + oidx;
2379 ptrs[oidx++] = iname_lab;
2382 /* The symbol referring to the code (.text). */
2384 asymbol *function_name;
2386 function_name = bfd_make_empty_symbol(abfd);
2387 function_name->name = make_label ("..", exp->name);
2388 function_name->section = secdata[TEXT].sec;
2389 function_name->flags = BSF_GLOBAL;
2390 function_name->value = 0;
2392 fn_pp = ptrs + oidx;
2393 ptrs[oidx++] = function_name;
2396 /* The .toc symbol. */
2398 asymbol *toc_symbol;
2400 toc_symbol = bfd_make_empty_symbol (abfd);
2401 toc_symbol->name = make_label (".", "toc");
2402 toc_symbol->section = (asection *)&bfd_und_section;
2403 toc_symbol->flags = BSF_GLOBAL;
2404 toc_symbol->value = 0;
2406 toc_pp = ptrs + oidx;
2407 ptrs[oidx++] = toc_symbol;
2413 for (i = 0; i < NSECS; i++)
2415 sinfo *si = secdata + i;
2416 asection *sec = si->sec;
2425 si->size = HOW_JTAB_SIZE;
2426 si->data = xmalloc (HOW_JTAB_SIZE);
2427 memcpy (si->data, HOW_JTAB, HOW_JTAB_SIZE);
2429 /* Add the reloc into idata$5. */
2430 rel = xmalloc (sizeof (arelent));
2432 rpp = xmalloc (sizeof (arelent *) * 2);
2436 rel->address = HOW_JTAB_ROFF;
2439 if (machine == MPPC)
2441 rel->howto = bfd_reloc_type_lookup (abfd,
2442 BFD_RELOC_16_GOTOFF);
2443 rel->sym_ptr_ptr = iname_pp;
2445 else if (machine == MX86)
2447 rel->howto = bfd_reloc_type_lookup (abfd,
2448 BFD_RELOC_32_PCREL);
2449 rel->sym_ptr_ptr = iname_pp;
2453 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2454 rel->sym_ptr_ptr = secdata[IDATA5].sympp;
2456 sec->orelocation = rpp;
2457 sec->reloc_count = 1;
2462 /* An idata$4 or idata$5 is one word long, and has an
2467 si->data = xmalloc (8);
2471 si->data[0] = exp->ordinal ;
2472 si->data[1] = exp->ordinal >> 8;
2473 si->data[2] = exp->ordinal >> 16;
2474 si->data[3] = exp->ordinal >> 24;
2482 sec->reloc_count = 1;
2483 memset (si->data, 0, si->size);
2484 rel = xmalloc (sizeof (arelent));
2485 rpp = xmalloc (sizeof (arelent *) * 2);
2490 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2491 rel->sym_ptr_ptr = secdata[IDATA6].sympp;
2492 sec->orelocation = rpp;
2497 si->data = xmalloc (4);
2502 si->data[0] = exp->ordinal ;
2503 si->data[1] = exp->ordinal >> 8;
2504 si->data[2] = exp->ordinal >> 16;
2509 sec->reloc_count = 1;
2510 memset (si->data, 0, si->size);
2511 rel = xmalloc (sizeof (arelent));
2512 rpp = xmalloc (sizeof (arelent *) * 2);
2517 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2518 rel->sym_ptr_ptr = secdata[IDATA6].sympp;
2519 sec->orelocation = rpp;
2527 /* This used to add 1 to exp->hint. I don't know
2528 why it did that, and it does not match what I see
2529 in programs compiled with the MS tools. */
2530 int idx = exp->hint;
2531 si->size = strlen (xlate (exp->import_name)) + 3;
2532 si->data = xmalloc (si->size);
2533 si->data[0] = idx & 0xff;
2534 si->data[1] = idx >> 8;
2535 strcpy ((char *) si->data + 2, xlate (exp->import_name));
2540 si->data = xmalloc (4);
2541 memset (si->data, 0, si->size);
2542 rel = xmalloc (sizeof (arelent));
2543 rpp = xmalloc (sizeof (arelent *) * 2);
2547 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2548 rel->sym_ptr_ptr = iname_lab_pp;
2549 sec->orelocation = rpp;
2550 sec->reloc_count = 1;
2556 /* The .pdata section is 5 words long.
2560 bfd_vma BeginAddress, [0x00]
2562 ExceptionHandler, [0x08]
2564 PrologEndAddress; [0x10]
2567 /* So this pdata section setups up this as a glue linkage to
2568 a dll routine. There are a number of house keeping things
2571 1. In the name of glue trickery, the ADDR32 relocs for 0,
2572 4, and 0x10 are set to point to the same place:
2574 2. There is one more reloc needed in the pdata section.
2575 The actual glue instruction to restore the toc on
2576 return is saved as the offset in an IMGLUE reloc.
2577 So we need a total of four relocs for this section.
2579 3. Lastly, the HandlerData field is set to 0x03, to indicate
2580 that this is a glue routine. */
2581 arelent *imglue, *ba_rel, *ea_rel, *pea_rel;
2583 /* Alignment must be set to 2**2 or you get extra stuff. */
2584 bfd_set_section_alignment(abfd, sec, 2);
2587 si->data = xmalloc (si->size);
2588 memset (si->data, 0, si->size);
2589 rpp = xmalloc (sizeof (arelent *) * 5);
2590 rpp[0] = imglue = xmalloc (sizeof (arelent));
2591 rpp[1] = ba_rel = xmalloc (sizeof (arelent));
2592 rpp[2] = ea_rel = xmalloc (sizeof (arelent));
2593 rpp[3] = pea_rel = xmalloc (sizeof (arelent));
2596 /* Stick the toc reload instruction in the glue reloc. */
2597 bfd_put_32(abfd, ppc_glue_insn, (char *) &imglue->address);
2600 imglue->howto = bfd_reloc_type_lookup (abfd,
2601 BFD_RELOC_32_GOTOFF);
2602 imglue->sym_ptr_ptr = fn_pp;
2604 ba_rel->address = 0;
2606 ba_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2607 ba_rel->sym_ptr_ptr = fn_pp;
2609 bfd_put_32 (abfd, 0x18, si->data + 0x04);
2610 ea_rel->address = 4;
2612 ea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2613 ea_rel->sym_ptr_ptr = fn_pp;
2615 /* Mark it as glue. */
2616 bfd_put_32 (abfd, 0x03, si->data + 0x0c);
2618 /* Mark the prolog end address. */
2619 bfd_put_32 (abfd, 0x0D, si->data + 0x10);
2620 pea_rel->address = 0x10;
2621 pea_rel->addend = 0;
2622 pea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2623 pea_rel->sym_ptr_ptr = fn_pp;
2625 sec->orelocation = rpp;
2626 sec->reloc_count = 4;
2630 /* Each external function in a PowerPC PE file has a two word
2631 descriptor consisting of:
2632 1. The address of the code.
2633 2. The address of the appropriate .toc
2634 We use relocs to build this. */
2636 si->data = xmalloc (8);
2637 memset (si->data, 0, si->size);
2639 rpp = xmalloc (sizeof (arelent *) * 3);
2640 rpp[0] = rel = xmalloc (sizeof (arelent));
2641 rpp[1] = xmalloc (sizeof (arelent));
2646 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2647 rel->sym_ptr_ptr = fn_pp;
2653 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2654 rel->sym_ptr_ptr = toc_pp;
2656 sec->orelocation = rpp;
2657 sec->reloc_count = 2;
2659 #endif /* DLLTOOL_PPC */
2665 /* Size up all the sections. */
2666 for (i = 0; i < NSECS; i++)
2668 sinfo *si = secdata + i;
2670 bfd_set_section_size (abfd, si->sec, si->size);
2671 bfd_set_section_vma (abfd, si->sec, vma);
2674 /* Write them out. */
2675 for (i = 0; i < NSECS; i++)
2677 sinfo *si = secdata + i;
2679 if (i == IDATA5 && no_idata5)
2682 if (i == IDATA4 && no_idata4)
2685 bfd_set_section_contents (abfd, si->sec,
2690 bfd_set_symtab (abfd, ptrs, oidx);
2692 abfd = bfd_openr (outname, HOW_BFD_READ_TARGET);
2699 FILE *f = fopen (TMP_HEAD_S, FOPEN_WT);
2703 fatal (_("failed to open temporary head file: %s"), TMP_HEAD_S);
2707 fprintf (f, "%s IMAGE_IMPORT_DESCRIPTOR\n", ASM_C);
2708 fprintf (f, "\t.section .idata$2\n");
2710 fprintf(f,"\t%s\t%s\n", ASM_GLOBAL,head_label);
2712 fprintf (f, "%s:\n", head_label);
2714 fprintf (f, "\t%shname%s\t%sPtr to image import by name list\n",
2715 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
2717 fprintf (f, "\t%sthis should be the timestamp, but NT sometimes\n", ASM_C);
2718 fprintf (f, "\t%sdoesn't load DLLs when this is set.\n", ASM_C);
2719 fprintf (f, "\t%s\t0\t%s loaded time\n", ASM_LONG, ASM_C);
2720 fprintf (f, "\t%s\t0\t%s Forwarder chain\n", ASM_LONG, ASM_C);
2721 fprintf (f, "\t%s__%s_iname%s\t%s imported dll's name\n",
2726 fprintf (f, "\t%sfthunk%s\t%s pointer to firstthunk\n",
2728 ASM_RVA_AFTER, ASM_C);
2730 fprintf (f, "%sStuff for compatibility\n", ASM_C);
2734 fprintf (f, "\t.section\t.idata$5\n");
2735 if (use_nul_prefixed_import_tables)
2738 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
2740 fprintf (f,"\t%s\t0\n", ASM_LONG);
2742 fprintf (f, "fthunk:\n");
2747 fprintf (f, "\t.section\t.idata$4\n");
2748 if (use_nul_prefixed_import_tables)
2751 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
2753 fprintf (f,"\t%s\t0\n", ASM_LONG);
2755 fprintf (f, "hname:\n");
2760 assemble_file (TMP_HEAD_S, TMP_HEAD_O);
2762 return bfd_openr (TMP_HEAD_O, HOW_BFD_READ_TARGET);
2768 FILE *f = fopen (TMP_TAIL_S, FOPEN_WT);
2772 fatal (_("failed to open temporary tail file: %s"), TMP_TAIL_S);
2778 fprintf (f, "\t.section .idata$4\n");
2780 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
2782 fprintf (f,"\t%s\t0\n", ASM_LONG); /* NULL terminating list. */
2787 fprintf (f, "\t.section .idata$5\n");
2789 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
2791 fprintf (f,"\t%s\t0\n", ASM_LONG); /* NULL terminating list. */
2795 /* Normally, we need to see a null descriptor built in idata$3 to
2796 act as the terminator for the list. The ideal way, I suppose,
2797 would be to mark this section as a comdat type 2 section, so
2798 only one would appear in the final .exe (if our linker supported
2799 comdat, that is) or cause it to be inserted by something else (say
2802 fprintf (f, "\t.section .idata$3\n");
2803 fprintf (f, "\t%s\t0\n", ASM_LONG);
2804 fprintf (f, "\t%s\t0\n", ASM_LONG);
2805 fprintf (f, "\t%s\t0\n", ASM_LONG);
2806 fprintf (f, "\t%s\t0\n", ASM_LONG);
2807 fprintf (f, "\t%s\t0\n", ASM_LONG);
2811 /* Other PowerPC NT compilers use idata$6 for the dllname, so I
2812 do too. Original, huh? */
2813 fprintf (f, "\t.section .idata$6\n");
2815 fprintf (f, "\t.section .idata$7\n");
2818 fprintf (f, "\t%s\t__%s_iname\n", ASM_GLOBAL, imp_name_lab);
2819 fprintf (f, "__%s_iname:\t%s\t\"%s\"\n",
2820 imp_name_lab, ASM_TEXT, dll_name);
2824 assemble_file (TMP_TAIL_S, TMP_TAIL_O);
2826 return bfd_openr (TMP_TAIL_O, HOW_BFD_READ_TARGET);
2841 outarch = bfd_openw (imp_name, HOW_BFD_WRITE_TARGET);
2844 /* xgettext:c-format */
2845 fatal (_("Can't open .lib file: %s"), imp_name);
2847 /* xgettext:c-format */
2848 inform (_("Creating library file: %s"), imp_name);
2850 bfd_set_format (outarch, bfd_archive);
2851 outarch->has_armap = 1;
2852 outarch->is_thin_archive = 0;
2854 /* Work out a reasonable size of things to put onto one line. */
2855 ar_head = make_head ();
2856 ar_tail = make_tail();
2858 if (ar_head == NULL || ar_tail == NULL)
2861 for (i = 0; (exp = d_exports_lexically[i]); i++)
2864 /* Don't add PRIVATE entries to import lib. */
2867 n = make_one_lib_file (exp, i);
2868 n->archive_next = head;
2870 if (ext_prefix_alias)
2872 export_type alias_exp;
2874 assert (i < PREFIX_ALIAS_BASE);
2875 alias_exp.name = make_imp_label (ext_prefix_alias, exp->name);
2876 alias_exp.internal_name = exp->internal_name;
2877 alias_exp.import_name = exp->name;
2878 alias_exp.ordinal = exp->ordinal;
2879 alias_exp.constant = exp->constant;
2880 alias_exp.noname = exp->noname;
2881 alias_exp.private = exp->private;
2882 alias_exp.data = exp->data;
2883 alias_exp.hint = exp->hint;
2884 alias_exp.forward = exp->forward;
2885 alias_exp.next = exp->next;
2886 n = make_one_lib_file (&alias_exp, i + PREFIX_ALIAS_BASE);
2887 n->archive_next = head;
2892 /* Now stick them all into the archive. */
2893 ar_head->archive_next = head;
2894 ar_tail->archive_next = ar_head;
2897 if (! bfd_set_archive_head (outarch, head))
2898 bfd_fatal ("bfd_set_archive_head");
2900 if (! bfd_close (outarch))
2901 bfd_fatal (imp_name);
2903 while (head != NULL)
2905 bfd *n = head->archive_next;
2910 /* Delete all the temp files. */
2911 if (dontdeltemps == 0)
2913 unlink (TMP_HEAD_O);
2914 unlink (TMP_HEAD_S);
2915 unlink (TMP_TAIL_O);
2916 unlink (TMP_TAIL_S);
2919 if (dontdeltemps < 2)
2923 name = (char *) alloca (strlen (TMP_STUB) + 10);
2924 for (i = 0; (exp = d_exports_lexically[i]); i++)
2926 /* Don't delete non-existent stubs for PRIVATE entries. */
2929 sprintf (name, "%s%05d.o", TMP_STUB, i);
2930 if (unlink (name) < 0)
2931 /* xgettext:c-format */
2932 non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
2933 if (ext_prefix_alias)
2935 sprintf (name, "%s%05d.o", TMP_STUB, i + PREFIX_ALIAS_BASE);
2936 if (unlink (name) < 0)
2937 /* xgettext:c-format */
2938 non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
2943 inform (_("Created lib file"));
2946 /* identify_dll_for_implib
2948 This is the main implementation for the --identify option.
2949 Given the name of an import library in identify_imp_name,
2950 search all archive members for an .idata$7 section
2951 (.idata$6 on PPC). This section will consist of a single
2952 char* constant, indicating the name of the DLL represented
2953 by the import library.
2955 It is possible to construct an import library that has
2956 two members with a non-empty .idata$7 section, but these
2957 are not often seen in normal operation. In this case,
2958 an error is flagged.
2961 identify_dll_for_implib (void)
2967 abfd = bfd_openr (identify_imp_name, 0);
2970 bfd_fatal (identify_imp_name);
2972 if (!bfd_check_format (abfd, bfd_archive))
2974 if (!bfd_close (abfd))
2975 bfd_fatal (identify_imp_name);
2977 fatal ("%s is not a library", identify_imp_name);
2980 identify_search_archive (abfd);
2982 if (!bfd_close (abfd))
2983 bfd_fatal (identify_imp_name);
2985 if (identify_dll_name && *identify_dll_name)
2987 printf ("%s\n",identify_dll_name);
2988 free (identify_dll_name);
2989 identify_dll_name = NULL;
2993 fatal ("Unable to determine dll name for %s (not an import library?)", identify_imp_name);
2997 /* identify_search_archive
2999 Loop over all members of the archive, inspecting
3000 each for the presence of an .idata$7 (.idata$6 on PPC)
3001 section with non-empty contents.
3004 identify_search_archive (bfd* abfd)
3007 bfd *last_arfile = NULL;
3012 arfile = bfd_openr_next_archived_file (abfd, arfile);
3016 if (bfd_get_error () != bfd_error_no_more_archived_files)
3017 bfd_fatal (bfd_get_filename (abfd));
3020 if (bfd_check_format_matches (arfile, bfd_object, &matching))
3022 identify_search_member (arfile, abfd);
3026 bfd_nonfatal (bfd_get_filename (arfile));
3029 if (last_arfile != NULL)
3031 bfd_close (last_arfile);
3033 last_arfile = arfile;
3036 if (last_arfile != NULL)
3038 bfd_close (last_arfile);
3042 /* identify_search_member
3044 Search all sections of an archive member for the
3045 one with section name of .idata$7 (.idata$6 on PPC)
3046 and non-empty contents.
3049 identify_search_member (bfd* abfd, bfd* archive_bfd ATTRIBUTE_UNUSED)
3051 bfd_map_over_sections (abfd, identify_search_section, NULL);
3054 /* identify_process_section_p
3056 This predicate returns true if section->name
3057 is .idata$7 (.idata$6 on PPC).
3060 identify_process_section_p (asection * section)
3062 static const char * SECTION_NAME =
3064 /* dllname is stored in idata$6 on PPC */
3070 if (strcmp (SECTION_NAME, section->name) == 0)
3075 /* identify_search_section
3077 If *section has contents and its name is .idata$7
3078 (.data$6 on PPC) then store the contents in
3079 identify_dll_name as an xmalloc'ed array.
3081 However, if identify_dll_name already has
3082 a value, flag an error. We don't know how to handle
3083 import libraries that directly reference more than
3084 one DLL. (This is different than forwarded symbols.
3085 Such import libraries are not seen in normal operation,
3086 and must be specifically constructed.)
3089 identify_search_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
3092 bfd_size_type datasize;
3094 if ((section->flags & SEC_HAS_CONTENTS) == 0)
3097 if (! identify_process_section_p (section))
3100 if ((datasize = bfd_section_size (abfd, section)) == 0)
3103 data = (bfd_byte*) xmalloc (datasize + 1);
3106 bfd_get_section_contents (abfd, section, data, 0, datasize);
3107 data[datasize] = '\0';
3109 if (data[0] != '\0')
3111 if (identify_dll_name != NULL)
3113 if (*identify_dll_name != '\0')
3115 /* The import library specifies two different DLLs.
3116 Treat this as an error. */
3117 fatal ("Import library `%s' specifies two or more dlls: `%s' and `%s'",
3118 identify_imp_name, identify_dll_name, data);
3122 /* For some reason memory was allocated, but the
3123 contents were empty. Free the memory and continue. */
3124 free (identify_dll_name);
3127 identify_dll_name = xstrdup ((char*) data);
3133 /* Run through the information gathered from the .o files and the
3134 .def file and work out the best stuff. */
3137 pfunc (const void *a, const void *b)
3139 export_type *ap = *(export_type **) a;
3140 export_type *bp = *(export_type **) b;
3141 if (ap->ordinal == bp->ordinal)
3144 /* Unset ordinals go to the bottom. */
3145 if (ap->ordinal == -1)
3147 if (bp->ordinal == -1)
3149 return (ap->ordinal - bp->ordinal);
3153 nfunc (const void *a, const void *b)
3155 export_type *ap = *(export_type **) a;
3156 export_type *bp = *(export_type **) b;
3157 const char *an = ap->name;
3158 const char *bn = bp->name;
3162 an = (an[0] == '@') ? an + 1 : an;
3163 bn = (bn[0] == '@') ? bn + 1 : bn;
3166 return (strcmp (an, bn));
3170 remove_null_names (export_type **ptr)
3175 for (dst = src = 0; src < d_nfuncs; src++)
3179 ptr[dst] = ptr[src];
3187 process_duplicates (export_type **d_export_vec)
3195 /* Remove duplicates. */
3196 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), nfunc);
3198 for (i = 0; i < d_nfuncs - 1; i++)
3200 if (strcmp (d_export_vec[i]->name,
3201 d_export_vec[i + 1]->name) == 0)
3203 export_type *a = d_export_vec[i];
3204 export_type *b = d_export_vec[i + 1];
3208 /* xgettext:c-format */
3209 inform (_("Warning, ignoring duplicate EXPORT %s %d,%d"),
3210 a->name, a->ordinal, b->ordinal);
3212 if (a->ordinal != -1
3213 && b->ordinal != -1)
3214 /* xgettext:c-format */
3215 fatal (_("Error, duplicate EXPORT with ordinals: %s"),
3218 /* Merge attributes. */
3219 b->ordinal = a->ordinal > 0 ? a->ordinal : b->ordinal;
3220 b->constant |= a->constant;
3221 b->noname |= a->noname;
3223 d_export_vec[i] = 0;
3226 remove_null_names (d_export_vec);
3230 /* Count the names. */
3231 for (i = 0; i < d_nfuncs; i++)
3232 if (!d_export_vec[i]->noname)
3237 fill_ordinals (export_type **d_export_vec)
3244 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
3246 /* Fill in the unset ordinals with ones from our range. */
3247 ptr = (char *) xmalloc (size);
3249 memset (ptr, 0, size);
3251 /* Mark in our large vector all the numbers that are taken. */
3252 for (i = 0; i < d_nfuncs; i++)
3254 if (d_export_vec[i]->ordinal != -1)
3256 ptr[d_export_vec[i]->ordinal] = 1;
3258 if (lowest == -1 || d_export_vec[i]->ordinal < lowest)
3259 lowest = d_export_vec[i]->ordinal;
3263 /* Start at 1 for compatibility with MS toolchain. */
3267 /* Now fill in ordinals where the user wants us to choose. */
3268 for (i = 0; i < d_nfuncs; i++)
3270 if (d_export_vec[i]->ordinal == -1)
3274 /* First try within or after any user supplied range. */
3275 for (j = lowest; j < size; j++)
3279 d_export_vec[i]->ordinal = j;
3283 /* Then try before the range. */
3284 for (j = lowest; j >0; j--)
3288 d_export_vec[i]->ordinal = j;
3298 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
3300 /* Work out the lowest and highest ordinal numbers. */
3303 if (d_export_vec[0])
3304 d_low_ord = d_export_vec[0]->ordinal;
3305 if (d_export_vec[d_nfuncs-1])
3306 d_high_ord = d_export_vec[d_nfuncs-1]->ordinal;
3313 /* First work out the minimum ordinal chosen. */
3318 export_type **d_export_vec = xmalloc (sizeof (export_type *) * d_nfuncs);
3320 inform (_("Processing definitions"));
3322 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3323 d_export_vec[i] = exp;
3325 process_duplicates (d_export_vec);
3326 fill_ordinals (d_export_vec);
3328 /* Put back the list in the new order. */
3330 for (i = d_nfuncs - 1; i >= 0; i--)
3332 d_export_vec[i]->next = d_exports;
3333 d_exports = d_export_vec[i];
3336 /* Build list in alpha order. */
3337 d_exports_lexically = (export_type **)
3338 xmalloc (sizeof (export_type *) * (d_nfuncs + 1));
3340 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3341 d_exports_lexically[i] = exp;
3343 d_exports_lexically[i] = 0;
3345 qsort (d_exports_lexically, i, sizeof (export_type *), nfunc);
3347 /* Fill exp entries with their hint values. */
3348 for (i = 0; i < d_nfuncs; i++)
3349 if (!d_exports_lexically[i]->noname || show_allnames)
3350 d_exports_lexically[i]->hint = hint++;
3352 inform (_("Processed definitions"));
3356 usage (FILE *file, int status)
3358 /* xgetext:c-format */
3359 fprintf (file, _("Usage %s <option(s)> <object-file(s)>\n"), program_name);
3360 /* xgetext:c-format */
3361 fprintf (file, _(" -m --machine <machine> Create as DLL for <machine>. [default: %s]\n"), mname);
3362 fprintf (file, _(" possible <machine>: arm[_interwork], i386, mcore[-elf]{-le|-be}, ppc, thumb\n"));
3363 fprintf (file, _(" -e --output-exp <outname> Generate an export file.\n"));
3364 fprintf (file, _(" -l --output-lib <outname> Generate an interface library.\n"));
3365 fprintf (file, _(" -a --add-indirect Add dll indirects to export file.\n"));
3366 fprintf (file, _(" -D --dllname <name> Name of input dll to put into interface lib.\n"));
3367 fprintf (file, _(" -d --input-def <deffile> Name of .def file to be read in.\n"));
3368 fprintf (file, _(" -z --output-def <deffile> Name of .def file to be created.\n"));
3369 fprintf (file, _(" --export-all-symbols Export all symbols to .def\n"));
3370 fprintf (file, _(" --no-export-all-symbols Only export listed symbols\n"));
3371 fprintf (file, _(" --exclude-symbols <list> Don't export <list>\n"));
3372 fprintf (file, _(" --no-default-excludes Clear default exclude symbols\n"));
3373 fprintf (file, _(" -b --base-file <basefile> Read linker generated base file.\n"));
3374 fprintf (file, _(" -x --no-idata4 Don't generate idata$4 section.\n"));
3375 fprintf (file, _(" -c --no-idata5 Don't generate idata$5 section.\n"));
3376 fprintf (file, _(" --use-nul-prefixed-import-tables Use zero prefixed idata$4 and idata$5.\n"));
3377 fprintf (file, _(" -U --add-underscore Add underscores to all symbols in interface library.\n"));
3378 fprintf (file, _(" --add-stdcall-underscore Add underscores to stdcall symbols in interface library.\n"));
3379 fprintf (file, _(" -k --kill-at Kill @<n> from exported names.\n"));
3380 fprintf (file, _(" -A --add-stdcall-alias Add aliases without @<n>.\n"));
3381 fprintf (file, _(" -p --ext-prefix-alias <prefix> Add aliases with <prefix>.\n"));
3382 fprintf (file, _(" -S --as <name> Use <name> for assembler.\n"));
3383 fprintf (file, _(" -f --as-flags <flags> Pass <flags> to the assembler.\n"));
3384 fprintf (file, _(" -C --compat-implib Create backward compatible import library.\n"));
3385 fprintf (file, _(" -n --no-delete Keep temp files (repeat for extra preservation).\n"));
3386 fprintf (file, _(" -t --temp-prefix <prefix> Use <prefix> to construct temp file names.\n"));
3387 fprintf (file, _(" -I --identify <implib> Report the name of the DLL associated with <implib>.\n"));
3388 fprintf (file, _(" -v --verbose Be verbose.\n"));
3389 fprintf (file, _(" -V --version Display the program version.\n"));
3390 fprintf (file, _(" -h --help Display this information.\n"));
3391 fprintf (file, _(" @<file> Read options from <file>.\n"));
3392 #ifdef DLLTOOL_MCORE_ELF
3393 fprintf (file, _(" -M --mcore-elf <outname> Process mcore-elf object files into <outname>.\n"));
3394 fprintf (file, _(" -L --linker <name> Use <name> as the linker.\n"));
3395 fprintf (file, _(" -F --linker-flags <flags> Pass <flags> to the linker.\n"));
3397 if (REPORT_BUGS_TO[0] && status == 0)
3398 fprintf (file, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3402 #define OPTION_EXPORT_ALL_SYMS 150
3403 #define OPTION_NO_EXPORT_ALL_SYMS (OPTION_EXPORT_ALL_SYMS + 1)
3404 #define OPTION_EXCLUDE_SYMS (OPTION_NO_EXPORT_ALL_SYMS + 1)
3405 #define OPTION_NO_DEFAULT_EXCLUDES (OPTION_EXCLUDE_SYMS + 1)
3406 #define OPTION_ADD_STDCALL_UNDERSCORE (OPTION_NO_DEFAULT_EXCLUDES + 1)
3407 #define OPTION_USE_NUL_PREFIXED_IMPORT_TABLES \
3408 (OPTION_ADD_STDCALL_UNDERSCORE + 1)
3410 static const struct option long_options[] =
3412 {"no-delete", no_argument, NULL, 'n'},
3413 {"dllname", required_argument, NULL, 'D'},
3414 {"no-idata4", no_argument, NULL, 'x'},
3415 {"no-idata5", no_argument, NULL, 'c'},
3416 {"use-nul-prefixed-import-tables", no_argument, NULL,
3417 OPTION_USE_NUL_PREFIXED_IMPORT_TABLES},
3418 {"output-exp", required_argument, NULL, 'e'},
3419 {"output-def", required_argument, NULL, 'z'},
3420 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL_SYMS},
3421 {"no-export-all-symbols", no_argument, NULL, OPTION_NO_EXPORT_ALL_SYMS},
3422 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMS},
3423 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
3424 {"output-lib", required_argument, NULL, 'l'},
3425 {"def", required_argument, NULL, 'd'}, /* for compatibility with older versions */
3426 {"input-def", required_argument, NULL, 'd'},
3427 {"add-underscore", no_argument, NULL, 'U'},
3428 {"add-stdcall-underscore", no_argument, NULL, OPTION_ADD_STDCALL_UNDERSCORE},
3429 {"kill-at", no_argument, NULL, 'k'},
3430 {"add-stdcall-alias", no_argument, NULL, 'A'},
3431 {"ext-prefix-alias", required_argument, NULL, 'p'},
3432 {"identify", required_argument, NULL, 'I'},
3433 {"verbose", no_argument, NULL, 'v'},
3434 {"version", no_argument, NULL, 'V'},
3435 {"help", no_argument, NULL, 'h'},
3436 {"machine", required_argument, NULL, 'm'},
3437 {"add-indirect", no_argument, NULL, 'a'},
3438 {"base-file", required_argument, NULL, 'b'},
3439 {"as", required_argument, NULL, 'S'},
3440 {"as-flags", required_argument, NULL, 'f'},
3441 {"mcore-elf", required_argument, NULL, 'M'},
3442 {"compat-implib", no_argument, NULL, 'C'},
3443 {"temp-prefix", required_argument, NULL, 't'},
3447 int main (int, char **);
3450 main (int ac, char **av)
3455 program_name = av[0];
3458 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
3459 setlocale (LC_MESSAGES, "");
3461 #if defined (HAVE_SETLOCALE)
3462 setlocale (LC_CTYPE, "");
3464 bindtextdomain (PACKAGE, LOCALEDIR);
3465 textdomain (PACKAGE);
3467 expandargv (&ac, &av);
3469 while ((c = getopt_long (ac, av,
3470 #ifdef DLLTOOL_MCORE_ELF
3471 "m:e:l:aD:d:z:b:xp:cCuUkAS:f:nI:vVHhM:L:F:",
3473 "m:e:l:aD:d:z:b:xp:cCuUkAS:f:nI:vVHh",
3480 case OPTION_EXPORT_ALL_SYMS:
3481 export_all_symbols = TRUE;
3483 case OPTION_NO_EXPORT_ALL_SYMS:
3484 export_all_symbols = FALSE;
3486 case OPTION_EXCLUDE_SYMS:
3487 add_excludes (optarg);
3489 case OPTION_NO_DEFAULT_EXCLUDES:
3490 do_default_excludes = FALSE;
3492 case OPTION_USE_NUL_PREFIXED_IMPORT_TABLES:
3493 use_nul_prefixed_import_tables = TRUE;
3495 case OPTION_ADD_STDCALL_UNDERSCORE:
3496 add_stdcall_underscore = 1;
3508 tmp_prefix = optarg;
3514 /* Ignored for compatibility. */
3521 output_def = fopen (optarg, FOPEN_WT);
3524 dll_name = (char*) lbasename (optarg);
3525 if (dll_name != optarg)
3526 non_fatal (_("Path components stripped from dllname, '%s'."),
3543 identify_imp_name = optarg;
3549 print_version (program_name);
3558 add_stdcall_alias = 1;
3561 ext_prefix_alias = optarg;
3570 base_file = fopen (optarg, FOPEN_RB);
3573 /* xgettext:c-format */
3574 fatal (_("Unable to open base-file: %s"), optarg);
3577 #ifdef DLLTOOL_MCORE_ELF
3579 mcore_elf_out_file = optarg;
3582 mcore_elf_linker = optarg;
3585 mcore_elf_linker_flags = optarg;
3589 create_compat_implib = 1;
3598 tmp_prefix = prefix_encode ("d", getpid ());
3600 for (i = 0; mtable[i].type; i++)
3601 if (strcmp (mtable[i].type, mname) == 0)
3604 if (!mtable[i].type)
3605 /* xgettext:c-format */
3606 fatal (_("Machine '%s' not supported"), mname);
3610 /* Check if we generated PE+. */
3611 create_for_pep = strcmp (mname, "i386:x86-64") == 0;
3613 if (!dll_name && exp_name)
3615 /* If we are inferring dll_name from exp_name,
3616 strip off any path components, without emitting
3618 const char* exp_basename = lbasename (exp_name);
3619 const int len = strlen (exp_basename) + 5;
3620 dll_name = xmalloc (len);
3621 strcpy (dll_name, exp_basename);
3622 strcat (dll_name, ".dll");
3625 if (as_name == NULL)
3626 as_name = deduce_name ("as");
3628 /* Don't use the default exclude list if we're reading only the
3629 symbols in the .drectve section. The default excludes are meant
3630 to avoid exporting DLL entry point and Cygwin32 impure_ptr. */
3631 if (! export_all_symbols)
3632 do_default_excludes = FALSE;
3634 if (do_default_excludes)
3635 set_default_excludes ();
3638 process_def_file (def_file);
3643 firstarg = av[optind];
3644 scan_obj_file (av[optind]);
3655 /* Make imp_name safe for use as a label. */
3658 imp_name_lab = xstrdup (imp_name);
3659 for (p = imp_name_lab; *p; p++)
3664 head_label = make_label("_head_", imp_name_lab);
3671 if (identify_imp_name)
3673 identify_dll_for_implib ();
3676 #ifdef DLLTOOL_MCORE_ELF
3677 if (mcore_elf_out_file)
3678 mcore_elf_gen_out_file ();
3684 /* Look for the program formed by concatenating PROG_NAME and the
3685 string running from PREFIX to END_PREFIX. If the concatenated
3686 string contains a '/', try appending EXECUTABLE_SUFFIX if it is
3690 look_for_prog (const char *prog_name, const char *prefix, int end_prefix)
3695 cmd = xmalloc (strlen (prefix)
3696 + strlen (prog_name)
3697 #ifdef HAVE_EXECUTABLE_SUFFIX
3698 + strlen (EXECUTABLE_SUFFIX)
3701 strcpy (cmd, prefix);
3703 sprintf (cmd + end_prefix, "%s", prog_name);
3705 if (strchr (cmd, '/') != NULL)
3709 found = (stat (cmd, &s) == 0
3710 #ifdef HAVE_EXECUTABLE_SUFFIX
3711 || stat (strcat (cmd, EXECUTABLE_SUFFIX), &s) == 0
3717 /* xgettext:c-format */
3718 inform (_("Tried file: %s"), cmd);
3724 /* xgettext:c-format */
3725 inform (_("Using file: %s"), cmd);
3730 /* Deduce the name of the program we are want to invoke.
3731 PROG_NAME is the basic name of the program we want to run,
3732 eg "as" or "ld". The catch is that we might want actually
3733 run "i386-pe-as" or "ppc-pe-ld".
3735 If argv[0] contains the full path, then try to find the program
3736 in the same place, with and then without a target-like prefix.
3738 Given, argv[0] = /usr/local/bin/i586-cygwin32-dlltool,
3739 deduce_name("as") uses the following search order:
3741 /usr/local/bin/i586-cygwin32-as
3745 If there's an EXECUTABLE_SUFFIX, it'll use that as well; for each
3746 name, it'll try without and then with EXECUTABLE_SUFFIX.
3748 Given, argv[0] = i586-cygwin32-dlltool, it will not even try "as"
3749 as the fallback, but rather return i586-cygwin32-as.
3751 Oh, and given, argv[0] = dlltool, it'll return "as".
3753 Returns a dynamically allocated string. */
3756 deduce_name (const char *prog_name)
3759 char *dash, *slash, *cp;
3763 for (cp = program_name; *cp != '\0'; ++cp)
3768 #if defined(__DJGPP__) || defined (__CYGWIN__) || defined(__WIN32__)
3769 *cp == ':' || *cp == '\\' ||
3782 /* First, try looking for a prefixed PROG_NAME in the
3783 PROGRAM_NAME directory, with the same prefix as PROGRAM_NAME. */
3784 cmd = look_for_prog (prog_name, program_name, dash - program_name + 1);
3787 if (slash != NULL && cmd == NULL)
3789 /* Next, try looking for a PROG_NAME in the same directory as
3790 that of this program. */
3791 cmd = look_for_prog (prog_name, program_name, slash - program_name + 1);
3796 /* Just return PROG_NAME as is. */
3797 cmd = xstrdup (prog_name);
3803 #ifdef DLLTOOL_MCORE_ELF
3804 typedef struct fname_cache
3806 const char * filename;
3807 struct fname_cache * next;
3811 static fname_cache fnames;
3814 mcore_elf_cache_filename (const char * filename)
3820 while (ptr->next != NULL)
3823 ptr->filename = filename;
3824 ptr->next = (fname_cache *) malloc (sizeof (fname_cache));
3825 if (ptr->next != NULL)
3826 ptr->next->next = NULL;
3829 #define MCORE_ELF_TMP_OBJ "mcoreelf.o"
3830 #define MCORE_ELF_TMP_EXP "mcoreelf.exp"
3831 #define MCORE_ELF_TMP_LIB "mcoreelf.lib"
3834 mcore_elf_gen_out_file (void)
3839 /* Step one. Run 'ld -r' on the input object files in order to resolve
3840 any internal references and to generate a single .exports section. */
3843 ds = dyn_string_new (100);
3844 dyn_string_append_cstr (ds, "-r ");
3846 if (mcore_elf_linker_flags != NULL)
3847 dyn_string_append_cstr (ds, mcore_elf_linker_flags);
3849 while (ptr->next != NULL)
3851 dyn_string_append_cstr (ds, ptr->filename);
3852 dyn_string_append_cstr (ds, " ");
3857 dyn_string_append_cstr (ds, "-o ");
3858 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
3860 if (mcore_elf_linker == NULL)
3861 mcore_elf_linker = deduce_name ("ld");
3863 run (mcore_elf_linker, ds->s);
3865 dyn_string_delete (ds);
3867 /* Step two. Create a .exp file and a .lib file from the temporary file.
3868 Do this by recursively invoking dlltool... */
3869 ds = dyn_string_new (100);
3871 dyn_string_append_cstr (ds, "-S ");
3872 dyn_string_append_cstr (ds, as_name);
3874 dyn_string_append_cstr (ds, " -e ");
3875 dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP);
3876 dyn_string_append_cstr (ds, " -l ");
3877 dyn_string_append_cstr (ds, MCORE_ELF_TMP_LIB);
3878 dyn_string_append_cstr (ds, " " );
3879 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
3882 dyn_string_append_cstr (ds, " -v");
3886 dyn_string_append_cstr (ds, " -n");
3888 if (dontdeltemps > 1)
3889 dyn_string_append_cstr (ds, " -n");
3892 /* XXX - FIME: ought to check/copy other command line options as well. */
3893 run (program_name, ds->s);
3895 dyn_string_delete (ds);
3897 /* Step four. Feed the .exp and object files to ld -shared to create the dll. */
3898 ds = dyn_string_new (100);
3900 dyn_string_append_cstr (ds, "-shared ");
3902 if (mcore_elf_linker_flags)
3903 dyn_string_append_cstr (ds, mcore_elf_linker_flags);
3905 dyn_string_append_cstr (ds, " ");
3906 dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP);
3907 dyn_string_append_cstr (ds, " ");
3908 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
3909 dyn_string_append_cstr (ds, " -o ");
3910 dyn_string_append_cstr (ds, mcore_elf_out_file);
3912 run (mcore_elf_linker, ds->s);
3914 dyn_string_delete (ds);
3916 if (dontdeltemps == 0)
3917 unlink (MCORE_ELF_TMP_EXP);
3919 if (dontdeltemps < 2)
3920 unlink (MCORE_ELF_TMP_OBJ);
3922 #endif /* DLLTOOL_MCORE_ELF */