1 /* dlltool.c -- tool to generate stuff for PE style DLLs
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
23 /* This program allows you to build the files necessary to create
24 DLLs to run on a system which understands PE format image files.
27 See "Peering Inside the PE: A Tour of the Win32 Portable Executable
28 File Format", MSJ 1994, Volume 9 for more information.
29 Also see "Microsoft Portable Executable and Common Object File Format,
30 Specification 4.1" for more information.
32 A DLL contains an export table which contains the information
33 which the runtime loader needs to tie up references from a
36 The export table is generated by this program by reading
37 in a .DEF file or scanning the .a and .o files which will be in the
38 DLL. A .o file can contain information in special ".drectve" sections
39 with export information.
41 A DEF file contains any number of the following commands:
44 NAME <name> [ , <base> ]
45 The result is going to be <name>.EXE
47 LIBRARY <name> [ , <base> ]
48 The result is going to be <name>.DLL
50 EXPORTS ( ( ( <name1> [ = <name2> ] )
51 | ( <name1> = <module-name> . <external-name>))
52 [ @ <integer> ] [ NONAME ] [CONSTANT] [DATA] [PRIVATE] ) *
53 Declares name1 as an exported symbol from the
54 DLL, with optional ordinal number <integer>.
55 Or declares name1 as an alias (forward) of the function <external-name>
56 in the DLL <module-name>.
58 IMPORTS ( ( <internal-name> = <module-name> . <integer> )
59 | ( [ <internal-name> = ] <module-name> . <external-name> )) *
60 Declares that <external-name> or the exported function whose ordinal number
61 is <integer> is to be imported from the file <module-name>. If
62 <internal-name> is specified then this is the name that the imported
63 function will be refereed to in the body of the DLL.
66 Puts <string> into output .exp file in the .rdata section
68 [STACKSIZE|HEAPSIZE] <number-reserve> [ , <number-commit> ]
69 Generates --stack|--heap <number-reserve>,<number-commit>
70 in the output .drectve section. The linker will
71 see this and act upon it.
74 SECTIONS ( <sectionname> <attr>+ )*
75 <attr> = READ | WRITE | EXECUTE | SHARED
76 Generates --attr <sectionname> <attr> in the output
77 .drectve section. The linker will see this and act
81 A -export:<name> in a .drectve section in an input .o or .a
82 file to this program is equivalent to a EXPORTS <name>
87 The program generates output files with the prefix supplied
88 on the command line, or in the def file, or taken from the first
91 The .exp.s file contains the information necessary to export
92 the routines in the DLL. The .lib.s file contains the information
93 necessary to use the DLL's routines from a referencing program.
100 asm (".section .drectve");
101 asm (".ascii \"-export:adef\"");
105 printf ("hello from the dll %s\n", s);
110 printf ("hello from the dll and the other entry point %s\n", s);
114 asm (".section .drectve");
115 asm (".ascii \"-export:cdef\"");
116 asm (".ascii \"-export:ddef\"");
120 printf ("hello from the dll %s\n", s);
125 printf ("hello from the dll and the other entry point %s\n", s);
143 HEAPSIZE 0x40000, 0x2000
147 SECTIONS donkey READ WRITE
150 # Compile up the parts of the dll and the program
152 gcc -c file1.c file2.c themain.c
154 # Optional: put the dll objects into a library
155 # (you don't have to, you could name all the object
156 # files on the dlltool line)
158 ar qcv thedll.in file1.o file2.o
161 # Run this tool over the DLL's .def file and generate an exports
162 # file (thedll.o) and an imports file (thedll.a).
163 # (You may have to use -S to tell dlltool where to find the assembler).
165 dlltool --def thedll.def --output-exp thedll.o --output-lib thedll.a
167 # Build the dll with the library and the export table
169 ld -o thedll.dll thedll.o thedll.in
171 # Link the executable with the import library
173 gcc -o themain.exe themain.o thedll.a
175 This example can be extended if relocations are needed in the DLL:
177 # Compile up the parts of the dll and the program
179 gcc -c file1.c file2.c themain.c
181 # Run this tool over the DLL's .def file and generate an imports file.
183 dlltool --def thedll.def --output-lib thedll.lib
185 # Link the executable with the import library and generate a base file
188 gcc -o themain.exe themain.o thedll.lib -Wl,--base-file -Wl,themain.base
190 # Run this tool over the DLL's .def file and generate an exports file
191 # which includes the relocations from the base file.
193 dlltool --def thedll.def --base-file themain.base --output-exp thedll.exp
195 # Build the dll with file1.o, file2.o and the export table
197 ld -o thedll.dll thedll.exp file1.o file2.o */
199 /* .idata section description
201 The .idata section is the import table. It is a collection of several
202 subsections used to keep the pieces for each dll together: .idata$[234567].
203 IE: Each dll's .idata$2's are catenated together, each .idata$3's, etc.
205 .idata$2 = Import Directory Table
206 = array of IMAGE_IMPORT_DESCRIPTOR's.
208 DWORD Import Lookup Table; - pointer to .idata$4
209 DWORD TimeDateStamp; - currently always 0
210 DWORD ForwarderChain; - currently always 0
211 DWORD Name; - pointer to dll's name
212 PIMAGE_THUNK_DATA FirstThunk; - pointer to .idata$5
214 .idata$3 = null terminating entry for .idata$2.
216 .idata$4 = Import Lookup Table
217 = array of array of pointers to hint name table.
218 There is one for each dll being imported from, and each dll's set is
219 terminated by a trailing NULL.
221 .idata$5 = Import Address Table
222 = array of array of pointers to hint name table.
223 There is one for each dll being imported from, and each dll's set is
224 terminated by a trailing NULL.
225 Initially, this table is identical to the Import Lookup Table. However,
226 at load time, the loader overwrites the entries with the address of the
229 .idata$6 = Hint Name Table
230 = Array of { short, asciz } entries, one for each imported function.
231 The `short' is the function's ordinal number.
233 .idata$7 = dll name (eg: "kernel32.dll"). (.idata$6 for ppc). */
235 /* AIX requires this to be the first thing in the file. */
242 #define show_allnames 0
244 #define PAGE_SIZE ((bfd_vma) 4096)
245 #define PAGE_MASK ((bfd_vma) (-4096))
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 bfd_boolean identify_strict;
358 /* Types used to implement a linked list of dllnames associated
359 with the specified import lib. Used by the identify_* code.
360 The head entry is acts as a sentinal node and is always empty
361 (head->dllname is NULL). */
362 typedef struct dll_name_list_node_t
365 struct dll_name_list_node_t * next;
366 } dll_name_list_node_type;
367 typedef struct dll_name_list_t
369 dll_name_list_node_type * head;
370 dll_name_list_node_type * tail;
371 } dll_name_list_type;
373 /* Types used to pass data to iterator functions. */
374 typedef struct symname_search_data_t
376 const char * symname;
378 } symname_search_data_type;
379 typedef struct identify_data_t
381 dll_name_list_type * list;
382 bfd_boolean ms_style_implib;
383 } identify_data_type;
386 static char *head_label;
387 static char *imp_name_lab;
388 static char *dll_name;
390 static int add_indirect = 0;
391 static int add_underscore = 0;
392 static int add_stdcall_underscore = 0;
393 static int dontdeltemps = 0;
395 /* TRUE if we should export all symbols. Otherwise, we only export
396 symbols listed in .drectve sections or in the def file. */
397 static bfd_boolean export_all_symbols;
399 /* TRUE if we should exclude the symbols in DEFAULT_EXCLUDES when
400 exporting all symbols. */
401 static bfd_boolean do_default_excludes = TRUE;
403 static bfd_boolean use_nul_prefixed_import_tables = FALSE;
405 /* Default symbols to exclude when exporting all the symbols. */
406 static const char *default_excludes = "DllMain@12,DllEntryPoint@0,impure_ptr";
408 /* TRUE if we should add __imp_<SYMBOL> to import libraries for backward
409 compatibility to old Cygwin releases. */
410 static bfd_boolean create_compat_implib;
412 /* TRUE if we have to write PE+ import libraries. */
413 static bfd_boolean create_for_pep;
415 static char *def_file;
417 extern char * program_name;
421 static int add_stdcall_alias;
422 static const char *ext_prefix_alias;
424 static FILE *output_def;
425 static FILE *base_file;
427 #ifdef DLLTOOL_DEFAULT_ARM
428 static const char *mname = "arm";
431 #ifdef DLLTOOL_DEFAULT_ARM_EPOC
432 static const char *mname = "arm-epoc";
435 #ifdef DLLTOOL_DEFAULT_ARM_WINCE
436 static const char *mname = "arm-wince";
439 #ifdef DLLTOOL_DEFAULT_I386
440 static const char *mname = "i386";
443 #ifdef DLLTOOL_DEFAULT_MX86_64
444 static const char *mname = "i386:x86-64";
447 #ifdef DLLTOOL_DEFAULT_PPC
448 static const char *mname = "ppc";
451 #ifdef DLLTOOL_DEFAULT_SH
452 static const char *mname = "sh";
455 #ifdef DLLTOOL_DEFAULT_MIPS
456 static const char *mname = "mips";
459 #ifdef DLLTOOL_DEFAULT_MCORE
460 static const char * mname = "mcore-le";
463 #ifdef DLLTOOL_DEFAULT_MCORE_ELF
464 static const char * mname = "mcore-elf";
465 static char * mcore_elf_out_file = NULL;
466 static char * mcore_elf_linker = NULL;
467 static char * mcore_elf_linker_flags = NULL;
469 #define DRECTVE_SECTION_NAME ((machine == MMCORE_ELF || machine == MMCORE_ELF_LE) ? ".exports" : ".drectve")
472 #ifndef DRECTVE_SECTION_NAME
473 #define DRECTVE_SECTION_NAME ".drectve"
476 /* What's the right name for this ? */
479 /* External name alias numbering starts here. */
480 #define PREFIX_ALIAS_BASE 20000
483 char *tmp_head_s_buf;
484 char *tmp_head_o_buf;
485 char *tmp_tail_s_buf;
486 char *tmp_tail_o_buf;
489 #define TMP_ASM dlltmp (&tmp_asm_buf, "%sc.s")
490 #define TMP_HEAD_S dlltmp (&tmp_head_s_buf, "%sh.s")
491 #define TMP_HEAD_O dlltmp (&tmp_head_o_buf, "%sh.o")
492 #define TMP_TAIL_S dlltmp (&tmp_tail_s_buf, "%st.s")
493 #define TMP_TAIL_O dlltmp (&tmp_tail_o_buf, "%st.o")
494 #define TMP_STUB dlltmp (&tmp_stub_buf, "%ss")
496 /* This bit of assembly does jmp * .... */
497 static const unsigned char i386_jtab[] =
499 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
502 static const unsigned char arm_jtab[] =
504 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
505 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
509 static const unsigned char arm_interwork_jtab[] =
511 0x04, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
512 0x00, 0xc0, 0x9c, 0xe5, /* ldr ip, [ip] */
513 0x1c, 0xff, 0x2f, 0xe1, /* bx ip */
517 static const unsigned char thumb_jtab[] =
519 0x40, 0xb4, /* push {r6} */
520 0x02, 0x4e, /* ldr r6, [pc, #8] */
521 0x36, 0x68, /* ldr r6, [r6] */
522 0xb4, 0x46, /* mov ip, r6 */
523 0x40, 0xbc, /* pop {r6} */
524 0x60, 0x47, /* bx ip */
528 static const unsigned char mcore_be_jtab[] =
530 0x71, 0x02, /* lrw r1,2 */
531 0x81, 0x01, /* ld.w r1,(r1,0) */
532 0x00, 0xC1, /* jmp r1 */
533 0x12, 0x00, /* nop */
534 0x00, 0x00, 0x00, 0x00 /* <address> */
537 static const unsigned char mcore_le_jtab[] =
539 0x02, 0x71, /* lrw r1,2 */
540 0x01, 0x81, /* ld.w r1,(r1,0) */
541 0xC1, 0x00, /* jmp r1 */
542 0x00, 0x12, /* nop */
543 0x00, 0x00, 0x00, 0x00 /* <address> */
546 /* This is the glue sequence for PowerPC PE. There is a
547 tocrel16-tocdefn reloc against the first instruction.
548 We also need a IMGLUE reloc against the glue function
549 to restore the toc saved by the third instruction in
551 static const unsigned char ppc_jtab[] =
553 0x00, 0x00, 0x62, 0x81, /* lwz r11,0(r2) */
554 /* Reloc TOCREL16 __imp_xxx */
555 0x00, 0x00, 0x8B, 0x81, /* lwz r12,0(r11) */
556 0x04, 0x00, 0x41, 0x90, /* stw r2,4(r1) */
557 0xA6, 0x03, 0x89, 0x7D, /* mtctr r12 */
558 0x04, 0x00, 0x4B, 0x80, /* lwz r2,4(r11) */
559 0x20, 0x04, 0x80, 0x4E /* bctr */
563 /* The glue instruction, picks up the toc from the stw in
564 the above code: "lwz r2,4(r1)". */
565 static bfd_vma ppc_glue_insn = 0x80410004;
571 const char *how_byte;
572 const char *how_short;
573 const char *how_long;
574 const char *how_asciz;
575 const char *how_comment;
576 const char *how_jump;
577 const char *how_global;
578 const char *how_space;
579 const char *how_align_short;
580 const char *how_align_long;
581 const char *how_default_as_switches;
582 const char *how_bfd_target;
583 enum bfd_architecture how_bfd_arch;
584 const unsigned char *how_jtab;
585 int how_jtab_size; /* Size of the jtab entry. */
586 int how_jtab_roff; /* Offset into it for the ind 32 reloc into idata 5. */
589 static const struct mac
594 "arm", ".byte", ".short", ".long", ".asciz", "@",
595 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
596 ".global", ".space", ".align\t2",".align\t4", "-mapcs-32",
597 "pe-arm-little", bfd_arch_arm,
598 arm_jtab, sizeof (arm_jtab), 8
603 "i386", ".byte", ".short", ".long", ".asciz", "#",
604 "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
605 "pe-i386",bfd_arch_i386,
606 i386_jtab, sizeof (i386_jtab), 2
611 "ppc", ".byte", ".short", ".long", ".asciz", "#",
612 "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
613 "pe-powerpcle",bfd_arch_powerpc,
614 ppc_jtab, sizeof (ppc_jtab), 0
619 "thumb", ".byte", ".short", ".long", ".asciz", "@",
620 "push\t{r6}\n\tldr\tr6, [pc, #8]\n\tldr\tr6, [r6]\n\tmov\tip, r6\n\tpop\t{r6}\n\tbx\tip",
621 ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
622 "pe-arm-little", bfd_arch_arm,
623 thumb_jtab, sizeof (thumb_jtab), 12
626 #define MARM_INTERWORK 4
628 "arm_interwork", ".byte", ".short", ".long", ".asciz", "@",
629 "ldr\tip,[pc]\n\tldr\tip,[ip]\n\tbx\tip\n\t.long",
630 ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
631 "pe-arm-little", bfd_arch_arm,
632 arm_interwork_jtab, sizeof (arm_interwork_jtab), 12
637 "mcore-be", ".byte", ".short", ".long", ".asciz", "//",
638 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
639 ".global", ".space", ".align\t2",".align\t4", "",
640 "pe-mcore-big", bfd_arch_mcore,
641 mcore_be_jtab, sizeof (mcore_be_jtab), 8
646 "mcore-le", ".byte", ".short", ".long", ".asciz", "//",
647 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
648 ".global", ".space", ".align\t2",".align\t4", "-EL",
649 "pe-mcore-little", bfd_arch_mcore,
650 mcore_le_jtab, sizeof (mcore_le_jtab), 8
655 "mcore-elf-be", ".byte", ".short", ".long", ".asciz", "//",
656 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
657 ".global", ".space", ".align\t2",".align\t4", "",
658 "elf32-mcore-big", bfd_arch_mcore,
659 mcore_be_jtab, sizeof (mcore_be_jtab), 8
663 #define MMCORE_ELF_LE 8
664 "mcore-elf-le", ".byte", ".short", ".long", ".asciz", "//",
665 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
666 ".global", ".space", ".align\t2",".align\t4", "-EL",
667 "elf32-mcore-little", bfd_arch_mcore,
668 mcore_le_jtab, sizeof (mcore_le_jtab), 8
673 "arm-epoc", ".byte", ".short", ".long", ".asciz", "@",
674 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
675 ".global", ".space", ".align\t2",".align\t4", "",
676 "epoc-pe-arm-little", bfd_arch_arm,
677 arm_jtab, sizeof (arm_jtab), 8
681 #define MARM_WINCE 10
682 "arm-wince", ".byte", ".short", ".long", ".asciz", "@",
683 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
684 ".global", ".space", ".align\t2",".align\t4", "-mapcs-32",
685 "pe-arm-wince-little", bfd_arch_arm,
686 arm_jtab, sizeof (arm_jtab), 8
691 "i386:x86-64", ".byte", ".short", ".long", ".asciz", "#",
692 "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
693 "pe-x86-64",bfd_arch_i386,
694 i386_jtab, sizeof (i386_jtab), 2
697 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
707 typedef struct export
710 const char *internal_name;
711 const char *import_name;
714 int noname; /* Don't put name in image file. */
715 int private; /* Don't put reference in import lib. */
718 int forward; /* Number of forward label, 0 means no forward. */
723 /* A list of symbols which we should not export. */
727 struct string_list *next;
731 static struct string_list *excludes;
733 static const char *rvaafter (int);
734 static const char *rvabefore (int);
735 static const char *asm_prefix (int, const char *);
736 static void process_def_file (const char *);
737 static void new_directive (char *);
738 static void append_import (const char *, const char *, int);
739 static void run (const char *, char *);
740 static void scan_drectve_symbols (bfd *);
741 static void scan_filtered_symbols (bfd *, void *, long, unsigned int);
742 static void add_excludes (const char *);
743 static bfd_boolean match_exclude (const char *);
744 static void set_default_excludes (void);
745 static long filter_symbols (bfd *, void *, long, unsigned int);
746 static void scan_all_symbols (bfd *);
747 static void scan_open_obj_file (bfd *);
748 static void scan_obj_file (const char *);
749 static void dump_def_info (FILE *);
750 static int sfunc (const void *, const void *);
751 static void flush_page (FILE *, bfd_vma *, bfd_vma, int);
752 static void gen_def_file (void);
753 static void generate_idata_ofile (FILE *);
754 static void assemble_file (const char *, const char *);
755 static void gen_exp_file (void);
756 static const char *xlate (const char *);
757 static char *make_label (const char *, const char *);
758 static char *make_imp_label (const char *, const char *);
759 static bfd *make_one_lib_file (export_type *, int);
760 static bfd *make_head (void);
761 static bfd *make_tail (void);
762 static void gen_lib_file (void);
763 static void dll_name_list_append (dll_name_list_type *, bfd_byte *);
764 static int dll_name_list_count (dll_name_list_type *);
765 static void dll_name_list_print (dll_name_list_type *);
766 static void dll_name_list_free_contents (dll_name_list_node_type *);
767 static void dll_name_list_free (dll_name_list_type *);
768 static dll_name_list_type * dll_name_list_create (void);
769 static void identify_dll_for_implib (void);
770 static void identify_search_archive
771 (bfd *, void (*) (bfd *, bfd *, void *), void *);
772 static void identify_search_member (bfd *, bfd *, void *);
773 static bfd_boolean identify_process_section_p (asection *, bfd_boolean);
774 static void identify_search_section (bfd *, asection *, void *);
775 static void identify_member_contains_symname (bfd *, bfd *, void *);
777 static int pfunc (const void *, const void *);
778 static int nfunc (const void *, const void *);
779 static void remove_null_names (export_type **);
780 static void process_duplicates (export_type **);
781 static void fill_ordinals (export_type **);
782 static void mangle_defs (void);
783 static void usage (FILE *, int);
784 static void inform (const char *, ...) ATTRIBUTE_PRINTF_1;
785 static void set_dll_name_from_def (const char *);
788 prefix_encode (char *start, unsigned code)
790 static char alpha[26] = "abcdefghijklmnopqrstuvwxyz";
794 p = strchr (buf, '\0');
796 *p++ = alpha[code % sizeof (alpha)];
797 while ((code /= sizeof (alpha)) != 0);
803 dlltmp (char **buf, const char *fmt)
807 *buf = malloc (strlen (tmp_prefix) + 64);
808 sprintf (*buf, fmt, tmp_prefix);
814 inform VPARAMS ((const char * message, ...))
816 VA_OPEN (args, message);
817 VA_FIXEDARG (args, const char *, message);
822 report (message, args);
828 rvaafter (int machine)
846 /* xgettext:c-format */
847 fatal (_("Internal error: Unknown machine type: %d"), machine);
854 rvabefore (int machine)
872 /* xgettext:c-format */
873 fatal (_("Internal error: Unknown machine type: %d"), machine);
880 asm_prefix (int machine, const char *name)
897 /* Symbol names starting with ? do not have a leading underscore. */
898 if (name && *name == '?')
903 /* xgettext:c-format */
904 fatal (_("Internal error: Unknown machine type: %d"), machine);
910 #define ASM_BYTE mtable[machine].how_byte
911 #define ASM_SHORT mtable[machine].how_short
912 #define ASM_LONG mtable[machine].how_long
913 #define ASM_TEXT mtable[machine].how_asciz
914 #define ASM_C mtable[machine].how_comment
915 #define ASM_JUMP mtable[machine].how_jump
916 #define ASM_GLOBAL mtable[machine].how_global
917 #define ASM_SPACE mtable[machine].how_space
918 #define ASM_ALIGN_SHORT mtable[machine].how_align_short
919 #define ASM_RVA_BEFORE rvabefore (machine)
920 #define ASM_RVA_AFTER rvaafter (machine)
921 #define ASM_PREFIX(NAME) asm_prefix (machine, (NAME))
922 #define ASM_ALIGN_LONG mtable[machine].how_align_long
923 #define HOW_BFD_READ_TARGET 0 /* Always default. */
924 #define HOW_BFD_WRITE_TARGET mtable[machine].how_bfd_target
925 #define HOW_BFD_ARCH mtable[machine].how_bfd_arch
926 #define HOW_JTAB mtable[machine].how_jtab
927 #define HOW_JTAB_SIZE mtable[machine].how_jtab_size
928 #define HOW_JTAB_ROFF mtable[machine].how_jtab_roff
929 #define ASM_SWITCHES mtable[machine].how_default_as_switches
934 process_def_file (const char *name)
936 FILE *f = fopen (name, FOPEN_RT);
939 /* xgettext:c-format */
940 fatal (_("Can't open def file: %s"), name);
944 /* xgettext:c-format */
945 inform (_("Processing def file: %s"), name);
949 inform (_("Processed def file"));
952 /**********************************************************************/
954 /* Communications with the parser. */
956 static int d_nfuncs; /* Number of functions exported. */
957 static int d_named_nfuncs; /* Number of named functions exported. */
958 static int d_low_ord; /* Lowest ordinal index. */
959 static int d_high_ord; /* Highest ordinal index. */
960 static export_type *d_exports; /* List of exported functions. */
961 static export_type **d_exports_lexically; /* Vector of exported functions in alpha order. */
962 static dlist_type *d_list; /* Descriptions. */
963 static dlist_type *a_list; /* Stuff to go in directives. */
964 static int d_nforwards = 0; /* Number of forwarded exports. */
970 yyerror (const char * err ATTRIBUTE_UNUSED)
972 /* xgettext:c-format */
973 non_fatal (_("Syntax error in def file %s:%d"), def_file, linenumber);
979 def_exports (const char *name, const char *internal_name, int ordinal,
980 int noname, int constant, int data, int private)
982 struct export *p = (struct export *) xmalloc (sizeof (*p));
985 p->internal_name = internal_name ? internal_name : name;
986 p->import_name = name;
987 p->ordinal = ordinal;
988 p->constant = constant;
990 p->private = private;
996 if ((internal_name != NULL)
997 && (strchr (internal_name, '.') != NULL))
998 p->forward = ++d_nforwards;
1000 p->forward = 0; /* no forward */
1004 set_dll_name_from_def (const char * name)
1006 const char* image_basename = lbasename (name);
1007 if (image_basename != name)
1008 non_fatal (_("%s: Path components stripped from image name, '%s'."),
1010 dll_name = xstrdup (image_basename);
1014 def_name (const char *name, int base)
1016 /* xgettext:c-format */
1017 inform (_("NAME: %s base: %x"), name, base);
1020 non_fatal (_("Can't have LIBRARY and NAME"));
1022 /* If --dllname not provided, use the one in the DEF file.
1023 FIXME: Is this appropriate for executables? */
1025 set_dll_name_from_def (name);
1030 def_library (const char *name, int base)
1032 /* xgettext:c-format */
1033 inform (_("LIBRARY: %s base: %x"), name, base);
1036 non_fatal (_("Can't have LIBRARY and NAME"));
1038 /* If --dllname not provided, use the one in the DEF file. */
1040 set_dll_name_from_def (name);
1045 def_description (const char *desc)
1047 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
1048 d->text = xstrdup (desc);
1054 new_directive (char *dir)
1056 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
1057 d->text = xstrdup (dir);
1063 def_heapsize (int reserve, int commit)
1067 sprintf (b, "-heap 0x%x,0x%x ", reserve, commit);
1069 sprintf (b, "-heap 0x%x ", reserve);
1070 new_directive (xstrdup (b));
1074 def_stacksize (int reserve, int commit)
1078 sprintf (b, "-stack 0x%x,0x%x ", reserve, commit);
1080 sprintf (b, "-stack 0x%x ", reserve);
1081 new_directive (xstrdup (b));
1084 /* append_import simply adds the given import definition to the global
1085 import_list. It is used by def_import. */
1088 append_import (const char *symbol_name, const char *dll_name, int func_ordinal)
1093 for (pq = &import_list; *pq != NULL; pq = &(*pq)->next)
1095 if (strcmp ((*pq)->dllname, dll_name) == 0)
1098 q->functail->next = xmalloc (sizeof (ifunctype));
1099 q->functail = q->functail->next;
1100 q->functail->ord = func_ordinal;
1101 q->functail->name = xstrdup (symbol_name);
1102 q->functail->next = NULL;
1108 q = xmalloc (sizeof (iheadtype));
1109 q->dllname = xstrdup (dll_name);
1111 q->funchead = xmalloc (sizeof (ifunctype));
1112 q->functail = q->funchead;
1114 q->functail->name = xstrdup (symbol_name);
1115 q->functail->ord = func_ordinal;
1116 q->functail->next = NULL;
1121 /* def_import is called from within defparse.y when an IMPORT
1122 declaration is encountered. Depending on the form of the
1123 declaration, the module name may or may not need ".dll" to be
1124 appended to it, the name of the function may be stored in internal
1125 or entry, and there may or may not be an ordinal value associated
1128 /* A note regarding the parse modes:
1129 In defparse.y we have to accept import declarations which follow
1130 any one of the following forms:
1131 <func_name_in_app> = <dll_name>.<func_name_in_dll>
1132 <func_name_in_app> = <dll_name>.<number>
1133 <dll_name>.<func_name_in_dll>
1135 Furthermore, the dll's name may or may not end with ".dll", which
1136 complicates the parsing a little. Normally the dll's name is
1137 passed to def_import() in the "module" parameter, but when it ends
1138 with ".dll" it gets passed in "module" sans ".dll" and that needs
1141 def_import gets five parameters:
1142 APP_NAME - the name of the function in the application, if
1143 present, or NULL if not present.
1144 MODULE - the name of the dll, possibly sans extension (ie, '.dll').
1145 DLLEXT - the extension of the dll, if present, NULL if not present.
1146 ENTRY - the name of the function in the dll, if present, or NULL.
1147 ORD_VAL - the numerical tag of the function in the dll, if present,
1148 or NULL. Exactly one of <entry> or <ord_val> must be
1149 present (i.e., not NULL). */
1152 def_import (const char *app_name, const char *module, const char *dllext,
1153 const char *entry, int ord_val)
1155 const char *application_name;
1159 application_name = entry;
1162 if (app_name != NULL)
1163 application_name = app_name;
1165 application_name = "";
1170 buf = (char *) alloca (strlen (module) + strlen (dllext) + 2);
1171 sprintf (buf, "%s.%s", module, dllext);
1175 append_import (application_name, module, ord_val);
1179 def_version (int major, int minor)
1181 printf ("VERSION %d.%d\n", major, minor);
1185 def_section (const char *name, int attr)
1200 sprintf (buf, "-attr %s %s", name, atts);
1201 new_directive (xstrdup (buf));
1208 def_section ("CODE", attr);
1214 def_section ("DATA", attr);
1217 /**********************************************************************/
1220 run (const char *what, char *args)
1223 int pid, wait_status;
1226 char *errmsg_fmt, *errmsg_arg;
1227 char *temp_base = choose_temp_base ();
1229 inform ("run: %s %s", what, args);
1231 /* Count the args */
1233 for (s = args; *s; s++)
1237 argv = alloca (sizeof (char *) * (i + 3));
1246 while (*s != ' ' && *s != 0)
1254 pid = pexecute (argv[0], (char * const *) argv, program_name, temp_base,
1255 &errmsg_fmt, &errmsg_arg, PEXECUTE_ONE | PEXECUTE_SEARCH);
1259 inform ("%s", strerror (errno));
1261 fatal (errmsg_fmt, errmsg_arg);
1264 pid = pwait (pid, & wait_status, 0);
1268 /* xgettext:c-format */
1269 fatal (_("wait: %s"), strerror (errno));
1271 else if (WIFSIGNALED (wait_status))
1273 /* xgettext:c-format */
1274 fatal (_("subprocess got fatal signal %d"), WTERMSIG (wait_status));
1276 else if (WIFEXITED (wait_status))
1278 if (WEXITSTATUS (wait_status) != 0)
1279 /* xgettext:c-format */
1280 non_fatal (_("%s exited with status %d"),
1281 what, WEXITSTATUS (wait_status));
1287 /* Look for a list of symbols to export in the .drectve section of
1288 ABFD. Pass each one to def_exports. */
1291 scan_drectve_symbols (bfd *abfd)
1299 /* Look for .drectve's */
1300 s = bfd_get_section_by_name (abfd, DRECTVE_SECTION_NAME);
1305 size = bfd_get_section_size (s);
1306 buf = xmalloc (size);
1308 bfd_get_section_contents (abfd, s, buf, 0, size);
1310 /* xgettext:c-format */
1311 inform (_("Sucking in info from %s section in %s"),
1312 DRECTVE_SECTION_NAME, bfd_get_filename (abfd));
1314 /* Search for -export: strings. The exported symbols can optionally
1315 have type tags (eg., -export:foo,data), so handle those as well.
1316 Currently only data tag is supported. */
1322 && CONST_STRNEQ (p, "-export:"))
1326 flagword flags = BSF_FUNCTION;
1330 while (p < e && *p != ',' && *p != ' ' && *p != '-')
1332 c = xmalloc (p - name + 1);
1333 memcpy (c, name, p - name);
1335 if (p < e && *p == ',') /* found type tag. */
1337 char *tag_start = ++p;
1338 while (p < e && *p != ' ' && *p != '-')
1340 if (CONST_STRNEQ (tag_start, "data"))
1341 flags &= ~BSF_FUNCTION;
1344 /* FIXME: The 5th arg is for the `constant' field.
1345 What should it be? Not that it matters since it's not
1346 currently useful. */
1347 def_exports (c, 0, -1, 0, 0, ! (flags & BSF_FUNCTION), 0);
1349 if (add_stdcall_alias && strchr (c, '@'))
1351 int lead_at = (*c == '@') ;
1352 char *exported_name = xstrdup (c + lead_at);
1353 char *atsym = strchr (exported_name, '@');
1355 /* Note: stdcall alias symbols can never be data. */
1356 def_exports (exported_name, xstrdup (c), -1, 0, 0, 0, 0);
1365 /* Look through the symbols in MINISYMS, and add each one to list of
1366 symbols to export. */
1369 scan_filtered_symbols (bfd *abfd, void *minisyms, long symcount,
1373 bfd_byte *from, *fromend;
1375 store = bfd_make_empty_symbol (abfd);
1377 bfd_fatal (bfd_get_filename (abfd));
1379 from = (bfd_byte *) minisyms;
1380 fromend = from + symcount * size;
1381 for (; from < fromend; from += size)
1384 const char *symbol_name;
1386 sym = bfd_minisymbol_to_symbol (abfd, FALSE, from, store);
1388 bfd_fatal (bfd_get_filename (abfd));
1390 symbol_name = bfd_asymbol_name (sym);
1391 if (bfd_get_symbol_leading_char (abfd) == symbol_name[0])
1394 def_exports (xstrdup (symbol_name) , 0, -1, 0, 0,
1395 ! (sym->flags & BSF_FUNCTION), 0);
1397 if (add_stdcall_alias && strchr (symbol_name, '@'))
1399 int lead_at = (*symbol_name == '@');
1400 char *exported_name = xstrdup (symbol_name + lead_at);
1401 char *atsym = strchr (exported_name, '@');
1403 /* Note: stdcall alias symbols can never be data. */
1404 def_exports (exported_name, xstrdup (symbol_name), -1, 0, 0, 0, 0);
1409 /* Add a list of symbols to exclude. */
1412 add_excludes (const char *new_excludes)
1415 char *exclude_string;
1417 local_copy = xstrdup (new_excludes);
1419 exclude_string = strtok (local_copy, ",:");
1420 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
1422 struct string_list *new_exclude;
1424 new_exclude = ((struct string_list *)
1425 xmalloc (sizeof (struct string_list)));
1426 new_exclude->string = (char *) xmalloc (strlen (exclude_string) + 2);
1427 /* Don't add a leading underscore for fastcall symbols. */
1428 if (*exclude_string == '@')
1429 sprintf (new_exclude->string, "%s", exclude_string);
1431 sprintf (new_exclude->string, "_%s", exclude_string);
1432 new_exclude->next = excludes;
1433 excludes = new_exclude;
1435 /* xgettext:c-format */
1436 inform (_("Excluding symbol: %s"), exclude_string);
1442 /* See if STRING is on the list of symbols to exclude. */
1445 match_exclude (const char *string)
1447 struct string_list *excl_item;
1449 for (excl_item = excludes; excl_item; excl_item = excl_item->next)
1450 if (strcmp (string, excl_item->string) == 0)
1455 /* Add the default list of symbols to exclude. */
1458 set_default_excludes (void)
1460 add_excludes (default_excludes);
1463 /* Choose which symbols to export. */
1466 filter_symbols (bfd *abfd, void *minisyms, long symcount, unsigned int size)
1468 bfd_byte *from, *fromend, *to;
1471 store = bfd_make_empty_symbol (abfd);
1473 bfd_fatal (bfd_get_filename (abfd));
1475 from = (bfd_byte *) minisyms;
1476 fromend = from + symcount * size;
1477 to = (bfd_byte *) minisyms;
1479 for (; from < fromend; from += size)
1484 sym = bfd_minisymbol_to_symbol (abfd, FALSE, (const void *) from, store);
1486 bfd_fatal (bfd_get_filename (abfd));
1488 /* Check for external and defined only symbols. */
1489 keep = (((sym->flags & BSF_GLOBAL) != 0
1490 || (sym->flags & BSF_WEAK) != 0
1491 || bfd_is_com_section (sym->section))
1492 && ! bfd_is_und_section (sym->section));
1494 keep = keep && ! match_exclude (sym->name);
1498 memcpy (to, from, size);
1503 return (to - (bfd_byte *) minisyms) / size;
1506 /* Export all symbols in ABFD, except for ones we were told not to
1510 scan_all_symbols (bfd *abfd)
1516 /* Ignore bfds with an import descriptor table. We assume that any
1517 such BFD contains symbols which are exported from another DLL,
1518 and we don't want to reexport them from here. */
1519 if (bfd_get_section_by_name (abfd, ".idata$4"))
1522 if (! (bfd_get_file_flags (abfd) & HAS_SYMS))
1524 /* xgettext:c-format */
1525 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1529 symcount = bfd_read_minisymbols (abfd, FALSE, &minisyms, &size);
1531 bfd_fatal (bfd_get_filename (abfd));
1535 /* xgettext:c-format */
1536 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1540 /* Discard the symbols we don't want to export. It's OK to do this
1541 in place; we'll free the storage anyway. */
1543 symcount = filter_symbols (abfd, minisyms, symcount, size);
1544 scan_filtered_symbols (abfd, minisyms, symcount, size);
1549 /* Look at the object file to decide which symbols to export. */
1552 scan_open_obj_file (bfd *abfd)
1554 if (export_all_symbols)
1555 scan_all_symbols (abfd);
1557 scan_drectve_symbols (abfd);
1559 /* FIXME: we ought to read in and block out the base relocations. */
1561 /* xgettext:c-format */
1562 inform (_("Done reading %s"), bfd_get_filename (abfd));
1566 scan_obj_file (const char *filename)
1568 bfd * f = bfd_openr (filename, 0);
1571 /* xgettext:c-format */
1572 fatal (_("Unable to open object file: %s"), filename);
1574 /* xgettext:c-format */
1575 inform (_("Scanning object file %s"), filename);
1577 if (bfd_check_format (f, bfd_archive))
1579 bfd *arfile = bfd_openr_next_archived_file (f, 0);
1582 if (bfd_check_format (arfile, bfd_object))
1583 scan_open_obj_file (arfile);
1585 arfile = bfd_openr_next_archived_file (f, arfile);
1588 #ifdef DLLTOOL_MCORE_ELF
1589 if (mcore_elf_out_file)
1590 inform (_("Cannot produce mcore-elf dll from archive file: %s"), filename);
1593 else if (bfd_check_format (f, bfd_object))
1595 scan_open_obj_file (f);
1597 #ifdef DLLTOOL_MCORE_ELF
1598 if (mcore_elf_out_file)
1599 mcore_elf_cache_filename (filename);
1606 /**********************************************************************/
1609 dump_def_info (FILE *f)
1613 fprintf (f, "%s ", ASM_C);
1614 for (i = 0; oav[i]; i++)
1615 fprintf (f, "%s ", oav[i]);
1617 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1619 fprintf (f, "%s %d = %s %s @ %d %s%s%s%s\n",
1625 exp->noname ? "NONAME " : "",
1626 exp->private ? "PRIVATE " : "",
1627 exp->constant ? "CONSTANT" : "",
1628 exp->data ? "DATA" : "");
1632 /* Generate the .exp file. */
1635 sfunc (const void *a, const void *b)
1637 if (*(const bfd_vma *) a == *(const bfd_vma *) b)
1640 return ((*(const bfd_vma *) a > *(const bfd_vma *) b) ? 1 : -1);
1644 flush_page (FILE *f, bfd_vma *need, bfd_vma page_addr, int on_page)
1648 /* Flush this page. */
1649 fprintf (f, "\t%s\t0x%08x\t%s Starting RVA for chunk\n",
1653 fprintf (f, "\t%s\t0x%x\t%s Size of block\n",
1655 (on_page * 2) + (on_page & 1) * 2 + 8,
1658 for (i = 0; i < on_page; i++)
1660 bfd_vma needed = need[i];
1664 if (!create_for_pep)
1666 /* Relocation via HIGHLOW. */
1667 needed = ((needed - page_addr) | 0x3000) & 0xffff;
1671 /* Relocation via DIR64. */
1672 needed = ((needed - page_addr) | 0xa000) & 0xffff;
1676 fprintf (f, "\t%s\t0x%lx\n", ASM_SHORT, (long) needed);
1681 fprintf (f, "\t%s\t0x%x\n", ASM_SHORT, 0 | 0x0000);
1690 inform (_("Adding exports to output file"));
1692 fprintf (output_def, ";");
1693 for (i = 0; oav[i]; i++)
1694 fprintf (output_def, " %s", oav[i]);
1696 fprintf (output_def, "\nEXPORTS\n");
1698 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1700 char *quote = strchr (exp->name, '.') ? "\"" : "";
1701 char *res = cplus_demangle (exp->internal_name, DMGL_ANSI | DMGL_PARAMS);
1705 fprintf (output_def,";\t%s\n", res);
1709 if (strcmp (exp->name, exp->internal_name) == 0)
1711 fprintf (output_def, "\t%s%s%s @ %d%s%s%s\n",
1716 exp->noname ? " NONAME" : "",
1717 exp->private ? "PRIVATE " : "",
1718 exp->data ? " DATA" : "");
1722 char * quote1 = strchr (exp->internal_name, '.') ? "\"" : "";
1724 fprintf (output_def, "\t%s%s%s = %s%s%s @ %d%s%s%s\n",
1732 exp->noname ? " NONAME" : "",
1733 exp->private ? "PRIVATE " : "",
1734 exp->data ? " DATA" : "");
1738 inform (_("Added exports to output file"));
1741 /* generate_idata_ofile generates the portable assembly source code
1742 for the idata sections. It appends the source code to the end of
1746 generate_idata_ofile (FILE *filvar)
1754 if (import_list == NULL)
1757 fprintf (filvar, "%s Import data sections\n", ASM_C);
1758 fprintf (filvar, "\n\t.section\t.idata$2\n");
1759 fprintf (filvar, "\t%s\tdoi_idata\n", ASM_GLOBAL);
1760 fprintf (filvar, "doi_idata:\n");
1763 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1765 fprintf (filvar, "\t%slistone%d%s\t%s %s\n",
1766 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER,
1767 ASM_C, headptr->dllname);
1768 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1769 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1770 fprintf (filvar, "\t%sdllname%d%s\n",
1771 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1772 fprintf (filvar, "\t%slisttwo%d%s\n\n",
1773 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1777 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL record at */
1778 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* end of idata$2 */
1779 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* section */
1780 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1781 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1783 fprintf (filvar, "\n\t.section\t.idata$4\n");
1785 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1787 fprintf (filvar, "listone%d:\n", headindex);
1788 for (funcindex = 0; funcindex < headptr->nfuncs; funcindex++)
1791 fprintf (filvar, "\t%sfuncptr%d_%d%s\n%s\t0\n",
1792 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER,
1795 fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1796 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1799 fprintf (filvar, "\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
1801 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list. */
1805 fprintf (filvar, "\n\t.section\t.idata$5\n");
1807 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1809 fprintf (filvar, "listtwo%d:\n", headindex);
1810 for (funcindex = 0; funcindex < headptr->nfuncs; funcindex++)
1813 fprintf (filvar, "\t%sfuncptr%d_%d%s\n%s\t0\n",
1814 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER,
1817 fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1818 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1821 fprintf (filvar, "\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
1823 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list. */
1827 fprintf (filvar, "\n\t.section\t.idata$6\n");
1829 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1832 for (funcptr = headptr->funchead; funcptr != NULL;
1833 funcptr = funcptr->next)
1835 fprintf (filvar,"funcptr%d_%d:\n", headindex, funcindex);
1836 fprintf (filvar,"\t%s\t%d\n", ASM_SHORT,
1837 ((funcptr->ord) & 0xFFFF));
1838 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, funcptr->name);
1839 fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1845 fprintf (filvar, "\n\t.section\t.idata$7\n");
1847 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1849 fprintf (filvar,"dllname%d:\n", headindex);
1850 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, headptr->dllname);
1851 fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1856 /* Assemble the specified file. */
1858 assemble_file (const char * source, const char * dest)
1862 cmd = (char *) alloca (strlen (ASM_SWITCHES) + strlen (as_flags)
1863 + strlen (source) + strlen (dest) + 50);
1865 sprintf (cmd, "%s %s -o %s %s", ASM_SWITCHES, as_flags, dest, source);
1878 /* xgettext:c-format */
1879 inform (_("Generating export file: %s"), exp_name);
1881 f = fopen (TMP_ASM, FOPEN_WT);
1883 /* xgettext:c-format */
1884 fatal (_("Unable to open temporary assembler file: %s"), TMP_ASM);
1886 /* xgettext:c-format */
1887 inform (_("Opened temporary file: %s"), TMP_ASM);
1893 fprintf (f, "\t.section .edata\n\n");
1894 fprintf (f, "\t%s 0 %s Allways 0\n", ASM_LONG, ASM_C);
1895 fprintf (f, "\t%s 0x%lx %s Time and date\n", ASM_LONG,
1896 (unsigned long) time(0), ASM_C);
1897 fprintf (f, "\t%s 0 %s Major and Minor version\n", ASM_LONG, ASM_C);
1898 fprintf (f, "\t%sname%s %s Ptr to name of dll\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1899 fprintf (f, "\t%s %d %s Starting ordinal of exports\n", ASM_LONG, d_low_ord, ASM_C);
1902 fprintf (f, "\t%s %d %s Number of functions\n", ASM_LONG, d_high_ord - d_low_ord + 1, ASM_C);
1903 fprintf(f,"\t%s named funcs %d, low ord %d, high ord %d\n",
1905 d_named_nfuncs, d_low_ord, d_high_ord);
1906 fprintf (f, "\t%s %d %s Number of names\n", ASM_LONG,
1907 show_allnames ? d_high_ord - d_low_ord + 1 : d_named_nfuncs, ASM_C);
1908 fprintf (f, "\t%safuncs%s %s Address of functions\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1910 fprintf (f, "\t%sanames%s %s Address of Name Pointer Table\n",
1911 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1913 fprintf (f, "\t%sanords%s %s Address of ordinals\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1915 fprintf (f, "name: %s \"%s\"\n", ASM_TEXT, dll_name);
1918 fprintf(f,"%s Export address Table\n", ASM_C);
1919 fprintf(f,"\t%s\n", ASM_ALIGN_LONG);
1920 fprintf (f, "afuncs:\n");
1923 for (exp = d_exports; exp; exp = exp->next)
1925 if (exp->ordinal != i)
1927 while (i < exp->ordinal)
1929 fprintf(f,"\t%s\t0\n", ASM_LONG);
1934 if (exp->forward == 0)
1936 if (exp->internal_name[0] == '@')
1937 fprintf (f, "\t%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
1938 exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1940 fprintf (f, "\t%s%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
1941 ASM_PREFIX (exp->internal_name),
1942 exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1945 fprintf (f, "\t%sf%d%s\t%s %d\n", ASM_RVA_BEFORE,
1946 exp->forward, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1950 fprintf (f,"%s Export Name Pointer Table\n", ASM_C);
1951 fprintf (f, "anames:\n");
1953 for (i = 0; (exp = d_exports_lexically[i]); i++)
1955 if (!exp->noname || show_allnames)
1956 fprintf (f, "\t%sn%d%s\n",
1957 ASM_RVA_BEFORE, exp->ordinal, ASM_RVA_AFTER);
1960 fprintf (f,"%s Export Ordinal Table\n", ASM_C);
1961 fprintf (f, "anords:\n");
1962 for (i = 0; (exp = d_exports_lexically[i]); i++)
1964 if (!exp->noname || show_allnames)
1965 fprintf (f, "\t%s %d\n", ASM_SHORT, exp->ordinal - d_low_ord);
1968 fprintf(f,"%s Export Name Table\n", ASM_C);
1969 for (i = 0; (exp = d_exports_lexically[i]); i++)
1971 if (!exp->noname || show_allnames)
1972 fprintf (f, "n%d: %s \"%s\"\n",
1973 exp->ordinal, ASM_TEXT, xlate (exp->name));
1974 if (exp->forward != 0)
1975 fprintf (f, "f%d: %s \"%s\"\n",
1976 exp->forward, ASM_TEXT, exp->internal_name);
1981 fprintf (f, "\t.section %s\n", DRECTVE_SECTION_NAME);
1982 for (dl = a_list; dl; dl = dl->next)
1984 fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, dl->text);
1990 fprintf (f, "\t.section .rdata\n");
1991 for (dl = d_list; dl; dl = dl->next)
1996 /* We don't output as ascii because there can
1997 be quote characters in the string. */
1999 for (p = dl->text; *p; p++)
2002 fprintf (f, "\t%s\t", ASM_BYTE);
2005 fprintf (f, "%d", *p);
2008 fprintf (f, ",0\n");
2022 /* Add to the output file a way of getting to the exported names
2023 without using the import library. */
2026 fprintf (f, "\t.section\t.rdata\n");
2027 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
2028 if (!exp->noname || show_allnames)
2030 /* We use a single underscore for MS compatibility, and a
2031 double underscore for backward compatibility with old
2033 if (create_compat_implib)
2034 fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name);
2035 fprintf (f, "\t%s\t_imp__%s\n", ASM_GLOBAL, exp->name);
2036 if (create_compat_implib)
2037 fprintf (f, "__imp_%s:\n", exp->name);
2038 fprintf (f, "_imp__%s:\n", exp->name);
2039 fprintf (f, "\t%s\t%s\n", ASM_LONG, exp->name);
2043 /* Dump the reloc section if a base file is provided. */
2047 bfd_vma need[PAGE_SIZE];
2049 bfd_size_type numbytes;
2054 fprintf (f, "\t.section\t.init\n");
2055 fprintf (f, "lab:\n");
2057 fseek (base_file, 0, SEEK_END);
2058 numbytes = ftell (base_file);
2059 fseek (base_file, 0, SEEK_SET);
2060 copy = xmalloc (numbytes);
2061 if (fread (copy, 1, numbytes, base_file) < numbytes)
2062 fatal (_("failed to read the number of entries from base file"));
2063 num_entries = numbytes / sizeof (bfd_vma);
2066 fprintf (f, "\t.section\t.reloc\n");
2071 bfd_vma last = (bfd_vma) -1;
2072 qsort (copy, num_entries, sizeof (bfd_vma), sfunc);
2073 /* Delete duplicates */
2074 for (src = 0; src < num_entries; src++)
2076 if (last != copy[src])
2077 last = copy[dst++] = copy[src];
2081 page_addr = addr & PAGE_MASK; /* work out the page addr */
2083 for (j = 0; j < num_entries; j++)
2086 if ((addr & PAGE_MASK) != page_addr)
2088 flush_page (f, need, page_addr, on_page);
2090 page_addr = addr & PAGE_MASK;
2092 need[on_page++] = addr;
2094 flush_page (f, need, page_addr, on_page);
2096 /* fprintf (f, "\t%s\t0,0\t%s End\n", ASM_LONG, ASM_C);*/
2100 generate_idata_ofile (f);
2104 /* Assemble the file. */
2105 assemble_file (TMP_ASM, exp_name);
2107 if (dontdeltemps == 0)
2110 inform (_("Generated exports file"));
2114 xlate (const char *name)
2116 int lead_at = (*name == '@');
2118 if (!lead_at && (add_underscore
2119 || (add_stdcall_underscore
2120 && strchr (name, '@'))))
2122 char *copy = xmalloc (strlen (name) + 2);
2125 strcpy (copy + 1, name);
2134 /* PR 9766: Look for the last @ sign in the name. */
2135 p = strrchr (name, '@');
2136 if (p && ISDIGIT (p[1]))
2152 unsigned char *data;
2167 #define TEXT_SEC_FLAGS \
2168 (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY | SEC_HAS_CONTENTS)
2169 #define DATA_SEC_FLAGS (SEC_ALLOC | SEC_LOAD | SEC_DATA)
2170 #define BSS_SEC_FLAGS SEC_ALLOC
2172 #define INIT_SEC_DATA(id, name, flags, align) \
2173 { id, name, flags, align, NULL, NULL, NULL, 0, NULL }
2174 static sinfo secdata[NSECS] =
2176 INIT_SEC_DATA (TEXT, ".text", TEXT_SEC_FLAGS, 2),
2177 INIT_SEC_DATA (DATA, ".data", DATA_SEC_FLAGS, 2),
2178 INIT_SEC_DATA (BSS, ".bss", BSS_SEC_FLAGS, 2),
2179 INIT_SEC_DATA (IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2),
2180 INIT_SEC_DATA (IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2),
2181 INIT_SEC_DATA (IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2),
2182 INIT_SEC_DATA (IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1)
2187 /* Sections numbered to make the order the same as other PowerPC NT
2188 compilers. This also keeps funny alignment thingies from happening. */
2201 static sinfo secdata[NSECS] =
2203 { TEXT, ".text", SEC_CODE | SEC_HAS_CONTENTS, 3},
2204 { PDATA, ".pdata", SEC_HAS_CONTENTS, 2},
2205 { RDATA, ".reldata", SEC_HAS_CONTENTS, 2},
2206 { IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2},
2207 { IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2},
2208 { IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1},
2209 { IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2},
2210 { DATA, ".data", SEC_DATA, 2},
2211 { BSS, ".bss", 0, 2}
2216 /* This is what we're trying to make. We generate the imp symbols with
2217 both single and double underscores, for compatibility.
2220 .global _GetFileVersionInfoSizeW@8
2221 .global __imp_GetFileVersionInfoSizeW@8
2222 _GetFileVersionInfoSizeW@8:
2223 jmp * __imp_GetFileVersionInfoSizeW@8
2224 .section .idata$7 # To force loading of head
2225 .long __version_a_head
2226 # Import Address Table
2228 __imp_GetFileVersionInfoSizeW@8:
2231 # Import Lookup Table
2237 .asciz "GetFileVersionInfoSizeW"
2240 For the PowerPC, here's the variation on the above scheme:
2242 # Rather than a simple "jmp *", the code to get to the dll function
2245 lwz r11,[tocv]__imp_function_name(r2)
2246 # RELOC: 00000000 TOCREL16,TOCDEFN __imp_function_name
2254 make_label (const char *prefix, const char *name)
2256 int len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name);
2257 char *copy = xmalloc (len + 1);
2259 strcpy (copy, ASM_PREFIX (name));
2260 strcat (copy, prefix);
2261 strcat (copy, name);
2266 make_imp_label (const char *prefix, const char *name)
2273 len = strlen (prefix) + strlen (name);
2274 copy = xmalloc (len + 1);
2275 strcpy (copy, prefix);
2276 strcat (copy, name);
2280 len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name);
2281 copy = xmalloc (len + 1);
2282 strcpy (copy, prefix);
2283 strcat (copy, ASM_PREFIX (name));
2284 strcat (copy, name);
2290 make_one_lib_file (export_type *exp, int i)
2293 asymbol * exp_label;
2294 asymbol * iname = 0;
2296 asymbol * iname_lab;
2297 asymbol ** iname_lab_pp;
2298 asymbol ** iname_pp;
2307 asymbol * ptrs[NSECS + 4 + EXTRA + 1];
2308 flagword applicable;
2309 char * outname = xmalloc (strlen (TMP_STUB) + 10);
2313 sprintf (outname, "%s%05d.o", TMP_STUB, i);
2315 abfd = bfd_openw (outname, HOW_BFD_WRITE_TARGET);
2318 /* xgettext:c-format */
2319 fatal (_("bfd_open failed open stub file: %s"), outname);
2321 /* xgettext:c-format */
2322 inform (_("Creating stub file: %s"), outname);
2324 bfd_set_format (abfd, bfd_object);
2325 bfd_set_arch_mach (abfd, HOW_BFD_ARCH, 0);
2328 if (machine == MARM_INTERWORK || machine == MTHUMB)
2329 bfd_set_private_flags (abfd, F_INTERWORK);
2332 applicable = bfd_applicable_section_flags (abfd);
2334 /* First make symbols for the sections. */
2335 for (i = 0; i < NSECS; i++)
2337 sinfo *si = secdata + i;
2341 si->sec = bfd_make_section_old_way (abfd, si->name);
2342 bfd_set_section_flags (abfd,
2344 si->flags & applicable);
2346 bfd_set_section_alignment(abfd, si->sec, si->align);
2347 si->sec->output_section = si->sec;
2348 si->sym = bfd_make_empty_symbol(abfd);
2349 si->sym->name = si->sec->name;
2350 si->sym->section = si->sec;
2351 si->sym->flags = BSF_LOCAL;
2353 ptrs[oidx] = si->sym;
2354 si->sympp = ptrs + oidx;
2363 exp_label = bfd_make_empty_symbol (abfd);
2364 exp_label->name = make_imp_label ("", exp->name);
2366 /* On PowerPC, the function name points to a descriptor in
2367 the rdata section, the first element of which is a
2368 pointer to the code (..function_name), and the second
2369 points to the .toc. */
2371 if (machine == MPPC)
2372 exp_label->section = secdata[RDATA].sec;
2375 exp_label->section = secdata[TEXT].sec;
2377 exp_label->flags = BSF_GLOBAL;
2378 exp_label->value = 0;
2381 if (machine == MTHUMB)
2382 bfd_coff_set_symbol_class (abfd, exp_label, C_THUMBEXTFUNC);
2384 ptrs[oidx++] = exp_label;
2387 /* Generate imp symbols with one underscore for Microsoft
2388 compatibility, and with two underscores for backward
2389 compatibility with old versions of cygwin. */
2390 if (create_compat_implib)
2392 iname = bfd_make_empty_symbol (abfd);
2393 iname->name = make_imp_label ("___imp", exp->name);
2394 iname->section = secdata[IDATA5].sec;
2395 iname->flags = BSF_GLOBAL;
2399 iname2 = bfd_make_empty_symbol (abfd);
2400 iname2->name = make_imp_label ("__imp_", exp->name);
2401 iname2->section = secdata[IDATA5].sec;
2402 iname2->flags = BSF_GLOBAL;
2405 iname_lab = bfd_make_empty_symbol (abfd);
2407 iname_lab->name = head_label;
2408 iname_lab->section = (asection *) &bfd_und_section;
2409 iname_lab->flags = 0;
2410 iname_lab->value = 0;
2412 iname_pp = ptrs + oidx;
2413 if (create_compat_implib)
2414 ptrs[oidx++] = iname;
2415 ptrs[oidx++] = iname2;
2417 iname_lab_pp = ptrs + oidx;
2418 ptrs[oidx++] = iname_lab;
2421 /* The symbol referring to the code (.text). */
2423 asymbol *function_name;
2425 function_name = bfd_make_empty_symbol(abfd);
2426 function_name->name = make_label ("..", exp->name);
2427 function_name->section = secdata[TEXT].sec;
2428 function_name->flags = BSF_GLOBAL;
2429 function_name->value = 0;
2431 fn_pp = ptrs + oidx;
2432 ptrs[oidx++] = function_name;
2435 /* The .toc symbol. */
2437 asymbol *toc_symbol;
2439 toc_symbol = bfd_make_empty_symbol (abfd);
2440 toc_symbol->name = make_label (".", "toc");
2441 toc_symbol->section = (asection *)&bfd_und_section;
2442 toc_symbol->flags = BSF_GLOBAL;
2443 toc_symbol->value = 0;
2445 toc_pp = ptrs + oidx;
2446 ptrs[oidx++] = toc_symbol;
2452 for (i = 0; i < NSECS; i++)
2454 sinfo *si = secdata + i;
2455 asection *sec = si->sec;
2464 si->size = HOW_JTAB_SIZE;
2465 si->data = xmalloc (HOW_JTAB_SIZE);
2466 memcpy (si->data, HOW_JTAB, HOW_JTAB_SIZE);
2468 /* Add the reloc into idata$5. */
2469 rel = xmalloc (sizeof (arelent));
2471 rpp = xmalloc (sizeof (arelent *) * 2);
2475 rel->address = HOW_JTAB_ROFF;
2478 if (machine == MPPC)
2480 rel->howto = bfd_reloc_type_lookup (abfd,
2481 BFD_RELOC_16_GOTOFF);
2482 rel->sym_ptr_ptr = iname_pp;
2484 else if (machine == MX86)
2486 rel->howto = bfd_reloc_type_lookup (abfd,
2487 BFD_RELOC_32_PCREL);
2488 rel->sym_ptr_ptr = iname_pp;
2492 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2493 rel->sym_ptr_ptr = secdata[IDATA5].sympp;
2495 sec->orelocation = rpp;
2496 sec->reloc_count = 1;
2501 /* An idata$4 or idata$5 is one word long, and has an
2506 si->data = xmalloc (8);
2510 si->data[0] = exp->ordinal ;
2511 si->data[1] = exp->ordinal >> 8;
2512 si->data[2] = exp->ordinal >> 16;
2513 si->data[3] = exp->ordinal >> 24;
2521 sec->reloc_count = 1;
2522 memset (si->data, 0, si->size);
2523 rel = xmalloc (sizeof (arelent));
2524 rpp = xmalloc (sizeof (arelent *) * 2);
2529 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2530 rel->sym_ptr_ptr = secdata[IDATA6].sympp;
2531 sec->orelocation = rpp;
2536 si->data = xmalloc (4);
2541 si->data[0] = exp->ordinal ;
2542 si->data[1] = exp->ordinal >> 8;
2543 si->data[2] = exp->ordinal >> 16;
2548 sec->reloc_count = 1;
2549 memset (si->data, 0, si->size);
2550 rel = xmalloc (sizeof (arelent));
2551 rpp = xmalloc (sizeof (arelent *) * 2);
2556 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2557 rel->sym_ptr_ptr = secdata[IDATA6].sympp;
2558 sec->orelocation = rpp;
2566 /* This used to add 1 to exp->hint. I don't know
2567 why it did that, and it does not match what I see
2568 in programs compiled with the MS tools. */
2569 int idx = exp->hint;
2570 si->size = strlen (xlate (exp->import_name)) + 3;
2571 si->data = xmalloc (si->size);
2572 si->data[0] = idx & 0xff;
2573 si->data[1] = idx >> 8;
2574 strcpy ((char *) si->data + 2, xlate (exp->import_name));
2579 si->data = xmalloc (4);
2580 memset (si->data, 0, si->size);
2581 rel = xmalloc (sizeof (arelent));
2582 rpp = xmalloc (sizeof (arelent *) * 2);
2586 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2587 rel->sym_ptr_ptr = iname_lab_pp;
2588 sec->orelocation = rpp;
2589 sec->reloc_count = 1;
2595 /* The .pdata section is 5 words long.
2599 bfd_vma BeginAddress, [0x00]
2601 ExceptionHandler, [0x08]
2603 PrologEndAddress; [0x10]
2606 /* So this pdata section setups up this as a glue linkage to
2607 a dll routine. There are a number of house keeping things
2610 1. In the name of glue trickery, the ADDR32 relocs for 0,
2611 4, and 0x10 are set to point to the same place:
2613 2. There is one more reloc needed in the pdata section.
2614 The actual glue instruction to restore the toc on
2615 return is saved as the offset in an IMGLUE reloc.
2616 So we need a total of four relocs for this section.
2618 3. Lastly, the HandlerData field is set to 0x03, to indicate
2619 that this is a glue routine. */
2620 arelent *imglue, *ba_rel, *ea_rel, *pea_rel;
2622 /* Alignment must be set to 2**2 or you get extra stuff. */
2623 bfd_set_section_alignment(abfd, sec, 2);
2626 si->data = xmalloc (si->size);
2627 memset (si->data, 0, si->size);
2628 rpp = xmalloc (sizeof (arelent *) * 5);
2629 rpp[0] = imglue = xmalloc (sizeof (arelent));
2630 rpp[1] = ba_rel = xmalloc (sizeof (arelent));
2631 rpp[2] = ea_rel = xmalloc (sizeof (arelent));
2632 rpp[3] = pea_rel = xmalloc (sizeof (arelent));
2635 /* Stick the toc reload instruction in the glue reloc. */
2636 bfd_put_32(abfd, ppc_glue_insn, (char *) &imglue->address);
2639 imglue->howto = bfd_reloc_type_lookup (abfd,
2640 BFD_RELOC_32_GOTOFF);
2641 imglue->sym_ptr_ptr = fn_pp;
2643 ba_rel->address = 0;
2645 ba_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2646 ba_rel->sym_ptr_ptr = fn_pp;
2648 bfd_put_32 (abfd, 0x18, si->data + 0x04);
2649 ea_rel->address = 4;
2651 ea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2652 ea_rel->sym_ptr_ptr = fn_pp;
2654 /* Mark it as glue. */
2655 bfd_put_32 (abfd, 0x03, si->data + 0x0c);
2657 /* Mark the prolog end address. */
2658 bfd_put_32 (abfd, 0x0D, si->data + 0x10);
2659 pea_rel->address = 0x10;
2660 pea_rel->addend = 0;
2661 pea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2662 pea_rel->sym_ptr_ptr = fn_pp;
2664 sec->orelocation = rpp;
2665 sec->reloc_count = 4;
2669 /* Each external function in a PowerPC PE file has a two word
2670 descriptor consisting of:
2671 1. The address of the code.
2672 2. The address of the appropriate .toc
2673 We use relocs to build this. */
2675 si->data = xmalloc (8);
2676 memset (si->data, 0, si->size);
2678 rpp = xmalloc (sizeof (arelent *) * 3);
2679 rpp[0] = rel = xmalloc (sizeof (arelent));
2680 rpp[1] = xmalloc (sizeof (arelent));
2685 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2686 rel->sym_ptr_ptr = fn_pp;
2692 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2693 rel->sym_ptr_ptr = toc_pp;
2695 sec->orelocation = rpp;
2696 sec->reloc_count = 2;
2698 #endif /* DLLTOOL_PPC */
2704 /* Size up all the sections. */
2705 for (i = 0; i < NSECS; i++)
2707 sinfo *si = secdata + i;
2709 bfd_set_section_size (abfd, si->sec, si->size);
2710 bfd_set_section_vma (abfd, si->sec, vma);
2713 /* Write them out. */
2714 for (i = 0; i < NSECS; i++)
2716 sinfo *si = secdata + i;
2718 if (i == IDATA5 && no_idata5)
2721 if (i == IDATA4 && no_idata4)
2724 bfd_set_section_contents (abfd, si->sec,
2729 bfd_set_symtab (abfd, ptrs, oidx);
2731 abfd = bfd_openr (outname, HOW_BFD_READ_TARGET);
2738 FILE *f = fopen (TMP_HEAD_S, FOPEN_WT);
2742 fatal (_("failed to open temporary head file: %s"), TMP_HEAD_S);
2746 fprintf (f, "%s IMAGE_IMPORT_DESCRIPTOR\n", ASM_C);
2747 fprintf (f, "\t.section .idata$2\n");
2749 fprintf(f,"\t%s\t%s\n", ASM_GLOBAL,head_label);
2751 fprintf (f, "%s:\n", head_label);
2753 fprintf (f, "\t%shname%s\t%sPtr to image import by name list\n",
2754 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
2756 fprintf (f, "\t%sthis should be the timestamp, but NT sometimes\n", ASM_C);
2757 fprintf (f, "\t%sdoesn't load DLLs when this is set.\n", ASM_C);
2758 fprintf (f, "\t%s\t0\t%s loaded time\n", ASM_LONG, ASM_C);
2759 fprintf (f, "\t%s\t0\t%s Forwarder chain\n", ASM_LONG, ASM_C);
2760 fprintf (f, "\t%s__%s_iname%s\t%s imported dll's name\n",
2765 fprintf (f, "\t%sfthunk%s\t%s pointer to firstthunk\n",
2767 ASM_RVA_AFTER, ASM_C);
2769 fprintf (f, "%sStuff for compatibility\n", ASM_C);
2773 fprintf (f, "\t.section\t.idata$5\n");
2774 if (use_nul_prefixed_import_tables)
2777 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
2779 fprintf (f,"\t%s\t0\n", ASM_LONG);
2781 fprintf (f, "fthunk:\n");
2786 fprintf (f, "\t.section\t.idata$4\n");
2787 if (use_nul_prefixed_import_tables)
2790 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
2792 fprintf (f,"\t%s\t0\n", ASM_LONG);
2794 fprintf (f, "hname:\n");
2799 assemble_file (TMP_HEAD_S, TMP_HEAD_O);
2801 return bfd_openr (TMP_HEAD_O, HOW_BFD_READ_TARGET);
2807 FILE *f = fopen (TMP_TAIL_S, FOPEN_WT);
2811 fatal (_("failed to open temporary tail file: %s"), TMP_TAIL_S);
2817 fprintf (f, "\t.section .idata$4\n");
2819 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
2821 fprintf (f,"\t%s\t0\n", ASM_LONG); /* NULL terminating list. */
2826 fprintf (f, "\t.section .idata$5\n");
2828 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
2830 fprintf (f,"\t%s\t0\n", ASM_LONG); /* NULL terminating list. */
2834 /* Normally, we need to see a null descriptor built in idata$3 to
2835 act as the terminator for the list. The ideal way, I suppose,
2836 would be to mark this section as a comdat type 2 section, so
2837 only one would appear in the final .exe (if our linker supported
2838 comdat, that is) or cause it to be inserted by something else (say
2841 fprintf (f, "\t.section .idata$3\n");
2842 fprintf (f, "\t%s\t0\n", ASM_LONG);
2843 fprintf (f, "\t%s\t0\n", ASM_LONG);
2844 fprintf (f, "\t%s\t0\n", ASM_LONG);
2845 fprintf (f, "\t%s\t0\n", ASM_LONG);
2846 fprintf (f, "\t%s\t0\n", ASM_LONG);
2850 /* Other PowerPC NT compilers use idata$6 for the dllname, so I
2851 do too. Original, huh? */
2852 fprintf (f, "\t.section .idata$6\n");
2854 fprintf (f, "\t.section .idata$7\n");
2857 fprintf (f, "\t%s\t__%s_iname\n", ASM_GLOBAL, imp_name_lab);
2858 fprintf (f, "__%s_iname:\t%s\t\"%s\"\n",
2859 imp_name_lab, ASM_TEXT, dll_name);
2863 assemble_file (TMP_TAIL_S, TMP_TAIL_O);
2865 return bfd_openr (TMP_TAIL_O, HOW_BFD_READ_TARGET);
2880 outarch = bfd_openw (imp_name, HOW_BFD_WRITE_TARGET);
2883 /* xgettext:c-format */
2884 fatal (_("Can't open .lib file: %s"), imp_name);
2886 /* xgettext:c-format */
2887 inform (_("Creating library file: %s"), imp_name);
2889 bfd_set_format (outarch, bfd_archive);
2890 outarch->has_armap = 1;
2891 outarch->is_thin_archive = 0;
2893 /* Work out a reasonable size of things to put onto one line. */
2894 ar_head = make_head ();
2895 ar_tail = make_tail();
2897 if (ar_head == NULL || ar_tail == NULL)
2900 for (i = 0; (exp = d_exports_lexically[i]); i++)
2903 /* Don't add PRIVATE entries to import lib. */
2906 n = make_one_lib_file (exp, i);
2907 n->archive_next = head;
2909 if (ext_prefix_alias)
2911 export_type alias_exp;
2913 assert (i < PREFIX_ALIAS_BASE);
2914 alias_exp.name = make_imp_label (ext_prefix_alias, exp->name);
2915 alias_exp.internal_name = exp->internal_name;
2916 alias_exp.import_name = exp->name;
2917 alias_exp.ordinal = exp->ordinal;
2918 alias_exp.constant = exp->constant;
2919 alias_exp.noname = exp->noname;
2920 alias_exp.private = exp->private;
2921 alias_exp.data = exp->data;
2922 alias_exp.hint = exp->hint;
2923 alias_exp.forward = exp->forward;
2924 alias_exp.next = exp->next;
2925 n = make_one_lib_file (&alias_exp, i + PREFIX_ALIAS_BASE);
2926 n->archive_next = head;
2931 /* Now stick them all into the archive. */
2932 ar_head->archive_next = head;
2933 ar_tail->archive_next = ar_head;
2936 if (! bfd_set_archive_head (outarch, head))
2937 bfd_fatal ("bfd_set_archive_head");
2939 if (! bfd_close (outarch))
2940 bfd_fatal (imp_name);
2942 while (head != NULL)
2944 bfd *n = head->archive_next;
2949 /* Delete all the temp files. */
2950 if (dontdeltemps == 0)
2952 unlink (TMP_HEAD_O);
2953 unlink (TMP_HEAD_S);
2954 unlink (TMP_TAIL_O);
2955 unlink (TMP_TAIL_S);
2958 if (dontdeltemps < 2)
2962 name = (char *) alloca (strlen (TMP_STUB) + 10);
2963 for (i = 0; (exp = d_exports_lexically[i]); i++)
2965 /* Don't delete non-existent stubs for PRIVATE entries. */
2968 sprintf (name, "%s%05d.o", TMP_STUB, i);
2969 if (unlink (name) < 0)
2970 /* xgettext:c-format */
2971 non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
2972 if (ext_prefix_alias)
2974 sprintf (name, "%s%05d.o", TMP_STUB, i + PREFIX_ALIAS_BASE);
2975 if (unlink (name) < 0)
2976 /* xgettext:c-format */
2977 non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
2982 inform (_("Created lib file"));
2985 /* Append a copy of data (cast to char *) to list. */
2988 dll_name_list_append (dll_name_list_type * list, bfd_byte * data)
2990 /* Error checking. */
2991 if (! list || ! list->tail)
2994 /* Allocate new node. */
2995 dll_name_list_node_type * entry =
2996 (dll_name_list_node_type *) xmalloc (sizeof (dll_name_list_node_type));
2998 /* Initialize its values. */
2999 entry->dllname = xstrdup ((char *) data);
3002 /* Add to tail, and move tail. */
3003 list->tail->next = entry;
3007 /* Count the number of entries in list. */
3010 dll_name_list_count (dll_name_list_type * list)
3012 /* Error checking. */
3013 if (! list || ! list->head)
3017 dll_name_list_node_type * p = list->head;
3019 while (p && p->next)
3027 /* Print each entry in list to stdout. */
3030 dll_name_list_print (dll_name_list_type * list)
3032 /* Error checking. */
3033 if (! list || ! list->head)
3036 dll_name_list_node_type * p = list->head;
3038 while (p && p->next && p->next->dllname && *(p->next->dllname))
3040 printf ("%s\n", p->next->dllname);
3045 /* Free all entries in list, and list itself. */
3048 dll_name_list_free (dll_name_list_type * list)
3052 dll_name_list_free_contents (list->head);
3059 /* Recursive function to free all nodes entry->next->next...
3060 as well as entry itself. */
3063 dll_name_list_free_contents (dll_name_list_node_type * entry)
3069 dll_name_list_free_contents (entry->next);
3074 free (entry->dllname);
3075 entry->dllname = NULL;
3081 /* Allocate and initialize a dll_name_list_type object,
3082 including its sentinel node. Caller is responsible
3083 for calling dll_name_list_free when finished with
3086 static dll_name_list_type *
3087 dll_name_list_create (void)
3089 /* Allocate list. */
3090 dll_name_list_type * list = xmalloc (sizeof (dll_name_list_type));
3092 /* Allocate and initialize sentinel node. */
3093 list->head = xmalloc (sizeof (dll_name_list_node_type));
3094 list->head->dllname = NULL;
3095 list->head->next = NULL;
3097 /* Bookkeeping for empty list. */
3098 list->tail = list->head;
3103 /* Search the symbol table of the suppled BFD for a symbol whose name matches
3104 OBJ (where obj is cast to const char *). If found, set global variable
3105 identify_member_contains_symname_result TRUE. It is the caller's
3106 responsibility to set the result variable FALSE before iterating with
3110 identify_member_contains_symname (bfd * abfd,
3111 bfd * archive_bfd ATTRIBUTE_UNUSED,
3114 long storage_needed;
3115 asymbol ** symbol_table;
3116 long number_of_symbols;
3118 symname_search_data_type * search_data = (symname_search_data_type *) obj;
3120 /* If we already found the symbol in a different member,
3122 if (search_data->found)
3125 storage_needed = bfd_get_symtab_upper_bound (abfd);
3126 if (storage_needed <= 0)
3129 symbol_table = xmalloc (storage_needed);
3130 number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
3131 if (number_of_symbols < 0)
3133 free (symbol_table);
3137 for (i = 0; i < number_of_symbols; i++)
3139 if (strncmp (symbol_table[i]->name,
3140 search_data->symname,
3141 strlen (search_data->symname)) == 0)
3143 search_data->found = TRUE;
3147 free (symbol_table);
3150 /* This is the main implementation for the --identify option.
3151 Given the name of an import library in identify_imp_name, first determine
3152 if the import library is a GNU binutils-style one (where the DLL name is
3153 stored in an .idata$7 (.idata$6 on PPC) section, or if it is a MS-style
3154 one (where the DLL name, along with much other data, is stored in the
3155 .idata$6 section). We determine the style of import library by searching
3156 for the DLL-structure symbol inserted by MS tools:
3157 __NULL_IMPORT_DESCRIPTOR.
3159 Once we know which section to search, evaluate each section for the
3160 appropriate properties that indicate it may contain the name of the
3161 associated DLL (this differs depending on the style). Add the contents
3162 of all sections which meet the criteria to a linked list of dll names.
3164 Finally, print them all to stdout. (If --identify-strict, an error is
3165 reported if more than one match was found). */
3168 identify_dll_for_implib (void)
3172 identify_data_type identify_data;
3173 symname_search_data_type search_data;
3175 /* Initialize identify_data. */
3176 identify_data.list = dll_name_list_create ();
3177 identify_data.ms_style_implib = FALSE;
3179 /* Initialize search_data. */
3180 search_data.symname = "__NULL_IMPORT_DESCRIPTOR";
3181 search_data.found = FALSE;
3185 abfd = bfd_openr (identify_imp_name, 0);
3187 bfd_fatal (identify_imp_name);
3189 if (! bfd_check_format (abfd, bfd_archive))
3191 if (! bfd_close (abfd))
3192 bfd_fatal (identify_imp_name);
3194 fatal (_("%s is not a library"), identify_imp_name);
3197 /* Detect if this a Microsoft import library. */
3198 identify_search_archive (abfd,
3199 identify_member_contains_symname,
3200 (void *)(& search_data));
3201 if (search_data.found)
3202 identify_data.ms_style_implib = TRUE;
3204 /* Rewind the bfd. */
3205 if (! bfd_close (abfd))
3206 bfd_fatal (identify_imp_name);
3207 abfd = bfd_openr (identify_imp_name, 0);
3209 bfd_fatal (identify_imp_name);
3211 if (!bfd_check_format (abfd, bfd_archive))
3213 if (!bfd_close (abfd))
3214 bfd_fatal (identify_imp_name);
3216 fatal (_("%s is not a library"), identify_imp_name);
3219 /* Now search for the dll name. */
3220 identify_search_archive (abfd,
3221 identify_search_member,
3222 (void *)(& identify_data));
3224 if (! bfd_close (abfd))
3225 bfd_fatal (identify_imp_name);
3227 count = dll_name_list_count (identify_data.list);
3230 if (identify_strict && count > 1)
3232 dll_name_list_free (identify_data.list);
3233 identify_data.list = NULL;
3234 fatal (_("Import library `%s' specifies two or more dlls"),
3237 dll_name_list_print (identify_data.list);
3238 dll_name_list_free (identify_data.list);
3239 identify_data.list = NULL;
3243 dll_name_list_free (identify_data.list);
3244 identify_data.list = NULL;
3245 fatal (_("Unable to determine dll name for `%s' (not an import library?)"),
3250 /* Loop over all members of the archive, applying the supplied function to
3251 each member that is a bfd_object. The function will be called as if:
3252 func (member_bfd, abfd, user_storage) */
3255 identify_search_archive (bfd * abfd,
3256 void (* operation) (bfd *, bfd *, void *),
3257 void * user_storage)
3259 bfd * arfile = NULL;
3260 bfd * last_arfile = NULL;
3265 arfile = bfd_openr_next_archived_file (abfd, arfile);
3269 if (bfd_get_error () != bfd_error_no_more_archived_files)
3270 bfd_fatal (bfd_get_filename (abfd));
3274 if (bfd_check_format_matches (arfile, bfd_object, &matching))
3275 (*operation) (arfile, abfd, user_storage);
3278 bfd_nonfatal (bfd_get_filename (arfile));
3282 if (last_arfile != NULL)
3283 bfd_close (last_arfile);
3285 last_arfile = arfile;
3288 if (last_arfile != NULL)
3290 bfd_close (last_arfile);
3294 /* Call the identify_search_section() function for each section of this
3298 identify_search_member (bfd *abfd,
3299 bfd *archive_bfd ATTRIBUTE_UNUSED,
3302 bfd_map_over_sections (abfd, identify_search_section, obj);
3305 /* This predicate returns true if section->name matches the desired value.
3306 By default, this is .idata$7 (.idata$6 on PPC, or if the import
3307 library is ms-style). */
3310 identify_process_section_p (asection * section, bfd_boolean ms_style_implib)
3312 static const char * SECTION_NAME =
3314 /* dllname is stored in idata$6 on PPC */
3319 static const char * MS_SECTION_NAME = ".idata$6";
3321 const char * section_name =
3322 (ms_style_implib ? MS_SECTION_NAME : SECTION_NAME);
3324 if (strcmp (section_name, section->name) == 0)
3329 /* If *section has contents and its name is .idata$7 (.data$6 on PPC or if
3330 import lib ms-generated) -- and it satisfies several other constraints
3331 -- then add the contents of the section to obj->list. */
3334 identify_search_section (bfd * abfd, asection * section, void * obj)
3337 bfd_size_type datasize;
3338 identify_data_type * identify_data = (identify_data_type *)obj;
3339 bfd_boolean ms_style = identify_data->ms_style_implib;
3341 if ((section->flags & SEC_HAS_CONTENTS) == 0)
3344 if (! identify_process_section_p (section, ms_style))
3347 /* Binutils import libs seem distinguish the .idata$7 section that contains
3348 the DLL name from other .idata$7 sections by the absence of the
3350 if (!ms_style && ((section->flags & SEC_RELOC) == SEC_RELOC))
3353 /* MS import libs seem to distinguish the .idata$6 section
3354 that contains the DLL name from other .idata$6 sections
3355 by the presence of the SEC_DATA flag. */
3356 if (ms_style && ((section->flags & SEC_DATA) == 0))
3359 if ((datasize = bfd_section_size (abfd, section)) == 0)
3362 data = (bfd_byte *) xmalloc (datasize + 1);
3365 bfd_get_section_contents (abfd, section, data, 0, datasize);
3366 data[datasize] = '\0';
3368 /* Use a heuristic to determine if data is a dll name.
3369 Possible to defeat this if (a) the library has MANY
3370 (more than 0x302f) imports, (b) it is an ms-style
3371 import library, but (c) it is buggy, in that the SEC_DATA
3372 flag is set on the "wrong" sections. This heuristic might
3373 also fail to record a valid dll name if the dllname uses
3374 a multibyte or unicode character set (is that valid?).
3376 This heuristic is based on the fact that symbols names in
3377 the chosen section -- as opposed to the dll name -- begin
3378 at offset 2 in the data. The first two bytes are a 16bit
3379 little-endian count, and start at 0x0000. However, the dll
3380 name begins at offset 0 in the data. We assume that the
3381 dll name does not contain unprintable characters. */
3382 if (data[0] != '\0' && ISPRINT (data[0])
3383 && ((datasize < 2) || ISPRINT (data[1])))
3384 dll_name_list_append (identify_data->list, data);
3389 /* Run through the information gathered from the .o files and the
3390 .def file and work out the best stuff. */
3393 pfunc (const void *a, const void *b)
3395 export_type *ap = *(export_type **) a;
3396 export_type *bp = *(export_type **) b;
3398 if (ap->ordinal == bp->ordinal)
3401 /* Unset ordinals go to the bottom. */
3402 if (ap->ordinal == -1)
3404 if (bp->ordinal == -1)
3406 return (ap->ordinal - bp->ordinal);
3410 nfunc (const void *a, const void *b)
3412 export_type *ap = *(export_type **) a;
3413 export_type *bp = *(export_type **) b;
3414 const char *an = ap->name;
3415 const char *bn = bp->name;
3419 an = (an[0] == '@') ? an + 1 : an;
3420 bn = (bn[0] == '@') ? bn + 1 : bn;
3423 return (strcmp (an, bn));
3427 remove_null_names (export_type **ptr)
3432 for (dst = src = 0; src < d_nfuncs; src++)
3436 ptr[dst] = ptr[src];
3444 process_duplicates (export_type **d_export_vec)
3452 /* Remove duplicates. */
3453 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), nfunc);
3455 for (i = 0; i < d_nfuncs - 1; i++)
3457 if (strcmp (d_export_vec[i]->name,
3458 d_export_vec[i + 1]->name) == 0)
3460 export_type *a = d_export_vec[i];
3461 export_type *b = d_export_vec[i + 1];
3465 /* xgettext:c-format */
3466 inform (_("Warning, ignoring duplicate EXPORT %s %d,%d"),
3467 a->name, a->ordinal, b->ordinal);
3469 if (a->ordinal != -1
3470 && b->ordinal != -1)
3471 /* xgettext:c-format */
3472 fatal (_("Error, duplicate EXPORT with ordinals: %s"),
3475 /* Merge attributes. */
3476 b->ordinal = a->ordinal > 0 ? a->ordinal : b->ordinal;
3477 b->constant |= a->constant;
3478 b->noname |= a->noname;
3480 d_export_vec[i] = 0;
3483 remove_null_names (d_export_vec);
3487 /* Count the names. */
3488 for (i = 0; i < d_nfuncs; i++)
3489 if (!d_export_vec[i]->noname)
3494 fill_ordinals (export_type **d_export_vec)
3501 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
3503 /* Fill in the unset ordinals with ones from our range. */
3504 ptr = (char *) xmalloc (size);
3506 memset (ptr, 0, size);
3508 /* Mark in our large vector all the numbers that are taken. */
3509 for (i = 0; i < d_nfuncs; i++)
3511 if (d_export_vec[i]->ordinal != -1)
3513 ptr[d_export_vec[i]->ordinal] = 1;
3515 if (lowest == -1 || d_export_vec[i]->ordinal < lowest)
3516 lowest = d_export_vec[i]->ordinal;
3520 /* Start at 1 for compatibility with MS toolchain. */
3524 /* Now fill in ordinals where the user wants us to choose. */
3525 for (i = 0; i < d_nfuncs; i++)
3527 if (d_export_vec[i]->ordinal == -1)
3531 /* First try within or after any user supplied range. */
3532 for (j = lowest; j < size; j++)
3536 d_export_vec[i]->ordinal = j;
3540 /* Then try before the range. */
3541 for (j = lowest; j >0; j--)
3545 d_export_vec[i]->ordinal = j;
3555 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
3557 /* Work out the lowest and highest ordinal numbers. */
3560 if (d_export_vec[0])
3561 d_low_ord = d_export_vec[0]->ordinal;
3562 if (d_export_vec[d_nfuncs-1])
3563 d_high_ord = d_export_vec[d_nfuncs-1]->ordinal;
3570 /* First work out the minimum ordinal chosen. */
3575 export_type **d_export_vec = xmalloc (sizeof (export_type *) * d_nfuncs);
3577 inform (_("Processing definitions"));
3579 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3580 d_export_vec[i] = exp;
3582 process_duplicates (d_export_vec);
3583 fill_ordinals (d_export_vec);
3585 /* Put back the list in the new order. */
3587 for (i = d_nfuncs - 1; i >= 0; i--)
3589 d_export_vec[i]->next = d_exports;
3590 d_exports = d_export_vec[i];
3593 /* Build list in alpha order. */
3594 d_exports_lexically = (export_type **)
3595 xmalloc (sizeof (export_type *) * (d_nfuncs + 1));
3597 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3598 d_exports_lexically[i] = exp;
3600 d_exports_lexically[i] = 0;
3602 qsort (d_exports_lexically, i, sizeof (export_type *), nfunc);
3604 /* Fill exp entries with their hint values. */
3605 for (i = 0; i < d_nfuncs; i++)
3606 if (!d_exports_lexically[i]->noname || show_allnames)
3607 d_exports_lexically[i]->hint = hint++;
3609 inform (_("Processed definitions"));
3613 usage (FILE *file, int status)
3615 /* xgetext:c-format */
3616 fprintf (file, _("Usage %s <option(s)> <object-file(s)>\n"), program_name);
3617 /* xgetext:c-format */
3618 fprintf (file, _(" -m --machine <machine> Create as DLL for <machine>. [default: %s]\n"), mname);
3619 fprintf (file, _(" possible <machine>: arm[_interwork], i386, mcore[-elf]{-le|-be}, ppc, thumb\n"));
3620 fprintf (file, _(" -e --output-exp <outname> Generate an export file.\n"));
3621 fprintf (file, _(" -l --output-lib <outname> Generate an interface library.\n"));
3622 fprintf (file, _(" -a --add-indirect Add dll indirects to export file.\n"));
3623 fprintf (file, _(" -D --dllname <name> Name of input dll to put into interface lib.\n"));
3624 fprintf (file, _(" -d --input-def <deffile> Name of .def file to be read in.\n"));
3625 fprintf (file, _(" -z --output-def <deffile> Name of .def file to be created.\n"));
3626 fprintf (file, _(" --export-all-symbols Export all symbols to .def\n"));
3627 fprintf (file, _(" --no-export-all-symbols Only export listed symbols\n"));
3628 fprintf (file, _(" --exclude-symbols <list> Don't export <list>\n"));
3629 fprintf (file, _(" --no-default-excludes Clear default exclude symbols\n"));
3630 fprintf (file, _(" -b --base-file <basefile> Read linker generated base file.\n"));
3631 fprintf (file, _(" -x --no-idata4 Don't generate idata$4 section.\n"));
3632 fprintf (file, _(" -c --no-idata5 Don't generate idata$5 section.\n"));
3633 fprintf (file, _(" --use-nul-prefixed-import-tables Use zero prefixed idata$4 and idata$5.\n"));
3634 fprintf (file, _(" -U --add-underscore Add underscores to all symbols in interface library.\n"));
3635 fprintf (file, _(" --add-stdcall-underscore Add underscores to stdcall symbols in interface library.\n"));
3636 fprintf (file, _(" -k --kill-at Kill @<n> from exported names.\n"));
3637 fprintf (file, _(" -A --add-stdcall-alias Add aliases without @<n>.\n"));
3638 fprintf (file, _(" -p --ext-prefix-alias <prefix> Add aliases with <prefix>.\n"));
3639 fprintf (file, _(" -S --as <name> Use <name> for assembler.\n"));
3640 fprintf (file, _(" -f --as-flags <flags> Pass <flags> to the assembler.\n"));
3641 fprintf (file, _(" -C --compat-implib Create backward compatible import library.\n"));
3642 fprintf (file, _(" -n --no-delete Keep temp files (repeat for extra preservation).\n"));
3643 fprintf (file, _(" -t --temp-prefix <prefix> Use <prefix> to construct temp file names.\n"));
3644 fprintf (file, _(" -I --identify <implib> Report the name of the DLL associated with <implib>.\n"));
3645 fprintf (file, _(" --identify-strict Causes --identify to report error when multiple DLLs.\n"));
3646 fprintf (file, _(" -v --verbose Be verbose.\n"));
3647 fprintf (file, _(" -V --version Display the program version.\n"));
3648 fprintf (file, _(" -h --help Display this information.\n"));
3649 fprintf (file, _(" @<file> Read options from <file>.\n"));
3650 #ifdef DLLTOOL_MCORE_ELF
3651 fprintf (file, _(" -M --mcore-elf <outname> Process mcore-elf object files into <outname>.\n"));
3652 fprintf (file, _(" -L --linker <name> Use <name> as the linker.\n"));
3653 fprintf (file, _(" -F --linker-flags <flags> Pass <flags> to the linker.\n"));
3655 if (REPORT_BUGS_TO[0] && status == 0)
3656 fprintf (file, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3660 #define OPTION_EXPORT_ALL_SYMS 150
3661 #define OPTION_NO_EXPORT_ALL_SYMS (OPTION_EXPORT_ALL_SYMS + 1)
3662 #define OPTION_EXCLUDE_SYMS (OPTION_NO_EXPORT_ALL_SYMS + 1)
3663 #define OPTION_NO_DEFAULT_EXCLUDES (OPTION_EXCLUDE_SYMS + 1)
3664 #define OPTION_ADD_STDCALL_UNDERSCORE (OPTION_NO_DEFAULT_EXCLUDES + 1)
3665 #define OPTION_USE_NUL_PREFIXED_IMPORT_TABLES \
3666 (OPTION_ADD_STDCALL_UNDERSCORE + 1)
3667 #define OPTION_IDENTIFY_STRICT (OPTION_USE_NUL_PREFIXED_IMPORT_TABLES + 1)
3669 static const struct option long_options[] =
3671 {"no-delete", no_argument, NULL, 'n'},
3672 {"dllname", required_argument, NULL, 'D'},
3673 {"no-idata4", no_argument, NULL, 'x'},
3674 {"no-idata5", no_argument, NULL, 'c'},
3675 {"use-nul-prefixed-import-tables", no_argument, NULL,
3676 OPTION_USE_NUL_PREFIXED_IMPORT_TABLES},
3677 {"output-exp", required_argument, NULL, 'e'},
3678 {"output-def", required_argument, NULL, 'z'},
3679 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL_SYMS},
3680 {"no-export-all-symbols", no_argument, NULL, OPTION_NO_EXPORT_ALL_SYMS},
3681 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMS},
3682 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
3683 {"output-lib", required_argument, NULL, 'l'},
3684 {"def", required_argument, NULL, 'd'}, /* for compatibility with older versions */
3685 {"input-def", required_argument, NULL, 'd'},
3686 {"add-underscore", no_argument, NULL, 'U'},
3687 {"add-stdcall-underscore", no_argument, NULL, OPTION_ADD_STDCALL_UNDERSCORE},
3688 {"kill-at", no_argument, NULL, 'k'},
3689 {"add-stdcall-alias", no_argument, NULL, 'A'},
3690 {"ext-prefix-alias", required_argument, NULL, 'p'},
3691 {"identify", required_argument, NULL, 'I'},
3692 {"identify-strict", no_argument, NULL, OPTION_IDENTIFY_STRICT},
3693 {"verbose", no_argument, NULL, 'v'},
3694 {"version", no_argument, NULL, 'V'},
3695 {"help", no_argument, NULL, 'h'},
3696 {"machine", required_argument, NULL, 'm'},
3697 {"add-indirect", no_argument, NULL, 'a'},
3698 {"base-file", required_argument, NULL, 'b'},
3699 {"as", required_argument, NULL, 'S'},
3700 {"as-flags", required_argument, NULL, 'f'},
3701 {"mcore-elf", required_argument, NULL, 'M'},
3702 {"compat-implib", no_argument, NULL, 'C'},
3703 {"temp-prefix", required_argument, NULL, 't'},
3707 int main (int, char **);
3710 main (int ac, char **av)
3715 program_name = av[0];
3718 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
3719 setlocale (LC_MESSAGES, "");
3721 #if defined (HAVE_SETLOCALE)
3722 setlocale (LC_CTYPE, "");
3724 bindtextdomain (PACKAGE, LOCALEDIR);
3725 textdomain (PACKAGE);
3727 expandargv (&ac, &av);
3729 while ((c = getopt_long (ac, av,
3730 #ifdef DLLTOOL_MCORE_ELF
3731 "m:e:l:aD:d:z:b:xp:cCuUkAS:f:nI:vVHhM:L:F:",
3733 "m:e:l:aD:d:z:b:xp:cCuUkAS:f:nI:vVHh",
3740 case OPTION_EXPORT_ALL_SYMS:
3741 export_all_symbols = TRUE;
3743 case OPTION_NO_EXPORT_ALL_SYMS:
3744 export_all_symbols = FALSE;
3746 case OPTION_EXCLUDE_SYMS:
3747 add_excludes (optarg);
3749 case OPTION_NO_DEFAULT_EXCLUDES:
3750 do_default_excludes = FALSE;
3752 case OPTION_USE_NUL_PREFIXED_IMPORT_TABLES:
3753 use_nul_prefixed_import_tables = TRUE;
3755 case OPTION_ADD_STDCALL_UNDERSCORE:
3756 add_stdcall_underscore = 1;
3758 case OPTION_IDENTIFY_STRICT:
3759 identify_strict = 1;
3771 tmp_prefix = optarg;
3777 /* Ignored for compatibility. */
3784 output_def = fopen (optarg, FOPEN_WT);
3787 dll_name = (char*) lbasename (optarg);
3788 if (dll_name != optarg)
3789 non_fatal (_("Path components stripped from dllname, '%s'."),
3806 identify_imp_name = optarg;
3812 print_version (program_name);
3821 add_stdcall_alias = 1;
3824 ext_prefix_alias = optarg;
3833 base_file = fopen (optarg, FOPEN_RB);
3836 /* xgettext:c-format */
3837 fatal (_("Unable to open base-file: %s"), optarg);
3840 #ifdef DLLTOOL_MCORE_ELF
3842 mcore_elf_out_file = optarg;
3845 mcore_elf_linker = optarg;
3848 mcore_elf_linker_flags = optarg;
3852 create_compat_implib = 1;
3861 tmp_prefix = prefix_encode ("d", getpid ());
3863 for (i = 0; mtable[i].type; i++)
3864 if (strcmp (mtable[i].type, mname) == 0)
3867 if (!mtable[i].type)
3868 /* xgettext:c-format */
3869 fatal (_("Machine '%s' not supported"), mname);
3873 /* Check if we generated PE+. */
3874 create_for_pep = strcmp (mname, "i386:x86-64") == 0;
3876 if (!dll_name && exp_name)
3878 /* If we are inferring dll_name from exp_name,
3879 strip off any path components, without emitting
3881 const char* exp_basename = lbasename (exp_name);
3882 const int len = strlen (exp_basename) + 5;
3883 dll_name = xmalloc (len);
3884 strcpy (dll_name, exp_basename);
3885 strcat (dll_name, ".dll");
3888 if (as_name == NULL)
3889 as_name = deduce_name ("as");
3891 /* Don't use the default exclude list if we're reading only the
3892 symbols in the .drectve section. The default excludes are meant
3893 to avoid exporting DLL entry point and Cygwin32 impure_ptr. */
3894 if (! export_all_symbols)
3895 do_default_excludes = FALSE;
3897 if (do_default_excludes)
3898 set_default_excludes ();
3901 process_def_file (def_file);
3906 firstarg = av[optind];
3907 scan_obj_file (av[optind]);
3918 /* Make imp_name safe for use as a label. */
3921 imp_name_lab = xstrdup (imp_name);
3922 for (p = imp_name_lab; *p; p++)
3927 head_label = make_label("_head_", imp_name_lab);
3934 if (identify_imp_name)
3936 identify_dll_for_implib ();
3939 #ifdef DLLTOOL_MCORE_ELF
3940 if (mcore_elf_out_file)
3941 mcore_elf_gen_out_file ();
3947 /* Look for the program formed by concatenating PROG_NAME and the
3948 string running from PREFIX to END_PREFIX. If the concatenated
3949 string contains a '/', try appending EXECUTABLE_SUFFIX if it is
3953 look_for_prog (const char *prog_name, const char *prefix, int end_prefix)
3958 cmd = xmalloc (strlen (prefix)
3959 + strlen (prog_name)
3960 #ifdef HAVE_EXECUTABLE_SUFFIX
3961 + strlen (EXECUTABLE_SUFFIX)
3964 strcpy (cmd, prefix);
3966 sprintf (cmd + end_prefix, "%s", prog_name);
3968 if (strchr (cmd, '/') != NULL)
3972 found = (stat (cmd, &s) == 0
3973 #ifdef HAVE_EXECUTABLE_SUFFIX
3974 || stat (strcat (cmd, EXECUTABLE_SUFFIX), &s) == 0
3980 /* xgettext:c-format */
3981 inform (_("Tried file: %s"), cmd);
3987 /* xgettext:c-format */
3988 inform (_("Using file: %s"), cmd);
3993 /* Deduce the name of the program we are want to invoke.
3994 PROG_NAME is the basic name of the program we want to run,
3995 eg "as" or "ld". The catch is that we might want actually
3996 run "i386-pe-as" or "ppc-pe-ld".
3998 If argv[0] contains the full path, then try to find the program
3999 in the same place, with and then without a target-like prefix.
4001 Given, argv[0] = /usr/local/bin/i586-cygwin32-dlltool,
4002 deduce_name("as") uses the following search order:
4004 /usr/local/bin/i586-cygwin32-as
4008 If there's an EXECUTABLE_SUFFIX, it'll use that as well; for each
4009 name, it'll try without and then with EXECUTABLE_SUFFIX.
4011 Given, argv[0] = i586-cygwin32-dlltool, it will not even try "as"
4012 as the fallback, but rather return i586-cygwin32-as.
4014 Oh, and given, argv[0] = dlltool, it'll return "as".
4016 Returns a dynamically allocated string. */
4019 deduce_name (const char *prog_name)
4022 char *dash, *slash, *cp;
4026 for (cp = program_name; *cp != '\0'; ++cp)
4031 #if defined(__DJGPP__) || defined (__CYGWIN__) || defined(__WIN32__)
4032 *cp == ':' || *cp == '\\' ||
4045 /* First, try looking for a prefixed PROG_NAME in the
4046 PROGRAM_NAME directory, with the same prefix as PROGRAM_NAME. */
4047 cmd = look_for_prog (prog_name, program_name, dash - program_name + 1);
4050 if (slash != NULL && cmd == NULL)
4052 /* Next, try looking for a PROG_NAME in the same directory as
4053 that of this program. */
4054 cmd = look_for_prog (prog_name, program_name, slash - program_name + 1);
4059 /* Just return PROG_NAME as is. */
4060 cmd = xstrdup (prog_name);
4066 #ifdef DLLTOOL_MCORE_ELF
4067 typedef struct fname_cache
4069 const char * filename;
4070 struct fname_cache * next;
4074 static fname_cache fnames;
4077 mcore_elf_cache_filename (const char * filename)
4083 while (ptr->next != NULL)
4086 ptr->filename = filename;
4087 ptr->next = (fname_cache *) malloc (sizeof (fname_cache));
4088 if (ptr->next != NULL)
4089 ptr->next->next = NULL;
4092 #define MCORE_ELF_TMP_OBJ "mcoreelf.o"
4093 #define MCORE_ELF_TMP_EXP "mcoreelf.exp"
4094 #define MCORE_ELF_TMP_LIB "mcoreelf.lib"
4097 mcore_elf_gen_out_file (void)
4102 /* Step one. Run 'ld -r' on the input object files in order to resolve
4103 any internal references and to generate a single .exports section. */
4106 ds = dyn_string_new (100);
4107 dyn_string_append_cstr (ds, "-r ");
4109 if (mcore_elf_linker_flags != NULL)
4110 dyn_string_append_cstr (ds, mcore_elf_linker_flags);
4112 while (ptr->next != NULL)
4114 dyn_string_append_cstr (ds, ptr->filename);
4115 dyn_string_append_cstr (ds, " ");
4120 dyn_string_append_cstr (ds, "-o ");
4121 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
4123 if (mcore_elf_linker == NULL)
4124 mcore_elf_linker = deduce_name ("ld");
4126 run (mcore_elf_linker, ds->s);
4128 dyn_string_delete (ds);
4130 /* Step two. Create a .exp file and a .lib file from the temporary file.
4131 Do this by recursively invoking dlltool... */
4132 ds = dyn_string_new (100);
4134 dyn_string_append_cstr (ds, "-S ");
4135 dyn_string_append_cstr (ds, as_name);
4137 dyn_string_append_cstr (ds, " -e ");
4138 dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP);
4139 dyn_string_append_cstr (ds, " -l ");
4140 dyn_string_append_cstr (ds, MCORE_ELF_TMP_LIB);
4141 dyn_string_append_cstr (ds, " " );
4142 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
4145 dyn_string_append_cstr (ds, " -v");
4149 dyn_string_append_cstr (ds, " -n");
4151 if (dontdeltemps > 1)
4152 dyn_string_append_cstr (ds, " -n");
4155 /* XXX - FIME: ought to check/copy other command line options as well. */
4156 run (program_name, ds->s);
4158 dyn_string_delete (ds);
4160 /* Step four. Feed the .exp and object files to ld -shared to create the dll. */
4161 ds = dyn_string_new (100);
4163 dyn_string_append_cstr (ds, "-shared ");
4165 if (mcore_elf_linker_flags)
4166 dyn_string_append_cstr (ds, mcore_elf_linker_flags);
4168 dyn_string_append_cstr (ds, " ");
4169 dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP);
4170 dyn_string_append_cstr (ds, " ");
4171 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
4172 dyn_string_append_cstr (ds, " -o ");
4173 dyn_string_append_cstr (ds, mcore_elf_out_file);
4175 run (mcore_elf_linker, ds->s);
4177 dyn_string_delete (ds);
4179 if (dontdeltemps == 0)
4180 unlink (MCORE_ELF_TMP_EXP);
4182 if (dontdeltemps < 2)
4183 unlink (MCORE_ELF_TMP_OBJ);
4185 #endif /* DLLTOOL_MCORE_ELF */