* ld-elf/elf.exp: Remove sec64k test.
[binutils.git] / binutils / dlltool.c
blob6e83cce25ccb622c38b0b69252a40ba625f5afd6
1 /* dlltool.c -- tool to generate stuff for PE style DLLs
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, 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] ) *
53 Declares name1 as an exported symbol from the
54 DLL, with optional ordinal number <integer>.
55 Or declares name1 as an alias (forward) of the function <external-name>
56 in the DLL <module-name>.
58 IMPORTS ( ( <internal-name> = <module-name> . <integer> )
59 | ( [ <internal-name> = ] <module-name> . <external-name> )) *
60 Declares that <external-name> or the exported function whoes ordinal number
61 is <integer> is to be imported from the file <module-name>. If
62 <internal-name> is specified then this is the name that the imported
63 function will be refered 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 #ifdef DLLTOOL_ARM
265 #include "coff/arm.h"
266 #include "coff/internal.h"
267 #endif
269 /* Forward references. */
270 static char *look_for_prog PARAMS ((const char *, const char *, int));
271 static char *deduce_name PARAMS ((const char *));
273 #ifdef DLLTOOL_MCORE_ELF
274 static void mcore_elf_cache_filename PARAMS ((char *));
275 static void mcore_elf_gen_out_file PARAMS ((void));
276 #endif
278 #ifdef HAVE_SYS_WAIT_H
279 #include <sys/wait.h>
280 #else /* ! HAVE_SYS_WAIT_H */
281 #if ! defined (_WIN32) || defined (__CYGWIN32__)
282 #ifndef WIFEXITED
283 #define WIFEXITED(w) (((w) & 0377) == 0)
284 #endif
285 #ifndef WIFSIGNALED
286 #define WIFSIGNALED(w) (((w) & 0377) != 0177 && ((w) & ~0377) == 0)
287 #endif
288 #ifndef WTERMSIG
289 #define WTERMSIG(w) ((w) & 0177)
290 #endif
291 #ifndef WEXITSTATUS
292 #define WEXITSTATUS(w) (((w) >> 8) & 0377)
293 #endif
294 #else /* defined (_WIN32) && ! defined (__CYGWIN32__) */
295 #ifndef WIFEXITED
296 #define WIFEXITED(w) (((w) & 0xff) == 0)
297 #endif
298 #ifndef WIFSIGNALED
299 #define WIFSIGNALED(w) (((w) & 0xff) != 0 && ((w) & 0xff) != 0x7f)
300 #endif
301 #ifndef WTERMSIG
302 #define WTERMSIG(w) ((w) & 0x7f)
303 #endif
304 #ifndef WEXITSTATUS
305 #define WEXITSTATUS(w) (((w) & 0xff00) >> 8)
306 #endif
307 #endif /* defined (_WIN32) && ! defined (__CYGWIN32__) */
308 #endif /* ! HAVE_SYS_WAIT_H */
310 /* ifunc and ihead data structures: ttk@cygnus.com 1997
312 When IMPORT declarations are encountered in a .def file the
313 function import information is stored in a structure referenced by
314 the global variable IMPORT_LIST. The structure is a linked list
315 containing the names of the dll files each function is imported
316 from and a linked list of functions being imported from that dll
317 file. This roughly parallels the structure of the .idata section
318 in the PE object file.
320 The contents of .def file are interpreted from within the
321 process_def_file function. Every time an IMPORT declaration is
322 encountered, it is broken up into its component parts and passed to
323 def_import. IMPORT_LIST is initialized to NULL in function main. */
325 typedef struct ifunct
327 char * name; /* Name of function being imported. */
328 int ord; /* Two-byte ordinal value associated with function. */
329 struct ifunct *next;
330 } ifunctype;
332 typedef struct iheadt
334 char *dllname; /* Name of dll file imported from. */
335 long nfuncs; /* Number of functions in list. */
336 struct ifunct *funchead; /* First function in list. */
337 struct ifunct *functail; /* Last function in list. */
338 struct iheadt *next; /* Next dll file in list. */
339 } iheadtype;
341 /* Structure containing all import information as defined in .def file
342 (qv "ihead structure"). */
344 static iheadtype *import_list = NULL;
346 static char *as_name = NULL;
347 static char * as_flags = "";
349 static int no_idata4;
350 static int no_idata5;
351 static char *exp_name;
352 static char *imp_name;
353 static char *head_label;
354 static char *imp_name_lab;
355 static char *dll_name;
357 static int add_indirect = 0;
358 static int add_underscore = 0;
359 static int dontdeltemps = 0;
361 /* True if we should export all symbols. Otherwise, we only export
362 symbols listed in .drectve sections or in the def file. */
363 static boolean export_all_symbols;
365 /* True if we should exclude the symbols in DEFAULT_EXCLUDES when
366 exporting all symbols. */
367 static boolean do_default_excludes=true;
369 /* Default symbols to exclude when exporting all the symbols. */
370 static const char *default_excludes = "DllMain@12,DllEntryPoint@0,impure_ptr";
372 /* True if we should add __imp_<SYMBOL> to import libraries for backward
373 compatibility to old Cygwin releases. */
374 static boolean create_compat_implib;
376 static char *def_file;
378 extern char * program_name;
380 static int machine;
381 static int killat;
382 static int add_stdcall_alias;
383 static int verbose;
384 static FILE *output_def;
385 static FILE *base_file;
387 #ifdef DLLTOOL_ARM
388 #ifdef DLLTOOL_ARM_EPOC
389 static const char *mname = "arm-epoc";
390 #else
391 static const char *mname = "arm";
392 #endif
393 #endif
395 #ifdef DLLTOOL_I386
396 static const char *mname = "i386";
397 #endif
399 #ifdef DLLTOOL_PPC
400 static const char *mname = "ppc";
401 #endif
403 #ifdef DLLTOOL_SH
404 static const char *mname = "sh";
405 #endif
407 #ifdef DLLTOOL_MIPS
408 static const char *mname = "mips";
409 #endif
411 #ifdef DLLTOOL_MCORE
412 static const char * mname = "mcore-le";
413 #endif
415 #ifdef DLLTOOL_MCORE_ELF
416 static const char * mname = "mcore-elf";
417 static char * mcore_elf_out_file = NULL;
418 static char * mcore_elf_linker = NULL;
419 static char * mcore_elf_linker_flags = NULL;
421 #define DRECTVE_SECTION_NAME ((machine == MMCORE_ELF || machine == MMCORE_ELF_LE) ? ".exports" : ".drectve")
422 #endif
424 #ifndef DRECTVE_SECTION_NAME
425 #define DRECTVE_SECTION_NAME ".drectve"
426 #endif
428 #define PATHMAX 250 /* What's the right name for this ? */
430 #define TMP_ASM "dc.s"
431 #define TMP_HEAD_S "dh.s"
432 #define TMP_HEAD_O "dh.o"
433 #define TMP_TAIL_S "dt.s"
434 #define TMP_TAIL_O "dt.o"
435 #define TMP_STUB "ds"
437 /* This bit of assemly does jmp * .... */
438 static const unsigned char i386_jtab[] =
440 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
443 static const unsigned char arm_jtab[] =
445 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
446 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
447 0, 0, 0, 0
450 static const unsigned char arm_interwork_jtab[] =
452 0x04, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
453 0x00, 0xc0, 0x9c, 0xe5, /* ldr ip, [ip] */
454 0x1c, 0xff, 0x2f, 0xe1, /* bx ip */
455 0, 0, 0, 0
458 static const unsigned char thumb_jtab[] =
460 0x40, 0xb4, /* push {r6} */
461 0x02, 0x4e, /* ldr r6, [pc, #8] */
462 0x36, 0x68, /* ldr r6, [r6] */
463 0xb4, 0x46, /* mov ip, r6 */
464 0x40, 0xbc, /* pop {r6} */
465 0x60, 0x47, /* bx ip */
466 0, 0, 0, 0
469 static const unsigned char mcore_be_jtab[] =
471 0x71, 0x02, /* lrw r1,2 */
472 0x81, 0x01, /* ld.w r1,(r1,0) */
473 0x00, 0xC1, /* jmp r1 */
474 0x12, 0x00, /* nop */
475 0x00, 0x00, 0x00, 0x00 /* <address> */
478 static const unsigned char mcore_le_jtab[] =
480 0x02, 0x71, /* lrw r1,2 */
481 0x01, 0x81, /* ld.w r1,(r1,0) */
482 0xC1, 0x00, /* jmp r1 */
483 0x00, 0x12, /* nop */
484 0x00, 0x00, 0x00, 0x00 /* <address> */
487 /* This is the glue sequence for PowerPC PE. There is a
488 tocrel16-tocdefn reloc against the first instruction.
489 We also need a IMGLUE reloc against the glue function
490 to restore the toc saved by the third instruction in
491 the glue. */
492 static const unsigned char ppc_jtab[] =
494 0x00, 0x00, 0x62, 0x81, /* lwz r11,0(r2) */
495 /* Reloc TOCREL16 __imp_xxx */
496 0x00, 0x00, 0x8B, 0x81, /* lwz r12,0(r11) */
497 0x04, 0x00, 0x41, 0x90, /* stw r2,4(r1) */
498 0xA6, 0x03, 0x89, 0x7D, /* mtctr r12 */
499 0x04, 0x00, 0x4B, 0x80, /* lwz r2,4(r11) */
500 0x20, 0x04, 0x80, 0x4E /* bctr */
503 #ifdef DLLTOOL_PPC
504 /* The glue instruction, picks up the toc from the stw in
505 the above code: "lwz r2,4(r1)". */
506 static bfd_vma ppc_glue_insn = 0x80410004;
507 #endif
509 struct mac
511 const char *type;
512 const char *how_byte;
513 const char *how_short;
514 const char *how_long;
515 const char *how_asciz;
516 const char *how_comment;
517 const char *how_jump;
518 const char *how_global;
519 const char *how_space;
520 const char *how_align_short;
521 const char *how_align_long;
522 const char *how_default_as_switches;
523 const char *how_bfd_target;
524 enum bfd_architecture how_bfd_arch;
525 const unsigned char *how_jtab;
526 int how_jtab_size; /* Size of the jtab entry. */
527 int how_jtab_roff; /* Offset into it for the ind 32 reloc into idata 5. */
530 static const struct mac
531 mtable[] =
534 #define MARM 0
535 "arm", ".byte", ".short", ".long", ".asciz", "@",
536 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
537 ".global", ".space", ".align\t2",".align\t4", "-mapcs-32",
538 "pe-arm-little", bfd_arch_arm,
539 arm_jtab, sizeof (arm_jtab), 8
543 #define M386 1
544 "i386", ".byte", ".short", ".long", ".asciz", "#",
545 "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
546 "pe-i386",bfd_arch_i386,
547 i386_jtab, sizeof (i386_jtab), 2
551 #define MPPC 2
552 "ppc", ".byte", ".short", ".long", ".asciz", "#",
553 "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
554 "pe-powerpcle",bfd_arch_powerpc,
555 ppc_jtab, sizeof (ppc_jtab), 0
559 #define MTHUMB 3
560 "thumb", ".byte", ".short", ".long", ".asciz", "@",
561 "push\t{r6}\n\tldr\tr6, [pc, #8]\n\tldr\tr6, [r6]\n\tmov\tip, r6\n\tpop\t{r6}\n\tbx\tip",
562 ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
563 "pe-arm-little", bfd_arch_arm,
564 thumb_jtab, sizeof (thumb_jtab), 12
567 #define MARM_INTERWORK 4
569 "arm_interwork", ".byte", ".short", ".long", ".asciz", "@",
570 "ldr\tip,[pc]\n\tldr\tip,[ip]\n\tbx\tip\n\t.long",
571 ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
572 "pe-arm-little", bfd_arch_arm,
573 arm_interwork_jtab, sizeof (arm_interwork_jtab), 12
577 #define MMCORE_BE 5
578 "mcore-be", ".byte", ".short", ".long", ".asciz", "//",
579 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
580 ".global", ".space", ".align\t2",".align\t4", "",
581 "pe-mcore-big", bfd_arch_mcore,
582 mcore_be_jtab, sizeof (mcore_be_jtab), 8
586 #define MMCORE_LE 6
587 "mcore-le", ".byte", ".short", ".long", ".asciz", "//",
588 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
589 ".global", ".space", ".align\t2",".align\t4", "-EL",
590 "pe-mcore-little", bfd_arch_mcore,
591 mcore_le_jtab, sizeof (mcore_le_jtab), 8
595 #define MMCORE_ELF 7
596 "mcore-elf-be", ".byte", ".short", ".long", ".asciz", "//",
597 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
598 ".global", ".space", ".align\t2",".align\t4", "",
599 "elf32-mcore-big", bfd_arch_mcore,
600 mcore_be_jtab, sizeof (mcore_be_jtab), 8
604 #define MMCORE_ELF_LE 8
605 "mcore-elf-le", ".byte", ".short", ".long", ".asciz", "//",
606 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
607 ".global", ".space", ".align\t2",".align\t4", "-EL",
608 "elf32-mcore-little", bfd_arch_mcore,
609 mcore_le_jtab, sizeof (mcore_le_jtab), 8
613 #define MARM_EPOC 9
614 "arm-epoc", ".byte", ".short", ".long", ".asciz", "@",
615 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
616 ".global", ".space", ".align\t2",".align\t4", "",
617 "epoc-pe-arm-little", bfd_arch_arm,
618 arm_jtab, sizeof (arm_jtab), 8
621 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
624 typedef struct dlist
626 char *text;
627 struct dlist *next;
629 dlist_type;
631 typedef struct export
633 const char *name;
634 const char *internal_name;
635 int ordinal;
636 int constant;
637 int noname;
638 int data;
639 int hint;
640 int forward; /* Number of forward label, 0 means no forward. */
641 struct export *next;
643 export_type;
645 /* A list of symbols which we should not export. */
647 struct string_list
649 struct string_list *next;
650 char *string;
653 static struct string_list *excludes;
655 static const char *rvaafter PARAMS ((int));
656 static const char *rvabefore PARAMS ((int));
657 static const char *asm_prefix PARAMS ((int));
658 static void process_def_file PARAMS ((const char *));
659 static void new_directive PARAMS ((char *));
660 static void append_import PARAMS ((const char *, const char *, int));
661 static void run PARAMS ((const char *, char *));
662 static void scan_drectve_symbols PARAMS ((bfd *));
663 static void scan_filtered_symbols PARAMS ((bfd *, PTR, long, unsigned int));
664 static void add_excludes PARAMS ((const char *));
665 static boolean match_exclude PARAMS ((const char *));
666 static void set_default_excludes PARAMS ((void));
667 static long filter_symbols PARAMS ((bfd *, PTR, long, unsigned int));
668 static void scan_all_symbols PARAMS ((bfd *));
669 static void scan_open_obj_file PARAMS ((bfd *));
670 static void scan_obj_file PARAMS ((const char *));
671 static void dump_def_info PARAMS ((FILE *));
672 static int sfunc PARAMS ((const void *, const void *));
673 static void flush_page PARAMS ((FILE *, long *, int, int));
674 static void gen_def_file PARAMS ((void));
675 static void generate_idata_ofile PARAMS ((FILE *));
676 static void assemble_file PARAMS ((const char *, const char *));
677 static void gen_exp_file PARAMS ((void));
678 static const char *xlate PARAMS ((const char *));
679 #if 0
680 static void dump_iat PARAMS ((FILE *, export_type *));
681 #endif
682 static char *make_label PARAMS ((const char *, const char *));
683 static char *make_imp_label PARAMS ((const char *, const char *));
684 static bfd *make_one_lib_file PARAMS ((export_type *, int));
685 static bfd *make_head PARAMS ((void));
686 static bfd *make_tail PARAMS ((void));
687 static void gen_lib_file PARAMS ((void));
688 static int pfunc PARAMS ((const void *, const void *));
689 static int nfunc PARAMS ((const void *, const void *));
690 static void remove_null_names PARAMS ((export_type **));
691 static void dtab PARAMS ((export_type **));
692 static void process_duplicates PARAMS ((export_type **));
693 static void fill_ordinals PARAMS ((export_type **));
694 static int alphafunc PARAMS ((const void *, const void *));
695 static void mangle_defs PARAMS ((void));
696 static void usage PARAMS ((FILE *, int));
697 static void inform PARAMS ((const char *, ...));
700 static void
701 inform VPARAMS ((const char * message, ...))
703 VA_OPEN (args, message);
704 VA_FIXEDARG (args, const char *, message);
706 if (!verbose)
707 return;
709 report (message, args);
711 VA_CLOSE (args);
714 static const char *
715 rvaafter (machine)
716 int machine;
718 switch (machine)
720 case MARM:
721 case M386:
722 case MPPC:
723 case MTHUMB:
724 case MARM_INTERWORK:
725 case MMCORE_BE:
726 case MMCORE_LE:
727 case MMCORE_ELF:
728 case MMCORE_ELF_LE:
729 case MARM_EPOC:
730 break;
731 default:
732 /* xgettext:c-format */
733 fatal (_("Internal error: Unknown machine type: %d"), machine);
734 break;
736 return "";
739 static const char *
740 rvabefore (machine)
741 int machine;
743 switch (machine)
745 case MARM:
746 case M386:
747 case MPPC:
748 case MTHUMB:
749 case MARM_INTERWORK:
750 case MMCORE_BE:
751 case MMCORE_LE:
752 case MMCORE_ELF:
753 case MMCORE_ELF_LE:
754 case MARM_EPOC:
755 return ".rva\t";
756 default:
757 /* xgettext:c-format */
758 fatal (_("Internal error: Unknown machine type: %d"), machine);
759 break;
761 return "";
764 static const char *
765 asm_prefix (machine)
766 int machine;
768 switch (machine)
770 case MARM:
771 case MPPC:
772 case MTHUMB:
773 case MARM_INTERWORK:
774 case MMCORE_BE:
775 case MMCORE_LE:
776 case MMCORE_ELF:
777 case MMCORE_ELF_LE:
778 case MARM_EPOC:
779 break;
780 case M386:
781 return "_";
782 default:
783 /* xgettext:c-format */
784 fatal (_("Internal error: Unknown machine type: %d"), machine);
785 break;
787 return "";
790 #define ASM_BYTE mtable[machine].how_byte
791 #define ASM_SHORT mtable[machine].how_short
792 #define ASM_LONG mtable[machine].how_long
793 #define ASM_TEXT mtable[machine].how_asciz
794 #define ASM_C mtable[machine].how_comment
795 #define ASM_JUMP mtable[machine].how_jump
796 #define ASM_GLOBAL mtable[machine].how_global
797 #define ASM_SPACE mtable[machine].how_space
798 #define ASM_ALIGN_SHORT mtable[machine].how_align_short
799 #define ASM_RVA_BEFORE rvabefore(machine)
800 #define ASM_RVA_AFTER rvaafter(machine)
801 #define ASM_PREFIX asm_prefix(machine)
802 #define ASM_ALIGN_LONG mtable[machine].how_align_long
803 #define HOW_BFD_READ_TARGET 0 /* always default*/
804 #define HOW_BFD_WRITE_TARGET mtable[machine].how_bfd_target
805 #define HOW_BFD_ARCH mtable[machine].how_bfd_arch
806 #define HOW_JTAB mtable[machine].how_jtab
807 #define HOW_JTAB_SIZE mtable[machine].how_jtab_size
808 #define HOW_JTAB_ROFF mtable[machine].how_jtab_roff
809 #define ASM_SWITCHES mtable[machine].how_default_as_switches
811 static char **oav;
813 static void
814 process_def_file (name)
815 const char *name;
817 FILE *f = fopen (name, FOPEN_RT);
819 if (!f)
820 /* xgettext:c-format */
821 fatal (_("Can't open def file: %s"), name);
823 yyin = f;
825 /* xgettext:c-format */
826 inform (_("Processing def file: %s"), name);
828 yyparse ();
830 inform (_("Processed def file"));
833 /**********************************************************************/
835 /* Communications with the parser. */
837 static const char *d_name; /* Arg to NAME or LIBRARY. */
838 static int d_nfuncs; /* Number of functions exported. */
839 static int d_named_nfuncs; /* Number of named functions exported. */
840 static int d_low_ord; /* Lowest ordinal index. */
841 static int d_high_ord; /* Highest ordinal index. */
842 static export_type *d_exports; /* List of exported functions. */
843 static export_type **d_exports_lexically; /* Vector of exported functions in alpha order. */
844 static dlist_type *d_list; /* Descriptions. */
845 static dlist_type *a_list; /* Stuff to go in directives. */
846 static int d_nforwards = 0; /* Number of forwarded exports. */
848 static int d_is_dll;
849 static int d_is_exe;
852 yyerror (err)
853 const char * err ATTRIBUTE_UNUSED;
855 /* xgettext:c-format */
856 non_fatal (_("Syntax error in def file %s:%d"), def_file, linenumber);
858 return 0;
861 void
862 def_exports (name, internal_name, ordinal, noname, constant, data)
863 const char *name;
864 const char *internal_name;
865 int ordinal;
866 int noname;
867 int constant;
868 int data;
870 struct export *p = (struct export *) xmalloc (sizeof (*p));
872 p->name = name;
873 p->internal_name = internal_name ? internal_name : name;
874 p->ordinal = ordinal;
875 p->constant = constant;
876 p->noname = noname;
877 p->data = data;
878 p->next = d_exports;
879 d_exports = p;
880 d_nfuncs++;
882 if ((internal_name != NULL)
883 && (strchr (internal_name, '.') != NULL))
884 p->forward = ++d_nforwards;
885 else
886 p->forward = 0; /* no forward */
889 void
890 def_name (name, base)
891 const char *name;
892 int base;
894 /* xgettext:c-format */
895 inform (_("NAME: %s base: %x"), name, base);
897 if (d_is_dll)
898 non_fatal (_("Can't have LIBRARY and NAME"));
900 d_name = name;
901 /* If --dllname not provided, use the one in the DEF file.
902 FIXME: Is this appropriate for executables? */
903 if (! dll_name)
904 dll_name = xstrdup (name);
905 d_is_exe = 1;
908 void
909 def_library (name, base)
910 const char *name;
911 int base;
913 /* xgettext:c-format */
914 inform (_("LIBRARY: %s base: %x"), name, base);
916 if (d_is_exe)
917 non_fatal (_("Can't have LIBRARY and NAME"));
919 d_name = name;
920 /* If --dllname not provided, use the one in the DEF file. */
921 if (! dll_name)
922 dll_name = xstrdup (name);
923 d_is_dll = 1;
926 void
927 def_description (desc)
928 const char *desc;
930 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
931 d->text = xstrdup (desc);
932 d->next = d_list;
933 d_list = d;
936 static void
937 new_directive (dir)
938 char *dir;
940 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
941 d->text = xstrdup (dir);
942 d->next = a_list;
943 a_list = d;
946 void
947 def_heapsize (reserve, commit)
948 int reserve;
949 int commit;
951 char b[200];
952 if (commit > 0)
953 sprintf (b, "-heap 0x%x,0x%x ", reserve, commit);
954 else
955 sprintf (b, "-heap 0x%x ", reserve);
956 new_directive (xstrdup (b));
959 void
960 def_stacksize (reserve, commit)
961 int reserve;
962 int commit;
964 char b[200];
965 if (commit > 0)
966 sprintf (b, "-stack 0x%x,0x%x ", reserve, commit);
967 else
968 sprintf (b, "-stack 0x%x ", reserve);
969 new_directive (xstrdup (b));
972 /* append_import simply adds the given import definition to the global
973 import_list. It is used by def_import. */
975 static void
976 append_import (symbol_name, dll_name, func_ordinal)
977 const char *symbol_name;
978 const char *dll_name;
979 int func_ordinal;
981 iheadtype **pq;
982 iheadtype *q;
984 for (pq = &import_list; *pq != NULL; pq = &(*pq)->next)
986 if (strcmp ((*pq)->dllname, dll_name) == 0)
988 q = *pq;
989 q->functail->next = xmalloc (sizeof (ifunctype));
990 q->functail = q->functail->next;
991 q->functail->ord = func_ordinal;
992 q->functail->name = xstrdup (symbol_name);
993 q->functail->next = NULL;
994 q->nfuncs++;
995 return;
999 q = xmalloc (sizeof (iheadtype));
1000 q->dllname = xstrdup (dll_name);
1001 q->nfuncs = 1;
1002 q->funchead = xmalloc (sizeof (ifunctype));
1003 q->functail = q->funchead;
1004 q->next = NULL;
1005 q->functail->name = xstrdup (symbol_name);
1006 q->functail->ord = func_ordinal;
1007 q->functail->next = NULL;
1009 *pq = q;
1012 /* def_import is called from within defparse.y when an IMPORT
1013 declaration is encountered. Depending on the form of the
1014 declaration, the module name may or may not need ".dll" to be
1015 appended to it, the name of the function may be stored in internal
1016 or entry, and there may or may not be an ordinal value associated
1017 with it. */
1019 /* A note regarding the parse modes:
1020 In defparse.y we have to accept import declarations which follow
1021 any one of the following forms:
1022 <func_name_in_app> = <dll_name>.<func_name_in_dll>
1023 <func_name_in_app> = <dll_name>.<number>
1024 <dll_name>.<func_name_in_dll>
1025 <dll_name>.<number>
1026 Furthermore, the dll's name may or may not end with ".dll", which
1027 complicates the parsing a little. Normally the dll's name is
1028 passed to def_import() in the "module" parameter, but when it ends
1029 with ".dll" it gets passed in "module" sans ".dll" and that needs
1030 to be reappended.
1032 def_import gets five parameters:
1033 APP_NAME - the name of the function in the application, if
1034 present, or NULL if not present.
1035 MODULE - the name of the dll, possibly sans extension (ie, '.dll').
1036 DLLEXT - the extension of the dll, if present, NULL if not present.
1037 ENTRY - the name of the function in the dll, if present, or NULL.
1038 ORD_VAL - the numerical tag of the function in the dll, if present,
1039 or NULL. Exactly one of <entry> or <ord_val> must be
1040 present (i.e., not NULL). */
1042 void
1043 def_import (app_name, module, dllext, entry, ord_val)
1044 const char *app_name;
1045 const char *module;
1046 const char *dllext;
1047 const char *entry;
1048 int ord_val;
1050 const char *application_name;
1051 char *buf;
1053 if (entry != NULL)
1054 application_name = entry;
1055 else
1057 if (app_name != NULL)
1058 application_name = app_name;
1059 else
1060 application_name = "";
1063 if (dllext != NULL)
1065 buf = (char *) alloca (strlen (module) + strlen (dllext) + 2);
1066 sprintf (buf, "%s.%s", module, dllext);
1067 module = buf;
1070 append_import (application_name, module, ord_val);
1073 void
1074 def_version (major, minor)
1075 int major;
1076 int minor;
1078 printf ("VERSION %d.%d\n", major, minor);
1081 void
1082 def_section (name, attr)
1083 const char *name;
1084 int attr;
1086 char buf[200];
1087 char atts[5];
1088 char *d = atts;
1089 if (attr & 1)
1090 *d++ = 'R';
1092 if (attr & 2)
1093 *d++ = 'W';
1094 if (attr & 4)
1095 *d++ = 'X';
1096 if (attr & 8)
1097 *d++ = 'S';
1098 *d++ = 0;
1099 sprintf (buf, "-attr %s %s", name, atts);
1100 new_directive (xstrdup (buf));
1103 void
1104 def_code (attr)
1105 int attr;
1108 def_section ("CODE", attr);
1111 void
1112 def_data (attr)
1113 int attr;
1115 def_section ("DATA", attr);
1118 /**********************************************************************/
1120 static void
1121 run (what, args)
1122 const char *what;
1123 char *args;
1125 char *s;
1126 int pid, wait_status;
1127 int i;
1128 const char **argv;
1129 char *errmsg_fmt, *errmsg_arg;
1130 char *temp_base = choose_temp_base ();
1132 inform ("run: %s %s", what, args);
1134 /* Count the args */
1135 i = 0;
1136 for (s = args; *s; s++)
1137 if (*s == ' ')
1138 i++;
1139 i++;
1140 argv = alloca (sizeof (char *) * (i + 3));
1141 i = 0;
1142 argv[i++] = what;
1143 s = args;
1144 while (1)
1146 while (*s == ' ')
1147 ++s;
1148 argv[i++] = s;
1149 while (*s != ' ' && *s != 0)
1150 s++;
1151 if (*s == 0)
1152 break;
1153 *s++ = 0;
1155 argv[i++] = NULL;
1157 pid = pexecute (argv[0], (char * const *) argv, program_name, temp_base,
1158 &errmsg_fmt, &errmsg_arg, PEXECUTE_ONE | PEXECUTE_SEARCH);
1160 if (pid == -1)
1162 inform (strerror (errno));
1164 fatal (errmsg_fmt, errmsg_arg);
1167 pid = pwait (pid, & wait_status, 0);
1169 if (pid == -1)
1171 /* xgettext:c-format */
1172 fatal (_("wait: %s"), strerror (errno));
1174 else if (WIFSIGNALED (wait_status))
1176 /* xgettext:c-format */
1177 fatal (_("subprocess got fatal signal %d"), WTERMSIG (wait_status));
1179 else if (WIFEXITED (wait_status))
1181 if (WEXITSTATUS (wait_status) != 0)
1182 /* xgettext:c-format */
1183 non_fatal (_("%s exited with status %d"),
1184 what, WEXITSTATUS (wait_status));
1186 else
1187 abort ();
1190 /* Look for a list of symbols to export in the .drectve section of
1191 ABFD. Pass each one to def_exports. */
1193 static void
1194 scan_drectve_symbols (abfd)
1195 bfd *abfd;
1197 asection * s;
1198 int size;
1199 char * buf;
1200 char * p;
1201 char * e;
1203 /* Look for .drectve's */
1204 s = bfd_get_section_by_name (abfd, DRECTVE_SECTION_NAME);
1206 if (s == NULL)
1207 return;
1209 size = bfd_get_section_size_before_reloc (s);
1210 buf = xmalloc (size);
1212 bfd_get_section_contents (abfd, s, buf, 0, size);
1214 /* xgettext:c-format */
1215 inform (_("Sucking in info from %s section in %s"),
1216 DRECTVE_SECTION_NAME, bfd_get_filename (abfd));
1218 /* Search for -export: strings. The exported symbols can optionally
1219 have type tags (eg., -export:foo,data), so handle those as well.
1220 Currently only data tag is supported. */
1221 p = buf;
1222 e = buf + size;
1223 while (p < e)
1225 if (p[0] == '-'
1226 && strncmp (p, "-export:", 8) == 0)
1228 char * name;
1229 char * c;
1230 flagword flags = BSF_FUNCTION;
1232 p += 8;
1233 name = p;
1234 while (p < e && *p != ',' && *p != ' ' && *p != '-')
1235 p++;
1236 c = xmalloc (p - name + 1);
1237 memcpy (c, name, p - name);
1238 c[p - name] = 0;
1239 if (p < e && *p == ',') /* found type tag. */
1241 char *tag_start = ++p;
1242 while (p < e && *p != ' ' && *p != '-')
1243 p++;
1244 if (strncmp (tag_start, "data", 4) == 0)
1245 flags &= ~BSF_FUNCTION;
1248 /* FIXME: The 5th arg is for the `constant' field.
1249 What should it be? Not that it matters since it's not
1250 currently useful. */
1251 def_exports (c, 0, -1, 0, 0, ! (flags & BSF_FUNCTION));
1253 if (add_stdcall_alias && strchr (c, '@'))
1255 int lead_at = (*c == '@') ;
1256 char *exported_name = xstrdup (c + lead_at);
1257 char *atsym = strchr (exported_name, '@');
1258 *atsym = '\0';
1259 /* Note: stdcall alias symbols can never be data. */
1260 def_exports (exported_name, xstrdup (c), -1, 0, 0, 0);
1263 else
1264 p++;
1266 free (buf);
1269 /* Look through the symbols in MINISYMS, and add each one to list of
1270 symbols to export. */
1272 static void
1273 scan_filtered_symbols (abfd, minisyms, symcount, size)
1274 bfd *abfd;
1275 PTR minisyms;
1276 long symcount;
1277 unsigned int size;
1279 asymbol *store;
1280 bfd_byte *from, *fromend;
1282 store = bfd_make_empty_symbol (abfd);
1283 if (store == NULL)
1284 bfd_fatal (bfd_get_filename (abfd));
1286 from = (bfd_byte *) minisyms;
1287 fromend = from + symcount * size;
1288 for (; from < fromend; from += size)
1290 asymbol *sym;
1291 const char *symbol_name;
1293 sym = bfd_minisymbol_to_symbol (abfd, false, from, store);
1294 if (sym == NULL)
1295 bfd_fatal (bfd_get_filename (abfd));
1297 symbol_name = bfd_asymbol_name (sym);
1298 if (bfd_get_symbol_leading_char (abfd) == symbol_name[0])
1299 ++symbol_name;
1301 def_exports (xstrdup (symbol_name) , 0, -1, 0, 0,
1302 ! (sym->flags & BSF_FUNCTION));
1304 if (add_stdcall_alias && strchr (symbol_name, '@'))
1306 int lead_at = (*symbol_name == '@');
1307 char *exported_name = xstrdup (symbol_name + lead_at);
1308 char *atsym = strchr (exported_name, '@');
1309 *atsym = '\0';
1310 /* Note: stdcall alias symbols can never be data. */
1311 def_exports (exported_name, xstrdup (symbol_name), -1, 0, 0, 0);
1316 /* Add a list of symbols to exclude. */
1318 static void
1319 add_excludes (new_excludes)
1320 const char *new_excludes;
1322 char *local_copy;
1323 char *exclude_string;
1325 local_copy = xstrdup (new_excludes);
1327 exclude_string = strtok (local_copy, ",:");
1328 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
1330 struct string_list *new_exclude;
1332 new_exclude = ((struct string_list *)
1333 xmalloc (sizeof (struct string_list)));
1334 new_exclude->string = (char *) xmalloc (strlen (exclude_string) + 2);
1335 /* Don't add a leading underscore for fastcall symbols. */
1336 if (*exclude_string == '@')
1337 sprintf (new_exclude->string, "%s", exclude_string);
1338 else
1339 sprintf (new_exclude->string, "_%s", exclude_string);
1340 new_exclude->next = excludes;
1341 excludes = new_exclude;
1343 /* xgettext:c-format */
1344 inform (_("Excluding symbol: %s"), exclude_string);
1347 free (local_copy);
1350 /* See if STRING is on the list of symbols to exclude. */
1352 static boolean
1353 match_exclude (string)
1354 const char *string;
1356 struct string_list *excl_item;
1358 for (excl_item = excludes; excl_item; excl_item = excl_item->next)
1359 if (strcmp (string, excl_item->string) == 0)
1360 return true;
1361 return false;
1364 /* Add the default list of symbols to exclude. */
1366 static void
1367 set_default_excludes (void)
1369 add_excludes (default_excludes);
1372 /* Choose which symbols to export. */
1374 static long
1375 filter_symbols (abfd, minisyms, symcount, size)
1376 bfd *abfd;
1377 PTR minisyms;
1378 long symcount;
1379 unsigned int size;
1381 bfd_byte *from, *fromend, *to;
1382 asymbol *store;
1384 store = bfd_make_empty_symbol (abfd);
1385 if (store == NULL)
1386 bfd_fatal (bfd_get_filename (abfd));
1388 from = (bfd_byte *) minisyms;
1389 fromend = from + symcount * size;
1390 to = (bfd_byte *) minisyms;
1392 for (; from < fromend; from += size)
1394 int keep = 0;
1395 asymbol *sym;
1397 sym = bfd_minisymbol_to_symbol (abfd, false, (const PTR) from, store);
1398 if (sym == NULL)
1399 bfd_fatal (bfd_get_filename (abfd));
1401 /* Check for external and defined only symbols. */
1402 keep = (((sym->flags & BSF_GLOBAL) != 0
1403 || (sym->flags & BSF_WEAK) != 0
1404 || bfd_is_com_section (sym->section))
1405 && ! bfd_is_und_section (sym->section));
1407 keep = keep && ! match_exclude (sym->name);
1409 if (keep)
1411 memcpy (to, from, size);
1412 to += size;
1416 return (to - (bfd_byte *) minisyms) / size;
1419 /* Export all symbols in ABFD, except for ones we were told not to
1420 export. */
1422 static void
1423 scan_all_symbols (abfd)
1424 bfd *abfd;
1426 long symcount;
1427 PTR minisyms;
1428 unsigned int size;
1430 /* Ignore bfds with an import descriptor table. We assume that any
1431 such BFD contains symbols which are exported from another DLL,
1432 and we don't want to reexport them from here. */
1433 if (bfd_get_section_by_name (abfd, ".idata$4"))
1434 return;
1436 if (! (bfd_get_file_flags (abfd) & HAS_SYMS))
1438 /* xgettext:c-format */
1439 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1440 return;
1443 symcount = bfd_read_minisymbols (abfd, false, &minisyms, &size);
1444 if (symcount < 0)
1445 bfd_fatal (bfd_get_filename (abfd));
1447 if (symcount == 0)
1449 /* xgettext:c-format */
1450 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1451 return;
1454 /* Discard the symbols we don't want to export. It's OK to do this
1455 in place; we'll free the storage anyway. */
1457 symcount = filter_symbols (abfd, minisyms, symcount, size);
1458 scan_filtered_symbols (abfd, minisyms, symcount, size);
1460 free (minisyms);
1463 /* Look at the object file to decide which symbols to export. */
1465 static void
1466 scan_open_obj_file (abfd)
1467 bfd *abfd;
1469 if (export_all_symbols)
1470 scan_all_symbols (abfd);
1471 else
1472 scan_drectve_symbols (abfd);
1474 /* FIXME: we ought to read in and block out the base relocations. */
1476 /* xgettext:c-format */
1477 inform (_("Done reading %s"), bfd_get_filename (abfd));
1480 static void
1481 scan_obj_file (filename)
1482 const char *filename;
1484 bfd * f = bfd_openr (filename, 0);
1486 if (!f)
1487 /* xgettext:c-format */
1488 fatal (_("Unable to open object file: %s"), filename);
1490 /* xgettext:c-format */
1491 inform (_("Scanning object file %s"), filename);
1493 if (bfd_check_format (f, bfd_archive))
1495 bfd *arfile = bfd_openr_next_archived_file (f, 0);
1496 while (arfile)
1498 if (bfd_check_format (arfile, bfd_object))
1499 scan_open_obj_file (arfile);
1500 bfd_close (arfile);
1501 arfile = bfd_openr_next_archived_file (f, arfile);
1504 #ifdef DLLTOOL_MCORE_ELF
1505 if (mcore_elf_out_file)
1506 inform (_("Cannot produce mcore-elf dll from archive file: %s"), filename);
1507 #endif
1509 else if (bfd_check_format (f, bfd_object))
1511 scan_open_obj_file (f);
1513 #ifdef DLLTOOL_MCORE_ELF
1514 if (mcore_elf_out_file)
1515 mcore_elf_cache_filename ((char *) filename);
1516 #endif
1519 bfd_close (f);
1522 /**********************************************************************/
1524 static void
1525 dump_def_info (f)
1526 FILE *f;
1528 int i;
1529 export_type *exp;
1530 fprintf (f, "%s ", ASM_C);
1531 for (i = 0; oav[i]; i++)
1532 fprintf (f, "%s ", oav[i]);
1533 fprintf (f, "\n");
1534 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1536 fprintf (f, "%s %d = %s %s @ %d %s%s%s\n",
1537 ASM_C,
1539 exp->name,
1540 exp->internal_name,
1541 exp->ordinal,
1542 exp->noname ? "NONAME " : "",
1543 exp->constant ? "CONSTANT" : "",
1544 exp->data ? "DATA" : "");
1548 /* Generate the .exp file. */
1550 static int
1551 sfunc (a, b)
1552 const void *a;
1553 const void *b;
1555 return *(const long *) a - *(const long *) b;
1558 static void
1559 flush_page (f, need, page_addr, on_page)
1560 FILE *f;
1561 long *need;
1562 int page_addr;
1563 int on_page;
1565 int i;
1567 /* Flush this page. */
1568 fprintf (f, "\t%s\t0x%08x\t%s Starting RVA for chunk\n",
1569 ASM_LONG,
1570 page_addr,
1571 ASM_C);
1572 fprintf (f, "\t%s\t0x%x\t%s Size of block\n",
1573 ASM_LONG,
1574 (on_page * 2) + (on_page & 1) * 2 + 8,
1575 ASM_C);
1577 for (i = 0; i < on_page; i++)
1579 long needed = need[i];
1581 if (needed)
1582 needed = ((needed - page_addr) | 0x3000) & 0xffff;
1584 fprintf (f, "\t%s\t0x%lx\n", ASM_SHORT, needed);
1587 /* And padding */
1588 if (on_page & 1)
1589 fprintf (f, "\t%s\t0x%x\n", ASM_SHORT, 0 | 0x0000);
1592 static void
1593 gen_def_file ()
1595 int i;
1596 export_type *exp;
1598 inform (_("Adding exports to output file"));
1600 fprintf (output_def, ";");
1601 for (i = 0; oav[i]; i++)
1602 fprintf (output_def, " %s", oav[i]);
1604 fprintf (output_def, "\nEXPORTS\n");
1606 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1608 char *quote = strchr (exp->name, '.') ? "\"" : "";
1609 char *res = cplus_demangle (exp->internal_name, DMGL_ANSI | DMGL_PARAMS);
1611 if (strcmp (exp->name, exp->internal_name) == 0)
1614 fprintf (output_def, "\t%s%s%s @ %d%s%s ; %s\n",
1615 quote,
1616 exp->name,
1617 quote,
1618 exp->ordinal,
1619 exp->noname ? " NONAME" : "",
1620 exp->data ? " DATA" : "",
1621 res ? res : "");
1623 else
1625 char *quote1 = strchr (exp->internal_name, '.') ? "\"" : "";
1626 /* char *alias = */
1627 fprintf (output_def, "\t%s%s%s = %s%s%s @ %d%s%s ; %s\n",
1628 quote,
1629 exp->name,
1630 quote,
1631 quote1,
1632 exp->internal_name,
1633 quote1,
1634 exp->ordinal,
1635 exp->noname ? " NONAME" : "",
1636 exp->data ? " DATA" : "",
1637 res ? res : "");
1639 if (res)
1640 free (res);
1643 inform (_("Added exports to output file"));
1646 /* generate_idata_ofile generates the portable assembly source code
1647 for the idata sections. It appends the source code to the end of
1648 the file. */
1650 static void
1651 generate_idata_ofile (filvar)
1652 FILE *filvar;
1654 iheadtype *headptr;
1655 ifunctype *funcptr;
1656 int headindex;
1657 int funcindex;
1658 int nheads;
1660 if (import_list == NULL)
1661 return;
1663 fprintf (filvar, "%s Import data sections\n", ASM_C);
1664 fprintf (filvar, "\n\t.section\t.idata$2\n");
1665 fprintf (filvar, "\t%s\tdoi_idata\n", ASM_GLOBAL);
1666 fprintf (filvar, "doi_idata:\n");
1668 nheads = 0;
1669 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1671 fprintf (filvar, "\t%slistone%d%s\t%s %s\n",
1672 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER,
1673 ASM_C, headptr->dllname);
1674 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1675 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1676 fprintf (filvar, "\t%sdllname%d%s\n",
1677 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1678 fprintf (filvar, "\t%slisttwo%d%s\n\n",
1679 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1680 nheads++;
1683 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL record at */
1684 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* end of idata$2 */
1685 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* section */
1686 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1687 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1689 fprintf (filvar, "\n\t.section\t.idata$4\n");
1690 headindex = 0;
1691 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1693 fprintf (filvar, "listone%d:\n", headindex);
1694 for ( funcindex = 0; funcindex < headptr->nfuncs; funcindex++ )
1695 fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1696 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1697 fprintf (filvar,"\t%s\t0\n", ASM_LONG); /* NULL terminating list */
1698 headindex++;
1701 fprintf (filvar, "\n\t.section\t.idata$5\n");
1702 headindex = 0;
1703 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1705 fprintf (filvar, "listtwo%d:\n", headindex);
1706 for ( funcindex = 0; funcindex < headptr->nfuncs; funcindex++ )
1707 fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1708 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1709 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list */
1710 headindex++;
1713 fprintf (filvar, "\n\t.section\t.idata$6\n");
1714 headindex = 0;
1715 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1717 funcindex = 0;
1718 for (funcptr = headptr->funchead; funcptr != NULL;
1719 funcptr = funcptr->next)
1721 fprintf (filvar,"funcptr%d_%d:\n", headindex, funcindex);
1722 fprintf (filvar,"\t%s\t%d\n", ASM_SHORT,
1723 ((funcptr->ord) & 0xFFFF));
1724 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, funcptr->name);
1725 fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1726 funcindex++;
1728 headindex++;
1731 fprintf (filvar, "\n\t.section\t.idata$7\n");
1732 headindex = 0;
1733 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1735 fprintf (filvar,"dllname%d:\n", headindex);
1736 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, headptr->dllname);
1737 fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1738 headindex++;
1742 /* Assemble the specified file. */
1743 static void
1744 assemble_file (source, dest)
1745 const char * source;
1746 const char * dest;
1748 char * cmd;
1750 cmd = (char *) alloca (strlen (ASM_SWITCHES) + strlen (as_flags)
1751 + strlen (source) + strlen (dest) + 50);
1753 sprintf (cmd, "%s %s -o %s %s", ASM_SWITCHES, as_flags, dest, source);
1755 run (as_name, cmd);
1758 static void
1759 gen_exp_file ()
1761 FILE *f;
1762 int i;
1763 export_type *exp;
1764 dlist_type *dl;
1766 /* xgettext:c-format */
1767 inform (_("Generating export file: %s"), exp_name);
1769 f = fopen (TMP_ASM, FOPEN_WT);
1770 if (!f)
1771 /* xgettext:c-format */
1772 fatal (_("Unable to open temporary assembler file: %s"), TMP_ASM);
1774 /* xgettext:c-format */
1775 inform (_("Opened temporary file: %s"), TMP_ASM);
1777 dump_def_info (f);
1779 if (d_exports)
1781 fprintf (f, "\t.section .edata\n\n");
1782 fprintf (f, "\t%s 0 %s Allways 0\n", ASM_LONG, ASM_C);
1783 fprintf (f, "\t%s 0x%lx %s Time and date\n", ASM_LONG, (long) time(0),
1784 ASM_C);
1785 fprintf (f, "\t%s 0 %s Major and Minor version\n", ASM_LONG, ASM_C);
1786 fprintf (f, "\t%sname%s %s Ptr to name of dll\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1787 fprintf (f, "\t%s %d %s Starting ordinal of exports\n", ASM_LONG, d_low_ord, ASM_C);
1790 fprintf (f, "\t%s %d %s Number of functions\n", ASM_LONG, d_high_ord - d_low_ord + 1, ASM_C);
1791 fprintf(f,"\t%s named funcs %d, low ord %d, high ord %d\n",
1792 ASM_C,
1793 d_named_nfuncs, d_low_ord, d_high_ord);
1794 fprintf (f, "\t%s %d %s Number of names\n", ASM_LONG,
1795 show_allnames ? d_high_ord - d_low_ord + 1 : d_named_nfuncs, ASM_C);
1796 fprintf (f, "\t%safuncs%s %s Address of functions\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1798 fprintf (f, "\t%sanames%s %s Address of Name Pointer Table\n",
1799 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1801 fprintf (f, "\t%sanords%s %s Address of ordinals\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1803 fprintf (f, "name: %s \"%s\"\n", ASM_TEXT, dll_name);
1806 fprintf(f,"%s Export address Table\n", ASM_C);
1807 fprintf(f,"\t%s\n", ASM_ALIGN_LONG);
1808 fprintf (f, "afuncs:\n");
1809 i = d_low_ord;
1811 for (exp = d_exports; exp; exp = exp->next)
1813 if (exp->ordinal != i)
1815 #if 0
1816 fprintf (f, "\t%s\t%d\t%s %d..%d missing\n",
1817 ASM_SPACE,
1818 (exp->ordinal - i) * 4,
1819 ASM_C,
1820 i, exp->ordinal - 1);
1821 i = exp->ordinal;
1822 #endif
1823 while (i < exp->ordinal)
1825 fprintf(f,"\t%s\t0\n", ASM_LONG);
1826 i++;
1830 if (exp->forward == 0)
1832 if (exp->internal_name[0] == '@')
1833 fprintf (f, "\t%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
1834 exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1835 else
1836 fprintf (f, "\t%s%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
1837 ASM_PREFIX,
1838 exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1840 else
1841 fprintf (f, "\t%sf%d%s\t%s %d\n", ASM_RVA_BEFORE,
1842 exp->forward, ASM_RVA_AFTER, ASM_C, exp->ordinal);
1843 i++;
1846 fprintf (f,"%s Export Name Pointer Table\n", ASM_C);
1847 fprintf (f, "anames:\n");
1849 for (i = 0; (exp = d_exports_lexically[i]); i++)
1851 if (!exp->noname || show_allnames)
1852 fprintf (f, "\t%sn%d%s\n",
1853 ASM_RVA_BEFORE, exp->ordinal, ASM_RVA_AFTER);
1856 fprintf (f,"%s Export Oridinal Table\n", ASM_C);
1857 fprintf (f, "anords:\n");
1858 for (i = 0; (exp = d_exports_lexically[i]); i++)
1860 if (!exp->noname || show_allnames)
1861 fprintf (f, "\t%s %d\n", ASM_SHORT, exp->ordinal - d_low_ord);
1864 fprintf(f,"%s Export Name Table\n", ASM_C);
1865 for (i = 0; (exp = d_exports_lexically[i]); i++)
1866 if (!exp->noname || show_allnames)
1868 fprintf (f, "n%d: %s \"%s\"\n",
1869 exp->ordinal, ASM_TEXT, xlate (exp->name));
1870 if (exp->forward != 0)
1871 fprintf (f, "f%d: %s \"%s\"\n",
1872 exp->forward, ASM_TEXT, exp->internal_name);
1875 if (a_list)
1877 fprintf (f, "\t.section %s\n", DRECTVE_SECTION_NAME);
1878 for (dl = a_list; dl; dl = dl->next)
1880 fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, dl->text);
1884 if (d_list)
1886 fprintf (f, "\t.section .rdata\n");
1887 for (dl = d_list; dl; dl = dl->next)
1889 char *p;
1890 int l;
1892 /* We don't output as ascii because there can
1893 be quote characters in the string. */
1894 l = 0;
1895 for (p = dl->text; *p; p++)
1897 if (l == 0)
1898 fprintf (f, "\t%s\t", ASM_BYTE);
1899 else
1900 fprintf (f, ",");
1901 fprintf (f, "%d", *p);
1902 if (p[1] == 0)
1904 fprintf (f, ",0\n");
1905 break;
1907 if (++l == 10)
1909 fprintf (f, "\n");
1910 l = 0;
1918 /* Add to the output file a way of getting to the exported names
1919 without using the import library. */
1920 if (add_indirect)
1922 fprintf (f, "\t.section\t.rdata\n");
1923 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1924 if (!exp->noname || show_allnames)
1926 /* We use a single underscore for MS compatibility, and a
1927 double underscore for backward compatibility with old
1928 cygwin releases. */
1929 if (create_compat_implib)
1930 fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name);
1931 fprintf (f, "\t%s\t_imp__%s\n", ASM_GLOBAL, exp->name);
1932 if (create_compat_implib)
1933 fprintf (f, "__imp_%s:\n", exp->name);
1934 fprintf (f, "_imp__%s:\n", exp->name);
1935 fprintf (f, "\t%s\t%s\n", ASM_LONG, exp->name);
1939 /* Dump the reloc section if a base file is provided. */
1940 if (base_file)
1942 int addr;
1943 long need[PAGE_SIZE];
1944 long page_addr;
1945 int numbytes;
1946 int num_entries;
1947 long *copy;
1948 int j;
1949 int on_page;
1950 fprintf (f, "\t.section\t.init\n");
1951 fprintf (f, "lab:\n");
1953 fseek (base_file, 0, SEEK_END);
1954 numbytes = ftell (base_file);
1955 fseek (base_file, 0, SEEK_SET);
1956 copy = xmalloc (numbytes);
1957 fread (copy, 1, numbytes, base_file);
1958 num_entries = numbytes / sizeof (long);
1961 fprintf (f, "\t.section\t.reloc\n");
1962 if (num_entries)
1964 int src;
1965 int dst = 0;
1966 int last = -1;
1967 qsort (copy, num_entries, sizeof (long), sfunc);
1968 /* Delete duplcates */
1969 for (src = 0; src < num_entries; src++)
1971 if (last != copy[src])
1972 last = copy[dst++] = copy[src];
1974 num_entries = dst;
1975 addr = copy[0];
1976 page_addr = addr & PAGE_MASK; /* work out the page addr */
1977 on_page = 0;
1978 for (j = 0; j < num_entries; j++)
1980 addr = copy[j];
1981 if ((addr & PAGE_MASK) != page_addr)
1983 flush_page (f, need, page_addr, on_page);
1984 on_page = 0;
1985 page_addr = addr & PAGE_MASK;
1987 need[on_page++] = addr;
1989 flush_page (f, need, page_addr, on_page);
1991 /* fprintf (f, "\t%s\t0,0\t%s End\n", ASM_LONG, ASM_C);*/
1995 generate_idata_ofile (f);
1997 fclose (f);
1999 /* Assemble the file. */
2000 assemble_file (TMP_ASM, exp_name);
2002 if (dontdeltemps == 0)
2003 unlink (TMP_ASM);
2005 inform (_("Generated exports file"));
2008 static const char *
2009 xlate (name)
2010 const char *name;
2012 int lead_at = (*name == '@');
2014 if (add_underscore && !lead_at)
2016 char *copy = xmalloc (strlen (name) + 2);
2018 copy[0] = '_';
2019 strcpy (copy + 1, name);
2020 name = copy;
2023 if (killat)
2025 char *p;
2027 name += lead_at;
2028 p = strchr (name, '@');
2029 if (p)
2030 *p = 0;
2032 return name;
2035 /**********************************************************************/
2037 #if 0
2039 static void
2040 dump_iat (f, exp)
2041 FILE *f;
2042 export_type *exp;
2044 if (exp->noname && !show_allnames )
2046 fprintf (f, "\t%s\t0x%08x\n",
2047 ASM_LONG,
2048 exp->ordinal | 0x80000000); /* hint or orindal ?? */
2050 else
2052 fprintf (f, "\t%sID%d%s\n", ASM_RVA_BEFORE,
2053 exp->ordinal,
2054 ASM_RVA_AFTER);
2058 #endif
2060 typedef struct
2062 int id;
2063 const char *name;
2064 int flags;
2065 int align;
2066 asection *sec;
2067 asymbol *sym;
2068 asymbol **sympp;
2069 int size;
2070 unsigned char *data;
2071 } sinfo;
2073 #ifndef DLLTOOL_PPC
2075 #define TEXT 0
2076 #define DATA 1
2077 #define BSS 2
2078 #define IDATA7 3
2079 #define IDATA5 4
2080 #define IDATA4 5
2081 #define IDATA6 6
2083 #define NSECS 7
2085 #define TEXT_SEC_FLAGS \
2086 (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY | SEC_HAS_CONTENTS)
2087 #define DATA_SEC_FLAGS (SEC_ALLOC | SEC_LOAD | SEC_DATA)
2088 #define BSS_SEC_FLAGS SEC_ALLOC
2090 #define INIT_SEC_DATA(id, name, flags, align) \
2091 { id, name, flags, align, NULL, NULL, NULL, 0, NULL }
2092 static sinfo secdata[NSECS] =
2094 INIT_SEC_DATA (TEXT, ".text", TEXT_SEC_FLAGS, 2),
2095 INIT_SEC_DATA (DATA, ".data", DATA_SEC_FLAGS, 2),
2096 INIT_SEC_DATA (BSS, ".bss", BSS_SEC_FLAGS, 2),
2097 INIT_SEC_DATA (IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2),
2098 INIT_SEC_DATA (IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2),
2099 INIT_SEC_DATA (IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2),
2100 INIT_SEC_DATA (IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1)
2103 #else
2105 /* Sections numbered to make the order the same as other PowerPC NT
2106 compilers. This also keeps funny alignment thingies from happening. */
2107 #define TEXT 0
2108 #define PDATA 1
2109 #define RDATA 2
2110 #define IDATA5 3
2111 #define IDATA4 4
2112 #define IDATA6 5
2113 #define IDATA7 6
2114 #define DATA 7
2115 #define BSS 8
2117 #define NSECS 9
2119 static sinfo secdata[NSECS] =
2121 { TEXT, ".text", SEC_CODE | SEC_HAS_CONTENTS, 3},
2122 { PDATA, ".pdata", SEC_HAS_CONTENTS, 2},
2123 { RDATA, ".reldata", SEC_HAS_CONTENTS, 2},
2124 { IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2},
2125 { IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2},
2126 { IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1},
2127 { IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2},
2128 { DATA, ".data", SEC_DATA, 2},
2129 { BSS, ".bss", 0, 2}
2132 #endif
2134 /* This is what we're trying to make. We generate the imp symbols with
2135 both single and double underscores, for compatibility.
2137 .text
2138 .global _GetFileVersionInfoSizeW@8
2139 .global __imp_GetFileVersionInfoSizeW@8
2140 _GetFileVersionInfoSizeW@8:
2141 jmp * __imp_GetFileVersionInfoSizeW@8
2142 .section .idata$7 # To force loading of head
2143 .long __version_a_head
2144 # Import Address Table
2145 .section .idata$5
2146 __imp_GetFileVersionInfoSizeW@8:
2147 .rva ID2
2149 # Import Lookup Table
2150 .section .idata$4
2151 .rva ID2
2152 # Hint/Name table
2153 .section .idata$6
2154 ID2: .short 2
2155 .asciz "GetFileVersionInfoSizeW"
2158 For the PowerPC, here's the variation on the above scheme:
2160 # Rather than a simple "jmp *", the code to get to the dll function
2161 # looks like:
2162 .text
2163 lwz r11,[tocv]__imp_function_name(r2)
2164 # RELOC: 00000000 TOCREL16,TOCDEFN __imp_function_name
2165 lwz r12,0(r11)
2166 stw r2,4(r1)
2167 mtctr r12
2168 lwz r2,4(r11)
2169 bctr */
2171 static char *
2172 make_label (prefix, name)
2173 const char *prefix;
2174 const char *name;
2176 int len = strlen (ASM_PREFIX) + strlen (prefix) + strlen (name);
2177 char *copy = xmalloc (len +1 );
2179 strcpy (copy, ASM_PREFIX);
2180 strcat (copy, prefix);
2181 strcat (copy, name);
2182 return copy;
2185 static char *
2186 make_imp_label (prefix, name)
2187 const char *prefix;
2188 const char *name;
2190 int len;
2191 char *copy;
2193 if (name[0] == '@')
2195 len = strlen (prefix) + strlen (name);
2196 copy = xmalloc (len + 1);
2197 strcpy (copy, prefix);
2198 strcat (copy, name);
2200 else
2202 len = strlen (ASM_PREFIX) + strlen (prefix) + strlen (name);
2203 copy = xmalloc (len + 1);
2204 strcpy (copy, prefix);
2205 strcat (copy, ASM_PREFIX);
2206 strcat (copy, name);
2208 return copy;
2211 static bfd *
2212 make_one_lib_file (exp, i)
2213 export_type *exp;
2214 int i;
2216 #if 0
2218 char *name;
2219 FILE *f;
2220 const char *prefix = "d";
2221 char *dest;
2223 name = (char *) alloca (strlen (prefix) + 10);
2224 sprintf (name, "%ss%05d.s", prefix, i);
2225 f = fopen (name, FOPEN_WT);
2226 fprintf (f, "\t.text\n");
2227 fprintf (f, "\t%s\t%s%s\n", ASM_GLOBAL, ASM_PREFIX, exp->name);
2228 if (create_compat_implib)
2229 fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name);
2230 fprintf (f, "\t%s\t_imp__%s\n", ASM_GLOBAL, exp->name);
2231 if (create_compat_implib)
2232 fprintf (f, "%s%s:\n\t%s\t__imp_%s\n", ASM_PREFIX,
2233 exp->name, ASM_JUMP, exp->name);
2235 fprintf (f, "\t.section\t.idata$7\t%s To force loading of head\n", ASM_C);
2236 fprintf (f, "\t%s\t%s\n", ASM_LONG, head_label);
2239 fprintf (f,"%s Import Address Table\n", ASM_C);
2241 fprintf (f, "\t.section .idata$5\n");
2242 if (create_compat_implib)
2243 fprintf (f, "__imp_%s:\n", exp->name);
2244 fprintf (f, "_imp__%s:\n", exp->name);
2246 dump_iat (f, exp);
2248 fprintf (f, "\n%s Import Lookup Table\n", ASM_C);
2249 fprintf (f, "\t.section .idata$4\n");
2251 dump_iat (f, exp);
2253 if(!exp->noname || show_allnames)
2255 fprintf (f, "%s Hint/Name table\n", ASM_C);
2256 fprintf (f, "\t.section .idata$6\n");
2257 fprintf (f, "ID%d:\t%s\t%d\n", exp->ordinal, ASM_SHORT, exp->hint);
2258 fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, xlate (exp->name));
2261 fclose (f);
2263 dest = (char *) alloca (strlen (prefix) + 10);
2264 sprintf (dest, "%ss%05d.o", prefix, i);
2265 assemble_file (name, dest);
2267 #else /* if 0 */
2269 bfd * abfd;
2270 asymbol * exp_label;
2271 asymbol * iname = 0;
2272 asymbol * iname2;
2273 asymbol * iname_lab;
2274 asymbol ** iname_lab_pp;
2275 asymbol ** iname_pp;
2276 #ifdef DLLTOOL_PPC
2277 asymbol ** fn_pp;
2278 asymbol ** toc_pp;
2279 #define EXTRA 2
2280 #endif
2281 #ifndef EXTRA
2282 #define EXTRA 0
2283 #endif
2284 asymbol * ptrs[NSECS + 4 + EXTRA + 1];
2285 flagword applicable;
2287 char * outname = xmalloc (10);
2288 int oidx = 0;
2291 sprintf (outname, "%s%05d.o", TMP_STUB, i);
2293 abfd = bfd_openw (outname, HOW_BFD_WRITE_TARGET);
2295 if (!abfd)
2296 /* xgettext:c-format */
2297 fatal (_("bfd_open failed open stub file: %s"), outname);
2299 /* xgettext:c-format */
2300 inform (_("Creating stub file: %s"), outname);
2302 bfd_set_format (abfd, bfd_object);
2303 bfd_set_arch_mach (abfd, HOW_BFD_ARCH, 0);
2305 #ifdef DLLTOOL_ARM
2306 if (machine == MARM_INTERWORK || machine == MTHUMB)
2307 bfd_set_private_flags (abfd, F_INTERWORK);
2308 #endif
2310 applicable = bfd_applicable_section_flags (abfd);
2312 /* First make symbols for the sections. */
2313 for (i = 0; i < NSECS; i++)
2315 sinfo *si = secdata + i;
2316 if (si->id != i)
2317 abort();
2318 si->sec = bfd_make_section_old_way (abfd, si->name);
2319 bfd_set_section_flags (abfd,
2320 si->sec,
2321 si->flags & applicable);
2323 bfd_set_section_alignment(abfd, si->sec, si->align);
2324 si->sec->output_section = si->sec;
2325 si->sym = bfd_make_empty_symbol(abfd);
2326 si->sym->name = si->sec->name;
2327 si->sym->section = si->sec;
2328 si->sym->flags = BSF_LOCAL;
2329 si->sym->value = 0;
2330 ptrs[oidx] = si->sym;
2331 si->sympp = ptrs + oidx;
2332 si->size = 0;
2333 si->data = NULL;
2335 oidx++;
2338 if (! exp->data)
2340 exp_label = bfd_make_empty_symbol (abfd);
2341 exp_label->name = make_imp_label ("", exp->name);
2343 /* On PowerPC, the function name points to a descriptor in
2344 the rdata section, the first element of which is a
2345 pointer to the code (..function_name), and the second
2346 points to the .toc. */
2347 #ifdef DLLTOOL_PPC
2348 if (machine == MPPC)
2349 exp_label->section = secdata[RDATA].sec;
2350 else
2351 #endif
2352 exp_label->section = secdata[TEXT].sec;
2354 exp_label->flags = BSF_GLOBAL;
2355 exp_label->value = 0;
2357 #ifdef DLLTOOL_ARM
2358 if (machine == MTHUMB)
2359 bfd_coff_set_symbol_class (abfd, exp_label, C_THUMBEXTFUNC);
2360 #endif
2361 ptrs[oidx++] = exp_label;
2364 /* Generate imp symbols with one underscore for Microsoft
2365 compatibility, and with two underscores for backward
2366 compatibility with old versions of cygwin. */
2367 if (create_compat_implib)
2369 iname = bfd_make_empty_symbol (abfd);
2370 iname->name = make_imp_label ("___imp", exp->name);
2371 iname->section = secdata[IDATA5].sec;
2372 iname->flags = BSF_GLOBAL;
2373 iname->value = 0;
2376 iname2 = bfd_make_empty_symbol (abfd);
2377 iname2->name = make_imp_label ("__imp_", exp->name);
2378 iname2->section = secdata[IDATA5].sec;
2379 iname2->flags = BSF_GLOBAL;
2380 iname2->value = 0;
2382 iname_lab = bfd_make_empty_symbol(abfd);
2384 iname_lab->name = head_label;
2385 iname_lab->section = (asection *)&bfd_und_section;
2386 iname_lab->flags = 0;
2387 iname_lab->value = 0;
2389 iname_pp = ptrs + oidx;
2390 if (create_compat_implib)
2391 ptrs[oidx++] = iname;
2392 ptrs[oidx++] = iname2;
2394 iname_lab_pp = ptrs + oidx;
2395 ptrs[oidx++] = iname_lab;
2397 #ifdef DLLTOOL_PPC
2398 /* The symbol refering to the code (.text). */
2400 asymbol *function_name;
2402 function_name = bfd_make_empty_symbol(abfd);
2403 function_name->name = make_label ("..", exp->name);
2404 function_name->section = secdata[TEXT].sec;
2405 function_name->flags = BSF_GLOBAL;
2406 function_name->value = 0;
2408 fn_pp = ptrs + oidx;
2409 ptrs[oidx++] = function_name;
2412 /* The .toc symbol. */
2414 asymbol *toc_symbol;
2416 toc_symbol = bfd_make_empty_symbol (abfd);
2417 toc_symbol->name = make_label (".", "toc");
2418 toc_symbol->section = (asection *)&bfd_und_section;
2419 toc_symbol->flags = BSF_GLOBAL;
2420 toc_symbol->value = 0;
2422 toc_pp = ptrs + oidx;
2423 ptrs[oidx++] = toc_symbol;
2425 #endif
2427 ptrs[oidx] = 0;
2429 for (i = 0; i < NSECS; i++)
2431 sinfo *si = secdata + i;
2432 asection *sec = si->sec;
2433 arelent *rel;
2434 arelent **rpp;
2436 switch (i)
2438 case TEXT:
2439 if (! exp->data)
2441 si->size = HOW_JTAB_SIZE;
2442 si->data = xmalloc (HOW_JTAB_SIZE);
2443 memcpy (si->data, HOW_JTAB, HOW_JTAB_SIZE);
2445 /* add the reloc into idata$5 */
2446 rel = xmalloc (sizeof (arelent));
2448 rpp = xmalloc (sizeof (arelent *) * 2);
2449 rpp[0] = rel;
2450 rpp[1] = 0;
2452 rel->address = HOW_JTAB_ROFF;
2453 rel->addend = 0;
2455 if (machine == MPPC)
2457 rel->howto = bfd_reloc_type_lookup (abfd,
2458 BFD_RELOC_16_GOTOFF);
2459 rel->sym_ptr_ptr = iname_pp;
2461 else
2463 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2464 rel->sym_ptr_ptr = secdata[IDATA5].sympp;
2466 sec->orelocation = rpp;
2467 sec->reloc_count = 1;
2469 break;
2470 case IDATA4:
2471 case IDATA5:
2472 /* An idata$4 or idata$5 is one word long, and has an
2473 rva to idata$6. */
2475 si->data = xmalloc (4);
2476 si->size = 4;
2478 if (exp->noname)
2480 si->data[0] = exp->ordinal ;
2481 si->data[1] = exp->ordinal >> 8;
2482 si->data[2] = exp->ordinal >> 16;
2483 si->data[3] = 0x80;
2485 else
2487 sec->reloc_count = 1;
2488 memset (si->data, 0, si->size);
2489 rel = xmalloc (sizeof (arelent));
2490 rpp = xmalloc (sizeof (arelent *) * 2);
2491 rpp[0] = rel;
2492 rpp[1] = 0;
2493 rel->address = 0;
2494 rel->addend = 0;
2495 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2496 rel->sym_ptr_ptr = secdata[IDATA6].sympp;
2497 sec->orelocation = rpp;
2500 break;
2502 case IDATA6:
2503 if (!exp->noname)
2505 /* This used to add 1 to exp->hint. I don't know
2506 why it did that, and it does not match what I see
2507 in programs compiled with the MS tools. */
2508 int idx = exp->hint;
2509 si->size = strlen (xlate (exp->name)) + 3;
2510 si->data = xmalloc (si->size);
2511 si->data[0] = idx & 0xff;
2512 si->data[1] = idx >> 8;
2513 strcpy (si->data + 2, xlate (exp->name));
2515 break;
2516 case IDATA7:
2517 si->size = 4;
2518 si->data =xmalloc (4);
2519 memset (si->data, 0, si->size);
2520 rel = xmalloc (sizeof (arelent));
2521 rpp = xmalloc (sizeof (arelent *) * 2);
2522 rpp[0] = rel;
2523 rel->address = 0;
2524 rel->addend = 0;
2525 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2526 rel->sym_ptr_ptr = iname_lab_pp;
2527 sec->orelocation = rpp;
2528 sec->reloc_count = 1;
2529 break;
2531 #ifdef DLLTOOL_PPC
2532 case PDATA:
2534 /* The .pdata section is 5 words long.
2535 Think of it as:
2536 struct
2538 bfd_vma BeginAddress, [0x00]
2539 EndAddress, [0x04]
2540 ExceptionHandler, [0x08]
2541 HandlerData, [0x0c]
2542 PrologEndAddress; [0x10]
2543 }; */
2545 /* So this pdata section setups up this as a glue linkage to
2546 a dll routine. There are a number of house keeping things
2547 we need to do:
2549 1. In the name of glue trickery, the ADDR32 relocs for 0,
2550 4, and 0x10 are set to point to the same place:
2551 "..function_name".
2552 2. There is one more reloc needed in the pdata section.
2553 The actual glue instruction to restore the toc on
2554 return is saved as the offset in an IMGLUE reloc.
2555 So we need a total of four relocs for this section.
2557 3. Lastly, the HandlerData field is set to 0x03, to indicate
2558 that this is a glue routine. */
2559 arelent *imglue, *ba_rel, *ea_rel, *pea_rel;
2561 /* Alignment must be set to 2**2 or you get extra stuff. */
2562 bfd_set_section_alignment(abfd, sec, 2);
2564 si->size = 4 * 5;
2565 si->data = xmalloc (si->size);
2566 memset (si->data, 0, si->size);
2567 rpp = xmalloc (sizeof (arelent *) * 5);
2568 rpp[0] = imglue = xmalloc (sizeof (arelent));
2569 rpp[1] = ba_rel = xmalloc (sizeof (arelent));
2570 rpp[2] = ea_rel = xmalloc (sizeof (arelent));
2571 rpp[3] = pea_rel = xmalloc (sizeof (arelent));
2572 rpp[4] = 0;
2574 /* Stick the toc reload instruction in the glue reloc. */
2575 bfd_put_32(abfd, ppc_glue_insn, (char *) &imglue->address);
2577 imglue->addend = 0;
2578 imglue->howto = bfd_reloc_type_lookup (abfd,
2579 BFD_RELOC_32_GOTOFF);
2580 imglue->sym_ptr_ptr = fn_pp;
2582 ba_rel->address = 0;
2583 ba_rel->addend = 0;
2584 ba_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2585 ba_rel->sym_ptr_ptr = fn_pp;
2587 bfd_put_32 (abfd, 0x18, si->data + 0x04);
2588 ea_rel->address = 4;
2589 ea_rel->addend = 0;
2590 ea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2591 ea_rel->sym_ptr_ptr = fn_pp;
2593 /* Mark it as glue. */
2594 bfd_put_32 (abfd, 0x03, si->data + 0x0c);
2596 /* Mark the prolog end address. */
2597 bfd_put_32 (abfd, 0x0D, si->data + 0x10);
2598 pea_rel->address = 0x10;
2599 pea_rel->addend = 0;
2600 pea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2601 pea_rel->sym_ptr_ptr = fn_pp;
2603 sec->orelocation = rpp;
2604 sec->reloc_count = 4;
2605 break;
2607 case RDATA:
2608 /* Each external function in a PowerPC PE file has a two word
2609 descriptor consisting of:
2610 1. The address of the code.
2611 2. The address of the appropriate .toc
2612 We use relocs to build this. */
2613 si->size = 8;
2614 si->data = xmalloc (8);
2615 memset (si->data, 0, si->size);
2617 rpp = xmalloc (sizeof (arelent *) * 3);
2618 rpp[0] = rel = xmalloc (sizeof (arelent));
2619 rpp[1] = xmalloc (sizeof (arelent));
2620 rpp[2] = 0;
2622 rel->address = 0;
2623 rel->addend = 0;
2624 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2625 rel->sym_ptr_ptr = fn_pp;
2627 rel = rpp[1];
2629 rel->address = 4;
2630 rel->addend = 0;
2631 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2632 rel->sym_ptr_ptr = toc_pp;
2634 sec->orelocation = rpp;
2635 sec->reloc_count = 2;
2636 break;
2637 #endif /* DLLTOOL_PPC */
2642 bfd_vma vma = 0;
2643 /* Size up all the sections. */
2644 for (i = 0; i < NSECS; i++)
2646 sinfo *si = secdata + i;
2648 bfd_set_section_size (abfd, si->sec, si->size);
2649 bfd_set_section_vma (abfd, si->sec, vma);
2651 /* vma += si->size;*/
2654 /* Write them out. */
2655 for (i = 0; i < NSECS; i++)
2657 sinfo *si = secdata + i;
2659 if (i == IDATA5 && no_idata5)
2660 continue;
2662 if (i == IDATA4 && no_idata4)
2663 continue;
2665 bfd_set_section_contents (abfd, si->sec,
2666 si->data, 0,
2667 si->size);
2670 bfd_set_symtab (abfd, ptrs, oidx);
2671 bfd_close (abfd);
2672 abfd = bfd_openr (outname, HOW_BFD_READ_TARGET);
2673 return abfd;
2675 #endif
2678 static bfd *
2679 make_head ()
2681 FILE *f = fopen (TMP_HEAD_S, FOPEN_WT);
2683 if (f == NULL)
2685 fatal (_("failed to open temporary head file: %s"), TMP_HEAD_S);
2686 return NULL;
2689 fprintf (f, "%s IMAGE_IMPORT_DESCRIPTOR\n", ASM_C);
2690 fprintf (f, "\t.section .idata$2\n");
2692 fprintf(f,"\t%s\t%s\n", ASM_GLOBAL,head_label);
2694 fprintf (f, "%s:\n", head_label);
2696 fprintf (f, "\t%shname%s\t%sPtr to image import by name list\n",
2697 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
2699 fprintf (f, "\t%sthis should be the timestamp, but NT sometimes\n", ASM_C);
2700 fprintf (f, "\t%sdoesn't load DLLs when this is set.\n", ASM_C);
2701 fprintf (f, "\t%s\t0\t%s loaded time\n", ASM_LONG, ASM_C);
2702 fprintf (f, "\t%s\t0\t%s Forwarder chain\n", ASM_LONG, ASM_C);
2703 fprintf (f, "\t%s__%s_iname%s\t%s imported dll's name\n",
2704 ASM_RVA_BEFORE,
2705 imp_name_lab,
2706 ASM_RVA_AFTER,
2707 ASM_C);
2708 fprintf (f, "\t%sfthunk%s\t%s pointer to firstthunk\n",
2709 ASM_RVA_BEFORE,
2710 ASM_RVA_AFTER, ASM_C);
2712 fprintf (f, "%sStuff for compatibility\n", ASM_C);
2714 if (!no_idata5)
2716 fprintf (f, "\t.section\t.idata$5\n");
2717 fprintf (f, "\t%s\t0\n", ASM_LONG);
2718 fprintf (f, "fthunk:\n");
2721 if (!no_idata4)
2723 fprintf (f, "\t.section\t.idata$4\n");
2725 fprintf (f, "\t%s\t0\n", ASM_LONG);
2726 fprintf (f, "\t.section .idata$4\n");
2727 fprintf (f, "hname:\n");
2730 fclose (f);
2732 assemble_file (TMP_HEAD_S, TMP_HEAD_O);
2734 return bfd_openr (TMP_HEAD_O, HOW_BFD_READ_TARGET);
2737 static bfd *
2738 make_tail ()
2740 FILE *f = fopen (TMP_TAIL_S, FOPEN_WT);
2742 if (f == NULL)
2744 fatal (_("failed to open temporary tail file: %s"), TMP_TAIL_S);
2745 return NULL;
2748 if (!no_idata4)
2750 fprintf (f, "\t.section .idata$4\n");
2751 fprintf (f, "\t%s\t0\n", ASM_LONG);
2754 if (!no_idata5)
2756 fprintf (f, "\t.section .idata$5\n");
2757 fprintf (f, "\t%s\t0\n", ASM_LONG);
2760 #ifdef DLLTOOL_PPC
2761 /* Normally, we need to see a null descriptor built in idata$3 to
2762 act as the terminator for the list. The ideal way, I suppose,
2763 would be to mark this section as a comdat type 2 section, so
2764 only one would appear in the final .exe (if our linker supported
2765 comdat, that is) or cause it to be inserted by something else (say
2766 crt0). */
2768 fprintf (f, "\t.section .idata$3\n");
2769 fprintf (f, "\t%s\t0\n", ASM_LONG);
2770 fprintf (f, "\t%s\t0\n", ASM_LONG);
2771 fprintf (f, "\t%s\t0\n", ASM_LONG);
2772 fprintf (f, "\t%s\t0\n", ASM_LONG);
2773 fprintf (f, "\t%s\t0\n", ASM_LONG);
2774 #endif
2776 #ifdef DLLTOOL_PPC
2777 /* Other PowerPC NT compilers use idata$6 for the dllname, so I
2778 do too. Original, huh? */
2779 fprintf (f, "\t.section .idata$6\n");
2780 #else
2781 fprintf (f, "\t.section .idata$7\n");
2782 #endif
2784 fprintf (f, "\t%s\t__%s_iname\n", ASM_GLOBAL, imp_name_lab);
2785 fprintf (f, "__%s_iname:\t%s\t\"%s\"\n",
2786 imp_name_lab, ASM_TEXT, dll_name);
2788 fclose (f);
2790 assemble_file (TMP_TAIL_S, TMP_TAIL_O);
2792 return bfd_openr (TMP_TAIL_O, HOW_BFD_READ_TARGET);
2795 static void
2796 gen_lib_file ()
2798 int i;
2799 export_type *exp;
2800 bfd *ar_head;
2801 bfd *ar_tail;
2802 bfd *outarch;
2803 bfd * head = 0;
2805 unlink (imp_name);
2807 outarch = bfd_openw (imp_name, HOW_BFD_WRITE_TARGET);
2809 if (!outarch)
2810 /* xgettext:c-format */
2811 fatal (_("Can't open .lib file: %s"), imp_name);
2813 /* xgettext:c-format */
2814 inform (_("Creating library file: %s"), imp_name);
2816 bfd_set_format (outarch, bfd_archive);
2817 outarch->has_armap = 1;
2819 /* Work out a reasonable size of things to put onto one line. */
2820 ar_head = make_head ();
2821 ar_tail = make_tail();
2823 if (ar_head == NULL || ar_tail == NULL)
2824 return;
2826 for (i = 0; (exp = d_exports_lexically[i]); i++)
2828 bfd *n = make_one_lib_file (exp, i);
2829 n->next = head;
2830 head = n;
2833 /* Now stick them all into the archive. */
2834 ar_head->next = head;
2835 ar_tail->next = ar_head;
2836 head = ar_tail;
2838 if (! bfd_set_archive_head (outarch, head))
2839 bfd_fatal ("bfd_set_archive_head");
2841 if (! bfd_close (outarch))
2842 bfd_fatal (imp_name);
2844 while (head != NULL)
2846 bfd *n = head->next;
2847 bfd_close (head);
2848 head = n;
2851 /* Delete all the temp files. */
2852 if (dontdeltemps == 0)
2854 unlink (TMP_HEAD_O);
2855 unlink (TMP_HEAD_S);
2856 unlink (TMP_TAIL_O);
2857 unlink (TMP_TAIL_S);
2860 if (dontdeltemps < 2)
2862 char *name;
2864 name = (char *) alloca (sizeof TMP_STUB + 10);
2865 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
2867 sprintf (name, "%s%05d.o", TMP_STUB, i);
2868 if (unlink (name) < 0)
2869 /* xgettext:c-format */
2870 non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
2874 inform (_("Created lib file"));
2877 /**********************************************************************/
2879 /* Run through the information gathered from the .o files and the
2880 .def file and work out the best stuff. */
2881 static int
2882 pfunc (a, b)
2883 const void *a;
2884 const void *b;
2886 export_type *ap = *(export_type **) a;
2887 export_type *bp = *(export_type **) b;
2888 if (ap->ordinal == bp->ordinal)
2889 return 0;
2891 /* Unset ordinals go to the bottom. */
2892 if (ap->ordinal == -1)
2893 return 1;
2894 if (bp->ordinal == -1)
2895 return -1;
2896 return (ap->ordinal - bp->ordinal);
2899 static int
2900 nfunc (a, b)
2901 const void *a;
2902 const void *b;
2904 export_type *ap = *(export_type **) a;
2905 export_type *bp = *(export_type **) b;
2907 return (strcmp (ap->name, bp->name));
2910 static void
2911 remove_null_names (ptr)
2912 export_type **ptr;
2914 int src;
2915 int dst;
2917 for (dst = src = 0; src < d_nfuncs; src++)
2919 if (ptr[src])
2921 ptr[dst] = ptr[src];
2922 dst++;
2925 d_nfuncs = dst;
2928 static void
2929 dtab (ptr)
2930 export_type ** ptr
2931 #ifndef SACDEBUG
2932 ATTRIBUTE_UNUSED
2933 #endif
2936 #ifdef SACDEBUG
2937 int i;
2938 for (i = 0; i < d_nfuncs; i++)
2940 if (ptr[i])
2942 printf ("%d %s @ %d %s%s%s\n",
2943 i, ptr[i]->name, ptr[i]->ordinal,
2944 ptr[i]->noname ? "NONAME " : "",
2945 ptr[i]->constant ? "CONSTANT" : "",
2946 ptr[i]->data ? "DATA" : "");
2948 else
2949 printf ("empty\n");
2951 #endif
2954 static void
2955 process_duplicates (d_export_vec)
2956 export_type **d_export_vec;
2958 int more = 1;
2959 int i;
2961 while (more)
2964 more = 0;
2965 /* Remove duplicates. */
2966 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), nfunc);
2968 dtab (d_export_vec);
2969 for (i = 0; i < d_nfuncs - 1; i++)
2971 if (strcmp (d_export_vec[i]->name,
2972 d_export_vec[i + 1]->name) == 0)
2975 export_type *a = d_export_vec[i];
2976 export_type *b = d_export_vec[i + 1];
2978 more = 1;
2980 /* xgettext:c-format */
2981 inform (_("Warning, ignoring duplicate EXPORT %s %d,%d"),
2982 a->name, a->ordinal, b->ordinal);
2984 if (a->ordinal != -1
2985 && b->ordinal != -1)
2986 /* xgettext:c-format */
2987 fatal (_("Error, duplicate EXPORT with oridinals: %s"),
2988 a->name);
2990 /* Merge attributes. */
2991 b->ordinal = a->ordinal > 0 ? a->ordinal : b->ordinal;
2992 b->constant |= a->constant;
2993 b->noname |= a->noname;
2994 b->data |= a->data;
2995 d_export_vec[i] = 0;
2998 dtab (d_export_vec);
2999 remove_null_names (d_export_vec);
3000 dtab (d_export_vec);
3005 /* Count the names. */
3006 for (i = 0; i < d_nfuncs; i++)
3008 if (!d_export_vec[i]->noname)
3009 d_named_nfuncs++;
3013 static void
3014 fill_ordinals (d_export_vec)
3015 export_type **d_export_vec;
3017 int lowest = -1;
3018 int i;
3019 char *ptr;
3020 int size = 65536;
3022 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
3024 /* Fill in the unset ordinals with ones from our range. */
3025 ptr = (char *) xmalloc (size);
3027 memset (ptr, 0, size);
3029 /* Mark in our large vector all the numbers that are taken. */
3030 for (i = 0; i < d_nfuncs; i++)
3032 if (d_export_vec[i]->ordinal != -1)
3034 ptr[d_export_vec[i]->ordinal] = 1;
3036 if (lowest == -1 || d_export_vec[i]->ordinal < lowest)
3037 lowest = d_export_vec[i]->ordinal;
3041 /* Start at 1 for compatibility with MS toolchain. */
3042 if (lowest == -1)
3043 lowest = 1;
3045 /* Now fill in ordinals where the user wants us to choose. */
3046 for (i = 0; i < d_nfuncs; i++)
3048 if (d_export_vec[i]->ordinal == -1)
3050 register int j;
3052 /* First try within or after any user supplied range. */
3053 for (j = lowest; j < size; j++)
3054 if (ptr[j] == 0)
3056 ptr[j] = 1;
3057 d_export_vec[i]->ordinal = j;
3058 goto done;
3061 /* Then try before the range. */
3062 for (j = lowest; j >0; j--)
3063 if (ptr[j] == 0)
3065 ptr[j] = 1;
3066 d_export_vec[i]->ordinal = j;
3067 goto done;
3069 done:;
3073 free (ptr);
3075 /* And resort. */
3076 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
3078 /* Work out the lowest and highest ordinal numbers. */
3079 if (d_nfuncs)
3081 if (d_export_vec[0])
3082 d_low_ord = d_export_vec[0]->ordinal;
3083 if (d_export_vec[d_nfuncs-1])
3084 d_high_ord = d_export_vec[d_nfuncs-1]->ordinal;
3088 static int
3089 alphafunc (av,bv)
3090 const void *av;
3091 const void *bv;
3093 const export_type **a = (const export_type **) av;
3094 const export_type **b = (const export_type **) bv;
3096 return strcmp ((*a)->name, (*b)->name);
3099 static void
3100 mangle_defs ()
3102 /* First work out the minimum ordinal chosen. */
3103 export_type *exp;
3105 int i;
3106 int hint = 0;
3107 export_type **d_export_vec
3108 = (export_type **) xmalloc (sizeof (export_type *) * d_nfuncs);
3110 inform (_("Processing definitions"));
3112 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3113 d_export_vec[i] = exp;
3115 process_duplicates (d_export_vec);
3116 fill_ordinals (d_export_vec);
3118 /* Put back the list in the new order. */
3119 d_exports = 0;
3120 for (i = d_nfuncs - 1; i >= 0; i--)
3122 d_export_vec[i]->next = d_exports;
3123 d_exports = d_export_vec[i];
3126 /* Build list in alpha order. */
3127 d_exports_lexically = (export_type **)
3128 xmalloc (sizeof (export_type *) * (d_nfuncs + 1));
3130 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3131 d_exports_lexically[i] = exp;
3133 d_exports_lexically[i] = 0;
3135 qsort (d_exports_lexically, i, sizeof (export_type *), alphafunc);
3137 /* Fill exp entries with their hint values. */
3138 for (i = 0; i < d_nfuncs; i++)
3139 if (!d_exports_lexically[i]->noname || show_allnames)
3140 d_exports_lexically[i]->hint = hint++;
3142 inform (_("Processed definitions"));
3145 /**********************************************************************/
3147 static void
3148 usage (file, status)
3149 FILE *file;
3150 int status;
3152 /* xgetext:c-format */
3153 fprintf (file, _("Usage %s <option(s)> <object-file(s)>\n"), program_name);
3154 /* xgetext:c-format */
3155 fprintf (file, _(" -m --machine <machine> Create as DLL for <machine>. [default: %s]\n"), mname);
3156 fprintf (file, _(" possible <machine>: arm[_interwork], i386, mcore[-elf]{-le|-be}, ppc, thumb\n"));
3157 fprintf (file, _(" -e --output-exp <outname> Generate an export file.\n"));
3158 fprintf (file, _(" -l --output-lib <outname> Generate an interface library.\n"));
3159 fprintf (file, _(" -a --add-indirect Add dll indirects to export file.\n"));
3160 fprintf (file, _(" -D --dllname <name> Name of input dll to put into interface lib.\n"));
3161 fprintf (file, _(" -d --input-def <deffile> Name of .def file to be read in.\n"));
3162 fprintf (file, _(" -z --output-def <deffile> Name of .def file to be created.\n"));
3163 fprintf (file, _(" --export-all-symbols Export all symbols to .def\n"));
3164 fprintf (file, _(" --no-export-all-symbols Only export listed symbols\n"));
3165 fprintf (file, _(" --exclude-symbols <list> Don't export <list>\n"));
3166 fprintf (file, _(" --no-default-excludes Clear default exclude symbols\n"));
3167 fprintf (file, _(" -b --base-file <basefile> Read linker generated base file.\n"));
3168 fprintf (file, _(" -x --no-idata4 Don't generate idata$4 section.\n"));
3169 fprintf (file, _(" -c --no-idata5 Don't generate idata$5 section.\n"));
3170 fprintf (file, _(" -U --add-underscore Add underscores to symbols in interface library.\n"));
3171 fprintf (file, _(" -k --kill-at Kill @<n> from exported names.\n"));
3172 fprintf (file, _(" -A --add-stdcall-alias Add aliases without @<n>.\n"));
3173 fprintf (file, _(" -S --as <name> Use <name> for assembler.\n"));
3174 fprintf (file, _(" -f --as-flags <flags> Pass <flags> to the assembler.\n"));
3175 fprintf (file, _(" -C --compat-implib Create backward compatible import library.\n"));
3176 fprintf (file, _(" -n --no-delete Keep temp files (repeat for extra preservation).\n"));
3177 fprintf (file, _(" -v --verbose Be verbose.\n"));
3178 fprintf (file, _(" -V --version Display the program version.\n"));
3179 fprintf (file, _(" -h --help Display this information.\n"));
3180 #ifdef DLLTOOL_MCORE_ELF
3181 fprintf (file, _(" -M --mcore-elf <outname> Process mcore-elf object files into <outname>.\n"));
3182 fprintf (file, _(" -L --linker <name> Use <name> as the linker.\n"));
3183 fprintf (file, _(" -F --linker-flags <flags> Pass <flags> to the linker.\n"));
3184 #endif
3185 exit (status);
3188 #define OPTION_EXPORT_ALL_SYMS 150
3189 #define OPTION_NO_EXPORT_ALL_SYMS (OPTION_EXPORT_ALL_SYMS + 1)
3190 #define OPTION_EXCLUDE_SYMS (OPTION_NO_EXPORT_ALL_SYMS + 1)
3191 #define OPTION_NO_DEFAULT_EXCLUDES (OPTION_EXCLUDE_SYMS + 1)
3193 static const struct option long_options[] =
3195 {"no-delete", no_argument, NULL, 'n'},
3196 {"dllname", required_argument, NULL, 'D'},
3197 {"no-idata4", no_argument, NULL, 'x'},
3198 {"no-idata5", no_argument, NULL, 'c'},
3199 {"output-exp", required_argument, NULL, 'e'},
3200 {"output-def", required_argument, NULL, 'z'},
3201 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL_SYMS},
3202 {"no-export-all-symbols", no_argument, NULL, OPTION_NO_EXPORT_ALL_SYMS},
3203 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMS},
3204 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
3205 {"output-lib", required_argument, NULL, 'l'},
3206 {"def", required_argument, NULL, 'd'}, /* for compatiblity with older versions */
3207 {"input-def", required_argument, NULL, 'd'},
3208 {"add-underscore", no_argument, NULL, 'U'},
3209 {"kill-at", no_argument, NULL, 'k'},
3210 {"add-stdcall-alias", no_argument, NULL, 'A'},
3211 {"verbose", no_argument, NULL, 'v'},
3212 {"version", no_argument, NULL, 'V'},
3213 {"help", no_argument, NULL, 'h'},
3214 {"machine", required_argument, NULL, 'm'},
3215 {"add-indirect", no_argument, NULL, 'a'},
3216 {"base-file", required_argument, NULL, 'b'},
3217 {"as", required_argument, NULL, 'S'},
3218 {"as-flags", required_argument, NULL, 'f'},
3219 {"mcore-elf", required_argument, NULL, 'M'},
3220 {"compat-implib", no_argument, NULL, 'C'},
3221 {NULL,0,NULL,0}
3224 int main PARAMS ((int, char **));
3227 main (ac, av)
3228 int ac;
3229 char **av;
3231 int c;
3232 int i;
3233 char *firstarg = 0;
3234 program_name = av[0];
3235 oav = av;
3237 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
3238 setlocale (LC_MESSAGES, "");
3239 #endif
3240 #if defined (HAVE_SETLOCALE)
3241 setlocale (LC_CTYPE, "");
3242 #endif
3243 bindtextdomain (PACKAGE, LOCALEDIR);
3244 textdomain (PACKAGE);
3246 while ((c = getopt_long (ac, av,
3247 #ifdef DLLTOOL_MCORE_ELF
3248 "m:e:l:aD:d:z:b:xcCuUkAS:f:nvVHhM:L:F:",
3249 #else
3250 "m:e:l:aD:d:z:b:xcCuUkAS:f:nvVHh",
3251 #endif
3252 long_options, 0))
3253 != EOF)
3255 switch (c)
3257 case OPTION_EXPORT_ALL_SYMS:
3258 export_all_symbols = true;
3259 break;
3260 case OPTION_NO_EXPORT_ALL_SYMS:
3261 export_all_symbols = false;
3262 break;
3263 case OPTION_EXCLUDE_SYMS:
3264 add_excludes (optarg);
3265 break;
3266 case OPTION_NO_DEFAULT_EXCLUDES:
3267 do_default_excludes = false;
3268 break;
3269 case 'x':
3270 no_idata4 = 1;
3271 break;
3272 case 'c':
3273 no_idata5 = 1;
3274 break;
3275 case 'S':
3276 as_name = optarg;
3277 break;
3278 case 'f':
3279 as_flags = optarg;
3280 break;
3282 /* ignored for compatibility */
3283 case 'u':
3284 break;
3285 case 'a':
3286 add_indirect = 1;
3287 break;
3288 case 'z':
3289 output_def = fopen (optarg, FOPEN_WT);
3290 break;
3291 case 'D':
3292 dll_name = optarg;
3293 break;
3294 case 'l':
3295 imp_name = optarg;
3296 break;
3297 case 'e':
3298 exp_name = optarg;
3299 break;
3300 case 'H':
3301 case 'h':
3302 usage (stdout, 0);
3303 break;
3304 case 'm':
3305 mname = optarg;
3306 break;
3307 case 'v':
3308 verbose = 1;
3309 break;
3310 case 'V':
3311 print_version (program_name);
3312 break;
3313 case 'U':
3314 add_underscore = 1;
3315 break;
3316 case 'k':
3317 killat = 1;
3318 break;
3319 case 'A':
3320 add_stdcall_alias = 1;
3321 break;
3322 case 'd':
3323 def_file = optarg;
3324 break;
3325 case 'n':
3326 dontdeltemps++;
3327 break;
3328 case 'b':
3329 base_file = fopen (optarg, FOPEN_RB);
3331 if (!base_file)
3332 /* xgettext:c-format */
3333 fatal (_("Unable to open base-file: %s"), optarg);
3335 break;
3336 #ifdef DLLTOOL_MCORE_ELF
3337 case 'M':
3338 mcore_elf_out_file = optarg;
3339 break;
3340 case 'L':
3341 mcore_elf_linker = optarg;
3342 break;
3343 case 'F':
3344 mcore_elf_linker_flags = optarg;
3345 break;
3346 #endif
3347 case 'C':
3348 create_compat_implib = 1;
3349 break;
3350 default:
3351 usage (stderr, 1);
3352 break;
3356 for (i = 0; mtable[i].type; i++)
3357 if (strcmp (mtable[i].type, mname) == 0)
3358 break;
3360 if (!mtable[i].type)
3361 /* xgettext:c-format */
3362 fatal (_("Machine '%s' not supported"), mname);
3364 machine = i;
3366 if (!dll_name && exp_name)
3368 int len = strlen (exp_name) + 5;
3369 dll_name = xmalloc (len);
3370 strcpy (dll_name, exp_name);
3371 strcat (dll_name, ".dll");
3374 if (as_name == NULL)
3375 as_name = deduce_name ("as");
3377 /* Don't use the default exclude list if we're reading only the
3378 symbols in the .drectve section. The default excludes are meant
3379 to avoid exporting DLL entry point and Cygwin32 impure_ptr. */
3380 if (! export_all_symbols)
3381 do_default_excludes = false;
3383 if (do_default_excludes)
3384 set_default_excludes ();
3386 if (def_file)
3387 process_def_file (def_file);
3389 while (optind < ac)
3391 if (!firstarg)
3392 firstarg = av[optind];
3393 scan_obj_file (av[optind]);
3394 optind++;
3397 mangle_defs ();
3399 if (exp_name)
3400 gen_exp_file ();
3402 if (imp_name)
3404 /* Make imp_name safe for use as a label. */
3405 char *p;
3407 imp_name_lab = xstrdup (imp_name);
3408 for (p = imp_name_lab; *p; p++)
3410 if (!ISALNUM (*p))
3411 *p = '_';
3413 head_label = make_label("_head_", imp_name_lab);
3414 gen_lib_file ();
3417 if (output_def)
3418 gen_def_file ();
3420 #ifdef DLLTOOL_MCORE_ELF
3421 if (mcore_elf_out_file)
3422 mcore_elf_gen_out_file ();
3423 #endif
3425 return 0;
3428 /* Look for the program formed by concatenating PROG_NAME and the
3429 string running from PREFIX to END_PREFIX. If the concatenated
3430 string contains a '/', try appending EXECUTABLE_SUFFIX if it is
3431 appropriate. */
3433 static char *
3434 look_for_prog (prog_name, prefix, end_prefix)
3435 const char *prog_name;
3436 const char *prefix;
3437 int end_prefix;
3439 struct stat s;
3440 char *cmd;
3442 cmd = xmalloc (strlen (prefix)
3443 + strlen (prog_name)
3444 #ifdef HAVE_EXECUTABLE_SUFFIX
3445 + strlen (EXECUTABLE_SUFFIX)
3446 #endif
3447 + 10);
3448 strcpy (cmd, prefix);
3450 sprintf (cmd + end_prefix, "%s", prog_name);
3452 if (strchr (cmd, '/') != NULL)
3454 int found;
3456 found = (stat (cmd, &s) == 0
3457 #ifdef HAVE_EXECUTABLE_SUFFIX
3458 || stat (strcat (cmd, EXECUTABLE_SUFFIX), &s) == 0
3459 #endif
3462 if (! found)
3464 /* xgettext:c-format */
3465 inform (_("Tried file: %s"), cmd);
3466 free (cmd);
3467 return NULL;
3471 /* xgettext:c-format */
3472 inform (_("Using file: %s"), cmd);
3474 return cmd;
3477 /* Deduce the name of the program we are want to invoke.
3478 PROG_NAME is the basic name of the program we want to run,
3479 eg "as" or "ld". The catch is that we might want actually
3480 run "i386-pe-as" or "ppc-pe-ld".
3482 If argv[0] contains the full path, then try to find the program
3483 in the same place, with and then without a target-like prefix.
3485 Given, argv[0] = /usr/local/bin/i586-cygwin32-dlltool,
3486 deduce_name("as") uses the following search order:
3488 /usr/local/bin/i586-cygwin32-as
3489 /usr/local/bin/as
3492 If there's an EXECUTABLE_SUFFIX, it'll use that as well; for each
3493 name, it'll try without and then with EXECUTABLE_SUFFIX.
3495 Given, argv[0] = i586-cygwin32-dlltool, it will not even try "as"
3496 as the fallback, but rather return i586-cygwin32-as.
3498 Oh, and given, argv[0] = dlltool, it'll return "as".
3500 Returns a dynamically allocated string. */
3502 static char *
3503 deduce_name (prog_name)
3504 const char *prog_name;
3506 char *cmd;
3507 char *dash, *slash, *cp;
3509 dash = NULL;
3510 slash = NULL;
3511 for (cp = program_name; *cp != '\0'; ++cp)
3513 if (*cp == '-')
3514 dash = cp;
3515 if (
3516 #if defined(__DJGPP__) || defined (__CYGWIN__) || defined(__WIN32__)
3517 *cp == ':' || *cp == '\\' ||
3518 #endif
3519 *cp == '/')
3521 slash = cp;
3522 dash = NULL;
3526 cmd = NULL;
3528 if (dash != NULL)
3530 /* First, try looking for a prefixed PROG_NAME in the
3531 PROGRAM_NAME directory, with the same prefix as PROGRAM_NAME. */
3532 cmd = look_for_prog (prog_name, program_name, dash - program_name + 1);
3535 if (slash != NULL && cmd == NULL)
3537 /* Next, try looking for a PROG_NAME in the same directory as
3538 that of this program. */
3539 cmd = look_for_prog (prog_name, program_name, slash - program_name + 1);
3542 if (cmd == NULL)
3544 /* Just return PROG_NAME as is. */
3545 cmd = xstrdup (prog_name);
3548 return cmd;
3551 #ifdef DLLTOOL_MCORE_ELF
3552 typedef struct fname_cache
3554 char * filename;
3555 struct fname_cache * next;
3557 fname_cache;
3559 static fname_cache fnames;
3561 static void
3562 mcore_elf_cache_filename (char * filename)
3564 fname_cache * ptr;
3566 ptr = & fnames;
3568 while (ptr->next != NULL)
3569 ptr = ptr->next;
3571 ptr->filename = filename;
3572 ptr->next = (fname_cache *) malloc (sizeof (fname_cache));
3573 if (ptr->next != NULL)
3574 ptr->next->next = NULL;
3577 #define MCORE_ELF_TMP_OBJ "mcoreelf.o"
3578 #define MCORE_ELF_TMP_EXP "mcoreelf.exp"
3579 #define MCORE_ELF_TMP_LIB "mcoreelf.lib"
3581 static void
3582 mcore_elf_gen_out_file (void)
3584 fname_cache * ptr;
3585 dyn_string_t ds;
3587 /* Step one. Run 'ld -r' on the input object files in order to resolve
3588 any internal references and to generate a single .exports section. */
3589 ptr = & fnames;
3591 ds = dyn_string_new (100);
3592 dyn_string_append (ds, "-r ");
3594 if (mcore_elf_linker_flags != NULL)
3595 dyn_string_append (ds, mcore_elf_linker_flags);
3597 while (ptr->next != NULL)
3599 dyn_string_append (ds, ptr->filename);
3600 dyn_string_append (ds, " ");
3602 ptr = ptr->next;
3605 dyn_string_append (ds, "-o ");
3606 dyn_string_append (ds, MCORE_ELF_TMP_OBJ);
3608 if (mcore_elf_linker == NULL)
3609 mcore_elf_linker = deduce_name ("ld");
3611 run (mcore_elf_linker, ds->s);
3613 dyn_string_delete (ds);
3615 /* Step two. Create a .exp file and a .lib file from the temporary file.
3616 Do this by recursively invoking dlltool... */
3617 ds = dyn_string_new (100);
3619 dyn_string_append (ds, "-S ");
3620 dyn_string_append (ds, as_name);
3622 dyn_string_append (ds, " -e ");
3623 dyn_string_append (ds, MCORE_ELF_TMP_EXP);
3624 dyn_string_append (ds, " -l ");
3625 dyn_string_append (ds, MCORE_ELF_TMP_LIB);
3626 dyn_string_append (ds, " " );
3627 dyn_string_append (ds, MCORE_ELF_TMP_OBJ);
3629 if (verbose)
3630 dyn_string_append (ds, " -v");
3632 if (dontdeltemps)
3634 dyn_string_append (ds, " -n");
3636 if (dontdeltemps > 1)
3637 dyn_string_append (ds, " -n");
3640 /* XXX - FIME: ought to check/copy other command line options as well. */
3641 run (program_name, ds->s);
3643 dyn_string_delete (ds);
3645 /* Step four. Feed the .exp and object files to ld -shared to create the dll. */
3646 ds = dyn_string_new (100);
3648 dyn_string_append (ds, "-shared ");
3650 if (mcore_elf_linker_flags)
3651 dyn_string_append (ds, mcore_elf_linker_flags);
3653 dyn_string_append (ds, " ");
3654 dyn_string_append (ds, MCORE_ELF_TMP_EXP);
3655 dyn_string_append (ds, " ");
3656 dyn_string_append (ds, MCORE_ELF_TMP_OBJ);
3657 dyn_string_append (ds, " -o ");
3658 dyn_string_append (ds, mcore_elf_out_file);
3660 run (mcore_elf_linker, ds->s);
3662 dyn_string_delete (ds);
3664 if (dontdeltemps == 0)
3665 unlink (MCORE_ELF_TMP_EXP);
3667 if (dontdeltemps < 2)
3668 unlink (MCORE_ELF_TMP_OBJ);
3670 #endif /* DLLTOOL_MCORE_ELF */