1 /* dlltool.c -- tool to generate stuff for PE style DLLs
2 Copyright (C) 1995, 96, 97, 98, 1999 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
23 This program allows you to build the files necessary to create
24 DLLs to run on a system which understands PE format image files.
27 See "Peering Inside the PE: A Tour of the Win32 Portable Executable
28 File Format", MSJ 1994, Volume 9 for more information.
29 Also see "Microsoft Portable Executable and Common Object File Format,
30 Specification 4.1" for more information.
32 A DLL contains an export table which contains the information
33 which the runtime loader needs to tie up references from a
36 The export table is generated by this program by reading
37 in a .DEF file or scanning the .a and .o files which will be in the
38 DLL. A .o file can contain information in special ".drectve" sections
39 with export information.
41 A DEF file contains any number of the following commands:
44 NAME <name> [ , <base> ]
45 The result is going to be <name>.EXE
47 LIBRARY <name> [ , <base> ]
48 The result is going to be <name>.DLL
50 EXPORTS ( <name1> [ = <name2> ] [ @ <integer> ] [ NONAME ] [CONSTANT] [DATA] ) *
51 Declares name1 as an exported symbol from the
52 DLL, with optional ordinal number <integer>
54 IMPORTS ( ( <internal-name> = <module-name> . <integer> )
55 | ( [ <internal-name> = ] <module-name> . <external-name> )) *
56 Declares that <external-name> or the exported function whoes ordinal number
57 is <integer> is to be imported from the file <module-name>. If
58 <internal-name> is specified then this is the name that the imported
59 function will be refered to in the body of the DLL.
62 Puts <string> into output .exp file in the .rdata section
64 [STACKSIZE|HEAPSIZE] <number-reserve> [ , <number-commit> ]
65 Generates --stack|--heap <number-reserve>,<number-commit>
66 in the output .drectve section. The linker will
67 see this and act upon it.
70 SECTIONS ( <sectionname> <attr>+ )*
71 <attr> = READ | WRITE | EXECUTE | SHARED
72 Generates --attr <sectionname> <attr> in the output
73 .drectve section. The linker will see this and act
77 A -export:<name> in a .drectve section in an input .o or .a
78 file to this program is equivalent to a EXPORTS <name>
83 The program generates output files with the prefix supplied
84 on the command line, or in the def file, or taken from the first
87 The .exp.s file contains the information necessary to export
88 the routines in the DLL. The .lib.s file contains the information
89 necessary to use the DLL's routines from a referencing program.
96 asm (".section .drectve");
97 asm (".ascii \"-export:adef\"");
101 printf ("hello from the dll %s\n", s);
106 printf ("hello from the dll and the other entry point %s\n", s);
110 asm (".section .drectve");
111 asm (".ascii \"-export:cdef\"");
112 asm (".ascii \"-export:ddef\"");
116 printf ("hello from the dll %s\n", s);
121 printf ("hello from the dll and the other entry point %s\n", s);
139 HEAPSIZE 0x40000, 0x2000
143 SECTIONS donkey READ WRITE
146 # Compile up the parts of the dll and the program
148 gcc -c file1.c file2.c themain.c
150 # Optional: put the dll objects into a library
151 # (you don't have to, you could name all the object
152 # files on the dlltool line)
154 ar qcv thedll.in file1.o file2.o
157 # Run this tool over the DLL's .def file and generate an exports
158 # file (thedll.o) and an imports file (thedll.a).
159 # (You may have to use -S to tell dlltool where to find the assembler).
161 dlltool --def thedll.def --output-exp thedll.o --output-lib thedll.a
163 # Build the dll with the library and the export table
165 ld -o thedll.dll thedll.o thedll.in
167 # Link the executable with the import library
169 gcc -o themain.exe themain.o thedll.a
171 This example can be extended if relocations are needed in the DLL:
173 # Compile up the parts of the dll and the program
175 gcc -c file1.c file2.c themain.c
177 # Run this tool over the DLL's .def file and generate an imports file.
179 dlltool --def thedll.def --output-lib thedll.lib
181 # Link the executable with the import library and generate a base file
184 gcc -o themain.exe themain.o thedll.lib -Wl,--base-file -Wl,themain.base
186 # Run this tool over the DLL's .def file and generate an exports file
187 # which includes the relocations from the base file.
189 dlltool --def thedll.def --base-file themain.base --output-exp thedll.exp
191 # Build the dll with file1.o, file2.o and the export table
193 ld -o thedll.dll thedll.exp file1.o file2.o
196 /* .idata section description
198 The .idata section is the import table. It is a collection of several
199 subsections used to keep the pieces for each dll together: .idata$[234567].
200 IE: Each dll's .idata$2's are catenated together, each .idata$3's, etc.
202 .idata$2 = Import Directory Table
203 = array of IMAGE_IMPORT_DESCRIPTOR's.
205 DWORD Import Lookup Table; - pointer to .idata$4
206 DWORD TimeDateStamp; - currently always 0
207 DWORD ForwarderChain; - currently always 0
208 DWORD Name; - pointer to dll's name
209 PIMAGE_THUNK_DATA FirstThunk; - pointer to .idata$5
211 .idata$3 = null terminating entry for .idata$2.
213 .idata$4 = Import Lookup Table
214 = array of array of pointers to hint name table.
215 There is one for each dll being imported from, and each dll's set is
216 terminated by a trailing NULL.
218 .idata$5 = Import Address Table
219 = array of array of pointers to hint name table.
220 There is one for each dll being imported from, and each dll's set is
221 terminated by a trailing NULL.
222 Initially, this table is identical to the Import Lookup Table. However,
223 at load time, the loader overwrites the entries with the address of the
226 .idata$6 = Hint Name Table
227 = Array of { short, asciz } entries, one for each imported function.
228 The `short' is the function's ordinal number.
230 .idata$7 = dll name (eg: "kernel32.dll"). (.idata$6 for ppc)
233 /* AIX requires this to be the first thing in the file. */
240 #define show_allnames 0
242 #define PAGE_SIZE 4096
243 #define PAGE_MASK (-PAGE_SIZE)
245 #include "libiberty.h"
248 #include "demangle.h"
249 #include "dyn-string.h"
254 #include <sys/stat.h>
256 #ifdef ANSI_PROTOTYPES
263 #include "coff/arm.h"
264 #include "coff/internal.h"
267 /* Forward references. */
268 static char *look_for_prog PARAMS ((const char *, const char *, int));
269 static char *deduce_name PARAMS ((const char *));
271 #ifdef DLLTOOL_MCORE_ELF
272 static void mcore_elf_cache_filename (char *);
273 static void mcore_elf_gen_out_file (void);
276 #ifdef HAVE_SYS_WAIT_H
277 #include <sys/wait.h>
278 #else /* ! HAVE_SYS_WAIT_H */
279 #if ! defined (_WIN32) || defined (__CYGWIN32__)
281 #define WIFEXITED(w) (((w)&0377) == 0)
284 #define WIFSIGNALED(w) (((w)&0377) != 0177 && ((w)&~0377) == 0)
287 #define WTERMSIG(w) ((w) & 0177)
290 #define WEXITSTATUS(w) (((w) >> 8) & 0377)
292 #else /* defined (_WIN32) && ! defined (__CYGWIN32__) */
294 #define WIFEXITED(w) (((w) & 0xff) == 0)
297 #define WIFSIGNALED(w) (((w) & 0xff) != 0 && ((w) & 0xff) != 0x7f)
300 #define WTERMSIG(w) ((w) & 0x7f)
303 #define WEXITSTATUS(w) (((w) & 0xff00) >> 8)
305 #endif /* defined (_WIN32) && ! defined (__CYGWIN32__) */
306 #endif /* ! HAVE_SYS_WAIT_H */
308 /* ifunc and ihead data structures: ttk@cygnus.com 1997
310 When IMPORT declarations are encountered in a .def file the
311 function import information is stored in a structure referenced by
312 the global variable IMPORT_LIST. The structure is a linked list
313 containing the names of the dll files each function is imported
314 from and a linked list of functions being imported from that dll
315 file. This roughly parallels the structure of the .idata section
316 in the PE object file.
318 The contents of .def file are interpreted from within the
319 process_def_file function. Every time an IMPORT declaration is
320 encountered, it is broken up into its component parts and passed to
321 def_import. IMPORT_LIST is initialized to NULL in function main. */
323 typedef struct ifunct
325 char *name; /* name of function being imported */
326 int ord; /* two-byte ordinal value associated with function */
330 typedef struct iheadt
332 char *dllname; /* name of dll file imported from */
333 long nfuncs; /* number of functions in list */
334 struct ifunct *funchead; /* first function in list */
335 struct ifunct *functail; /* last function in list */
336 struct iheadt *next; /* next dll file in list */
339 /* Structure containing all import information as defined in .def file
340 (qv "ihead structure"). */
342 static iheadtype *import_list = NULL;
344 static char *as_name = NULL;
345 static char * as_flags = "";
347 static int no_idata4;
348 static int no_idata5;
349 static char *exp_name;
350 static char *imp_name;
351 static char *head_label;
352 static char *imp_name_lab;
353 static char *dll_name;
355 static int add_indirect = 0;
356 static int add_underscore = 0;
357 static int dontdeltemps = 0;
359 /* True if we should export all symbols. Otherwise, we only export
360 symbols listed in .drectve sections or in the def file. */
361 static boolean export_all_symbols;
363 /* True if we should exclude the symbols in DEFAULT_EXCLUDES when
364 exporting all symbols. */
365 static boolean do_default_excludes;
367 /* Default symbols to exclude when exporting all the symbols. */
368 static const char *default_excludes = "DllMain@12,DllEntryPoint@0,impure_ptr";
370 static char *def_file;
372 extern char * program_name;
376 static int add_stdcall_alias;
378 static FILE *output_def;
379 static FILE *base_file;
382 static const char *mname = "arm";
386 static const char *mname = "i386";
390 static const char *mname = "ppc";
394 static const char * mname = "mcore";
397 #ifdef DLLTOOL_MCORE_ELF
398 static const char * mname = "mcore-elf";
399 static char * mcore_elf_out_file = NULL;
400 static char * mcore_elf_linker = NULL;
401 static char * mcore_elf_linker_flags = NULL;
403 #define DRECTVE_SECTION_NAME ((machine == MMCORE_ELF || machine == MMCORE_ELF_LE) ? ".exports" : ".drectve")
406 #ifndef DRECTVE_SECTION_NAME
407 #define DRECTVE_SECTION_NAME ".drectve"
410 #define PATHMAX 250 /* What's the right name for this ? */
412 #define TMP_ASM "dc.s"
413 #define TMP_HEAD_S "dh.s"
414 #define TMP_HEAD_O "dh.o"
415 #define TMP_TAIL_S "dt.s"
416 #define TMP_TAIL_O "dt.o"
417 #define TMP_STUB "ds"
419 /* This bit of assemly does jmp * .... */
420 static const unsigned char i386_jtab[] =
422 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
425 static const unsigned char arm_jtab[] =
427 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
428 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
432 static const unsigned char arm_interwork_jtab[] =
434 0x04, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
435 0x00, 0xc0, 0x9c, 0xe5, /* ldr ip, [ip] */
436 0x1c, 0xff, 0x2f, 0xe1, /* bx ip */
440 static const unsigned char thumb_jtab[] =
442 0x40, 0xb4, /* push {r6} */
443 0x02, 0x4e, /* ldr r6, [pc, #8] */
444 0x36, 0x68, /* ldr r6, [r6] */
445 0xb4, 0x46, /* mov ip, r6 */
446 0x40, 0xbc, /* pop {r6} */
447 0x60, 0x47, /* bx ip */
451 static const unsigned char mcore_be_jtab[] =
453 0x70, 0x01, /* jmpi 1 */
454 0x12, 0x11, /* nop */
455 0x00, 0x00, 0x00, 0x00 /* <address> */
458 static const unsigned char mcore_le_jtab[] =
460 0x01, 0x70, /* jmpi 1 */
461 0x11, 0x12, /* nop */
462 0x00, 0x00, 0x00, 0x00 /* <address> */
465 /* This is the glue sequence for PowerPC PE. There is a */
466 /* tocrel16-tocdefn reloc against the first instruction. */
467 /* We also need a IMGLUE reloc against the glue function */
468 /* to restore the toc saved by the third instruction in */
470 static const unsigned char ppc_jtab[] =
472 0x00, 0x00, 0x62, 0x81, /* lwz r11,0(r2) */
473 /* Reloc TOCREL16 __imp_xxx */
474 0x00, 0x00, 0x8B, 0x81, /* lwz r12,0(r11) */
475 0x04, 0x00, 0x41, 0x90, /* stw r2,4(r1) */
476 0xA6, 0x03, 0x89, 0x7D, /* mtctr r12 */
477 0x04, 0x00, 0x4B, 0x80, /* lwz r2,4(r11) */
478 0x20, 0x04, 0x80, 0x4E /* bctr */
482 /* the glue instruction, picks up the toc from the stw in */
483 /* the above code: "lwz r2,4(r1)" */
484 static bfd_vma ppc_glue_insn = 0x80410004;
490 const char *how_byte;
491 const char *how_short;
492 const char *how_long;
493 const char *how_asciz;
494 const char *how_comment;
495 const char *how_jump;
496 const char *how_global;
497 const char *how_space;
498 const char *how_align_short;
499 const char *how_align_long;
500 const char *how_default_as_switches;
501 const char *how_bfd_target;
502 enum bfd_architecture how_bfd_arch;
503 const unsigned char *how_jtab;
504 int how_jtab_size; /* size of the jtab entry */
505 int how_jtab_roff; /* offset into it for the ind 32 reloc into idata 5 */
508 static const struct mac
513 "arm", ".byte", ".short", ".long", ".asciz", "@",
514 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
515 ".global", ".space", ".align\t2",".align\t4", "",
516 "pe-arm-little", bfd_arch_arm,
517 arm_jtab, sizeof (arm_jtab), 8
522 "i386", ".byte", ".short", ".long", ".asciz", "#",
523 "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
524 "pe-i386",bfd_arch_i386,
525 i386_jtab, sizeof (i386_jtab), 2
530 "ppc", ".byte", ".short", ".long", ".asciz", "#",
531 "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
532 "pe-powerpcle",bfd_arch_powerpc,
533 ppc_jtab, sizeof (ppc_jtab), 0
538 "thumb", ".byte", ".short", ".long", ".asciz", "@",
539 "push\t{r6}\n\tldr\tr6, [pc, #8]\n\tldr\tr6, [r6]\n\tmov\tip, r6\n\tpop\t{r6}\n\tbx\tip",
540 ".global", ".space", ".align\t2",".align\t4", "=mthumb-interwork",
541 "pe-arm-little", bfd_arch_arm,
542 thumb_jtab, sizeof (thumb_jtab), 12
545 #define MARM_INTERWORK 4
547 "arm_interwork", ".byte", ".short", ".long", ".asciz", "@",
548 "ldr\tip,[pc]\n\tldr\tip,[ip]\n\tbx\tip\n\t.long",
549 ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
550 "pe-arm-little", bfd_arch_arm,
551 arm_interwork_jtab, sizeof (arm_interwork_jtab), 12
556 "mcore", ".byte", ".short", ".long", ".asciz", "//",
557 "jmpi\t1\n\tnop\n\t.long",
558 ".global", ".space", ".align\t2",".align\t4", "",
559 "pe-mcore-big", bfd_arch_mcore,
560 mcore_be_jtab, sizeof (mcore_be_jtab), 8
565 "mcore-le", ".byte", ".short", ".long", ".asciz", "//",
566 "jmpi\t1\n\tnop\n\t.long",
567 ".global", ".space", ".align\t2",".align\t4", "-EL",
568 "pe-mcore-little", bfd_arch_mcore,
569 mcore_le_jtab, sizeof (mcore_le_jtab), 8
574 "mcore-elf", ".byte", ".short", ".long", ".asciz", "//",
575 "jmpi\t1\n\tnop\n\t.long",
576 ".global", ".space", ".align\t2",".align\t4", "",
577 "elf32-mcore-big", bfd_arch_mcore,
578 mcore_be_jtab, sizeof (mcore_be_jtab), 8
582 #define MMCORE_ELF_LE 8
583 "mcore-elf-le", ".byte", ".short", ".long", ".asciz", "//",
584 "jmpi\t1\n\tnop\n\t.long",
585 ".global", ".space", ".align\t2",".align\t4", "-EL",
586 "elf32-mcore-little", bfd_arch_mcore,
587 mcore_le_jtab, sizeof (mcore_le_jtab), 8
600 typedef struct export
603 const char *internal_name;
613 /* A list of symbols which we should not export. */
617 struct string_list *next;
621 static struct string_list *excludes;
623 static const char *rvaafter PARAMS ((int));
624 static const char *rvabefore PARAMS ((int));
625 static const char *asm_prefix PARAMS ((int));
626 static void append_import PARAMS ((const char *, const char *, int));
627 static void run PARAMS ((const char *, char *));
628 static void scan_drectve_symbols PARAMS ((bfd *));
629 static void scan_filtered_symbols PARAMS ((bfd *, PTR, long, unsigned int));
630 static void add_excludes PARAMS ((const char *));
631 static boolean match_exclude PARAMS ((const char *));
632 static void set_default_excludes PARAMS ((void));
633 static long filter_symbols PARAMS ((bfd *, PTR, long, unsigned int));
634 static void scan_all_symbols PARAMS ((bfd *));
635 static void scan_open_obj_file PARAMS ((bfd *));
636 static void scan_obj_file PARAMS ((const char *));
637 static void dump_def_info PARAMS ((FILE *));
638 static int sfunc PARAMS ((const void *, const void *));
639 static void flush_page PARAMS ((FILE *, long *, int, int));
640 static void gen_def_file PARAMS ((void));
641 static void generate_idata_ofile PARAMS ((FILE *));
642 static void gen_exp_file PARAMS ((void));
643 static const char *xlate PARAMS ((const char *));
645 static void dump_iat PARAMS ((FILE *, export_type *));
647 static char *make_label PARAMS ((const char *, const char *));
648 static bfd *make_one_lib_file PARAMS ((export_type *, int));
649 static bfd *make_head PARAMS ((void));
650 static bfd *make_tail PARAMS ((void));
651 static void gen_lib_file PARAMS ((void));
652 static int pfunc PARAMS ((const void *, const void *));
653 static int nfunc PARAMS ((const void *, const void *));
654 static void remove_null_names PARAMS ((export_type **));
655 static void dtab PARAMS ((export_type **));
656 static void process_duplicates PARAMS ((export_type **));
657 static void fill_ordinals PARAMS ((export_type **));
658 static int alphafunc PARAMS ((const void *, const void *));
659 static void mangle_defs PARAMS ((void));
660 static void usage PARAMS ((FILE *, int));
661 static void display PARAMS ((const char *, va_list));
662 static void inform PARAMS ((const char *, ...));
663 static void warn PARAMS ((const char *, ...));
666 display (message, args)
667 const char * message;
670 if (program_name != NULL)
671 fprintf (stderr, "%s: ", program_name);
673 vfprintf (stderr, message, args);
675 if (message [strlen (message) - 1] != '\n')
676 fputc ('\n', stderr);
682 inform (const char * message, ...)
684 inform (message, va_alist)
685 const char * message;
695 va_start (args, message);
700 display (message, args);
707 warn (const char * message, ...)
709 warn (message, va_alist)
710 const char * message;
717 va_start (args, message);
722 display (message, args);
744 /* xgettext:c-format */
745 fatal (_("Internal error: Unknown machine type: %d\n"), machine);
768 /* xgettext:c-format */
769 fatal (_("Internal error: Unknown machine type: %d\n"), machine);
793 /* xgettext:c-format */
794 fatal (_("Internal error: Unknown machine type: %d\n"), machine);
800 #define ASM_BYTE mtable[machine].how_byte
801 #define ASM_SHORT mtable[machine].how_short
802 #define ASM_LONG mtable[machine].how_long
803 #define ASM_TEXT mtable[machine].how_asciz
804 #define ASM_C mtable[machine].how_comment
805 #define ASM_JUMP mtable[machine].how_jump
806 #define ASM_GLOBAL mtable[machine].how_global
807 #define ASM_SPACE mtable[machine].how_space
808 #define ASM_ALIGN_SHORT mtable[machine].how_align_short
809 #define ASM_RVA_BEFORE rvabefore(machine)
810 #define ASM_RVA_AFTER rvaafter(machine)
811 #define ASM_PREFIX asm_prefix(machine)
812 #define ASM_ALIGN_LONG mtable[machine].how_align_long
813 #define HOW_BFD_READ_TARGET 0 /* always default*/
814 #define HOW_BFD_WRITE_TARGET mtable[machine].how_bfd_target
815 #define HOW_BFD_ARCH mtable[machine].how_bfd_arch
816 #define HOW_JTAB mtable[machine].how_jtab
817 #define HOW_JTAB_SIZE mtable[machine].how_jtab_size
818 #define HOW_JTAB_ROFF mtable[machine].how_jtab_roff
819 #define ASM_SWITCHES mtable[machine].how_default_as_switches
824 process_def_file (name)
827 FILE *f = fopen (name, FOPEN_RT);
830 /* xgettext:c-format */
831 fatal (_("Can't open def file: %s"), name);
835 /* xgettext:c-format */
836 inform (_("Processing def file: %s"), name);
840 inform (_("Processed def file"));
843 /**********************************************************************/
845 /* Communications with the parser */
847 static const char *d_name; /* Arg to NAME or LIBRARY */
848 static int d_nfuncs; /* Number of functions exported */
849 static int d_named_nfuncs; /* Number of named functions exported */
850 static int d_low_ord; /* Lowest ordinal index */
851 static int d_high_ord; /* Highest ordinal index */
852 static export_type *d_exports; /*list of exported functions */
853 static export_type **d_exports_lexically; /* vector of exported functions in alpha order */
854 static dlist_type *d_list; /* Descriptions */
855 static dlist_type *a_list; /* Stuff to go in directives */
864 /* xgettext:c-format */
865 warn (_("Syntax error in def file %s:%d\n"), def_file, linenumber);
871 def_exports (name, internal_name, ordinal, noname, constant, data)
873 const char *internal_name;
879 struct export *p = (struct export *) xmalloc (sizeof (*p));
882 p->internal_name = internal_name ? internal_name : name;
883 p->ordinal = ordinal;
884 p->constant = constant;
893 def_name (name, base)
897 /* xgettext:c-format */
898 inform (_("NAME: %s base: %x"), name, base);
901 warn (_("Can't have LIBRARY and NAME\n"));
904 /* if --dllname not provided, use the one in the DEF file.
905 FIXME: Is this appropriate for executables? */
907 dll_name = xstrdup (name);
912 def_library (name, base)
916 /* xgettext:c-format */
917 inform (_("LIBRARY: %s base: %x"), name, base);
920 warn (_("%s: Can't have LIBRARY and NAME\n"), program_name);
923 /* if --dllname not provided, use the one in the DEF file. */
925 dll_name = xstrdup (name);
930 def_description (desc)
933 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
934 d->text = xstrdup (desc);
943 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
944 d->text = xstrdup (dir);
950 def_heapsize (reserve, commit)
956 sprintf (b, "-heap 0x%x,0x%x ", reserve, commit);
958 sprintf (b, "-heap 0x%x ", reserve);
959 new_directive (xstrdup (b));
963 def_stacksize (reserve, commit)
969 sprintf (b, "-stack 0x%x,0x%x ", reserve, commit);
971 sprintf (b, "-stack 0x%x ", reserve);
972 new_directive (xstrdup (b));
975 /* append_import simply adds the given import definition to the global
976 import_list. It is used by def_import. */
979 append_import (symbol_name, dll_name, func_ordinal)
980 const char *symbol_name;
981 const char *dll_name;
987 for (pq = &import_list; *pq != NULL; pq = &(*pq)->next)
989 if (strcmp ((*pq)->dllname, dll_name) == 0)
992 q->functail->next = xmalloc (sizeof (ifunctype));
993 q->functail = q->functail->next;
994 q->functail->ord = func_ordinal;
995 q->functail->name = xstrdup (symbol_name);
996 q->functail->next = NULL;
1002 q = xmalloc (sizeof (iheadtype));
1003 q->dllname = xstrdup (dll_name);
1005 q->funchead = xmalloc (sizeof (ifunctype));
1006 q->functail = q->funchead;
1008 q->functail->name = xstrdup (symbol_name);
1009 q->functail->ord = func_ordinal;
1010 q->functail->next = NULL;
1015 /* def_import is called from within defparse.y when an IMPORT
1016 declaration is encountered. Depending on the form of the
1017 declaration, the module name may or may not need ".dll" to be
1018 appended to it, the name of the function may be stored in internal
1019 or entry, and there may or may not be an ordinal value associated
1022 /* A note regarding the parse modes:
1023 In defparse.y we have to accept import declarations which follow
1024 any one of the following forms:
1025 <func_name_in_app> = <dll_name>.<func_name_in_dll>
1026 <func_name_in_app> = <dll_name>.<number>
1027 <dll_name>.<func_name_in_dll>
1029 Furthermore, the dll's name may or may not end with ".dll", which
1030 complicates the parsing a little. Normally the dll's name is
1031 passed to def_import() in the "module" parameter, but when it ends
1032 with ".dll" it gets passed in "module" sans ".dll" and that needs
1035 def_import gets five parameters:
1036 APP_NAME - the name of the function in the application, if
1037 present, or NULL if not present.
1038 MODULE - the name of the dll, possibly sans extension (ie, '.dll').
1039 DLLEXT - the extension of the dll, if present, NULL if not present.
1040 ENTRY - the name of the function in the dll, if present, or NULL.
1041 ORD_VAL - the numerical tag of the function in the dll, if present,
1042 or NULL. Exactly one of <entry> or <ord_val> must be
1043 present (i.e., not NULL). */
1046 def_import (app_name, module, dllext, entry, ord_val)
1047 const char *app_name;
1053 const char *application_name;
1057 application_name = entry;
1060 if (app_name != NULL)
1061 application_name = app_name;
1063 application_name = "";
1068 buf = (char *) alloca (strlen (module) + strlen (dllext) + 2);
1069 sprintf (buf, "%s.%s", module, dllext);
1073 append_import (application_name, module, ord_val);
1077 def_version (major, minor)
1081 printf ("VERSION %d.%d\n", major, minor);
1085 def_section (name, attr)
1102 sprintf (buf, "-attr %s %s", name, atts);
1103 new_directive (xstrdup (buf));
1111 def_section ("CODE", attr);
1118 def_section ("DATA", attr);
1121 /**********************************************************************/
1129 int pid, wait_status;
1132 char *errmsg_fmt, *errmsg_arg;
1133 char *temp_base = choose_temp_base ();
1135 inform ("run: %s %s\n", what, args);
1137 /* Count the args */
1139 for (s = args; *s; s++)
1143 argv = alloca (sizeof (char *) * (i + 3));
1152 while (*s != ' ' && *s != 0)
1160 pid = pexecute (argv[0], (char * const *) argv, program_name, temp_base,
1161 &errmsg_fmt, &errmsg_arg, PEXECUTE_ONE | PEXECUTE_SEARCH);
1165 inform (strerror (errno));
1167 fatal (errmsg_fmt, errmsg_arg);
1170 pid = pwait (pid, & wait_status, 0);
1174 /* xgettext:c-format */
1175 fatal (_("wait: %s"), strerror (errno));
1177 else if (WIFSIGNALED (wait_status))
1179 /* xgettext:c-format */
1180 fatal (_("subprocess got fatal signal %d"), WTERMSIG (wait_status));
1182 else if (WIFEXITED (wait_status))
1184 if (WEXITSTATUS (wait_status) != 0)
1185 /* xgettext:c-format */
1186 warn (_("%s exited with status %d\n"),
1187 what, WEXITSTATUS (wait_status));
1193 /* Look for a list of symbols to export in the .drectve section of
1194 ABFD. Pass each one to def_exports. */
1197 scan_drectve_symbols (abfd)
1206 /* Look for .drectve's */
1207 s = bfd_get_section_by_name (abfd, DRECTVE_SECTION_NAME);
1212 size = bfd_get_section_size_before_reloc (s);
1213 buf = xmalloc (size);
1215 bfd_get_section_contents (abfd, s, buf, 0, size);
1217 /* xgettext:c-format */
1218 inform (_("Sucking in info from %s section in %s\n"),
1219 DRECTVE_SECTION_NAME, bfd_get_filename (abfd));
1221 /* Search for -export: strings. The exported symbols can optionally
1222 have type tags (eg., -export:foo,data), so handle those as well.
1223 Currently only data tag is supported. */
1229 && strncmp (p, "-export:", 8) == 0)
1233 flagword flags = BSF_FUNCTION;
1237 while (p < e && *p != ',' && *p != ' ' && *p != '-')
1239 c = xmalloc (p - name + 1);
1240 memcpy (c, name, p - name);
1242 if (p < e && *p == ',') /* found type tag. */
1244 char *tag_start = ++p;
1245 while (p < e && *p != ' ' && *p != '-')
1247 if (strncmp (tag_start, "data", 4) == 0)
1248 flags &= ~BSF_FUNCTION;
1252 /* FIXME: The 5th arg is for the `constant' field.
1253 What should it be? Not that it matters since it's not
1254 currently useful. */
1255 def_exports (c, 0, -1, 0, 0, ! (flags & BSF_FUNCTION));
1257 if (add_stdcall_alias && strchr (c, '@'))
1259 char *exported_name = xstrdup (c);
1260 char *atsym = strchr (exported_name, '@');
1262 /* Note: stdcall alias symbols can never be data. */
1263 def_exports (exported_name, xstrdup (c), -1, 0, 0, 0);
1272 /* Look through the symbols in MINISYMS, and add each one to list of
1273 symbols to export. */
1276 scan_filtered_symbols (abfd, minisyms, symcount, size)
1283 bfd_byte *from, *fromend;
1285 store = bfd_make_empty_symbol (abfd);
1287 bfd_fatal (bfd_get_filename (abfd));
1289 from = (bfd_byte *) minisyms;
1290 fromend = from + symcount * size;
1291 for (; from < fromend; from += size)
1294 const char *symbol_name;
1296 sym = bfd_minisymbol_to_symbol (abfd, false, from, store);
1298 bfd_fatal (bfd_get_filename (abfd));
1300 symbol_name = bfd_asymbol_name (sym);
1301 if (bfd_get_symbol_leading_char (abfd) == symbol_name[0])
1304 def_exports (xstrdup (symbol_name) , 0, -1, 0, 0,
1305 ! (sym->flags & BSF_FUNCTION));
1307 if (add_stdcall_alias && strchr (symbol_name, '@'))
1309 char *exported_name = xstrdup (symbol_name);
1310 char *atsym = strchr (exported_name, '@');
1312 /* Note: stdcall alias symbols can never be data. */
1313 def_exports (exported_name, xstrdup (symbol_name), -1, 0, 0, 0);
1318 /* Add a list of symbols to exclude. */
1321 add_excludes (new_excludes)
1322 const char *new_excludes;
1325 char *exclude_string;
1327 local_copy = xstrdup (new_excludes);
1329 exclude_string = strtok (local_copy, ",:");
1330 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
1332 struct string_list *new_exclude;
1334 new_exclude = ((struct string_list *)
1335 xmalloc (sizeof (struct string_list)));
1336 new_exclude->string = (char *) xmalloc (strlen (exclude_string) + 2);
1337 /* FIXME: Is it always right to add a leading underscore? */
1338 sprintf (new_exclude->string, "_%s", exclude_string);
1339 new_exclude->next = excludes;
1340 excludes = new_exclude;
1342 /* xgettext:c-format */
1343 inform (_("Excluding symbol: %s\n"), exclude_string);
1349 /* See if STRING is on the list of symbols to exclude. */
1352 match_exclude (string)
1355 struct string_list *excl_item;
1357 for (excl_item = excludes; excl_item; excl_item = excl_item->next)
1358 if (strcmp (string, excl_item->string) == 0)
1363 /* Add the default list of symbols to exclude. */
1366 set_default_excludes (void)
1368 add_excludes (default_excludes);
1371 /* Choose which symbols to export. */
1374 filter_symbols (abfd, minisyms, symcount, size)
1380 bfd_byte *from, *fromend, *to;
1383 store = bfd_make_empty_symbol (abfd);
1385 bfd_fatal (bfd_get_filename (abfd));
1387 from = (bfd_byte *) minisyms;
1388 fromend = from + symcount * size;
1389 to = (bfd_byte *) minisyms;
1391 for (; from < fromend; from += size)
1396 sym = bfd_minisymbol_to_symbol (abfd, false, (const PTR) from, store);
1398 bfd_fatal (bfd_get_filename (abfd));
1400 /* Check for external and defined only symbols. */
1401 keep = (((sym->flags & BSF_GLOBAL) != 0
1402 || (sym->flags & BSF_WEAK) != 0
1403 || bfd_is_com_section (sym->section))
1404 && ! bfd_is_und_section (sym->section));
1406 keep = keep && ! match_exclude (sym->name);
1410 memcpy (to, from, size);
1415 return (to - (bfd_byte *) minisyms) / size;
1418 /* Export all symbols in ABFD, except for ones we were told not to
1422 scan_all_symbols (abfd)
1429 /* Ignore bfds with an import descriptor table. We assume that any
1430 such BFD contains symbols which are exported from another DLL,
1431 and we don't want to reexport them from here. */
1432 if (bfd_get_section_by_name (abfd, ".idata$4"))
1435 if (! (bfd_get_file_flags (abfd) & HAS_SYMS))
1437 /* xgettext:c-format */
1438 warn (_("%s: no symbols\n"), bfd_get_filename (abfd));
1442 symcount = bfd_read_minisymbols (abfd, false, &minisyms, &size);
1444 bfd_fatal (bfd_get_filename (abfd));
1448 /* xgettext:c-format */
1449 warn (_("%s: no symbols\n"), bfd_get_filename (abfd));
1453 /* Discard the symbols we don't want to export. It's OK to do this
1454 in place; we'll free the storage anyway. */
1456 symcount = filter_symbols (abfd, minisyms, symcount, size);
1457 scan_filtered_symbols (abfd, minisyms, symcount, size);
1462 /* Look at the object file to decide which symbols to export. */
1465 scan_open_obj_file (abfd)
1468 if (export_all_symbols)
1469 scan_all_symbols (abfd);
1471 scan_drectve_symbols (abfd);
1473 /* FIXME: we ought to read in and block out the base relocations */
1475 /* xgettext:c-format */
1476 inform (_("Done reading %s\n"), bfd_get_filename (abfd));
1480 scan_obj_file (filename)
1481 const char *filename;
1483 bfd * f = bfd_openr (filename, 0);
1486 /* xgettext:c-format */
1487 fatal (_("Unable to open object file: %s"), filename);
1489 /* xgettext:c-format */
1490 inform (_("Scanning object file %s"), filename);
1492 if (bfd_check_format (f, bfd_archive))
1494 bfd *arfile = bfd_openr_next_archived_file (f, 0);
1497 if (bfd_check_format (arfile, bfd_object))
1498 scan_open_obj_file (arfile);
1500 arfile = bfd_openr_next_archived_file (f, arfile);
1503 #ifdef DLLTOOL_MCORE_ELF
1504 if (mcore_elf_out_file)
1505 inform (_("Cannot produce mcore-elf dll from archive file: %s"), filename);
1508 else if (bfd_check_format (f, bfd_object))
1510 scan_open_obj_file (f);
1512 #ifdef DLLTOOL_MCORE_ELF
1513 if (mcore_elf_out_file)
1514 mcore_elf_cache_filename ((char *) filename);
1521 /**********************************************************************/
1529 fprintf (f, "%s ", ASM_C);
1530 for (i = 0; oav[i]; i++)
1531 fprintf (f, "%s ", oav[i]);
1533 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1535 fprintf (f, "%s %d = %s %s @ %d %s%s%s\n",
1541 exp->noname ? "NONAME " : "",
1542 exp->constant ? "CONSTANT" : "",
1543 exp->data ? "DATA" : "");
1547 /* Generate the .exp file */
1554 return *(const long *) a - *(const long *) b;
1558 flush_page (f, need, page_addr, on_page)
1566 /* Flush this page */
1567 fprintf (f, "\t%s\t0x%08x\t%s Starting RVA for chunk\n",
1571 fprintf (f, "\t%s\t0x%x\t%s Size of block\n",
1573 (on_page * 2) + (on_page & 1) * 2 + 8,
1575 for (i = 0; i < on_page; i++)
1577 fprintf (f, "\t%s\t0x%lx\n", ASM_SHORT, (need[i] - page_addr) | 0x3000);
1581 fprintf (f, "\t%s\t0x%x\n", ASM_SHORT, 0 | 0x0000);
1590 inform (_("Adding exports to output file"));
1592 fprintf (output_def, ";");
1593 for (i = 0; oav[i]; i++)
1594 fprintf (output_def, " %s", oav[i]);
1596 fprintf (output_def, "\nEXPORTS\n");
1598 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1600 char *quote = strchr (exp->name, '.') ? "\"" : "";
1601 char *res = cplus_demangle (exp->internal_name, DMGL_ANSI | DMGL_PARAMS);
1603 if (strcmp (exp->name, exp->internal_name) == 0)
1606 fprintf (output_def, "\t%s%s%s @ %d%s%s ; %s\n",
1611 exp->noname ? " NONAME" : "",
1612 exp->data ? " DATA" : "",
1617 char *quote1 = strchr (exp->internal_name, '.') ? "\"" : "";
1619 fprintf (output_def, "\t%s%s%s = %s%s%s @ %d%s%s ; %s\n",
1627 exp->noname ? " NONAME" : "",
1628 exp->data ? " DATA" : "",
1635 inform (_("Added exports to output file"));
1638 /* generate_idata_ofile generates the portable assembly source code
1639 for the idata sections. It appends the source code to the end of
1643 generate_idata_ofile (filvar)
1652 if (import_list == NULL)
1655 fprintf (filvar, "%s Import data sections\n", ASM_C);
1656 fprintf (filvar, "\n\t.section\t.idata$2\n");
1657 fprintf (filvar, "\t%s\tdoi_idata\n", ASM_GLOBAL);
1658 fprintf (filvar, "doi_idata:\n");
1661 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1663 fprintf (filvar, "\t%slistone%d%s\t%s %s\n",
1664 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER,
1665 ASM_C, headptr->dllname);
1666 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1667 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1668 fprintf (filvar, "\t%sdllname%d%s\n",
1669 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1670 fprintf (filvar, "\t%slisttwo%d%s\n\n",
1671 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1675 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL record at */
1676 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* end of idata$2 */
1677 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* section */
1678 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1679 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1681 fprintf (filvar, "\n\t.section\t.idata$4\n");
1683 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1685 fprintf (filvar, "listone%d:\n", headindex);
1686 for ( funcindex = 0; funcindex < headptr->nfuncs; funcindex++ )
1687 fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1688 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1689 fprintf (filvar,"\t%s\t0\n", ASM_LONG); /* NULL terminating list */
1693 fprintf (filvar, "\n\t.section\t.idata$5\n");
1695 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1697 fprintf (filvar, "listtwo%d:\n", headindex);
1698 for ( funcindex = 0; funcindex < headptr->nfuncs; funcindex++ )
1699 fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1700 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1701 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list */
1705 fprintf (filvar, "\n\t.section\t.idata$6\n");
1707 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1710 for (funcptr = headptr->funchead; funcptr != NULL;
1711 funcptr = funcptr->next)
1713 fprintf (filvar,"funcptr%d_%d:\n", headindex, funcindex);
1714 fprintf (filvar,"\t%s\t%d\n", ASM_SHORT,
1715 ((funcptr->ord) & 0xFFFF));
1716 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, funcptr->name);
1717 fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1723 fprintf (filvar, "\n\t.section\t.idata$7\n");
1725 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1727 fprintf (filvar,"dllname%d:\n", headindex);
1728 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, headptr->dllname);
1729 fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1734 /* Assemble the specified file. */
1736 assemble_file (source, dest)
1737 const char * source;
1742 cmd = (char *) alloca (strlen (ASM_SWITCHES) + strlen (as_flags)
1743 + strlen (exp_name) + strlen (source)
1744 + strlen (dest) + 50);
1746 sprintf (cmd, "%s %s -o %s %s", ASM_SWITCHES, as_flags, dest, source);
1759 /* xgettext:c-format */
1760 inform (_("Generating export file: %s\n"), exp_name);
1762 f = fopen (TMP_ASM, FOPEN_WT);
1764 /* xgettext:c-format */
1765 fatal (_("Unable to open temporary assembler file: %s"), TMP_ASM);
1767 /* xgettext:c-format */
1768 inform (_("Opened temporary file: %s"), TMP_ASM);
1774 fprintf (f, "\t.section .edata\n\n");
1775 fprintf (f, "\t%s 0 %s Allways 0\n", ASM_LONG, ASM_C);
1776 fprintf (f, "\t%s 0x%lx %s Time and date\n", ASM_LONG, (long) time(0),
1778 fprintf (f, "\t%s 0 %s Major and Minor version\n", ASM_LONG, ASM_C);
1779 fprintf (f, "\t%sname%s %s Ptr to name of dll\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1780 fprintf (f, "\t%s %d %s Starting ordinal of exports\n", ASM_LONG, d_low_ord, ASM_C);
1783 fprintf (f, "\t%s %d %s Number of functions\n", ASM_LONG, d_high_ord - d_low_ord + 1, ASM_C);
1784 fprintf(f,"\t%s named funcs %d, low ord %d, high ord %d\n",
1786 d_named_nfuncs, d_low_ord, d_high_ord);
1787 fprintf (f, "\t%s %d %s Number of names\n", ASM_LONG,
1788 show_allnames ? d_high_ord - d_low_ord + 1 : d_named_nfuncs, ASM_C);
1789 fprintf (f, "\t%safuncs%s %s Address of functions\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1791 fprintf (f, "\t%sanames%s %s Address of Name Pointer Table\n",
1792 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1794 fprintf (f, "\t%sanords%s %s Address of ordinals\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1796 fprintf (f, "name: %s \"%s\"\n", ASM_TEXT, dll_name);
1799 fprintf(f,"%s Export address Table\n", ASM_C);
1800 fprintf(f,"\t%s\n", ASM_ALIGN_LONG);
1801 fprintf (f, "afuncs:\n");
1804 for (exp = d_exports; exp; exp = exp->next)
1806 if (exp->ordinal != i)
1809 fprintf (f, "\t%s\t%d\t%s %d..%d missing\n",
1811 (exp->ordinal - i) * 4,
1813 i, exp->ordinal - 1);
1816 while (i < exp->ordinal)
1818 fprintf(f,"\t%s\t0\n", ASM_LONG);
1822 fprintf (f, "\t%s%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
1824 exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1828 fprintf (f,"%s Export Name Pointer Table\n", ASM_C);
1829 fprintf (f, "anames:\n");
1831 for (i = 0; (exp = d_exports_lexically[i]); i++)
1833 if (!exp->noname || show_allnames)
1834 fprintf (f, "\t%sn%d%s\n",
1835 ASM_RVA_BEFORE, exp->ordinal, ASM_RVA_AFTER);
1838 fprintf (f,"%s Export Oridinal Table\n", ASM_C);
1839 fprintf (f, "anords:\n");
1840 for (i = 0; (exp = d_exports_lexically[i]); i++)
1842 if (!exp->noname || show_allnames)
1843 fprintf (f, "\t%s %d\n", ASM_SHORT, exp->ordinal - d_low_ord);
1846 fprintf(f,"%s Export Name Table\n", ASM_C);
1847 for (i = 0; (exp = d_exports_lexically[i]); i++)
1848 if (!exp->noname || show_allnames)
1849 fprintf (f, "n%d: %s \"%s\"\n",
1850 exp->ordinal, ASM_TEXT, exp->name);
1854 fprintf (f, "\t.section %s\n", DRECTVE_SECTION_NAME);
1855 for (dl = a_list; dl; dl = dl->next)
1857 fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, dl->text);
1863 fprintf (f, "\t.section .rdata\n");
1864 for (dl = d_list; dl; dl = dl->next)
1868 /* We dont output as ascii 'cause there can
1869 be quote characters in the string */
1872 for (p = dl->text; *p; p++)
1875 fprintf (f, "\t%s\t", ASM_BYTE);
1878 fprintf (f, "%d", *p);
1881 fprintf (f, ",0\n");
1895 /* Add to the output file a way of getting to the exported names
1896 without using the import library. */
1899 fprintf (f, "\t.section\t.rdata\n");
1900 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1901 if (!exp->noname || show_allnames)
1903 /* We use a single underscore for MS compatibility, and a
1904 double underscore for backward compatibility with old
1906 fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name);
1907 fprintf (f, "\t%s\t_imp__%s\n", ASM_GLOBAL, exp->name);
1908 fprintf (f, "__imp_%s:\n", exp->name);
1909 fprintf (f, "_imp__%s:\n", exp->name);
1910 fprintf (f, "\t%s\t%s\n", ASM_LONG, exp->name);
1914 /* Dump the reloc section if a base file is provided */
1918 long need[PAGE_SIZE];
1925 fprintf (f, "\t.section\t.init\n");
1926 fprintf (f, "lab:\n");
1928 fseek (base_file, 0, SEEK_END);
1929 numbytes = ftell (base_file);
1930 fseek (base_file, 0, SEEK_SET);
1931 copy = xmalloc (numbytes);
1932 fread (copy, 1, numbytes, base_file);
1933 num_entries = numbytes / sizeof (long);
1936 fprintf (f, "\t.section\t.reloc\n");
1942 qsort (copy, num_entries, sizeof (long), sfunc);
1943 /* Delete duplcates */
1944 for (src = 0; src < num_entries; src++)
1946 if (last != copy[src])
1947 last = copy[dst++] = copy[src];
1951 page_addr = addr & PAGE_MASK; /* work out the page addr */
1953 for (j = 0; j < num_entries; j++)
1956 if ((addr & PAGE_MASK) != page_addr)
1958 flush_page (f, need, page_addr, on_page);
1960 page_addr = addr & PAGE_MASK;
1962 need[on_page++] = addr;
1964 flush_page (f, need, page_addr, on_page);
1966 /* fprintf (f, "\t%s\t0,0\t%s End\n", ASM_LONG, ASM_C);*/
1970 generate_idata_ofile (f);
1974 /* assemble the file */
1975 assemble_file (TMP_ASM, exp_name);
1977 if (dontdeltemps == 0)
1980 inform (_("Generated exports file"));
1989 char *copy = xmalloc (strlen (name) + 2);
1991 strcpy (copy + 1, name);
1998 p = strchr (name, '@');
2005 /**********************************************************************/
2014 if (exp->noname && !show_allnames )
2016 fprintf (f, "\t%s\t0x%08x\n",
2018 exp->ordinal | 0x80000000); /* hint or orindal ?? */
2022 fprintf (f, "\t%sID%d%s\n", ASM_RVA_BEFORE,
2040 unsigned char *data;
2055 static sinfo secdata[NSECS] =
2057 { TEXT, ".text", SEC_CODE | SEC_HAS_CONTENTS, 2},
2058 { DATA, ".data", SEC_DATA, 2},
2059 { BSS, ".bss", 0, 2},
2060 { IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2},
2061 { IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2},
2062 { IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2},
2063 { IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1}
2068 /* Sections numbered to make the order the same as other PowerPC NT */
2069 /* compilers. This also keeps funny alignment thingies from happening. */
2082 static sinfo secdata[NSECS] =
2084 { TEXT, ".text", SEC_CODE | SEC_HAS_CONTENTS, 3},
2085 { PDATA, ".pdata", SEC_HAS_CONTENTS, 2},
2086 { RDATA, ".reldata", SEC_HAS_CONTENTS, 2},
2087 { IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2},
2088 { IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2},
2089 { IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1},
2090 { IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2},
2091 { DATA, ".data", SEC_DATA, 2},
2092 { BSS, ".bss", 0, 2}
2098 This is what we're trying to make. We generate the imp symbols with
2099 both single and double underscores, for compatibility.
2102 .global _GetFileVersionInfoSizeW@8
2103 .global __imp_GetFileVersionInfoSizeW@8
2104 _GetFileVersionInfoSizeW@8:
2105 jmp * __imp_GetFileVersionInfoSizeW@8
2106 .section .idata$7 # To force loading of head
2107 .long __version_a_head
2108 # Import Address Table
2110 __imp_GetFileVersionInfoSizeW@8:
2113 # Import Lookup Table
2119 .asciz "GetFileVersionInfoSizeW"
2122 For the PowerPC, here's the variation on the above scheme:
2124 # Rather than a simple "jmp *", the code to get to the dll function
2127 lwz r11,[tocv]__imp_function_name(r2)
2128 # RELOC: 00000000 TOCREL16,TOCDEFN __imp_function_name
2137 make_label (prefix, name)
2141 int len = strlen (ASM_PREFIX) + strlen (prefix) + strlen (name);
2142 char *copy = xmalloc (len +1 );
2143 strcpy (copy, ASM_PREFIX);
2144 strcat (copy, prefix);
2145 strcat (copy, name);
2150 make_one_lib_file (exp, i)
2158 const char *prefix = "d";
2161 name = (char *) alloca (strlen (prefix) + 10);
2162 sprintf (name, "%ss%05d.s", prefix, i);
2163 f = fopen (name, FOPEN_WT);
2164 fprintf (f, "\t.text\n");
2165 fprintf (f, "\t%s\t%s%s\n", ASM_GLOBAL, ASM_PREFIX, exp->name);
2166 fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name);
2167 fprintf (f, "\t%s\t_imp__%s\n", ASM_GLOBAL, exp->name);
2168 fprintf (f, "%s%s:\n\t%s\t__imp_%s\n", ASM_PREFIX,
2169 exp->name, ASM_JUMP, exp->name);
2171 fprintf (f, "\t.section\t.idata$7\t%s To force loading of head\n", ASM_C);
2172 fprintf (f, "\t%s\t%s\n", ASM_LONG, head_label);
2175 fprintf (f,"%s Import Address Table\n", ASM_C);
2177 fprintf (f, "\t.section .idata$5\n");
2178 fprintf (f, "__imp_%s:\n", exp->name);
2179 fprintf (f, "_imp__%s:\n", exp->name);
2183 fprintf (f, "\n%s Import Lookup Table\n", ASM_C);
2184 fprintf (f, "\t.section .idata$4\n");
2188 if(!exp->noname || show_allnames)
2190 fprintf (f, "%s Hint/Name table\n", ASM_C);
2191 fprintf (f, "\t.section .idata$6\n");
2192 fprintf (f, "ID%d:\t%s\t%d\n", exp->ordinal, ASM_SHORT, exp->hint);
2193 fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, xlate (exp->name));
2198 dest = (char *) alloca (strlen (prefix) + 10);
2199 sprintf (dest, "%ss%05d.o", prefix, i);
2200 assemble_file (name, dest);
2205 asymbol * exp_label;
2208 asymbol * iname_lab;
2209 asymbol ** iname_lab_pp;
2210 asymbol ** iname_pp;
2219 asymbol * ptrs[NSECS + 4 + EXTRA + 1];
2221 char * outname = xmalloc (10);
2225 sprintf (outname, "%s%05d.o", TMP_STUB, i);
2227 abfd = bfd_openw (outname, HOW_BFD_WRITE_TARGET);
2230 /* xgettext:c-format */
2231 fatal (_("bfd_open failed open stub file: %s"), outname);
2233 /* xgettext:c-format */
2234 inform (_("Creating stub file: %s"), outname);
2236 bfd_set_format (abfd, bfd_object);
2237 bfd_set_arch_mach (abfd, HOW_BFD_ARCH, 0);
2240 if (machine == MARM_INTERWORK || machine == MTHUMB)
2241 bfd_set_private_flags (abfd, F_INTERWORK);
2244 /* First make symbols for the sections */
2245 for (i = 0; i < NSECS; i++)
2247 sinfo *si = secdata + i;
2250 si->sec = bfd_make_section_old_way (abfd, si->name);
2251 bfd_set_section_flags (abfd,
2255 bfd_set_section_alignment(abfd, si->sec, si->align);
2256 si->sec->output_section = si->sec;
2257 si->sym = bfd_make_empty_symbol(abfd);
2258 si->sym->name = si->sec->name;
2259 si->sym->section = si->sec;
2260 si->sym->flags = BSF_LOCAL;
2262 ptrs[oidx] = si->sym;
2263 si->sympp = ptrs + oidx;
2272 exp_label = bfd_make_empty_symbol (abfd);
2273 exp_label->name = make_label ("", exp->name);
2275 /* On PowerPC, the function name points to a descriptor in
2276 the rdata section, the first element of which is a
2277 pointer to the code (..function_name), and the second
2278 points to the .toc */
2280 if (machine == MPPC)
2281 exp_label->section = secdata[RDATA].sec;
2284 exp_label->section = secdata[TEXT].sec;
2286 exp_label->flags = BSF_GLOBAL;
2287 exp_label->value = 0;
2290 if (machine == MTHUMB)
2291 bfd_coff_set_symbol_class (abfd, exp_label, C_THUMBEXTFUNC);
2293 ptrs[oidx++] = exp_label;
2296 /* Generate imp symbols with one underscore for Microsoft
2297 compatibility, and with two underscores for backward
2298 compatibility with old versions of cygwin. */
2299 iname = bfd_make_empty_symbol(abfd);
2300 iname->name = make_label ("__imp_", exp->name);
2301 iname->section = secdata[IDATA5].sec;
2302 iname->flags = BSF_GLOBAL;
2305 iname2 = bfd_make_empty_symbol(abfd);
2306 iname2->name = make_label ("_imp__", exp->name);
2307 iname2->section = secdata[IDATA5].sec;
2308 iname2->flags = BSF_GLOBAL;
2311 iname_lab = bfd_make_empty_symbol(abfd);
2313 iname_lab->name = head_label;
2314 iname_lab->section = (asection *)&bfd_und_section;
2315 iname_lab->flags = 0;
2316 iname_lab->value = 0;
2319 iname_pp = ptrs + oidx;
2320 ptrs[oidx++] = iname;
2321 ptrs[oidx++] = iname2;
2323 iname_lab_pp = ptrs + oidx;
2324 ptrs[oidx++] = iname_lab;
2327 /* The symbol refering to the code (.text) */
2329 asymbol *function_name;
2331 function_name = bfd_make_empty_symbol(abfd);
2332 function_name->name = make_label ("..", exp->name);
2333 function_name->section = secdata[TEXT].sec;
2334 function_name->flags = BSF_GLOBAL;
2335 function_name->value = 0;
2337 fn_pp = ptrs + oidx;
2338 ptrs[oidx++] = function_name;
2341 /* The .toc symbol */
2343 asymbol *toc_symbol; /* The .toc symbol */
2345 toc_symbol = bfd_make_empty_symbol (abfd);
2346 toc_symbol->name = make_label (".", "toc");
2347 toc_symbol->section = (asection *)&bfd_und_section;
2348 toc_symbol->flags = BSF_GLOBAL;
2349 toc_symbol->value = 0;
2351 toc_pp = ptrs + oidx;
2352 ptrs[oidx++] = toc_symbol;
2358 for (i = 0; i < NSECS; i++)
2360 sinfo *si = secdata + i;
2361 asection *sec = si->sec;
2370 si->size = HOW_JTAB_SIZE;
2371 si->data = xmalloc (HOW_JTAB_SIZE);
2372 memcpy (si->data, HOW_JTAB, HOW_JTAB_SIZE);
2374 /* add the reloc into idata$5 */
2375 rel = xmalloc (sizeof (arelent));
2377 rpp = xmalloc (sizeof (arelent *) * 2);
2381 rel->address = HOW_JTAB_ROFF;
2384 if (machine == MPPC)
2386 rel->howto = bfd_reloc_type_lookup (abfd,
2387 BFD_RELOC_16_GOTOFF);
2388 rel->sym_ptr_ptr = iname_pp;
2392 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2393 rel->sym_ptr_ptr = secdata[IDATA5].sympp;
2395 sec->orelocation = rpp;
2396 sec->reloc_count = 1;
2401 /* An idata$4 or idata$5 is one word long, and has an
2404 si->data = xmalloc (4);
2409 si->data[0] = exp->ordinal ;
2410 si->data[1] = exp->ordinal >> 8;
2411 si->data[2] = exp->ordinal >> 16;
2416 sec->reloc_count = 1;
2417 memset (si->data, 0, si->size);
2418 rel = xmalloc (sizeof (arelent));
2419 rpp = xmalloc (sizeof (arelent *) * 2);
2424 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2425 rel->sym_ptr_ptr = secdata[IDATA6].sympp;
2426 sec->orelocation = rpp;
2434 /* This used to add 1 to exp->hint. I don't know
2435 why it did that, and it does not match what I see
2436 in programs compiled with the MS tools. */
2437 int idx = exp->hint;
2438 si->size = strlen (xlate (exp->name)) + 3;
2439 si->data = xmalloc (si->size);
2440 si->data[0] = idx & 0xff;
2441 si->data[1] = idx >> 8;
2442 strcpy (si->data + 2, xlate (exp->name));
2447 si->data =xmalloc(4);
2448 memset (si->data, 0, si->size);
2449 rel = xmalloc (sizeof (arelent));
2450 rpp = xmalloc (sizeof (arelent *) * 2);
2454 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2455 rel->sym_ptr_ptr = iname_lab_pp;
2456 sec->orelocation = rpp;
2457 sec->reloc_count = 1;
2463 /* The .pdata section is 5 words long. */
2464 /* Think of it as: */
2467 /* bfd_vma BeginAddress, [0x00] */
2468 /* EndAddress, [0x04] */
2469 /* ExceptionHandler, [0x08] */
2470 /* HandlerData, [0x0c] */
2471 /* PrologEndAddress; [0x10] */
2474 /* So this pdata section setups up this as a glue linkage to
2475 a dll routine. There are a number of house keeping things
2478 1. In the name of glue trickery, the ADDR32 relocs for 0,
2479 4, and 0x10 are set to point to the same place:
2481 2. There is one more reloc needed in the pdata section.
2482 The actual glue instruction to restore the toc on
2483 return is saved as the offset in an IMGLUE reloc.
2484 So we need a total of four relocs for this section.
2486 3. Lastly, the HandlerData field is set to 0x03, to indicate
2487 that this is a glue routine.
2489 arelent *imglue, *ba_rel, *ea_rel, *pea_rel;
2491 /* alignment must be set to 2**2 or you get extra stuff */
2492 bfd_set_section_alignment(abfd, sec, 2);
2495 si->data =xmalloc(4 * 5);
2496 memset (si->data, 0, si->size);
2497 rpp = xmalloc (sizeof (arelent *) * 5);
2498 rpp[0] = imglue = xmalloc (sizeof (arelent));
2499 rpp[1] = ba_rel = xmalloc (sizeof (arelent));
2500 rpp[2] = ea_rel = xmalloc (sizeof (arelent));
2501 rpp[3] = pea_rel = xmalloc (sizeof (arelent));
2504 /* stick the toc reload instruction in the glue reloc */
2505 bfd_put_32(abfd, ppc_glue_insn, (char *) &imglue->address);
2508 imglue->howto = bfd_reloc_type_lookup (abfd,
2509 BFD_RELOC_32_GOTOFF);
2510 imglue->sym_ptr_ptr = fn_pp;
2512 ba_rel->address = 0;
2514 ba_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2515 ba_rel->sym_ptr_ptr = fn_pp;
2517 bfd_put_32(abfd, 0x18, si->data + 0x04);
2518 ea_rel->address = 4;
2520 ea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2521 ea_rel->sym_ptr_ptr = fn_pp;
2523 /* mark it as glue */
2524 bfd_put_32(abfd, 0x03, si->data + 0x0c);
2526 /* mark the prolog end address */
2527 bfd_put_32(abfd, 0x0D, si->data + 0x10);
2528 pea_rel->address = 0x10;
2529 pea_rel->addend = 0;
2530 pea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2531 pea_rel->sym_ptr_ptr = fn_pp;
2533 sec->orelocation = rpp;
2534 sec->reloc_count = 4;
2538 /* Each external function in a PowerPC PE file has a two word
2539 descriptor consisting of:
2540 1. The address of the code.
2541 2. The address of the appropriate .toc
2542 We use relocs to build this.
2546 si->data = xmalloc (8);
2547 memset (si->data, 0, si->size);
2549 rpp = xmalloc (sizeof (arelent *) * 3);
2550 rpp[0] = rel = xmalloc (sizeof (arelent));
2551 rpp[1] = xmalloc (sizeof (arelent));
2556 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2557 rel->sym_ptr_ptr = fn_pp;
2563 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2564 rel->sym_ptr_ptr = toc_pp;
2566 sec->orelocation = rpp;
2567 sec->reloc_count = 2;
2569 #endif /* DLLTOOL_PPC */
2575 /* Size up all the sections */
2576 for (i = 0; i < NSECS; i++)
2578 sinfo *si = secdata + i;
2580 bfd_set_section_size (abfd, si->sec, si->size);
2581 bfd_set_section_vma (abfd, si->sec, vma);
2583 /* vma += si->size;*/
2586 /* Write them out */
2587 for (i = 0; i < NSECS; i++)
2589 sinfo *si = secdata + i;
2591 if (i == IDATA5 && no_idata5)
2594 if (i == IDATA4 && no_idata4)
2597 bfd_set_section_contents (abfd, si->sec,
2602 bfd_set_symtab (abfd, ptrs, oidx);
2604 abfd = bfd_openr (outname, HOW_BFD_READ_TARGET);
2613 FILE *f = fopen (TMP_HEAD_S, FOPEN_WT);
2617 fatal (_("failed to open temporary head file: %s"), TMP_HEAD_S);
2621 fprintf (f, "%s IMAGE_IMPORT_DESCRIPTOR\n", ASM_C);
2622 fprintf (f, "\t.section .idata$2\n");
2624 fprintf(f,"\t%s\t%s\n", ASM_GLOBAL,head_label);
2626 fprintf (f, "%s:\n", head_label);
2628 fprintf (f, "\t%shname%s\t%sPtr to image import by name list\n",
2629 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
2631 fprintf (f, "\t%sthis should be the timestamp, but NT sometimes\n", ASM_C);
2632 fprintf (f, "\t%sdoesn't load DLLs when this is set.\n", ASM_C);
2633 fprintf (f, "\t%s\t0\t%s loaded time\n", ASM_LONG, ASM_C);
2634 fprintf (f, "\t%s\t0\t%s Forwarder chain\n", ASM_LONG, ASM_C);
2635 fprintf (f, "\t%s__%s_iname%s\t%s imported dll's name\n",
2640 fprintf (f, "\t%sfthunk%s\t%s pointer to firstthunk\n",
2642 ASM_RVA_AFTER, ASM_C);
2644 fprintf (f, "%sStuff for compatibility\n", ASM_C);
2648 fprintf (f, "\t.section\t.idata$5\n");
2649 fprintf (f, "\t%s\t0\n", ASM_LONG);
2650 fprintf (f, "fthunk:\n");
2655 fprintf (f, "\t.section\t.idata$4\n");
2657 fprintf (f, "\t%s\t0\n", ASM_LONG);
2658 fprintf (f, "\t.section .idata$4\n");
2659 fprintf (f, "hname:\n");
2664 assemble_file (TMP_HEAD_S, TMP_HEAD_O);
2666 return bfd_openr (TMP_HEAD_O, HOW_BFD_READ_TARGET);
2672 FILE *f = fopen (TMP_TAIL_S, FOPEN_WT);
2676 fatal (_("failed to open temporary tail file: %s"), TMP_TAIL_S);
2682 fprintf (f, "\t.section .idata$4\n");
2683 fprintf (f, "\t%s\t0\n", ASM_LONG);
2688 fprintf (f, "\t.section .idata$5\n");
2689 fprintf (f, "\t%s\t0\n", ASM_LONG);
2693 /* Normally, we need to see a null descriptor built in idata$3 to
2694 act as the terminator for the list. The ideal way, I suppose,
2695 would be to mark this section as a comdat type 2 section, so
2696 only one would appear in the final .exe (if our linker supported
2697 comdat, that is) or cause it to be inserted by something else (say
2701 fprintf (f, "\t.section .idata$3\n");
2702 fprintf (f, "\t%s\t0\n", ASM_LONG);
2703 fprintf (f, "\t%s\t0\n", ASM_LONG);
2704 fprintf (f, "\t%s\t0\n", ASM_LONG);
2705 fprintf (f, "\t%s\t0\n", ASM_LONG);
2706 fprintf (f, "\t%s\t0\n", ASM_LONG);
2710 /* Other PowerPC NT compilers use idata$6 for the dllname, so I
2711 do too. Original, huh? */
2712 fprintf (f, "\t.section .idata$6\n");
2714 fprintf (f, "\t.section .idata$7\n");
2717 fprintf (f, "\t%s\t__%s_iname\n", ASM_GLOBAL, imp_name_lab);
2718 fprintf (f, "__%s_iname:\t%s\t\"%s\"\n",
2719 imp_name_lab, ASM_TEXT, dll_name);
2723 assemble_file (TMP_TAIL_S, TMP_TAIL_O);
2725 return bfd_openr (TMP_TAIL_O, HOW_BFD_READ_TARGET);
2740 outarch = bfd_openw (imp_name, HOW_BFD_WRITE_TARGET);
2743 /* xgettext:c-format */
2744 fatal (_("Can't open .lib file: %s"), imp_name);
2746 /* xgettext:c-format */
2747 inform (_("Creating library file: %s\n"), imp_name);
2749 bfd_set_format (outarch, bfd_archive);
2750 outarch->has_armap = 1;
2752 /* Work out a reasonable size of things to put onto one line. */
2754 ar_head = make_head ();
2755 ar_tail = make_tail();
2757 if (ar_head == NULL || ar_tail == NULL)
2760 for (i = 0; (exp = d_exports_lexically[i]); i++)
2762 bfd *n = make_one_lib_file (exp, i);
2767 /* Now stick them all into the archive */
2769 ar_head->next = head;
2770 ar_tail->next = ar_head;
2773 if (! bfd_set_archive_head (outarch, head))
2774 bfd_fatal ("bfd_set_archive_head");
2776 if (! bfd_close (outarch))
2777 bfd_fatal (imp_name);
2779 while (head != NULL)
2781 bfd *n = head->next;
2786 /* Delete all the temp files */
2788 if (dontdeltemps == 0)
2790 unlink (TMP_HEAD_O);
2791 unlink (TMP_HEAD_S);
2792 unlink (TMP_TAIL_O);
2793 unlink (TMP_TAIL_S);
2796 if (dontdeltemps < 2)
2800 name = (char *) alloca (sizeof TMP_STUB + 10);
2801 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
2803 sprintf (name, "%s%05d.o", TMP_STUB, i);
2804 if (unlink (name) < 0)
2805 /* xgettext:c-format */
2806 warn (_("cannot delete %s: %s\n"), name, strerror (errno));
2810 inform (_("Created lib file"));
2813 /**********************************************************************/
2815 /* Run through the information gathered from the .o files and the
2816 .def file and work out the best stuff */
2822 export_type *ap = *(export_type **) a;
2823 export_type *bp = *(export_type **) b;
2824 if (ap->ordinal == bp->ordinal)
2827 /* unset ordinals go to the bottom */
2828 if (ap->ordinal == -1)
2830 if (bp->ordinal == -1)
2832 return (ap->ordinal - bp->ordinal);
2840 export_type *ap = *(export_type **) a;
2841 export_type *bp = *(export_type **) b;
2843 return (strcmp (ap->name, bp->name));
2847 remove_null_names (ptr)
2852 for (dst = src = 0; src < d_nfuncs; src++)
2856 ptr[dst] = ptr[src];
2869 for (i = 0; i < d_nfuncs; i++)
2873 printf ("%d %s @ %d %s%s%s\n",
2874 i, ptr[i]->name, ptr[i]->ordinal,
2875 ptr[i]->noname ? "NONAME " : "",
2876 ptr[i]->constant ? "CONSTANT" : "",
2877 ptr[i]->data ? "DATA" : "");
2886 process_duplicates (d_export_vec)
2887 export_type **d_export_vec;
2895 /* Remove duplicates */
2896 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), nfunc);
2898 dtab (d_export_vec);
2899 for (i = 0; i < d_nfuncs - 1; i++)
2901 if (strcmp (d_export_vec[i]->name,
2902 d_export_vec[i + 1]->name) == 0)
2905 export_type *a = d_export_vec[i];
2906 export_type *b = d_export_vec[i + 1];
2910 /* xgettext:c-format */
2911 inform (_("Warning, ignoring duplicate EXPORT %s %d,%d\n"),
2912 a->name, a->ordinal, b->ordinal);
2914 if (a->ordinal != -1
2915 && b->ordinal != -1)
2916 /* xgettext:c-format */
2917 fatal (_("Error, duplicate EXPORT with oridinals: %s"),
2920 /* Merge attributes */
2921 b->ordinal = a->ordinal > 0 ? a->ordinal : b->ordinal;
2922 b->constant |= a->constant;
2923 b->noname |= a->noname;
2925 d_export_vec[i] = 0;
2928 dtab (d_export_vec);
2929 remove_null_names (d_export_vec);
2930 dtab (d_export_vec);
2935 /* Count the names */
2936 for (i = 0; i < d_nfuncs; i++)
2938 if (!d_export_vec[i]->noname)
2944 fill_ordinals (d_export_vec)
2945 export_type **d_export_vec;
2952 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
2954 /* fill in the unset ordinals with ones from our range */
2956 ptr = (char *) xmalloc (size);
2958 memset (ptr, 0, size);
2960 /* Mark in our large vector all the numbers that are taken */
2961 for (i = 0; i < d_nfuncs; i++)
2963 if (d_export_vec[i]->ordinal != -1)
2965 ptr[d_export_vec[i]->ordinal] = 1;
2966 if (lowest == -1 || d_export_vec[i]->ordinal < lowest)
2968 lowest = d_export_vec[i]->ordinal;
2973 /* Start at 1 for compatibility with MS toolchain. */
2977 /* Now fill in ordinals where the user wants us to choose. */
2978 for (i = 0; i < d_nfuncs; i++)
2980 if (d_export_vec[i]->ordinal == -1)
2984 /* First try within or after any user supplied range. */
2985 for (j = lowest; j < size; j++)
2989 d_export_vec[i]->ordinal = j;
2993 /* Then try before the range. */
2994 for (j = lowest; j >0; j--)
2998 d_export_vec[i]->ordinal = j;
3009 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
3011 /* Work out the lowest and highest ordinal numbers. */
3014 if (d_export_vec[0])
3015 d_low_ord = d_export_vec[0]->ordinal;
3016 if (d_export_vec[d_nfuncs-1])
3017 d_high_ord = d_export_vec[d_nfuncs-1]->ordinal;
3026 const export_type **a = (const export_type **) av;
3027 const export_type **b = (const export_type **) bv;
3029 return strcmp ((*a)->name, (*b)->name);
3035 /* First work out the minimum ordinal chosen */
3041 export_type **d_export_vec
3042 = (export_type **) xmalloc (sizeof (export_type *) * d_nfuncs);
3044 inform (_("Processing definitions"));
3046 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3048 d_export_vec[i] = exp;
3051 process_duplicates (d_export_vec);
3052 fill_ordinals (d_export_vec);
3054 /* Put back the list in the new order */
3056 for (i = d_nfuncs - 1; i >= 0; i--)
3058 d_export_vec[i]->next = d_exports;
3059 d_exports = d_export_vec[i];
3062 /* Build list in alpha order */
3063 d_exports_lexically = (export_type **)
3064 xmalloc (sizeof (export_type *) * (d_nfuncs + 1));
3066 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3068 d_exports_lexically[i] = exp;
3070 d_exports_lexically[i] = 0;
3072 qsort (d_exports_lexically, i, sizeof (export_type *), alphafunc);
3074 /* Fill exp entries with their hint values */
3076 for (i = 0; i < d_nfuncs; i++)
3078 if (!d_exports_lexically[i]->noname || show_allnames)
3079 d_exports_lexically[i]->hint = hint++;
3082 inform (_("Processed definitions"));
3085 /**********************************************************************/
3088 usage (file, status)
3092 /* xgetext:c-format */
3093 fprintf (file, _("Usage %s <options> <object-files>\n"), program_name);
3094 /* xgetext:c-format */
3095 fprintf (file, _(" -m --machine <machine> Create as DLL for <machine>. [default: %s]\n"), mname);
3096 fprintf (file, _(" possible <machine>: arm[_interwork], i386, mcore[-elf][-le], ppc, thumb\n"));
3097 fprintf (file, _(" -e --output-exp <outname> Generate an export file.\n"));
3098 fprintf (file, _(" -l --output-lib <outname> Generate an interface library.\n"));
3099 fprintf (file, _(" -a --add-indirect Add dll indirects to export file.\n"));
3100 fprintf (file, _(" -D --dllname <name> Name of input dll to put into interface lib.\n"));
3101 fprintf (file, _(" -d --input-def <deffile> Name of .def file to be read in.\n"));
3102 fprintf (file, _(" -z --output-def <deffile> Name of .def file to be created.\n"));
3103 fprintf (file, _(" --export-all-symbols Export all symbols to .def\n"));
3104 fprintf (file, _(" --no-export-all-symbols Only export listed symbols\n"));
3105 fprintf (file, _(" --exclude-symbols <list> Don't export <list>\n"));
3106 fprintf (file, _(" --no-default-excludes Clear default exclude symbols\n"));
3107 fprintf (file, _(" -b --base-file <basefile> Read linker generated base file.\n"));
3108 fprintf (file, _(" -x --no-idata4 Don't generate idata$4 section.\n"));
3109 fprintf (file, _(" -c --no-idata5 Don't generate idata$5 section.\n"));
3110 fprintf (file, _(" -U --add-underscore Add underscores to symbols in interface library.\n"));
3111 fprintf (file, _(" -k --kill-at Kill @<n> from exported names.\n"));
3112 fprintf (file, _(" -A --add-stdcall-alias Add aliases without @<n>.\n"));
3113 fprintf (file, _(" -S --as <name> Use <name> for assembler.\n"));
3114 fprintf (file, _(" -f --as-flags <flags> Pass <flags> to the assembler.\n"));
3115 fprintf (file, _(" -n --no-delete Keep temp files (repeat for extra preservation).\n"));
3116 fprintf (file, _(" -v --verbose Be verbose.\n"));
3117 fprintf (file, _(" -V --version Display the program version.\n"));
3118 fprintf (file, _(" -h --help Display this information.\n"));
3119 #ifdef DLLTOOL_MCORE_ELF
3120 fprintf (file, _(" -M --mcore-elf <outname> Process mcore-elf object files into <outname>.\n"));
3121 fprintf (file, _(" -L --linker <name> Use <name> as the linker.\n"));
3122 fprintf (file, _(" -F --linker-flags <flags> Pass <flags> to the linker.\n"));
3127 #define OPTION_EXPORT_ALL_SYMS 150
3128 #define OPTION_NO_EXPORT_ALL_SYMS (OPTION_EXPORT_ALL_SYMS + 1)
3129 #define OPTION_EXCLUDE_SYMS (OPTION_NO_EXPORT_ALL_SYMS + 1)
3130 #define OPTION_NO_DEFAULT_EXCLUDES (OPTION_EXCLUDE_SYMS + 1)
3132 static const struct option long_options[] =
3134 {"no-delete", no_argument, NULL, 'n'},
3135 {"dllname", required_argument, NULL, 'D'},
3136 {"no-idata4", no_argument, NULL, 'x'},
3137 {"no-idata5", no_argument, NULL, 'c'},
3138 {"output-exp", required_argument, NULL, 'e'},
3139 {"output-def", required_argument, NULL, 'z'},
3140 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL_SYMS},
3141 {"no-export-all-symbols", no_argument, NULL, OPTION_NO_EXPORT_ALL_SYMS},
3142 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMS},
3143 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
3144 {"output-lib", required_argument, NULL, 'l'},
3145 {"def", required_argument, NULL, 'd'}, /* for compatiblity with older versions */
3146 {"input-def", required_argument, NULL, 'd'},
3147 {"add-underscore", no_argument, NULL, 'U'},
3148 {"kill-at", no_argument, NULL, 'k'},
3149 {"add-stdcall-alias", no_argument, NULL, 'A'},
3150 {"verbose", no_argument, NULL, 'v'},
3151 {"version", no_argument, NULL, 'V'},
3152 {"help", no_argument, NULL, 'h'},
3153 {"machine", required_argument, NULL, 'm'},
3154 {"add-indirect", no_argument, NULL, 'a'},
3155 {"base-file", required_argument, NULL, 'b'},
3156 {"as", required_argument, NULL, 'S'},
3157 {"as-flags", required_argument, NULL, 'f'},
3158 {"mcore-elf", required_argument, NULL, 'M'},
3170 program_name = av[0];
3173 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
3174 setlocale (LC_MESSAGES, "");
3176 bindtextdomain (PACKAGE, LOCALEDIR);
3177 textdomain (PACKAGE);
3179 while ((c = getopt_long (ac, av,
3180 #ifdef DLLTOOL_MCORE_ELF
3181 "m:e:l:aD:d:z:b:xcuUkAS:f:nvVhM:L:F:",
3183 "m:e:l:aD:d:z:b:xcuUkAS:f:nvVh",
3190 case OPTION_EXPORT_ALL_SYMS:
3191 export_all_symbols = true;
3193 case OPTION_NO_EXPORT_ALL_SYMS:
3194 export_all_symbols = false;
3196 case OPTION_EXCLUDE_SYMS:
3197 add_excludes (optarg);
3199 case OPTION_NO_DEFAULT_EXCLUDES:
3200 do_default_excludes = false;
3215 /* ignored for compatibility */
3222 output_def = fopen (optarg, FOPEN_WT);
3243 print_version (program_name);
3252 add_stdcall_alias = 1;
3261 base_file = fopen (optarg, FOPEN_RB);
3264 /* xgettext:c-format */
3265 fatal (_("Unable to open base-file: %s"), optarg);
3268 #ifdef DLLTOOL_MCORE_ELF
3270 mcore_elf_out_file = optarg;
3273 mcore_elf_linker = optarg;
3276 mcore_elf_linker_flags = optarg;
3285 for (i = 0; mtable[i].type; i++)
3286 if (strcmp (mtable[i].type, mname) == 0)
3289 if (!mtable[i].type)
3290 /* xgettext:c-format */
3291 fatal (_("Machine '%s' not supported"), mname);
3295 if (!dll_name && exp_name)
3297 int len = strlen (exp_name) + 5;
3298 dll_name = xmalloc (len);
3299 strcpy (dll_name, exp_name);
3300 strcat (dll_name, ".dll");
3303 if (as_name == NULL)
3304 as_name = deduce_name ("as");
3306 /* Don't use the default exclude list if we're reading only the
3307 symbols in the .drectve section. The default excludes are meant
3308 to avoid exporting DLL entry point and Cygwin32 impure_ptr. */
3309 if (! export_all_symbols)
3310 do_default_excludes = false;
3312 if (do_default_excludes)
3313 set_default_excludes ();
3316 process_def_file (def_file);
3321 firstarg = av[optind];
3322 scan_obj_file (av[optind]);
3333 /* Make imp_name safe for use as a label. */
3336 imp_name_lab = xstrdup (imp_name);
3337 for (p = imp_name_lab; *p; p++)
3339 if (!isalpha ((unsigned char) *p) && !isdigit ((unsigned char) *p))
3342 head_label = make_label("_head_", imp_name_lab);
3349 #ifdef DLLTOOL_MCORE_ELF
3350 if (mcore_elf_out_file)
3351 mcore_elf_gen_out_file ();
3357 /* Look for the program formed by concatenating PROG_NAME and the
3358 string running from PREFIX to END_PREFIX. If the concatenated
3359 string contains a '/', try appending EXECUTABLE_SUFFIX if it is
3363 look_for_prog (prog_name, prefix, end_prefix)
3364 const char *prog_name;
3371 cmd = xmalloc (strlen (prefix)
3372 + strlen (prog_name)
3373 #ifdef HAVE_EXECUTABLE_SUFFIX
3374 + strlen (EXECUTABLE_SUFFIX)
3377 strcpy (cmd, prefix);
3379 sprintf (cmd + end_prefix, "%s", prog_name);
3381 if (strchr (cmd, '/') != NULL)
3385 found = (stat (cmd, &s) == 0
3386 #ifdef HAVE_EXECUTABLE_SUFFIX
3387 || stat (strcat (cmd, EXECUTABLE_SUFFIX), &s) == 0
3393 /* xgettext:c-format */
3394 inform (_("Tried file: %s"), cmd);
3400 /* xgettext:c-format */
3401 inform (_("Using file: %s"), cmd);
3406 /* Deduce the name of the program we are want to invoke.
3407 PROG_NAME is the basic name of the program we want to run,
3408 eg "as" or "ld". The catch is that we might want actually
3409 run "i386-pe-as" or "ppc-pe-ld".
3411 If argv[0] contains the full path, then try to find the program
3412 in the same place, with and then without a target-like prefix.
3414 Given, argv[0] = /usr/local/bin/i586-cygwin32-dlltool,
3415 deduce_name("as") uses the following search order:
3417 /usr/local/bin/i586-cygwin32-as
3421 If there's an EXECUTABLE_SUFFIX, it'll use that as well; for each
3422 name, it'll try without and then with EXECUTABLE_SUFFIX.
3424 Given, argv[0] = i586-cygwin32-dlltool, it will not even try "as"
3425 as the fallback, but rather return i586-cygwin32-as.
3427 Oh, and given, argv[0] = dlltool, it'll return "as".
3429 Returns a dynamically allocated string. */
3432 deduce_name (prog_name)
3433 const char *prog_name;
3436 char *dash, *slash, *cp;
3440 for (cp = program_name; *cp != '\0'; ++cp)
3445 #if defined(__DJGPP__) || defined (__CYGWIN__) || defined(__WIN32__)
3446 *cp == ':' || *cp == '\\' ||
3459 /* First, try looking for a prefixed PROG_NAME in the
3460 PROGRAM_NAME directory, with the same prefix as PROGRAM_NAME. */
3461 cmd = look_for_prog (prog_name, program_name, dash - program_name + 1);
3464 if (slash != NULL && cmd == NULL)
3466 /* Next, try looking for a PROG_NAME in the same directory as
3467 that of this program. */
3468 cmd = look_for_prog (prog_name, program_name, slash - program_name + 1);
3473 /* Just return PROG_NAME as is. */
3474 cmd = xstrdup (prog_name);
3480 #ifdef DLLTOOL_MCORE_ELF
3481 typedef struct fname_cache
3484 struct fname_cache * next;
3488 static fname_cache fnames;
3491 mcore_elf_cache_filename (char * filename)
3497 while (ptr->next != NULL)
3500 ptr->filename = filename;
3501 ptr->next = (fname_cache *) malloc (sizeof (fname_cache));
3502 if (ptr->next != NULL)
3503 ptr->next->next = NULL;
3506 #define MCORE_ELF_TMP_OBJ "mcoreelf.o"
3507 #define MCORE_ELF_TMP_EXP "mcoreelf.exp"
3508 #define MCORE_ELF_TMP_LIB "mcoreelf.lib"
3511 mcore_elf_gen_out_file (void)
3516 /* Step one. Run 'ld -r' on the input object files in order to resolve
3517 any internal references and to generate a single .exports section. */
3520 ds = dyn_string_new (100);
3521 dyn_string_append (ds, "-r ");
3523 if (mcore_elf_linker_flags != NULL)
3524 dyn_string_append (ds, mcore_elf_linker_flags);
3526 while (ptr->next != NULL)
3528 dyn_string_append (ds, ptr->filename);
3529 dyn_string_append (ds, " ");
3534 dyn_string_append (ds, "-o ");
3535 dyn_string_append (ds, MCORE_ELF_TMP_OBJ);
3537 if (mcore_elf_linker == NULL)
3538 mcore_elf_linker = deduce_name ("ld");
3540 run (mcore_elf_linker, ds->s);
3542 dyn_string_delete (ds);
3544 /* Step two. Create a .exp file and a .lib file from the temporary file.
3545 Do this by recursively invoking dlltool....*/
3546 ds = dyn_string_new (100);
3548 dyn_string_append (ds, "-S ");
3549 dyn_string_append (ds, as_name);
3551 dyn_string_append (ds, " -e ");
3552 dyn_string_append (ds, MCORE_ELF_TMP_EXP);
3553 dyn_string_append (ds, " -l ");
3554 dyn_string_append (ds, MCORE_ELF_TMP_LIB);
3555 dyn_string_append (ds, " " );
3556 dyn_string_append (ds, MCORE_ELF_TMP_OBJ);
3559 dyn_string_append (ds, " -v");
3563 dyn_string_append (ds, " -n");
3565 if (dontdeltemps > 1)
3566 dyn_string_append (ds, " -n");
3569 /* XXX - FIME: ought to check/copy other command line options as well. */
3571 run (program_name, ds->s);
3573 dyn_string_delete (ds);
3575 /* Step four. Feed the .exp and object files to ld -shared to create the dll. */
3576 ds = dyn_string_new (100);
3578 dyn_string_append (ds, "-shared ");
3580 if (mcore_elf_linker_flags)
3581 dyn_string_append (ds, mcore_elf_linker_flags);
3583 dyn_string_append (ds, " ");
3584 dyn_string_append (ds, MCORE_ELF_TMP_EXP);
3585 dyn_string_append (ds, " ");
3586 dyn_string_append (ds, MCORE_ELF_TMP_OBJ);
3587 dyn_string_append (ds, " -o ");
3588 dyn_string_append (ds, mcore_elf_out_file);
3590 run (mcore_elf_linker, ds->s);
3592 dyn_string_delete (ds);
3594 if (dontdeltemps == 0)
3595 unlink (MCORE_ELF_TMP_EXP);
3597 if (dontdeltemps < 2)
3598 unlink (MCORE_ELF_TMP_OBJ);
3600 #endif /* DLLTOOL_MCORE_ELF */