* elf32-ppc.c (LWZU_0_X_11): Delete.
[binutils.git] / binutils / dlltool.c
blob760f4375ad6ef942d6a591a75eed49d3cf2f1104
1 /* dlltool.c -- tool to generate stuff for PE style DLLs
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
20 02110-1301, USA. */
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.
25 (eg, Windows NT)
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
34 referencing program.
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.
65 DESCRIPTION <string>
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.
73 [CODE|DATA] <attr>+
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
78 upon it.
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>
83 in a .DEF file.
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
89 supplied argument.
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.
97 Example:
99 file1.c:
100 asm (".section .drectve");
101 asm (".ascii \"-export:adef\"");
103 void adef (char * s)
105 printf ("hello from the dll %s\n", s);
108 void bdef (char * s)
110 printf ("hello from the dll and the other entry point %s\n", s);
113 file2.c:
114 asm (".section .drectve");
115 asm (".ascii \"-export:cdef\"");
116 asm (".ascii \"-export:ddef\"");
118 void cdef (char * s)
120 printf ("hello from the dll %s\n", s);
123 void ddef (char * s)
125 printf ("hello from the dll and the other entry point %s\n", s);
128 int printf (void)
130 return 9;
133 themain.c:
134 int main (void)
136 cdef ();
137 return 0;
140 thedll.def
142 LIBRARY thedll
143 HEAPSIZE 0x40000, 0x2000
144 EXPORTS bdef @ 20
145 cdef @ 30 NONAME
147 SECTIONS donkey READ WRITE
148 aardvark EXECUTE
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
159 ranlib thedll.in
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
186 # at the same time
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
227 function.
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. */
236 #ifndef __GNUC__
237 # ifdef _AIX
238 #pragma alloca
239 #endif
240 #endif
242 #define show_allnames 0
244 #define PAGE_SIZE 4096
245 #define PAGE_MASK (-PAGE_SIZE)
246 #include "bfd.h"
247 #include "libiberty.h"
248 #include "bucomm.h"
249 #include "getopt.h"
250 #include "demangle.h"
251 #include "dyn-string.h"
252 #include "dlltool.h"
253 #include "safe-ctype.h"
255 #include <time.h>
256 #include <sys/stat.h>
258 #ifdef ANSI_PROTOTYPES
259 #include <stdarg.h>
260 #else
261 #include <varargs.h>
262 #endif
264 #include <assert.h>
266 #ifdef DLLTOOL_ARM
267 #include "coff/arm.h"
268 #include "coff/internal.h"
269 #endif
271 /* Forward references. */
272 static char *look_for_prog (const char *, const char *, int);
273 static char *deduce_name (const char *);
275 #ifdef DLLTOOL_MCORE_ELF
276 static void mcore_elf_cache_filename (char *);
277 static void mcore_elf_gen_out_file (void);
278 #endif
280 #ifdef HAVE_SYS_WAIT_H
281 #include <sys/wait.h>
282 #else /* ! HAVE_SYS_WAIT_H */
283 #if ! defined (_WIN32) || defined (__CYGWIN32__)
284 #ifndef WIFEXITED
285 #define WIFEXITED(w) (((w) & 0377) == 0)
286 #endif
287 #ifndef WIFSIGNALED
288 #define WIFSIGNALED(w) (((w) & 0377) != 0177 && ((w) & ~0377) == 0)
289 #endif
290 #ifndef WTERMSIG
291 #define WTERMSIG(w) ((w) & 0177)
292 #endif
293 #ifndef WEXITSTATUS
294 #define WEXITSTATUS(w) (((w) >> 8) & 0377)
295 #endif
296 #else /* defined (_WIN32) && ! defined (__CYGWIN32__) */
297 #ifndef WIFEXITED
298 #define WIFEXITED(w) (((w) & 0xff) == 0)
299 #endif
300 #ifndef WIFSIGNALED
301 #define WIFSIGNALED(w) (((w) & 0xff) != 0 && ((w) & 0xff) != 0x7f)
302 #endif
303 #ifndef WTERMSIG
304 #define WTERMSIG(w) ((w) & 0x7f)
305 #endif
306 #ifndef WEXITSTATUS
307 #define WEXITSTATUS(w) (((w) & 0xff00) >> 8)
308 #endif
309 #endif /* defined (_WIN32) && ! defined (__CYGWIN32__) */
310 #endif /* ! HAVE_SYS_WAIT_H */
312 /* ifunc and ihead data structures: ttk@cygnus.com 1997
314 When IMPORT declarations are encountered in a .def file the
315 function import information is stored in a structure referenced by
316 the global variable IMPORT_LIST. The structure is a linked list
317 containing the names of the dll files each function is imported
318 from and a linked list of functions being imported from that dll
319 file. This roughly parallels the structure of the .idata section
320 in the PE object file.
322 The contents of .def file are interpreted from within the
323 process_def_file function. Every time an IMPORT declaration is
324 encountered, it is broken up into its component parts and passed to
325 def_import. IMPORT_LIST is initialized to NULL in function main. */
327 typedef struct ifunct
329 char * name; /* Name of function being imported. */
330 int ord; /* Two-byte ordinal value associated with function. */
331 struct ifunct *next;
332 } ifunctype;
334 typedef struct iheadt
336 char *dllname; /* Name of dll file imported from. */
337 long nfuncs; /* Number of functions in list. */
338 struct ifunct *funchead; /* First function in list. */
339 struct ifunct *functail; /* Last function in list. */
340 struct iheadt *next; /* Next dll file in list. */
341 } iheadtype;
343 /* Structure containing all import information as defined in .def file
344 (qv "ihead structure"). */
346 static iheadtype *import_list = NULL;
348 static char *as_name = NULL;
349 static char * as_flags = "";
351 static char *tmp_prefix;
353 static int no_idata4;
354 static int no_idata5;
355 static char *exp_name;
356 static char *imp_name;
357 static char *head_label;
358 static char *imp_name_lab;
359 static char *dll_name;
361 static int add_indirect = 0;
362 static int add_underscore = 0;
363 static int dontdeltemps = 0;
365 /* TRUE if we should export all symbols. Otherwise, we only export
366 symbols listed in .drectve sections or in the def file. */
367 static bfd_boolean export_all_symbols;
369 /* TRUE if we should exclude the symbols in DEFAULT_EXCLUDES when
370 exporting all symbols. */
371 static bfd_boolean do_default_excludes = TRUE;
373 /* Default symbols to exclude when exporting all the symbols. */
374 static const char *default_excludes = "DllMain@12,DllEntryPoint@0,impure_ptr";
376 /* TRUE if we should add __imp_<SYMBOL> to import libraries for backward
377 compatibility to old Cygwin releases. */
378 static bfd_boolean create_compat_implib;
380 static char *def_file;
382 extern char * program_name;
384 static int machine;
385 static int killat;
386 static int add_stdcall_alias;
387 static const char *ext_prefix_alias;
388 static int verbose;
389 static FILE *output_def;
390 static FILE *base_file;
392 #ifdef DLLTOOL_ARM
393 #ifdef DLLTOOL_ARM_EPOC
394 static const char *mname = "arm-epoc";
395 #else
396 static const char *mname = "arm";
397 #endif
398 #endif
400 #ifdef DLLTOOL_I386
401 static const char *mname = "i386";
402 #endif
404 #ifdef DLLTOOL_PPC
405 static const char *mname = "ppc";
406 #endif
408 #ifdef DLLTOOL_SH
409 static const char *mname = "sh";
410 #endif
412 #ifdef DLLTOOL_MIPS
413 static const char *mname = "mips";
414 #endif
416 #ifdef DLLTOOL_MCORE
417 static const char * mname = "mcore-le";
418 #endif
420 #ifdef DLLTOOL_MCORE_ELF
421 static const char * mname = "mcore-elf";
422 static char * mcore_elf_out_file = NULL;
423 static char * mcore_elf_linker = NULL;
424 static char * mcore_elf_linker_flags = NULL;
426 #define DRECTVE_SECTION_NAME ((machine == MMCORE_ELF || machine == MMCORE_ELF_LE) ? ".exports" : ".drectve")
427 #endif
429 #ifndef DRECTVE_SECTION_NAME
430 #define DRECTVE_SECTION_NAME ".drectve"
431 #endif
433 /* What's the right name for this ? */
434 #define PATHMAX 250
436 /* External name alias numbering starts here. */
437 #define PREFIX_ALIAS_BASE 20000
439 char *tmp_asm_buf;
440 char *tmp_head_s_buf;
441 char *tmp_head_o_buf;
442 char *tmp_tail_s_buf;
443 char *tmp_tail_o_buf;
444 char *tmp_stub_buf;
446 #define TMP_ASM dlltmp (&tmp_asm_buf, "%sc.s")
447 #define TMP_HEAD_S dlltmp (&tmp_head_s_buf, "%sh.s")
448 #define TMP_HEAD_O dlltmp (&tmp_head_o_buf, "%sh.o")
449 #define TMP_TAIL_S dlltmp (&tmp_tail_s_buf, "%st.s")
450 #define TMP_TAIL_O dlltmp (&tmp_tail_o_buf, "%st.o")
451 #define TMP_STUB dlltmp (&tmp_stub_buf, "%ss")
453 /* This bit of assembly does jmp * .... */
454 static const unsigned char i386_jtab[] =
456 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
459 static const unsigned char arm_jtab[] =
461 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
462 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
463 0, 0, 0, 0
466 static const unsigned char arm_interwork_jtab[] =
468 0x04, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
469 0x00, 0xc0, 0x9c, 0xe5, /* ldr ip, [ip] */
470 0x1c, 0xff, 0x2f, 0xe1, /* bx ip */
471 0, 0, 0, 0
474 static const unsigned char thumb_jtab[] =
476 0x40, 0xb4, /* push {r6} */
477 0x02, 0x4e, /* ldr r6, [pc, #8] */
478 0x36, 0x68, /* ldr r6, [r6] */
479 0xb4, 0x46, /* mov ip, r6 */
480 0x40, 0xbc, /* pop {r6} */
481 0x60, 0x47, /* bx ip */
482 0, 0, 0, 0
485 static const unsigned char mcore_be_jtab[] =
487 0x71, 0x02, /* lrw r1,2 */
488 0x81, 0x01, /* ld.w r1,(r1,0) */
489 0x00, 0xC1, /* jmp r1 */
490 0x12, 0x00, /* nop */
491 0x00, 0x00, 0x00, 0x00 /* <address> */
494 static const unsigned char mcore_le_jtab[] =
496 0x02, 0x71, /* lrw r1,2 */
497 0x01, 0x81, /* ld.w r1,(r1,0) */
498 0xC1, 0x00, /* jmp r1 */
499 0x00, 0x12, /* nop */
500 0x00, 0x00, 0x00, 0x00 /* <address> */
503 /* This is the glue sequence for PowerPC PE. There is a
504 tocrel16-tocdefn reloc against the first instruction.
505 We also need a IMGLUE reloc against the glue function
506 to restore the toc saved by the third instruction in
507 the glue. */
508 static const unsigned char ppc_jtab[] =
510 0x00, 0x00, 0x62, 0x81, /* lwz r11,0(r2) */
511 /* Reloc TOCREL16 __imp_xxx */
512 0x00, 0x00, 0x8B, 0x81, /* lwz r12,0(r11) */
513 0x04, 0x00, 0x41, 0x90, /* stw r2,4(r1) */
514 0xA6, 0x03, 0x89, 0x7D, /* mtctr r12 */
515 0x04, 0x00, 0x4B, 0x80, /* lwz r2,4(r11) */
516 0x20, 0x04, 0x80, 0x4E /* bctr */
519 #ifdef DLLTOOL_PPC
520 /* The glue instruction, picks up the toc from the stw in
521 the above code: "lwz r2,4(r1)". */
522 static bfd_vma ppc_glue_insn = 0x80410004;
523 #endif
525 struct mac
527 const char *type;
528 const char *how_byte;
529 const char *how_short;
530 const char *how_long;
531 const char *how_asciz;
532 const char *how_comment;
533 const char *how_jump;
534 const char *how_global;
535 const char *how_space;
536 const char *how_align_short;
537 const char *how_align_long;
538 const char *how_default_as_switches;
539 const char *how_bfd_target;
540 enum bfd_architecture how_bfd_arch;
541 const unsigned char *how_jtab;
542 int how_jtab_size; /* Size of the jtab entry. */
543 int how_jtab_roff; /* Offset into it for the ind 32 reloc into idata 5. */
546 static const struct mac
547 mtable[] =
550 #define MARM 0
551 "arm", ".byte", ".short", ".long", ".asciz", "@",
552 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
553 ".global", ".space", ".align\t2",".align\t4", "-mapcs-32",
554 "pe-arm-little", bfd_arch_arm,
555 arm_jtab, sizeof (arm_jtab), 8
559 #define M386 1
560 "i386", ".byte", ".short", ".long", ".asciz", "#",
561 "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
562 "pe-i386",bfd_arch_i386,
563 i386_jtab, sizeof (i386_jtab), 2
567 #define MPPC 2
568 "ppc", ".byte", ".short", ".long", ".asciz", "#",
569 "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
570 "pe-powerpcle",bfd_arch_powerpc,
571 ppc_jtab, sizeof (ppc_jtab), 0
575 #define MTHUMB 3
576 "thumb", ".byte", ".short", ".long", ".asciz", "@",
577 "push\t{r6}\n\tldr\tr6, [pc, #8]\n\tldr\tr6, [r6]\n\tmov\tip, r6\n\tpop\t{r6}\n\tbx\tip",
578 ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
579 "pe-arm-little", bfd_arch_arm,
580 thumb_jtab, sizeof (thumb_jtab), 12
583 #define MARM_INTERWORK 4
585 "arm_interwork", ".byte", ".short", ".long", ".asciz", "@",
586 "ldr\tip,[pc]\n\tldr\tip,[ip]\n\tbx\tip\n\t.long",
587 ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
588 "pe-arm-little", bfd_arch_arm,
589 arm_interwork_jtab, sizeof (arm_interwork_jtab), 12
593 #define MMCORE_BE 5
594 "mcore-be", ".byte", ".short", ".long", ".asciz", "//",
595 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
596 ".global", ".space", ".align\t2",".align\t4", "",
597 "pe-mcore-big", bfd_arch_mcore,
598 mcore_be_jtab, sizeof (mcore_be_jtab), 8
602 #define MMCORE_LE 6
603 "mcore-le", ".byte", ".short", ".long", ".asciz", "//",
604 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
605 ".global", ".space", ".align\t2",".align\t4", "-EL",
606 "pe-mcore-little", bfd_arch_mcore,
607 mcore_le_jtab, sizeof (mcore_le_jtab), 8
611 #define MMCORE_ELF 7
612 "mcore-elf-be", ".byte", ".short", ".long", ".asciz", "//",
613 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
614 ".global", ".space", ".align\t2",".align\t4", "",
615 "elf32-mcore-big", bfd_arch_mcore,
616 mcore_be_jtab, sizeof (mcore_be_jtab), 8
620 #define MMCORE_ELF_LE 8
621 "mcore-elf-le", ".byte", ".short", ".long", ".asciz", "//",
622 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
623 ".global", ".space", ".align\t2",".align\t4", "-EL",
624 "elf32-mcore-little", bfd_arch_mcore,
625 mcore_le_jtab, sizeof (mcore_le_jtab), 8
629 #define MARM_EPOC 9
630 "arm-epoc", ".byte", ".short", ".long", ".asciz", "@",
631 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
632 ".global", ".space", ".align\t2",".align\t4", "",
633 "epoc-pe-arm-little", bfd_arch_arm,
634 arm_jtab, sizeof (arm_jtab), 8
637 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
640 typedef struct dlist
642 char *text;
643 struct dlist *next;
645 dlist_type;
647 typedef struct export
649 const char *name;
650 const char *internal_name;
651 const char *import_name;
652 int ordinal;
653 int constant;
654 int noname; /* Don't put name in image file. */
655 int private; /* Don't put reference in import lib. */
656 int data;
657 int hint;
658 int forward; /* Number of forward label, 0 means no forward. */
659 struct export *next;
661 export_type;
663 /* A list of symbols which we should not export. */
665 struct string_list
667 struct string_list *next;
668 char *string;
671 static struct string_list *excludes;
673 static const char *rvaafter (int);
674 static const char *rvabefore (int);
675 static const char *asm_prefix (int, const char *);
676 static void process_def_file (const char *);
677 static void new_directive (char *);
678 static void append_import (const char *, const char *, int);
679 static void run (const char *, char *);
680 static void scan_drectve_symbols (bfd *);
681 static void scan_filtered_symbols (bfd *, void *, long, unsigned int);
682 static void add_excludes (const char *);
683 static bfd_boolean match_exclude (const char *);
684 static void set_default_excludes (void);
685 static long filter_symbols (bfd *, void *, long, unsigned int);
686 static void scan_all_symbols (bfd *);
687 static void scan_open_obj_file (bfd *);
688 static void scan_obj_file (const char *);
689 static void dump_def_info (FILE *);
690 static int sfunc (const void *, const void *);
691 static void flush_page (FILE *, long *, int, int);
692 static void gen_def_file (void);
693 static void generate_idata_ofile (FILE *);
694 static void assemble_file (const char *, const char *);
695 static void gen_exp_file (void);
696 static const char *xlate (const char *);
697 static char *make_label (const char *, const char *);
698 static char *make_imp_label (const char *, const char *);
699 static bfd *make_one_lib_file (export_type *, int);
700 static bfd *make_head (void);
701 static bfd *make_tail (void);
702 static void gen_lib_file (void);
703 static int pfunc (const void *, const void *);
704 static int nfunc (const void *, const void *);
705 static void remove_null_names (export_type **);
706 static void process_duplicates (export_type **);
707 static void fill_ordinals (export_type **);
708 static int alphafunc (const void *, const void *);
709 static void mangle_defs (void);
710 static void usage (FILE *, int);
711 static void inform (const char *, ...);
712 static void set_dll_name_from_def (const char *);
714 static char *
715 prefix_encode (char *start, unsigned code)
717 static char alpha[26] = "abcdefghijklmnopqrstuvwxyz";
718 static char buf[32];
719 char *p;
720 strcpy (buf, start);
721 p = strchr (buf, '\0');
723 *p++ = alpha[code % sizeof (alpha)];
724 while ((code /= sizeof (alpha)) != 0);
725 *p = '\0';
726 return buf;
729 static char *
730 dlltmp (char **buf, const char *fmt)
732 if (!*buf)
734 *buf = malloc (strlen (tmp_prefix) + 64);
735 sprintf (*buf, fmt, tmp_prefix);
737 return *buf;
740 static void
741 inform VPARAMS ((const char * message, ...))
743 VA_OPEN (args, message);
744 VA_FIXEDARG (args, const char *, message);
746 if (!verbose)
747 return;
749 report (message, args);
751 VA_CLOSE (args);
754 static const char *
755 rvaafter (int machine)
757 switch (machine)
759 case MARM:
760 case M386:
761 case MPPC:
762 case MTHUMB:
763 case MARM_INTERWORK:
764 case MMCORE_BE:
765 case MMCORE_LE:
766 case MMCORE_ELF:
767 case MMCORE_ELF_LE:
768 case MARM_EPOC:
769 break;
770 default:
771 /* xgettext:c-format */
772 fatal (_("Internal error: Unknown machine type: %d"), machine);
773 break;
775 return "";
778 static const char *
779 rvabefore (int machine)
781 switch (machine)
783 case MARM:
784 case M386:
785 case MPPC:
786 case MTHUMB:
787 case MARM_INTERWORK:
788 case MMCORE_BE:
789 case MMCORE_LE:
790 case MMCORE_ELF:
791 case MMCORE_ELF_LE:
792 case MARM_EPOC:
793 return ".rva\t";
794 default:
795 /* xgettext:c-format */
796 fatal (_("Internal error: Unknown machine type: %d"), machine);
797 break;
799 return "";
802 static const char *
803 asm_prefix (int machine, const char *name)
805 switch (machine)
807 case MARM:
808 case MPPC:
809 case MTHUMB:
810 case MARM_INTERWORK:
811 case MMCORE_BE:
812 case MMCORE_LE:
813 case MMCORE_ELF:
814 case MMCORE_ELF_LE:
815 case MARM_EPOC:
816 break;
817 case M386:
818 /* Symbol names starting with ? do not have a leading underscore. */
819 if (name && *name == '?')
820 break;
821 else
822 return "_";
823 default:
824 /* xgettext:c-format */
825 fatal (_("Internal error: Unknown machine type: %d"), machine);
826 break;
828 return "";
831 #define ASM_BYTE mtable[machine].how_byte
832 #define ASM_SHORT mtable[machine].how_short
833 #define ASM_LONG mtable[machine].how_long
834 #define ASM_TEXT mtable[machine].how_asciz
835 #define ASM_C mtable[machine].how_comment
836 #define ASM_JUMP mtable[machine].how_jump
837 #define ASM_GLOBAL mtable[machine].how_global
838 #define ASM_SPACE mtable[machine].how_space
839 #define ASM_ALIGN_SHORT mtable[machine].how_align_short
840 #define ASM_RVA_BEFORE rvabefore (machine)
841 #define ASM_RVA_AFTER rvaafter (machine)
842 #define ASM_PREFIX(NAME) asm_prefix (machine, (NAME))
843 #define ASM_ALIGN_LONG mtable[machine].how_align_long
844 #define HOW_BFD_READ_TARGET 0 /* Always default. */
845 #define HOW_BFD_WRITE_TARGET mtable[machine].how_bfd_target
846 #define HOW_BFD_ARCH mtable[machine].how_bfd_arch
847 #define HOW_JTAB mtable[machine].how_jtab
848 #define HOW_JTAB_SIZE mtable[machine].how_jtab_size
849 #define HOW_JTAB_ROFF mtable[machine].how_jtab_roff
850 #define ASM_SWITCHES mtable[machine].how_default_as_switches
852 static char **oav;
854 static void
855 process_def_file (const char *name)
857 FILE *f = fopen (name, FOPEN_RT);
859 if (!f)
860 /* xgettext:c-format */
861 fatal (_("Can't open def file: %s"), name);
863 yyin = f;
865 /* xgettext:c-format */
866 inform (_("Processing def file: %s"), name);
868 yyparse ();
870 inform (_("Processed def file"));
873 /**********************************************************************/
875 /* Communications with the parser. */
877 static int d_nfuncs; /* Number of functions exported. */
878 static int d_named_nfuncs; /* Number of named functions exported. */
879 static int d_low_ord; /* Lowest ordinal index. */
880 static int d_high_ord; /* Highest ordinal index. */
881 static export_type *d_exports; /* List of exported functions. */
882 static export_type **d_exports_lexically; /* Vector of exported functions in alpha order. */
883 static dlist_type *d_list; /* Descriptions. */
884 static dlist_type *a_list; /* Stuff to go in directives. */
885 static int d_nforwards = 0; /* Number of forwarded exports. */
887 static int d_is_dll;
888 static int d_is_exe;
891 yyerror (const char * err ATTRIBUTE_UNUSED)
893 /* xgettext:c-format */
894 non_fatal (_("Syntax error in def file %s:%d"), def_file, linenumber);
896 return 0;
899 void
900 def_exports (const char *name, const char *internal_name, int ordinal,
901 int noname, int constant, int data, int private)
903 struct export *p = (struct export *) xmalloc (sizeof (*p));
905 p->name = name;
906 p->internal_name = internal_name ? internal_name : name;
907 p->import_name = name;
908 p->ordinal = ordinal;
909 p->constant = constant;
910 p->noname = noname;
911 p->private = private;
912 p->data = data;
913 p->next = d_exports;
914 d_exports = p;
915 d_nfuncs++;
917 if ((internal_name != NULL)
918 && (strchr (internal_name, '.') != NULL))
919 p->forward = ++d_nforwards;
920 else
921 p->forward = 0; /* no forward */
924 static void
925 set_dll_name_from_def (const char * name)
927 const char* image_basename = lbasename (name);
928 if (image_basename != name)
929 non_fatal (_("%s: Path components stripped from image name, '%s'."),
930 def_file, name);
931 dll_name = xstrdup (image_basename);
934 void
935 def_name (const char *name, int base)
937 /* xgettext:c-format */
938 inform (_("NAME: %s base: %x"), name, base);
940 if (d_is_dll)
941 non_fatal (_("Can't have LIBRARY and NAME"));
943 /* If --dllname not provided, use the one in the DEF file.
944 FIXME: Is this appropriate for executables? */
945 if (! dll_name)
946 set_dll_name_from_def (name);
947 d_is_exe = 1;
950 void
951 def_library (const char *name, int base)
953 /* xgettext:c-format */
954 inform (_("LIBRARY: %s base: %x"), name, base);
956 if (d_is_exe)
957 non_fatal (_("Can't have LIBRARY and NAME"));
959 /* If --dllname not provided, use the one in the DEF file. */
960 if (! dll_name)
961 set_dll_name_from_def (name);
962 d_is_dll = 1;
965 void
966 def_description (const char *desc)
968 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
969 d->text = xstrdup (desc);
970 d->next = d_list;
971 d_list = d;
974 static void
975 new_directive (char *dir)
977 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
978 d->text = xstrdup (dir);
979 d->next = a_list;
980 a_list = d;
983 void
984 def_heapsize (int reserve, int commit)
986 char b[200];
987 if (commit > 0)
988 sprintf (b, "-heap 0x%x,0x%x ", reserve, commit);
989 else
990 sprintf (b, "-heap 0x%x ", reserve);
991 new_directive (xstrdup (b));
994 void
995 def_stacksize (int reserve, int commit)
997 char b[200];
998 if (commit > 0)
999 sprintf (b, "-stack 0x%x,0x%x ", reserve, commit);
1000 else
1001 sprintf (b, "-stack 0x%x ", reserve);
1002 new_directive (xstrdup (b));
1005 /* append_import simply adds the given import definition to the global
1006 import_list. It is used by def_import. */
1008 static void
1009 append_import (const char *symbol_name, const char *dll_name, int func_ordinal)
1011 iheadtype **pq;
1012 iheadtype *q;
1014 for (pq = &import_list; *pq != NULL; pq = &(*pq)->next)
1016 if (strcmp ((*pq)->dllname, dll_name) == 0)
1018 q = *pq;
1019 q->functail->next = xmalloc (sizeof (ifunctype));
1020 q->functail = q->functail->next;
1021 q->functail->ord = func_ordinal;
1022 q->functail->name = xstrdup (symbol_name);
1023 q->functail->next = NULL;
1024 q->nfuncs++;
1025 return;
1029 q = xmalloc (sizeof (iheadtype));
1030 q->dllname = xstrdup (dll_name);
1031 q->nfuncs = 1;
1032 q->funchead = xmalloc (sizeof (ifunctype));
1033 q->functail = q->funchead;
1034 q->next = NULL;
1035 q->functail->name = xstrdup (symbol_name);
1036 q->functail->ord = func_ordinal;
1037 q->functail->next = NULL;
1039 *pq = q;
1042 /* def_import is called from within defparse.y when an IMPORT
1043 declaration is encountered. Depending on the form of the
1044 declaration, the module name may or may not need ".dll" to be
1045 appended to it, the name of the function may be stored in internal
1046 or entry, and there may or may not be an ordinal value associated
1047 with it. */
1049 /* A note regarding the parse modes:
1050 In defparse.y we have to accept import declarations which follow
1051 any one of the following forms:
1052 <func_name_in_app> = <dll_name>.<func_name_in_dll>
1053 <func_name_in_app> = <dll_name>.<number>
1054 <dll_name>.<func_name_in_dll>
1055 <dll_name>.<number>
1056 Furthermore, the dll's name may or may not end with ".dll", which
1057 complicates the parsing a little. Normally the dll's name is
1058 passed to def_import() in the "module" parameter, but when it ends
1059 with ".dll" it gets passed in "module" sans ".dll" and that needs
1060 to be reappended.
1062 def_import gets five parameters:
1063 APP_NAME - the name of the function in the application, if
1064 present, or NULL if not present.
1065 MODULE - the name of the dll, possibly sans extension (ie, '.dll').
1066 DLLEXT - the extension of the dll, if present, NULL if not present.
1067 ENTRY - the name of the function in the dll, if present, or NULL.
1068 ORD_VAL - the numerical tag of the function in the dll, if present,
1069 or NULL. Exactly one of <entry> or <ord_val> must be
1070 present (i.e., not NULL). */
1072 void
1073 def_import (const char *app_name, const char *module, const char *dllext,
1074 const char *entry, int ord_val)
1076 const char *application_name;
1077 char *buf;
1079 if (entry != NULL)
1080 application_name = entry;
1081 else
1083 if (app_name != NULL)
1084 application_name = app_name;
1085 else
1086 application_name = "";
1089 if (dllext != NULL)
1091 buf = (char *) alloca (strlen (module) + strlen (dllext) + 2);
1092 sprintf (buf, "%s.%s", module, dllext);
1093 module = buf;
1096 append_import (application_name, module, ord_val);
1099 void
1100 def_version (int major, int minor)
1102 printf ("VERSION %d.%d\n", major, minor);
1105 void
1106 def_section (const char *name, int attr)
1108 char buf[200];
1109 char atts[5];
1110 char *d = atts;
1111 if (attr & 1)
1112 *d++ = 'R';
1114 if (attr & 2)
1115 *d++ = 'W';
1116 if (attr & 4)
1117 *d++ = 'X';
1118 if (attr & 8)
1119 *d++ = 'S';
1120 *d++ = 0;
1121 sprintf (buf, "-attr %s %s", name, atts);
1122 new_directive (xstrdup (buf));
1125 void
1126 def_code (int attr)
1129 def_section ("CODE", attr);
1132 void
1133 def_data (int attr)
1135 def_section ("DATA", attr);
1138 /**********************************************************************/
1140 static void
1141 run (const char *what, char *args)
1143 char *s;
1144 int pid, wait_status;
1145 int i;
1146 const char **argv;
1147 char *errmsg_fmt, *errmsg_arg;
1148 char *temp_base = choose_temp_base ();
1150 inform ("run: %s %s", what, args);
1152 /* Count the args */
1153 i = 0;
1154 for (s = args; *s; s++)
1155 if (*s == ' ')
1156 i++;
1157 i++;
1158 argv = alloca (sizeof (char *) * (i + 3));
1159 i = 0;
1160 argv[i++] = what;
1161 s = args;
1162 while (1)
1164 while (*s == ' ')
1165 ++s;
1166 argv[i++] = s;
1167 while (*s != ' ' && *s != 0)
1168 s++;
1169 if (*s == 0)
1170 break;
1171 *s++ = 0;
1173 argv[i++] = NULL;
1175 pid = pexecute (argv[0], (char * const *) argv, program_name, temp_base,
1176 &errmsg_fmt, &errmsg_arg, PEXECUTE_ONE | PEXECUTE_SEARCH);
1178 if (pid == -1)
1180 inform (strerror (errno));
1182 fatal (errmsg_fmt, errmsg_arg);
1185 pid = pwait (pid, & wait_status, 0);
1187 if (pid == -1)
1189 /* xgettext:c-format */
1190 fatal (_("wait: %s"), strerror (errno));
1192 else if (WIFSIGNALED (wait_status))
1194 /* xgettext:c-format */
1195 fatal (_("subprocess got fatal signal %d"), WTERMSIG (wait_status));
1197 else if (WIFEXITED (wait_status))
1199 if (WEXITSTATUS (wait_status) != 0)
1200 /* xgettext:c-format */
1201 non_fatal (_("%s exited with status %d"),
1202 what, WEXITSTATUS (wait_status));
1204 else
1205 abort ();
1208 /* Look for a list of symbols to export in the .drectve section of
1209 ABFD. Pass each one to def_exports. */
1211 static void
1212 scan_drectve_symbols (bfd *abfd)
1214 asection * s;
1215 int size;
1216 char * buf;
1217 char * p;
1218 char * e;
1220 /* Look for .drectve's */
1221 s = bfd_get_section_by_name (abfd, DRECTVE_SECTION_NAME);
1223 if (s == NULL)
1224 return;
1226 size = bfd_get_section_size (s);
1227 buf = xmalloc (size);
1229 bfd_get_section_contents (abfd, s, buf, 0, size);
1231 /* xgettext:c-format */
1232 inform (_("Sucking in info from %s section in %s"),
1233 DRECTVE_SECTION_NAME, bfd_get_filename (abfd));
1235 /* Search for -export: strings. The exported symbols can optionally
1236 have type tags (eg., -export:foo,data), so handle those as well.
1237 Currently only data tag is supported. */
1238 p = buf;
1239 e = buf + size;
1240 while (p < e)
1242 if (p[0] == '-'
1243 && strncmp (p, "-export:", 8) == 0)
1245 char * name;
1246 char * c;
1247 flagword flags = BSF_FUNCTION;
1249 p += 8;
1250 name = p;
1251 while (p < e && *p != ',' && *p != ' ' && *p != '-')
1252 p++;
1253 c = xmalloc (p - name + 1);
1254 memcpy (c, name, p - name);
1255 c[p - name] = 0;
1256 if (p < e && *p == ',') /* found type tag. */
1258 char *tag_start = ++p;
1259 while (p < e && *p != ' ' && *p != '-')
1260 p++;
1261 if (strncmp (tag_start, "data", 4) == 0)
1262 flags &= ~BSF_FUNCTION;
1265 /* FIXME: The 5th arg is for the `constant' field.
1266 What should it be? Not that it matters since it's not
1267 currently useful. */
1268 def_exports (c, 0, -1, 0, 0, ! (flags & BSF_FUNCTION), 0);
1270 if (add_stdcall_alias && strchr (c, '@'))
1272 int lead_at = (*c == '@') ;
1273 char *exported_name = xstrdup (c + lead_at);
1274 char *atsym = strchr (exported_name, '@');
1275 *atsym = '\0';
1276 /* Note: stdcall alias symbols can never be data. */
1277 def_exports (exported_name, xstrdup (c), -1, 0, 0, 0, 0);
1280 else
1281 p++;
1283 free (buf);
1286 /* Look through the symbols in MINISYMS, and add each one to list of
1287 symbols to export. */
1289 static void
1290 scan_filtered_symbols (bfd *abfd, void *minisyms, long symcount,
1291 unsigned int size)
1293 asymbol *store;
1294 bfd_byte *from, *fromend;
1296 store = bfd_make_empty_symbol (abfd);
1297 if (store == NULL)
1298 bfd_fatal (bfd_get_filename (abfd));
1300 from = (bfd_byte *) minisyms;
1301 fromend = from + symcount * size;
1302 for (; from < fromend; from += size)
1304 asymbol *sym;
1305 const char *symbol_name;
1307 sym = bfd_minisymbol_to_symbol (abfd, FALSE, from, store);
1308 if (sym == NULL)
1309 bfd_fatal (bfd_get_filename (abfd));
1311 symbol_name = bfd_asymbol_name (sym);
1312 if (bfd_get_symbol_leading_char (abfd) == symbol_name[0])
1313 ++symbol_name;
1315 def_exports (xstrdup (symbol_name) , 0, -1, 0, 0,
1316 ! (sym->flags & BSF_FUNCTION), 0);
1318 if (add_stdcall_alias && strchr (symbol_name, '@'))
1320 int lead_at = (*symbol_name == '@');
1321 char *exported_name = xstrdup (symbol_name + lead_at);
1322 char *atsym = strchr (exported_name, '@');
1323 *atsym = '\0';
1324 /* Note: stdcall alias symbols can never be data. */
1325 def_exports (exported_name, xstrdup (symbol_name), -1, 0, 0, 0, 0);
1330 /* Add a list of symbols to exclude. */
1332 static void
1333 add_excludes (const char *new_excludes)
1335 char *local_copy;
1336 char *exclude_string;
1338 local_copy = xstrdup (new_excludes);
1340 exclude_string = strtok (local_copy, ",:");
1341 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
1343 struct string_list *new_exclude;
1345 new_exclude = ((struct string_list *)
1346 xmalloc (sizeof (struct string_list)));
1347 new_exclude->string = (char *) xmalloc (strlen (exclude_string) + 2);
1348 /* Don't add a leading underscore for fastcall symbols. */
1349 if (*exclude_string == '@')
1350 sprintf (new_exclude->string, "%s", exclude_string);
1351 else
1352 sprintf (new_exclude->string, "_%s", exclude_string);
1353 new_exclude->next = excludes;
1354 excludes = new_exclude;
1356 /* xgettext:c-format */
1357 inform (_("Excluding symbol: %s"), exclude_string);
1360 free (local_copy);
1363 /* See if STRING is on the list of symbols to exclude. */
1365 static bfd_boolean
1366 match_exclude (const char *string)
1368 struct string_list *excl_item;
1370 for (excl_item = excludes; excl_item; excl_item = excl_item->next)
1371 if (strcmp (string, excl_item->string) == 0)
1372 return TRUE;
1373 return FALSE;
1376 /* Add the default list of symbols to exclude. */
1378 static void
1379 set_default_excludes (void)
1381 add_excludes (default_excludes);
1384 /* Choose which symbols to export. */
1386 static long
1387 filter_symbols (bfd *abfd, void *minisyms, long symcount, unsigned int size)
1389 bfd_byte *from, *fromend, *to;
1390 asymbol *store;
1392 store = bfd_make_empty_symbol (abfd);
1393 if (store == NULL)
1394 bfd_fatal (bfd_get_filename (abfd));
1396 from = (bfd_byte *) minisyms;
1397 fromend = from + symcount * size;
1398 to = (bfd_byte *) minisyms;
1400 for (; from < fromend; from += size)
1402 int keep = 0;
1403 asymbol *sym;
1405 sym = bfd_minisymbol_to_symbol (abfd, FALSE, (const void *) from, store);
1406 if (sym == NULL)
1407 bfd_fatal (bfd_get_filename (abfd));
1409 /* Check for external and defined only symbols. */
1410 keep = (((sym->flags & BSF_GLOBAL) != 0
1411 || (sym->flags & BSF_WEAK) != 0
1412 || bfd_is_com_section (sym->section))
1413 && ! bfd_is_und_section (sym->section));
1415 keep = keep && ! match_exclude (sym->name);
1417 if (keep)
1419 memcpy (to, from, size);
1420 to += size;
1424 return (to - (bfd_byte *) minisyms) / size;
1427 /* Export all symbols in ABFD, except for ones we were told not to
1428 export. */
1430 static void
1431 scan_all_symbols (bfd *abfd)
1433 long symcount;
1434 void *minisyms;
1435 unsigned int size;
1437 /* Ignore bfds with an import descriptor table. We assume that any
1438 such BFD contains symbols which are exported from another DLL,
1439 and we don't want to reexport them from here. */
1440 if (bfd_get_section_by_name (abfd, ".idata$4"))
1441 return;
1443 if (! (bfd_get_file_flags (abfd) & HAS_SYMS))
1445 /* xgettext:c-format */
1446 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1447 return;
1450 symcount = bfd_read_minisymbols (abfd, FALSE, &minisyms, &size);
1451 if (symcount < 0)
1452 bfd_fatal (bfd_get_filename (abfd));
1454 if (symcount == 0)
1456 /* xgettext:c-format */
1457 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1458 return;
1461 /* Discard the symbols we don't want to export. It's OK to do this
1462 in place; we'll free the storage anyway. */
1464 symcount = filter_symbols (abfd, minisyms, symcount, size);
1465 scan_filtered_symbols (abfd, minisyms, symcount, size);
1467 free (minisyms);
1470 /* Look at the object file to decide which symbols to export. */
1472 static void
1473 scan_open_obj_file (bfd *abfd)
1475 if (export_all_symbols)
1476 scan_all_symbols (abfd);
1477 else
1478 scan_drectve_symbols (abfd);
1480 /* FIXME: we ought to read in and block out the base relocations. */
1482 /* xgettext:c-format */
1483 inform (_("Done reading %s"), bfd_get_filename (abfd));
1486 static void
1487 scan_obj_file (const char *filename)
1489 bfd * f = bfd_openr (filename, 0);
1491 if (!f)
1492 /* xgettext:c-format */
1493 fatal (_("Unable to open object file: %s"), filename);
1495 /* xgettext:c-format */
1496 inform (_("Scanning object file %s"), filename);
1498 if (bfd_check_format (f, bfd_archive))
1500 bfd *arfile = bfd_openr_next_archived_file (f, 0);
1501 while (arfile)
1503 if (bfd_check_format (arfile, bfd_object))
1504 scan_open_obj_file (arfile);
1505 bfd_close (arfile);
1506 arfile = bfd_openr_next_archived_file (f, arfile);
1509 #ifdef DLLTOOL_MCORE_ELF
1510 if (mcore_elf_out_file)
1511 inform (_("Cannot produce mcore-elf dll from archive file: %s"), filename);
1512 #endif
1514 else if (bfd_check_format (f, bfd_object))
1516 scan_open_obj_file (f);
1518 #ifdef DLLTOOL_MCORE_ELF
1519 if (mcore_elf_out_file)
1520 mcore_elf_cache_filename ((char *) filename);
1521 #endif
1524 bfd_close (f);
1527 /**********************************************************************/
1529 static void
1530 dump_def_info (FILE *f)
1532 int i;
1533 export_type *exp;
1534 fprintf (f, "%s ", ASM_C);
1535 for (i = 0; oav[i]; i++)
1536 fprintf (f, "%s ", oav[i]);
1537 fprintf (f, "\n");
1538 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1540 fprintf (f, "%s %d = %s %s @ %d %s%s%s%s\n",
1541 ASM_C,
1543 exp->name,
1544 exp->internal_name,
1545 exp->ordinal,
1546 exp->noname ? "NONAME " : "",
1547 exp->private ? "PRIVATE " : "",
1548 exp->constant ? "CONSTANT" : "",
1549 exp->data ? "DATA" : "");
1553 /* Generate the .exp file. */
1555 static int
1556 sfunc (const void *a, const void *b)
1558 return *(const long *) a - *(const long *) b;
1561 static void
1562 flush_page (FILE *f, long *need, int page_addr, int on_page)
1564 int i;
1566 /* Flush this page. */
1567 fprintf (f, "\t%s\t0x%08x\t%s Starting RVA for chunk\n",
1568 ASM_LONG,
1569 page_addr,
1570 ASM_C);
1571 fprintf (f, "\t%s\t0x%x\t%s Size of block\n",
1572 ASM_LONG,
1573 (on_page * 2) + (on_page & 1) * 2 + 8,
1574 ASM_C);
1576 for (i = 0; i < on_page; i++)
1578 long needed = need[i];
1580 if (needed)
1581 needed = ((needed - page_addr) | 0x3000) & 0xffff;
1583 fprintf (f, "\t%s\t0x%lx\n", ASM_SHORT, needed);
1586 /* And padding */
1587 if (on_page & 1)
1588 fprintf (f, "\t%s\t0x%x\n", ASM_SHORT, 0 | 0x0000);
1591 static void
1592 gen_def_file (void)
1594 int i;
1595 export_type *exp;
1597 inform (_("Adding exports to output file"));
1599 fprintf (output_def, ";");
1600 for (i = 0; oav[i]; i++)
1601 fprintf (output_def, " %s", oav[i]);
1603 fprintf (output_def, "\nEXPORTS\n");
1605 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1607 char *quote = strchr (exp->name, '.') ? "\"" : "";
1608 char *res = cplus_demangle (exp->internal_name, DMGL_ANSI | DMGL_PARAMS);
1610 if (res)
1612 fprintf (output_def,";\t%s\n", res);
1613 free (res);
1616 if (strcmp (exp->name, exp->internal_name) == 0)
1618 fprintf (output_def, "\t%s%s%s @ %d%s%s%s\n",
1619 quote,
1620 exp->name,
1621 quote,
1622 exp->ordinal,
1623 exp->noname ? " NONAME" : "",
1624 exp->private ? "PRIVATE " : "",
1625 exp->data ? " DATA" : "");
1627 else
1629 char * quote1 = strchr (exp->internal_name, '.') ? "\"" : "";
1630 /* char *alias = */
1631 fprintf (output_def, "\t%s%s%s = %s%s%s @ %d%s%s%s\n",
1632 quote,
1633 exp->name,
1634 quote,
1635 quote1,
1636 exp->internal_name,
1637 quote1,
1638 exp->ordinal,
1639 exp->noname ? " NONAME" : "",
1640 exp->private ? "PRIVATE " : "",
1641 exp->data ? " DATA" : "");
1645 inform (_("Added exports to output file"));
1648 /* generate_idata_ofile generates the portable assembly source code
1649 for the idata sections. It appends the source code to the end of
1650 the file. */
1652 static void
1653 generate_idata_ofile (FILE *filvar)
1655 iheadtype *headptr;
1656 ifunctype *funcptr;
1657 int headindex;
1658 int funcindex;
1659 int nheads;
1661 if (import_list == NULL)
1662 return;
1664 fprintf (filvar, "%s Import data sections\n", ASM_C);
1665 fprintf (filvar, "\n\t.section\t.idata$2\n");
1666 fprintf (filvar, "\t%s\tdoi_idata\n", ASM_GLOBAL);
1667 fprintf (filvar, "doi_idata:\n");
1669 nheads = 0;
1670 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1672 fprintf (filvar, "\t%slistone%d%s\t%s %s\n",
1673 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER,
1674 ASM_C, headptr->dllname);
1675 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1676 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1677 fprintf (filvar, "\t%sdllname%d%s\n",
1678 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1679 fprintf (filvar, "\t%slisttwo%d%s\n\n",
1680 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1681 nheads++;
1684 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL record at */
1685 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* end of idata$2 */
1686 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* section */
1687 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1688 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1690 fprintf (filvar, "\n\t.section\t.idata$4\n");
1691 headindex = 0;
1692 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1694 fprintf (filvar, "listone%d:\n", headindex);
1695 for ( funcindex = 0; funcindex < headptr->nfuncs; funcindex++ )
1696 fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1697 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1698 fprintf (filvar,"\t%s\t0\n", ASM_LONG); /* NULL terminating list */
1699 headindex++;
1702 fprintf (filvar, "\n\t.section\t.idata$5\n");
1703 headindex = 0;
1704 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1706 fprintf (filvar, "listtwo%d:\n", headindex);
1707 for ( funcindex = 0; funcindex < headptr->nfuncs; funcindex++ )
1708 fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1709 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1710 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list */
1711 headindex++;
1714 fprintf (filvar, "\n\t.section\t.idata$6\n");
1715 headindex = 0;
1716 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1718 funcindex = 0;
1719 for (funcptr = headptr->funchead; funcptr != NULL;
1720 funcptr = funcptr->next)
1722 fprintf (filvar,"funcptr%d_%d:\n", headindex, funcindex);
1723 fprintf (filvar,"\t%s\t%d\n", ASM_SHORT,
1724 ((funcptr->ord) & 0xFFFF));
1725 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, funcptr->name);
1726 fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1727 funcindex++;
1729 headindex++;
1732 fprintf (filvar, "\n\t.section\t.idata$7\n");
1733 headindex = 0;
1734 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1736 fprintf (filvar,"dllname%d:\n", headindex);
1737 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, headptr->dllname);
1738 fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1739 headindex++;
1743 /* Assemble the specified file. */
1744 static void
1745 assemble_file (const char * source, const char * dest)
1747 char * cmd;
1749 cmd = (char *) alloca (strlen (ASM_SWITCHES) + strlen (as_flags)
1750 + strlen (source) + strlen (dest) + 50);
1752 sprintf (cmd, "%s %s -o %s %s", ASM_SWITCHES, as_flags, dest, source);
1754 run (as_name, cmd);
1757 static void
1758 gen_exp_file (void)
1760 FILE *f;
1761 int i;
1762 export_type *exp;
1763 dlist_type *dl;
1765 /* xgettext:c-format */
1766 inform (_("Generating export file: %s"), exp_name);
1768 f = fopen (TMP_ASM, FOPEN_WT);
1769 if (!f)
1770 /* xgettext:c-format */
1771 fatal (_("Unable to open temporary assembler file: %s"), TMP_ASM);
1773 /* xgettext:c-format */
1774 inform (_("Opened temporary file: %s"), TMP_ASM);
1776 dump_def_info (f);
1778 if (d_exports)
1780 fprintf (f, "\t.section .edata\n\n");
1781 fprintf (f, "\t%s 0 %s Allways 0\n", ASM_LONG, ASM_C);
1782 fprintf (f, "\t%s 0x%lx %s Time and date\n", ASM_LONG, (long) time(0),
1783 ASM_C);
1784 fprintf (f, "\t%s 0 %s Major and Minor version\n", ASM_LONG, ASM_C);
1785 fprintf (f, "\t%sname%s %s Ptr to name of dll\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1786 fprintf (f, "\t%s %d %s Starting ordinal of exports\n", ASM_LONG, d_low_ord, ASM_C);
1789 fprintf (f, "\t%s %d %s Number of functions\n", ASM_LONG, d_high_ord - d_low_ord + 1, ASM_C);
1790 fprintf(f,"\t%s named funcs %d, low ord %d, high ord %d\n",
1791 ASM_C,
1792 d_named_nfuncs, d_low_ord, d_high_ord);
1793 fprintf (f, "\t%s %d %s Number of names\n", ASM_LONG,
1794 show_allnames ? d_high_ord - d_low_ord + 1 : d_named_nfuncs, ASM_C);
1795 fprintf (f, "\t%safuncs%s %s Address of functions\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1797 fprintf (f, "\t%sanames%s %s Address of Name Pointer Table\n",
1798 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1800 fprintf (f, "\t%sanords%s %s Address of ordinals\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1802 fprintf (f, "name: %s \"%s\"\n", ASM_TEXT, dll_name);
1805 fprintf(f,"%s Export address Table\n", ASM_C);
1806 fprintf(f,"\t%s\n", ASM_ALIGN_LONG);
1807 fprintf (f, "afuncs:\n");
1808 i = d_low_ord;
1810 for (exp = d_exports; exp; exp = exp->next)
1812 if (exp->ordinal != i)
1814 while (i < exp->ordinal)
1816 fprintf(f,"\t%s\t0\n", ASM_LONG);
1817 i++;
1821 if (exp->forward == 0)
1823 if (exp->internal_name[0] == '@')
1824 fprintf (f, "\t%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
1825 exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1826 else
1827 fprintf (f, "\t%s%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
1828 ASM_PREFIX (exp->internal_name),
1829 exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1831 else
1832 fprintf (f, "\t%sf%d%s\t%s %d\n", ASM_RVA_BEFORE,
1833 exp->forward, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1834 i++;
1837 fprintf (f,"%s Export Name Pointer Table\n", ASM_C);
1838 fprintf (f, "anames:\n");
1840 for (i = 0; (exp = d_exports_lexically[i]); i++)
1842 if (!exp->noname || show_allnames)
1843 fprintf (f, "\t%sn%d%s\n",
1844 ASM_RVA_BEFORE, exp->ordinal, ASM_RVA_AFTER);
1847 fprintf (f,"%s Export Oridinal Table\n", ASM_C);
1848 fprintf (f, "anords:\n");
1849 for (i = 0; (exp = d_exports_lexically[i]); i++)
1851 if (!exp->noname || show_allnames)
1852 fprintf (f, "\t%s %d\n", ASM_SHORT, exp->ordinal - d_low_ord);
1855 fprintf(f,"%s Export Name Table\n", ASM_C);
1856 for (i = 0; (exp = d_exports_lexically[i]); i++)
1858 if (!exp->noname || show_allnames)
1859 fprintf (f, "n%d: %s \"%s\"\n",
1860 exp->ordinal, ASM_TEXT, xlate (exp->name));
1861 if (exp->forward != 0)
1862 fprintf (f, "f%d: %s \"%s\"\n",
1863 exp->forward, ASM_TEXT, exp->internal_name);
1866 if (a_list)
1868 fprintf (f, "\t.section %s\n", DRECTVE_SECTION_NAME);
1869 for (dl = a_list; dl; dl = dl->next)
1871 fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, dl->text);
1875 if (d_list)
1877 fprintf (f, "\t.section .rdata\n");
1878 for (dl = d_list; dl; dl = dl->next)
1880 char *p;
1881 int l;
1883 /* We don't output as ascii because there can
1884 be quote characters in the string. */
1885 l = 0;
1886 for (p = dl->text; *p; p++)
1888 if (l == 0)
1889 fprintf (f, "\t%s\t", ASM_BYTE);
1890 else
1891 fprintf (f, ",");
1892 fprintf (f, "%d", *p);
1893 if (p[1] == 0)
1895 fprintf (f, ",0\n");
1896 break;
1898 if (++l == 10)
1900 fprintf (f, "\n");
1901 l = 0;
1909 /* Add to the output file a way of getting to the exported names
1910 without using the import library. */
1911 if (add_indirect)
1913 fprintf (f, "\t.section\t.rdata\n");
1914 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1915 if (!exp->noname || show_allnames)
1917 /* We use a single underscore for MS compatibility, and a
1918 double underscore for backward compatibility with old
1919 cygwin releases. */
1920 if (create_compat_implib)
1921 fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name);
1922 fprintf (f, "\t%s\t_imp__%s\n", ASM_GLOBAL, exp->name);
1923 if (create_compat_implib)
1924 fprintf (f, "__imp_%s:\n", exp->name);
1925 fprintf (f, "_imp__%s:\n", exp->name);
1926 fprintf (f, "\t%s\t%s\n", ASM_LONG, exp->name);
1930 /* Dump the reloc section if a base file is provided. */
1931 if (base_file)
1933 int addr;
1934 long need[PAGE_SIZE];
1935 long page_addr;
1936 int numbytes;
1937 int num_entries;
1938 long *copy;
1939 int j;
1940 int on_page;
1941 fprintf (f, "\t.section\t.init\n");
1942 fprintf (f, "lab:\n");
1944 fseek (base_file, 0, SEEK_END);
1945 numbytes = ftell (base_file);
1946 fseek (base_file, 0, SEEK_SET);
1947 copy = xmalloc (numbytes);
1948 fread (copy, 1, numbytes, base_file);
1949 num_entries = numbytes / sizeof (long);
1952 fprintf (f, "\t.section\t.reloc\n");
1953 if (num_entries)
1955 int src;
1956 int dst = 0;
1957 int last = -1;
1958 qsort (copy, num_entries, sizeof (long), sfunc);
1959 /* Delete duplicates */
1960 for (src = 0; src < num_entries; src++)
1962 if (last != copy[src])
1963 last = copy[dst++] = copy[src];
1965 num_entries = dst;
1966 addr = copy[0];
1967 page_addr = addr & PAGE_MASK; /* work out the page addr */
1968 on_page = 0;
1969 for (j = 0; j < num_entries; j++)
1971 addr = copy[j];
1972 if ((addr & PAGE_MASK) != page_addr)
1974 flush_page (f, need, page_addr, on_page);
1975 on_page = 0;
1976 page_addr = addr & PAGE_MASK;
1978 need[on_page++] = addr;
1980 flush_page (f, need, page_addr, on_page);
1982 /* fprintf (f, "\t%s\t0,0\t%s End\n", ASM_LONG, ASM_C);*/
1986 generate_idata_ofile (f);
1988 fclose (f);
1990 /* Assemble the file. */
1991 assemble_file (TMP_ASM, exp_name);
1993 if (dontdeltemps == 0)
1994 unlink (TMP_ASM);
1996 inform (_("Generated exports file"));
1999 static const char *
2000 xlate (const char *name)
2002 int lead_at = (*name == '@');
2004 if (add_underscore && !lead_at)
2006 char *copy = xmalloc (strlen (name) + 2);
2008 copy[0] = '_';
2009 strcpy (copy + 1, name);
2010 name = copy;
2013 if (killat)
2015 char *p;
2017 name += lead_at;
2018 p = strchr (name, '@');
2019 if (p)
2020 *p = 0;
2022 return name;
2025 typedef struct
2027 int id;
2028 const char *name;
2029 int flags;
2030 int align;
2031 asection *sec;
2032 asymbol *sym;
2033 asymbol **sympp;
2034 int size;
2035 unsigned char *data;
2036 } sinfo;
2038 #ifndef DLLTOOL_PPC
2040 #define TEXT 0
2041 #define DATA 1
2042 #define BSS 2
2043 #define IDATA7 3
2044 #define IDATA5 4
2045 #define IDATA4 5
2046 #define IDATA6 6
2048 #define NSECS 7
2050 #define TEXT_SEC_FLAGS \
2051 (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY | SEC_HAS_CONTENTS)
2052 #define DATA_SEC_FLAGS (SEC_ALLOC | SEC_LOAD | SEC_DATA)
2053 #define BSS_SEC_FLAGS SEC_ALLOC
2055 #define INIT_SEC_DATA(id, name, flags, align) \
2056 { id, name, flags, align, NULL, NULL, NULL, 0, NULL }
2057 static sinfo secdata[NSECS] =
2059 INIT_SEC_DATA (TEXT, ".text", TEXT_SEC_FLAGS, 2),
2060 INIT_SEC_DATA (DATA, ".data", DATA_SEC_FLAGS, 2),
2061 INIT_SEC_DATA (BSS, ".bss", BSS_SEC_FLAGS, 2),
2062 INIT_SEC_DATA (IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2),
2063 INIT_SEC_DATA (IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2),
2064 INIT_SEC_DATA (IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2),
2065 INIT_SEC_DATA (IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1)
2068 #else
2070 /* Sections numbered to make the order the same as other PowerPC NT
2071 compilers. This also keeps funny alignment thingies from happening. */
2072 #define TEXT 0
2073 #define PDATA 1
2074 #define RDATA 2
2075 #define IDATA5 3
2076 #define IDATA4 4
2077 #define IDATA6 5
2078 #define IDATA7 6
2079 #define DATA 7
2080 #define BSS 8
2082 #define NSECS 9
2084 static sinfo secdata[NSECS] =
2086 { TEXT, ".text", SEC_CODE | SEC_HAS_CONTENTS, 3},
2087 { PDATA, ".pdata", SEC_HAS_CONTENTS, 2},
2088 { RDATA, ".reldata", SEC_HAS_CONTENTS, 2},
2089 { IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2},
2090 { IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2},
2091 { IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1},
2092 { IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2},
2093 { DATA, ".data", SEC_DATA, 2},
2094 { BSS, ".bss", 0, 2}
2097 #endif
2099 /* This is what we're trying to make. We generate the imp symbols with
2100 both single and double underscores, for compatibility.
2102 .text
2103 .global _GetFileVersionInfoSizeW@8
2104 .global __imp_GetFileVersionInfoSizeW@8
2105 _GetFileVersionInfoSizeW@8:
2106 jmp * __imp_GetFileVersionInfoSizeW@8
2107 .section .idata$7 # To force loading of head
2108 .long __version_a_head
2109 # Import Address Table
2110 .section .idata$5
2111 __imp_GetFileVersionInfoSizeW@8:
2112 .rva ID2
2114 # Import Lookup Table
2115 .section .idata$4
2116 .rva ID2
2117 # Hint/Name table
2118 .section .idata$6
2119 ID2: .short 2
2120 .asciz "GetFileVersionInfoSizeW"
2123 For the PowerPC, here's the variation on the above scheme:
2125 # Rather than a simple "jmp *", the code to get to the dll function
2126 # looks like:
2127 .text
2128 lwz r11,[tocv]__imp_function_name(r2)
2129 # RELOC: 00000000 TOCREL16,TOCDEFN __imp_function_name
2130 lwz r12,0(r11)
2131 stw r2,4(r1)
2132 mtctr r12
2133 lwz r2,4(r11)
2134 bctr */
2136 static char *
2137 make_label (const char *prefix, const char *name)
2139 int len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name);
2140 char *copy = xmalloc (len + 1);
2142 strcpy (copy, ASM_PREFIX (name));
2143 strcat (copy, prefix);
2144 strcat (copy, name);
2145 return copy;
2148 static char *
2149 make_imp_label (const char *prefix, const char *name)
2151 int len;
2152 char *copy;
2154 if (name[0] == '@')
2156 len = strlen (prefix) + strlen (name);
2157 copy = xmalloc (len + 1);
2158 strcpy (copy, prefix);
2159 strcat (copy, name);
2161 else
2163 len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name);
2164 copy = xmalloc (len + 1);
2165 strcpy (copy, prefix);
2166 strcat (copy, ASM_PREFIX (name));
2167 strcat (copy, name);
2169 return copy;
2172 static bfd *
2173 make_one_lib_file (export_type *exp, int i)
2175 bfd * abfd;
2176 asymbol * exp_label;
2177 asymbol * iname = 0;
2178 asymbol * iname2;
2179 asymbol * iname_lab;
2180 asymbol ** iname_lab_pp;
2181 asymbol ** iname_pp;
2182 #ifdef DLLTOOL_PPC
2183 asymbol ** fn_pp;
2184 asymbol ** toc_pp;
2185 #define EXTRA 2
2186 #endif
2187 #ifndef EXTRA
2188 #define EXTRA 0
2189 #endif
2190 asymbol * ptrs[NSECS + 4 + EXTRA + 1];
2191 flagword applicable;
2192 char * outname = xmalloc (strlen (TMP_STUB) + 10);
2193 int oidx = 0;
2196 sprintf (outname, "%s%05d.o", TMP_STUB, i);
2198 abfd = bfd_openw (outname, HOW_BFD_WRITE_TARGET);
2200 if (!abfd)
2201 /* xgettext:c-format */
2202 fatal (_("bfd_open failed open stub file: %s"), outname);
2204 /* xgettext:c-format */
2205 inform (_("Creating stub file: %s"), outname);
2207 bfd_set_format (abfd, bfd_object);
2208 bfd_set_arch_mach (abfd, HOW_BFD_ARCH, 0);
2210 #ifdef DLLTOOL_ARM
2211 if (machine == MARM_INTERWORK || machine == MTHUMB)
2212 bfd_set_private_flags (abfd, F_INTERWORK);
2213 #endif
2215 applicable = bfd_applicable_section_flags (abfd);
2217 /* First make symbols for the sections. */
2218 for (i = 0; i < NSECS; i++)
2220 sinfo *si = secdata + i;
2222 if (si->id != i)
2223 abort();
2224 si->sec = bfd_make_section_old_way (abfd, si->name);
2225 bfd_set_section_flags (abfd,
2226 si->sec,
2227 si->flags & applicable);
2229 bfd_set_section_alignment(abfd, si->sec, si->align);
2230 si->sec->output_section = si->sec;
2231 si->sym = bfd_make_empty_symbol(abfd);
2232 si->sym->name = si->sec->name;
2233 si->sym->section = si->sec;
2234 si->sym->flags = BSF_LOCAL;
2235 si->sym->value = 0;
2236 ptrs[oidx] = si->sym;
2237 si->sympp = ptrs + oidx;
2238 si->size = 0;
2239 si->data = NULL;
2241 oidx++;
2244 if (! exp->data)
2246 exp_label = bfd_make_empty_symbol (abfd);
2247 exp_label->name = make_imp_label ("", exp->name);
2249 /* On PowerPC, the function name points to a descriptor in
2250 the rdata section, the first element of which is a
2251 pointer to the code (..function_name), and the second
2252 points to the .toc. */
2253 #ifdef DLLTOOL_PPC
2254 if (machine == MPPC)
2255 exp_label->section = secdata[RDATA].sec;
2256 else
2257 #endif
2258 exp_label->section = secdata[TEXT].sec;
2260 exp_label->flags = BSF_GLOBAL;
2261 exp_label->value = 0;
2263 #ifdef DLLTOOL_ARM
2264 if (machine == MTHUMB)
2265 bfd_coff_set_symbol_class (abfd, exp_label, C_THUMBEXTFUNC);
2266 #endif
2267 ptrs[oidx++] = exp_label;
2270 /* Generate imp symbols with one underscore for Microsoft
2271 compatibility, and with two underscores for backward
2272 compatibility with old versions of cygwin. */
2273 if (create_compat_implib)
2275 iname = bfd_make_empty_symbol (abfd);
2276 iname->name = make_imp_label ("___imp", exp->name);
2277 iname->section = secdata[IDATA5].sec;
2278 iname->flags = BSF_GLOBAL;
2279 iname->value = 0;
2282 iname2 = bfd_make_empty_symbol (abfd);
2283 iname2->name = make_imp_label ("__imp_", exp->name);
2284 iname2->section = secdata[IDATA5].sec;
2285 iname2->flags = BSF_GLOBAL;
2286 iname2->value = 0;
2288 iname_lab = bfd_make_empty_symbol (abfd);
2290 iname_lab->name = head_label;
2291 iname_lab->section = (asection *) &bfd_und_section;
2292 iname_lab->flags = 0;
2293 iname_lab->value = 0;
2295 iname_pp = ptrs + oidx;
2296 if (create_compat_implib)
2297 ptrs[oidx++] = iname;
2298 ptrs[oidx++] = iname2;
2300 iname_lab_pp = ptrs + oidx;
2301 ptrs[oidx++] = iname_lab;
2303 #ifdef DLLTOOL_PPC
2304 /* The symbol referring to the code (.text). */
2306 asymbol *function_name;
2308 function_name = bfd_make_empty_symbol(abfd);
2309 function_name->name = make_label ("..", exp->name);
2310 function_name->section = secdata[TEXT].sec;
2311 function_name->flags = BSF_GLOBAL;
2312 function_name->value = 0;
2314 fn_pp = ptrs + oidx;
2315 ptrs[oidx++] = function_name;
2318 /* The .toc symbol. */
2320 asymbol *toc_symbol;
2322 toc_symbol = bfd_make_empty_symbol (abfd);
2323 toc_symbol->name = make_label (".", "toc");
2324 toc_symbol->section = (asection *)&bfd_und_section;
2325 toc_symbol->flags = BSF_GLOBAL;
2326 toc_symbol->value = 0;
2328 toc_pp = ptrs + oidx;
2329 ptrs[oidx++] = toc_symbol;
2331 #endif
2333 ptrs[oidx] = 0;
2335 for (i = 0; i < NSECS; i++)
2337 sinfo *si = secdata + i;
2338 asection *sec = si->sec;
2339 arelent *rel;
2340 arelent **rpp;
2342 switch (i)
2344 case TEXT:
2345 if (! exp->data)
2347 si->size = HOW_JTAB_SIZE;
2348 si->data = xmalloc (HOW_JTAB_SIZE);
2349 memcpy (si->data, HOW_JTAB, HOW_JTAB_SIZE);
2351 /* add the reloc into idata$5 */
2352 rel = xmalloc (sizeof (arelent));
2354 rpp = xmalloc (sizeof (arelent *) * 2);
2355 rpp[0] = rel;
2356 rpp[1] = 0;
2358 rel->address = HOW_JTAB_ROFF;
2359 rel->addend = 0;
2361 if (machine == MPPC)
2363 rel->howto = bfd_reloc_type_lookup (abfd,
2364 BFD_RELOC_16_GOTOFF);
2365 rel->sym_ptr_ptr = iname_pp;
2367 else
2369 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2370 rel->sym_ptr_ptr = secdata[IDATA5].sympp;
2372 sec->orelocation = rpp;
2373 sec->reloc_count = 1;
2375 break;
2376 case IDATA4:
2377 case IDATA5:
2378 /* An idata$4 or idata$5 is one word long, and has an
2379 rva to idata$6. */
2381 si->data = xmalloc (4);
2382 si->size = 4;
2384 if (exp->noname)
2386 si->data[0] = exp->ordinal ;
2387 si->data[1] = exp->ordinal >> 8;
2388 si->data[2] = exp->ordinal >> 16;
2389 si->data[3] = 0x80;
2391 else
2393 sec->reloc_count = 1;
2394 memset (si->data, 0, si->size);
2395 rel = xmalloc (sizeof (arelent));
2396 rpp = xmalloc (sizeof (arelent *) * 2);
2397 rpp[0] = rel;
2398 rpp[1] = 0;
2399 rel->address = 0;
2400 rel->addend = 0;
2401 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2402 rel->sym_ptr_ptr = secdata[IDATA6].sympp;
2403 sec->orelocation = rpp;
2406 break;
2408 case IDATA6:
2409 if (!exp->noname)
2411 /* This used to add 1 to exp->hint. I don't know
2412 why it did that, and it does not match what I see
2413 in programs compiled with the MS tools. */
2414 int idx = exp->hint;
2415 si->size = strlen (xlate (exp->import_name)) + 3;
2416 si->data = xmalloc (si->size);
2417 si->data[0] = idx & 0xff;
2418 si->data[1] = idx >> 8;
2419 strcpy ((char *) si->data + 2, xlate (exp->import_name));
2421 break;
2422 case IDATA7:
2423 si->size = 4;
2424 si->data = xmalloc (4);
2425 memset (si->data, 0, si->size);
2426 rel = xmalloc (sizeof (arelent));
2427 rpp = xmalloc (sizeof (arelent *) * 2);
2428 rpp[0] = rel;
2429 rel->address = 0;
2430 rel->addend = 0;
2431 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2432 rel->sym_ptr_ptr = iname_lab_pp;
2433 sec->orelocation = rpp;
2434 sec->reloc_count = 1;
2435 break;
2437 #ifdef DLLTOOL_PPC
2438 case PDATA:
2440 /* The .pdata section is 5 words long.
2441 Think of it as:
2442 struct
2444 bfd_vma BeginAddress, [0x00]
2445 EndAddress, [0x04]
2446 ExceptionHandler, [0x08]
2447 HandlerData, [0x0c]
2448 PrologEndAddress; [0x10]
2449 }; */
2451 /* So this pdata section setups up this as a glue linkage to
2452 a dll routine. There are a number of house keeping things
2453 we need to do:
2455 1. In the name of glue trickery, the ADDR32 relocs for 0,
2456 4, and 0x10 are set to point to the same place:
2457 "..function_name".
2458 2. There is one more reloc needed in the pdata section.
2459 The actual glue instruction to restore the toc on
2460 return is saved as the offset in an IMGLUE reloc.
2461 So we need a total of four relocs for this section.
2463 3. Lastly, the HandlerData field is set to 0x03, to indicate
2464 that this is a glue routine. */
2465 arelent *imglue, *ba_rel, *ea_rel, *pea_rel;
2467 /* Alignment must be set to 2**2 or you get extra stuff. */
2468 bfd_set_section_alignment(abfd, sec, 2);
2470 si->size = 4 * 5;
2471 si->data = xmalloc (si->size);
2472 memset (si->data, 0, si->size);
2473 rpp = xmalloc (sizeof (arelent *) * 5);
2474 rpp[0] = imglue = xmalloc (sizeof (arelent));
2475 rpp[1] = ba_rel = xmalloc (sizeof (arelent));
2476 rpp[2] = ea_rel = xmalloc (sizeof (arelent));
2477 rpp[3] = pea_rel = xmalloc (sizeof (arelent));
2478 rpp[4] = 0;
2480 /* Stick the toc reload instruction in the glue reloc. */
2481 bfd_put_32(abfd, ppc_glue_insn, (char *) &imglue->address);
2483 imglue->addend = 0;
2484 imglue->howto = bfd_reloc_type_lookup (abfd,
2485 BFD_RELOC_32_GOTOFF);
2486 imglue->sym_ptr_ptr = fn_pp;
2488 ba_rel->address = 0;
2489 ba_rel->addend = 0;
2490 ba_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2491 ba_rel->sym_ptr_ptr = fn_pp;
2493 bfd_put_32 (abfd, 0x18, si->data + 0x04);
2494 ea_rel->address = 4;
2495 ea_rel->addend = 0;
2496 ea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2497 ea_rel->sym_ptr_ptr = fn_pp;
2499 /* Mark it as glue. */
2500 bfd_put_32 (abfd, 0x03, si->data + 0x0c);
2502 /* Mark the prolog end address. */
2503 bfd_put_32 (abfd, 0x0D, si->data + 0x10);
2504 pea_rel->address = 0x10;
2505 pea_rel->addend = 0;
2506 pea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2507 pea_rel->sym_ptr_ptr = fn_pp;
2509 sec->orelocation = rpp;
2510 sec->reloc_count = 4;
2511 break;
2513 case RDATA:
2514 /* Each external function in a PowerPC PE file has a two word
2515 descriptor consisting of:
2516 1. The address of the code.
2517 2. The address of the appropriate .toc
2518 We use relocs to build this. */
2519 si->size = 8;
2520 si->data = xmalloc (8);
2521 memset (si->data, 0, si->size);
2523 rpp = xmalloc (sizeof (arelent *) * 3);
2524 rpp[0] = rel = xmalloc (sizeof (arelent));
2525 rpp[1] = xmalloc (sizeof (arelent));
2526 rpp[2] = 0;
2528 rel->address = 0;
2529 rel->addend = 0;
2530 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2531 rel->sym_ptr_ptr = fn_pp;
2533 rel = rpp[1];
2535 rel->address = 4;
2536 rel->addend = 0;
2537 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2538 rel->sym_ptr_ptr = toc_pp;
2540 sec->orelocation = rpp;
2541 sec->reloc_count = 2;
2542 break;
2543 #endif /* DLLTOOL_PPC */
2548 bfd_vma vma = 0;
2549 /* Size up all the sections. */
2550 for (i = 0; i < NSECS; i++)
2552 sinfo *si = secdata + i;
2554 bfd_set_section_size (abfd, si->sec, si->size);
2555 bfd_set_section_vma (abfd, si->sec, vma);
2558 /* Write them out. */
2559 for (i = 0; i < NSECS; i++)
2561 sinfo *si = secdata + i;
2563 if (i == IDATA5 && no_idata5)
2564 continue;
2566 if (i == IDATA4 && no_idata4)
2567 continue;
2569 bfd_set_section_contents (abfd, si->sec,
2570 si->data, 0,
2571 si->size);
2574 bfd_set_symtab (abfd, ptrs, oidx);
2575 bfd_close (abfd);
2576 abfd = bfd_openr (outname, HOW_BFD_READ_TARGET);
2577 return abfd;
2580 static bfd *
2581 make_head (void)
2583 FILE *f = fopen (TMP_HEAD_S, FOPEN_WT);
2585 if (f == NULL)
2587 fatal (_("failed to open temporary head file: %s"), TMP_HEAD_S);
2588 return NULL;
2591 fprintf (f, "%s IMAGE_IMPORT_DESCRIPTOR\n", ASM_C);
2592 fprintf (f, "\t.section .idata$2\n");
2594 fprintf(f,"\t%s\t%s\n", ASM_GLOBAL,head_label);
2596 fprintf (f, "%s:\n", head_label);
2598 fprintf (f, "\t%shname%s\t%sPtr to image import by name list\n",
2599 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
2601 fprintf (f, "\t%sthis should be the timestamp, but NT sometimes\n", ASM_C);
2602 fprintf (f, "\t%sdoesn't load DLLs when this is set.\n", ASM_C);
2603 fprintf (f, "\t%s\t0\t%s loaded time\n", ASM_LONG, ASM_C);
2604 fprintf (f, "\t%s\t0\t%s Forwarder chain\n", ASM_LONG, ASM_C);
2605 fprintf (f, "\t%s__%s_iname%s\t%s imported dll's name\n",
2606 ASM_RVA_BEFORE,
2607 imp_name_lab,
2608 ASM_RVA_AFTER,
2609 ASM_C);
2610 fprintf (f, "\t%sfthunk%s\t%s pointer to firstthunk\n",
2611 ASM_RVA_BEFORE,
2612 ASM_RVA_AFTER, ASM_C);
2614 fprintf (f, "%sStuff for compatibility\n", ASM_C);
2616 if (!no_idata5)
2618 fprintf (f, "\t.section\t.idata$5\n");
2619 fprintf (f, "\t%s\t0\n", ASM_LONG);
2620 fprintf (f, "fthunk:\n");
2623 if (!no_idata4)
2625 fprintf (f, "\t.section\t.idata$4\n");
2627 fprintf (f, "\t%s\t0\n", ASM_LONG);
2628 fprintf (f, "\t.section .idata$4\n");
2629 fprintf (f, "hname:\n");
2632 fclose (f);
2634 assemble_file (TMP_HEAD_S, TMP_HEAD_O);
2636 return bfd_openr (TMP_HEAD_O, HOW_BFD_READ_TARGET);
2639 static bfd *
2640 make_tail (void)
2642 FILE *f = fopen (TMP_TAIL_S, FOPEN_WT);
2644 if (f == NULL)
2646 fatal (_("failed to open temporary tail file: %s"), TMP_TAIL_S);
2647 return NULL;
2650 if (!no_idata4)
2652 fprintf (f, "\t.section .idata$4\n");
2653 fprintf (f, "\t%s\t0\n", ASM_LONG);
2656 if (!no_idata5)
2658 fprintf (f, "\t.section .idata$5\n");
2659 fprintf (f, "\t%s\t0\n", ASM_LONG);
2662 #ifdef DLLTOOL_PPC
2663 /* Normally, we need to see a null descriptor built in idata$3 to
2664 act as the terminator for the list. The ideal way, I suppose,
2665 would be to mark this section as a comdat type 2 section, so
2666 only one would appear in the final .exe (if our linker supported
2667 comdat, that is) or cause it to be inserted by something else (say
2668 crt0). */
2670 fprintf (f, "\t.section .idata$3\n");
2671 fprintf (f, "\t%s\t0\n", ASM_LONG);
2672 fprintf (f, "\t%s\t0\n", ASM_LONG);
2673 fprintf (f, "\t%s\t0\n", ASM_LONG);
2674 fprintf (f, "\t%s\t0\n", ASM_LONG);
2675 fprintf (f, "\t%s\t0\n", ASM_LONG);
2676 #endif
2678 #ifdef DLLTOOL_PPC
2679 /* Other PowerPC NT compilers use idata$6 for the dllname, so I
2680 do too. Original, huh? */
2681 fprintf (f, "\t.section .idata$6\n");
2682 #else
2683 fprintf (f, "\t.section .idata$7\n");
2684 #endif
2686 fprintf (f, "\t%s\t__%s_iname\n", ASM_GLOBAL, imp_name_lab);
2687 fprintf (f, "__%s_iname:\t%s\t\"%s\"\n",
2688 imp_name_lab, ASM_TEXT, dll_name);
2690 fclose (f);
2692 assemble_file (TMP_TAIL_S, TMP_TAIL_O);
2694 return bfd_openr (TMP_TAIL_O, HOW_BFD_READ_TARGET);
2697 static void
2698 gen_lib_file (void)
2700 int i;
2701 export_type *exp;
2702 bfd *ar_head;
2703 bfd *ar_tail;
2704 bfd *outarch;
2705 bfd * head = 0;
2707 unlink (imp_name);
2709 outarch = bfd_openw (imp_name, HOW_BFD_WRITE_TARGET);
2711 if (!outarch)
2712 /* xgettext:c-format */
2713 fatal (_("Can't open .lib file: %s"), imp_name);
2715 /* xgettext:c-format */
2716 inform (_("Creating library file: %s"), imp_name);
2718 bfd_set_format (outarch, bfd_archive);
2719 outarch->has_armap = 1;
2721 /* Work out a reasonable size of things to put onto one line. */
2722 ar_head = make_head ();
2723 ar_tail = make_tail();
2725 if (ar_head == NULL || ar_tail == NULL)
2726 return;
2728 for (i = 0; (exp = d_exports_lexically[i]); i++)
2730 bfd *n;
2731 /* Don't add PRIVATE entries to import lib. */
2732 if (exp->private)
2733 continue;
2734 n = make_one_lib_file (exp, i);
2735 n->next = head;
2736 head = n;
2737 if (ext_prefix_alias)
2739 export_type alias_exp;
2741 assert (i < PREFIX_ALIAS_BASE);
2742 alias_exp.name = make_imp_label (ext_prefix_alias, exp->name);
2743 alias_exp.internal_name = exp->internal_name;
2744 alias_exp.import_name = exp->name;
2745 alias_exp.ordinal = exp->ordinal;
2746 alias_exp.constant = exp->constant;
2747 alias_exp.noname = exp->noname;
2748 alias_exp.private = exp->private;
2749 alias_exp.data = exp->data;
2750 alias_exp.hint = exp->hint;
2751 alias_exp.forward = exp->forward;
2752 alias_exp.next = exp->next;
2753 n = make_one_lib_file (&alias_exp, i + PREFIX_ALIAS_BASE);
2754 n->next = head;
2755 head = n;
2759 /* Now stick them all into the archive. */
2760 ar_head->next = head;
2761 ar_tail->next = ar_head;
2762 head = ar_tail;
2764 if (! bfd_set_archive_head (outarch, head))
2765 bfd_fatal ("bfd_set_archive_head");
2767 if (! bfd_close (outarch))
2768 bfd_fatal (imp_name);
2770 while (head != NULL)
2772 bfd *n = head->next;
2773 bfd_close (head);
2774 head = n;
2777 /* Delete all the temp files. */
2778 if (dontdeltemps == 0)
2780 unlink (TMP_HEAD_O);
2781 unlink (TMP_HEAD_S);
2782 unlink (TMP_TAIL_O);
2783 unlink (TMP_TAIL_S);
2786 if (dontdeltemps < 2)
2788 char *name;
2790 name = (char *) alloca (strlen (TMP_STUB) + 10);
2791 for (i = 0; (exp = d_exports_lexically[i]); i++)
2793 /* Don't delete non-existent stubs for PRIVATE entries. */
2794 if (exp->private)
2795 continue;
2796 sprintf (name, "%s%05d.o", TMP_STUB, i);
2797 if (unlink (name) < 0)
2798 /* xgettext:c-format */
2799 non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
2800 if (ext_prefix_alias)
2802 sprintf (name, "%s%05d.o", TMP_STUB, i + PREFIX_ALIAS_BASE);
2803 if (unlink (name) < 0)
2804 /* xgettext:c-format */
2805 non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
2810 inform (_("Created lib file"));
2813 /* Run through the information gathered from the .o files and the
2814 .def file and work out the best stuff. */
2816 static int
2817 pfunc (const void *a, const void *b)
2819 export_type *ap = *(export_type **) a;
2820 export_type *bp = *(export_type **) b;
2821 if (ap->ordinal == bp->ordinal)
2822 return 0;
2824 /* Unset ordinals go to the bottom. */
2825 if (ap->ordinal == -1)
2826 return 1;
2827 if (bp->ordinal == -1)
2828 return -1;
2829 return (ap->ordinal - bp->ordinal);
2832 static int
2833 nfunc (const void *a, const void *b)
2835 export_type *ap = *(export_type **) a;
2836 export_type *bp = *(export_type **) b;
2838 return (strcmp (ap->name, bp->name));
2841 static void
2842 remove_null_names (export_type **ptr)
2844 int src;
2845 int dst;
2847 for (dst = src = 0; src < d_nfuncs; src++)
2849 if (ptr[src])
2851 ptr[dst] = ptr[src];
2852 dst++;
2855 d_nfuncs = dst;
2858 static void
2859 process_duplicates (export_type **d_export_vec)
2861 int more = 1;
2862 int i;
2864 while (more)
2866 more = 0;
2867 /* Remove duplicates. */
2868 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), nfunc);
2870 for (i = 0; i < d_nfuncs - 1; i++)
2872 if (strcmp (d_export_vec[i]->name,
2873 d_export_vec[i + 1]->name) == 0)
2875 export_type *a = d_export_vec[i];
2876 export_type *b = d_export_vec[i + 1];
2878 more = 1;
2880 /* xgettext:c-format */
2881 inform (_("Warning, ignoring duplicate EXPORT %s %d,%d"),
2882 a->name, a->ordinal, b->ordinal);
2884 if (a->ordinal != -1
2885 && b->ordinal != -1)
2886 /* xgettext:c-format */
2887 fatal (_("Error, duplicate EXPORT with oridinals: %s"),
2888 a->name);
2890 /* Merge attributes. */
2891 b->ordinal = a->ordinal > 0 ? a->ordinal : b->ordinal;
2892 b->constant |= a->constant;
2893 b->noname |= a->noname;
2894 b->data |= a->data;
2895 d_export_vec[i] = 0;
2898 remove_null_names (d_export_vec);
2902 /* Count the names. */
2903 for (i = 0; i < d_nfuncs; i++)
2904 if (!d_export_vec[i]->noname)
2905 d_named_nfuncs++;
2908 static void
2909 fill_ordinals (export_type **d_export_vec)
2911 int lowest = -1;
2912 int i;
2913 char *ptr;
2914 int size = 65536;
2916 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
2918 /* Fill in the unset ordinals with ones from our range. */
2919 ptr = (char *) xmalloc (size);
2921 memset (ptr, 0, size);
2923 /* Mark in our large vector all the numbers that are taken. */
2924 for (i = 0; i < d_nfuncs; i++)
2926 if (d_export_vec[i]->ordinal != -1)
2928 ptr[d_export_vec[i]->ordinal] = 1;
2930 if (lowest == -1 || d_export_vec[i]->ordinal < lowest)
2931 lowest = d_export_vec[i]->ordinal;
2935 /* Start at 1 for compatibility with MS toolchain. */
2936 if (lowest == -1)
2937 lowest = 1;
2939 /* Now fill in ordinals where the user wants us to choose. */
2940 for (i = 0; i < d_nfuncs; i++)
2942 if (d_export_vec[i]->ordinal == -1)
2944 int j;
2946 /* First try within or after any user supplied range. */
2947 for (j = lowest; j < size; j++)
2948 if (ptr[j] == 0)
2950 ptr[j] = 1;
2951 d_export_vec[i]->ordinal = j;
2952 goto done;
2955 /* Then try before the range. */
2956 for (j = lowest; j >0; j--)
2957 if (ptr[j] == 0)
2959 ptr[j] = 1;
2960 d_export_vec[i]->ordinal = j;
2961 goto done;
2963 done:;
2967 free (ptr);
2969 /* And resort. */
2970 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
2972 /* Work out the lowest and highest ordinal numbers. */
2973 if (d_nfuncs)
2975 if (d_export_vec[0])
2976 d_low_ord = d_export_vec[0]->ordinal;
2977 if (d_export_vec[d_nfuncs-1])
2978 d_high_ord = d_export_vec[d_nfuncs-1]->ordinal;
2982 static int
2983 alphafunc (const void *av, const void *bv)
2985 const export_type **a = (const export_type **) av;
2986 const export_type **b = (const export_type **) bv;
2988 return strcmp ((*a)->name, (*b)->name);
2991 static void
2992 mangle_defs (void)
2994 /* First work out the minimum ordinal chosen. */
2995 export_type *exp;
2997 int i;
2998 int hint = 0;
2999 export_type **d_export_vec = xmalloc (sizeof (export_type *) * d_nfuncs);
3001 inform (_("Processing definitions"));
3003 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3004 d_export_vec[i] = exp;
3006 process_duplicates (d_export_vec);
3007 fill_ordinals (d_export_vec);
3009 /* Put back the list in the new order. */
3010 d_exports = 0;
3011 for (i = d_nfuncs - 1; i >= 0; i--)
3013 d_export_vec[i]->next = d_exports;
3014 d_exports = d_export_vec[i];
3017 /* Build list in alpha order. */
3018 d_exports_lexically = (export_type **)
3019 xmalloc (sizeof (export_type *) * (d_nfuncs + 1));
3021 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3022 d_exports_lexically[i] = exp;
3024 d_exports_lexically[i] = 0;
3026 qsort (d_exports_lexically, i, sizeof (export_type *), alphafunc);
3028 /* Fill exp entries with their hint values. */
3029 for (i = 0; i < d_nfuncs; i++)
3030 if (!d_exports_lexically[i]->noname || show_allnames)
3031 d_exports_lexically[i]->hint = hint++;
3033 inform (_("Processed definitions"));
3036 static void
3037 usage (FILE *file, int status)
3039 /* xgetext:c-format */
3040 fprintf (file, _("Usage %s <option(s)> <object-file(s)>\n"), program_name);
3041 /* xgetext:c-format */
3042 fprintf (file, _(" -m --machine <machine> Create as DLL for <machine>. [default: %s]\n"), mname);
3043 fprintf (file, _(" possible <machine>: arm[_interwork], i386, mcore[-elf]{-le|-be}, ppc, thumb\n"));
3044 fprintf (file, _(" -e --output-exp <outname> Generate an export file.\n"));
3045 fprintf (file, _(" -l --output-lib <outname> Generate an interface library.\n"));
3046 fprintf (file, _(" -a --add-indirect Add dll indirects to export file.\n"));
3047 fprintf (file, _(" -D --dllname <name> Name of input dll to put into interface lib.\n"));
3048 fprintf (file, _(" -d --input-def <deffile> Name of .def file to be read in.\n"));
3049 fprintf (file, _(" -z --output-def <deffile> Name of .def file to be created.\n"));
3050 fprintf (file, _(" --export-all-symbols Export all symbols to .def\n"));
3051 fprintf (file, _(" --no-export-all-symbols Only export listed symbols\n"));
3052 fprintf (file, _(" --exclude-symbols <list> Don't export <list>\n"));
3053 fprintf (file, _(" --no-default-excludes Clear default exclude symbols\n"));
3054 fprintf (file, _(" -b --base-file <basefile> Read linker generated base file.\n"));
3055 fprintf (file, _(" -x --no-idata4 Don't generate idata$4 section.\n"));
3056 fprintf (file, _(" -c --no-idata5 Don't generate idata$5 section.\n"));
3057 fprintf (file, _(" -U --add-underscore Add underscores to symbols in interface library.\n"));
3058 fprintf (file, _(" -k --kill-at Kill @<n> from exported names.\n"));
3059 fprintf (file, _(" -A --add-stdcall-alias Add aliases without @<n>.\n"));
3060 fprintf (file, _(" -p --ext-prefix-alias <prefix> Add aliases with <prefix>.\n"));
3061 fprintf (file, _(" -S --as <name> Use <name> for assembler.\n"));
3062 fprintf (file, _(" -f --as-flags <flags> Pass <flags> to the assembler.\n"));
3063 fprintf (file, _(" -C --compat-implib Create backward compatible import library.\n"));
3064 fprintf (file, _(" -n --no-delete Keep temp files (repeat for extra preservation).\n"));
3065 fprintf (file, _(" -t --temp-prefix <prefix> Use <prefix> to construct temp file names.\n"));
3066 fprintf (file, _(" -v --verbose Be verbose.\n"));
3067 fprintf (file, _(" -V --version Display the program version.\n"));
3068 fprintf (file, _(" -h --help Display this information.\n"));
3069 #ifdef DLLTOOL_MCORE_ELF
3070 fprintf (file, _(" -M --mcore-elf <outname> Process mcore-elf object files into <outname>.\n"));
3071 fprintf (file, _(" -L --linker <name> Use <name> as the linker.\n"));
3072 fprintf (file, _(" -F --linker-flags <flags> Pass <flags> to the linker.\n"));
3073 #endif
3074 exit (status);
3077 #define OPTION_EXPORT_ALL_SYMS 150
3078 #define OPTION_NO_EXPORT_ALL_SYMS (OPTION_EXPORT_ALL_SYMS + 1)
3079 #define OPTION_EXCLUDE_SYMS (OPTION_NO_EXPORT_ALL_SYMS + 1)
3080 #define OPTION_NO_DEFAULT_EXCLUDES (OPTION_EXCLUDE_SYMS + 1)
3082 static const struct option long_options[] =
3084 {"no-delete", no_argument, NULL, 'n'},
3085 {"dllname", required_argument, NULL, 'D'},
3086 {"no-idata4", no_argument, NULL, 'x'},
3087 {"no-idata5", no_argument, NULL, 'c'},
3088 {"output-exp", required_argument, NULL, 'e'},
3089 {"output-def", required_argument, NULL, 'z'},
3090 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL_SYMS},
3091 {"no-export-all-symbols", no_argument, NULL, OPTION_NO_EXPORT_ALL_SYMS},
3092 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMS},
3093 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
3094 {"output-lib", required_argument, NULL, 'l'},
3095 {"def", required_argument, NULL, 'd'}, /* for compatibility with older versions */
3096 {"input-def", required_argument, NULL, 'd'},
3097 {"add-underscore", no_argument, NULL, 'U'},
3098 {"kill-at", no_argument, NULL, 'k'},
3099 {"add-stdcall-alias", no_argument, NULL, 'A'},
3100 {"ext-prefix-alias", required_argument, NULL, 'p'},
3101 {"verbose", no_argument, NULL, 'v'},
3102 {"version", no_argument, NULL, 'V'},
3103 {"help", no_argument, NULL, 'h'},
3104 {"machine", required_argument, NULL, 'm'},
3105 {"add-indirect", no_argument, NULL, 'a'},
3106 {"base-file", required_argument, NULL, 'b'},
3107 {"as", required_argument, NULL, 'S'},
3108 {"as-flags", required_argument, NULL, 'f'},
3109 {"mcore-elf", required_argument, NULL, 'M'},
3110 {"compat-implib", no_argument, NULL, 'C'},
3111 {"temp-prefix", required_argument, NULL, 't'},
3112 {NULL,0,NULL,0}
3115 int main (int, char **);
3118 main (int ac, char **av)
3120 int c;
3121 int i;
3122 char *firstarg = 0;
3123 program_name = av[0];
3124 oav = av;
3126 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
3127 setlocale (LC_MESSAGES, "");
3128 #endif
3129 #if defined (HAVE_SETLOCALE)
3130 setlocale (LC_CTYPE, "");
3131 #endif
3132 bindtextdomain (PACKAGE, LOCALEDIR);
3133 textdomain (PACKAGE);
3135 while ((c = getopt_long (ac, av,
3136 #ifdef DLLTOOL_MCORE_ELF
3137 "m:e:l:aD:d:z:b:xp:cCuUkAS:f:nvVHhM:L:F:",
3138 #else
3139 "m:e:l:aD:d:z:b:xp:cCuUkAS:f:nvVHh",
3140 #endif
3141 long_options, 0))
3142 != EOF)
3144 switch (c)
3146 case OPTION_EXPORT_ALL_SYMS:
3147 export_all_symbols = TRUE;
3148 break;
3149 case OPTION_NO_EXPORT_ALL_SYMS:
3150 export_all_symbols = FALSE;
3151 break;
3152 case OPTION_EXCLUDE_SYMS:
3153 add_excludes (optarg);
3154 break;
3155 case OPTION_NO_DEFAULT_EXCLUDES:
3156 do_default_excludes = FALSE;
3157 break;
3158 case 'x':
3159 no_idata4 = 1;
3160 break;
3161 case 'c':
3162 no_idata5 = 1;
3163 break;
3164 case 'S':
3165 as_name = optarg;
3166 break;
3167 case 't':
3168 tmp_prefix = optarg;
3169 break;
3170 case 'f':
3171 as_flags = optarg;
3172 break;
3174 /* Ignored for compatibility. */
3175 case 'u':
3176 break;
3177 case 'a':
3178 add_indirect = 1;
3179 break;
3180 case 'z':
3181 output_def = fopen (optarg, FOPEN_WT);
3182 break;
3183 case 'D':
3184 dll_name = (char*) lbasename (optarg);
3185 if (dll_name != optarg)
3186 non_fatal (_("Path components stripped from dllname, '%s'."),
3187 optarg);
3188 break;
3189 case 'l':
3190 imp_name = optarg;
3191 break;
3192 case 'e':
3193 exp_name = optarg;
3194 break;
3195 case 'H':
3196 case 'h':
3197 usage (stdout, 0);
3198 break;
3199 case 'm':
3200 mname = optarg;
3201 break;
3202 case 'v':
3203 verbose = 1;
3204 break;
3205 case 'V':
3206 print_version (program_name);
3207 break;
3208 case 'U':
3209 add_underscore = 1;
3210 break;
3211 case 'k':
3212 killat = 1;
3213 break;
3214 case 'A':
3215 add_stdcall_alias = 1;
3216 break;
3217 case 'p':
3218 ext_prefix_alias = optarg;
3219 break;
3220 case 'd':
3221 def_file = optarg;
3222 break;
3223 case 'n':
3224 dontdeltemps++;
3225 break;
3226 case 'b':
3227 base_file = fopen (optarg, FOPEN_RB);
3229 if (!base_file)
3230 /* xgettext:c-format */
3231 fatal (_("Unable to open base-file: %s"), optarg);
3233 break;
3234 #ifdef DLLTOOL_MCORE_ELF
3235 case 'M':
3236 mcore_elf_out_file = optarg;
3237 break;
3238 case 'L':
3239 mcore_elf_linker = optarg;
3240 break;
3241 case 'F':
3242 mcore_elf_linker_flags = optarg;
3243 break;
3244 #endif
3245 case 'C':
3246 create_compat_implib = 1;
3247 break;
3248 default:
3249 usage (stderr, 1);
3250 break;
3254 if (!tmp_prefix)
3255 tmp_prefix = prefix_encode ("d", getpid ());
3257 for (i = 0; mtable[i].type; i++)
3258 if (strcmp (mtable[i].type, mname) == 0)
3259 break;
3261 if (!mtable[i].type)
3262 /* xgettext:c-format */
3263 fatal (_("Machine '%s' not supported"), mname);
3265 machine = i;
3267 if (!dll_name && exp_name)
3269 /* If we are inferring dll_name from exp_name,
3270 strip off any path components, without emitting
3271 a warning. */
3272 const char* exp_basename = lbasename (exp_name);
3273 const int len = strlen (exp_basename) + 5;
3274 dll_name = xmalloc (len);
3275 strcpy (dll_name, exp_basename);
3276 strcat (dll_name, ".dll");
3279 if (as_name == NULL)
3280 as_name = deduce_name ("as");
3282 /* Don't use the default exclude list if we're reading only the
3283 symbols in the .drectve section. The default excludes are meant
3284 to avoid exporting DLL entry point and Cygwin32 impure_ptr. */
3285 if (! export_all_symbols)
3286 do_default_excludes = FALSE;
3288 if (do_default_excludes)
3289 set_default_excludes ();
3291 if (def_file)
3292 process_def_file (def_file);
3294 while (optind < ac)
3296 if (!firstarg)
3297 firstarg = av[optind];
3298 scan_obj_file (av[optind]);
3299 optind++;
3302 mangle_defs ();
3304 if (exp_name)
3305 gen_exp_file ();
3307 if (imp_name)
3309 /* Make imp_name safe for use as a label. */
3310 char *p;
3312 imp_name_lab = xstrdup (imp_name);
3313 for (p = imp_name_lab; *p; p++)
3315 if (!ISALNUM (*p))
3316 *p = '_';
3318 head_label = make_label("_head_", imp_name_lab);
3319 gen_lib_file ();
3322 if (output_def)
3323 gen_def_file ();
3325 #ifdef DLLTOOL_MCORE_ELF
3326 if (mcore_elf_out_file)
3327 mcore_elf_gen_out_file ();
3328 #endif
3330 return 0;
3333 /* Look for the program formed by concatenating PROG_NAME and the
3334 string running from PREFIX to END_PREFIX. If the concatenated
3335 string contains a '/', try appending EXECUTABLE_SUFFIX if it is
3336 appropriate. */
3338 static char *
3339 look_for_prog (const char *prog_name, const char *prefix, int end_prefix)
3341 struct stat s;
3342 char *cmd;
3344 cmd = xmalloc (strlen (prefix)
3345 + strlen (prog_name)
3346 #ifdef HAVE_EXECUTABLE_SUFFIX
3347 + strlen (EXECUTABLE_SUFFIX)
3348 #endif
3349 + 10);
3350 strcpy (cmd, prefix);
3352 sprintf (cmd + end_prefix, "%s", prog_name);
3354 if (strchr (cmd, '/') != NULL)
3356 int found;
3358 found = (stat (cmd, &s) == 0
3359 #ifdef HAVE_EXECUTABLE_SUFFIX
3360 || stat (strcat (cmd, EXECUTABLE_SUFFIX), &s) == 0
3361 #endif
3364 if (! found)
3366 /* xgettext:c-format */
3367 inform (_("Tried file: %s"), cmd);
3368 free (cmd);
3369 return NULL;
3373 /* xgettext:c-format */
3374 inform (_("Using file: %s"), cmd);
3376 return cmd;
3379 /* Deduce the name of the program we are want to invoke.
3380 PROG_NAME is the basic name of the program we want to run,
3381 eg "as" or "ld". The catch is that we might want actually
3382 run "i386-pe-as" or "ppc-pe-ld".
3384 If argv[0] contains the full path, then try to find the program
3385 in the same place, with and then without a target-like prefix.
3387 Given, argv[0] = /usr/local/bin/i586-cygwin32-dlltool,
3388 deduce_name("as") uses the following search order:
3390 /usr/local/bin/i586-cygwin32-as
3391 /usr/local/bin/as
3394 If there's an EXECUTABLE_SUFFIX, it'll use that as well; for each
3395 name, it'll try without and then with EXECUTABLE_SUFFIX.
3397 Given, argv[0] = i586-cygwin32-dlltool, it will not even try "as"
3398 as the fallback, but rather return i586-cygwin32-as.
3400 Oh, and given, argv[0] = dlltool, it'll return "as".
3402 Returns a dynamically allocated string. */
3404 static char *
3405 deduce_name (const char *prog_name)
3407 char *cmd;
3408 char *dash, *slash, *cp;
3410 dash = NULL;
3411 slash = NULL;
3412 for (cp = program_name; *cp != '\0'; ++cp)
3414 if (*cp == '-')
3415 dash = cp;
3416 if (
3417 #if defined(__DJGPP__) || defined (__CYGWIN__) || defined(__WIN32__)
3418 *cp == ':' || *cp == '\\' ||
3419 #endif
3420 *cp == '/')
3422 slash = cp;
3423 dash = NULL;
3427 cmd = NULL;
3429 if (dash != NULL)
3431 /* First, try looking for a prefixed PROG_NAME in the
3432 PROGRAM_NAME directory, with the same prefix as PROGRAM_NAME. */
3433 cmd = look_for_prog (prog_name, program_name, dash - program_name + 1);
3436 if (slash != NULL && cmd == NULL)
3438 /* Next, try looking for a PROG_NAME in the same directory as
3439 that of this program. */
3440 cmd = look_for_prog (prog_name, program_name, slash - program_name + 1);
3443 if (cmd == NULL)
3445 /* Just return PROG_NAME as is. */
3446 cmd = xstrdup (prog_name);
3449 return cmd;
3452 #ifdef DLLTOOL_MCORE_ELF
3453 typedef struct fname_cache
3455 char * filename;
3456 struct fname_cache * next;
3458 fname_cache;
3460 static fname_cache fnames;
3462 static void
3463 mcore_elf_cache_filename (char * filename)
3465 fname_cache * ptr;
3467 ptr = & fnames;
3469 while (ptr->next != NULL)
3470 ptr = ptr->next;
3472 ptr->filename = filename;
3473 ptr->next = (fname_cache *) malloc (sizeof (fname_cache));
3474 if (ptr->next != NULL)
3475 ptr->next->next = NULL;
3478 #define MCORE_ELF_TMP_OBJ "mcoreelf.o"
3479 #define MCORE_ELF_TMP_EXP "mcoreelf.exp"
3480 #define MCORE_ELF_TMP_LIB "mcoreelf.lib"
3482 static void
3483 mcore_elf_gen_out_file (void)
3485 fname_cache * ptr;
3486 dyn_string_t ds;
3488 /* Step one. Run 'ld -r' on the input object files in order to resolve
3489 any internal references and to generate a single .exports section. */
3490 ptr = & fnames;
3492 ds = dyn_string_new (100);
3493 dyn_string_append_cstr (ds, "-r ");
3495 if (mcore_elf_linker_flags != NULL)
3496 dyn_string_append_cstr (ds, mcore_elf_linker_flags);
3498 while (ptr->next != NULL)
3500 dyn_string_append_cstr (ds, ptr->filename);
3501 dyn_string_append_cstr (ds, " ");
3503 ptr = ptr->next;
3506 dyn_string_append_cstr (ds, "-o ");
3507 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
3509 if (mcore_elf_linker == NULL)
3510 mcore_elf_linker = deduce_name ("ld");
3512 run (mcore_elf_linker, ds->s);
3514 dyn_string_delete (ds);
3516 /* Step two. Create a .exp file and a .lib file from the temporary file.
3517 Do this by recursively invoking dlltool... */
3518 ds = dyn_string_new (100);
3520 dyn_string_append_cstr (ds, "-S ");
3521 dyn_string_append_cstr (ds, as_name);
3523 dyn_string_append_cstr (ds, " -e ");
3524 dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP);
3525 dyn_string_append_cstr (ds, " -l ");
3526 dyn_string_append_cstr (ds, MCORE_ELF_TMP_LIB);
3527 dyn_string_append_cstr (ds, " " );
3528 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
3530 if (verbose)
3531 dyn_string_append_cstr (ds, " -v");
3533 if (dontdeltemps)
3535 dyn_string_append_cstr (ds, " -n");
3537 if (dontdeltemps > 1)
3538 dyn_string_append_cstr (ds, " -n");
3541 /* XXX - FIME: ought to check/copy other command line options as well. */
3542 run (program_name, ds->s);
3544 dyn_string_delete (ds);
3546 /* Step four. Feed the .exp and object files to ld -shared to create the dll. */
3547 ds = dyn_string_new (100);
3549 dyn_string_append_cstr (ds, "-shared ");
3551 if (mcore_elf_linker_flags)
3552 dyn_string_append_cstr (ds, mcore_elf_linker_flags);
3554 dyn_string_append_cstr (ds, " ");
3555 dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP);
3556 dyn_string_append_cstr (ds, " ");
3557 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
3558 dyn_string_append_cstr (ds, " -o ");
3559 dyn_string_append_cstr (ds, mcore_elf_out_file);
3561 run (mcore_elf_linker, ds->s);
3563 dyn_string_delete (ds);
3565 if (dontdeltemps == 0)
3566 unlink (MCORE_ELF_TMP_EXP);
3568 if (dontdeltemps < 2)
3569 unlink (MCORE_ELF_TMP_OBJ);
3571 #endif /* DLLTOOL_MCORE_ELF */