1 /* dlltool.c -- tool to generate stuff for PE style DLLs
2 Copyright (C) 1995-2016 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 /* This program allows you to build the files necessary to create
23 DLLs to run on a system which understands PE format image files.
26 See "Peering Inside the PE: A Tour of the Win32 Portable Executable
27 File Format", MSJ 1994, Volume 9 for more information.
28 Also see "Microsoft Portable Executable and Common Object File Format,
29 Specification 4.1" for more information.
31 A DLL contains an export table which contains the information
32 which the runtime loader needs to tie up references from a
35 The export table is generated by this program by reading
36 in a .DEF file or scanning the .a and .o files which will be in the
37 DLL. A .o file can contain information in special ".drectve" sections
38 with export information.
40 A DEF file contains any number of the following commands:
43 NAME <name> [ , <base> ]
44 The result is going to be <name>.EXE
46 LIBRARY <name> [ , <base> ]
47 The result is going to be <name>.DLL
49 EXPORTS ( ( ( <name1> [ = <name2> ] )
50 | ( <name1> = <module-name> . <external-name>))
51 [ @ <integer> ] [ NONAME ] [CONSTANT] [DATA] [PRIVATE] ) *
52 Declares name1 as an exported symbol from the
53 DLL, with optional ordinal number <integer>.
54 Or declares name1 as an alias (forward) of the function <external-name>
55 in the DLL <module-name>.
57 IMPORTS ( ( <internal-name> = <module-name> . <integer> )
58 | ( [ <internal-name> = ] <module-name> . <external-name> )) *
59 Declares that <external-name> or the exported function whose ordinal number
60 is <integer> is to be imported from the file <module-name>. If
61 <internal-name> is specified then this is the name that the imported
62 function will be refereed to in the body of the DLL.
65 Puts <string> into output .exp file in the .rdata section
67 [STACKSIZE|HEAPSIZE] <number-reserve> [ , <number-commit> ]
68 Generates --stack|--heap <number-reserve>,<number-commit>
69 in the output .drectve section. The linker will
70 see this and act upon it.
73 SECTIONS ( <sectionname> <attr>+ )*
74 <attr> = READ | WRITE | EXECUTE | SHARED
75 Generates --attr <sectionname> <attr> in the output
76 .drectve section. The linker will see this and act
80 A -export:<name> in a .drectve section in an input .o or .a
81 file to this program is equivalent to a EXPORTS <name>
86 The program generates output files with the prefix supplied
87 on the command line, or in the def file, or taken from the first
90 The .exp.s file contains the information necessary to export
91 the routines in the DLL. The .lib.s file contains the information
92 necessary to use the DLL's routines from a referencing program.
99 asm (".section .drectve");
100 asm (".ascii \"-export:adef\"");
104 printf ("hello from the dll %s\n", s);
109 printf ("hello from the dll and the other entry point %s\n", s);
113 asm (".section .drectve");
114 asm (".ascii \"-export:cdef\"");
115 asm (".ascii \"-export:ddef\"");
119 printf ("hello from the dll %s\n", s);
124 printf ("hello from the dll and the other entry point %s\n", s);
142 HEAPSIZE 0x40000, 0x2000
146 SECTIONS donkey READ WRITE
149 # Compile up the parts of the dll and the program
151 gcc -c file1.c file2.c themain.c
153 # Optional: put the dll objects into a library
154 # (you don't have to, you could name all the object
155 # files on the dlltool line)
157 ar qcv thedll.in file1.o file2.o
160 # Run this tool over the DLL's .def file and generate an exports
161 # file (thedll.o) and an imports file (thedll.a).
162 # (You may have to use -S to tell dlltool where to find the assembler).
164 dlltool --def thedll.def --output-exp thedll.o --output-lib thedll.a
166 # Build the dll with the library and the export table
168 ld -o thedll.dll thedll.o thedll.in
170 # Link the executable with the import library
172 gcc -o themain.exe themain.o thedll.a
174 This example can be extended if relocations are needed in the DLL:
176 # Compile up the parts of the dll and the program
178 gcc -c file1.c file2.c themain.c
180 # Run this tool over the DLL's .def file and generate an imports file.
182 dlltool --def thedll.def --output-lib thedll.lib
184 # Link the executable with the import library and generate a base file
187 gcc -o themain.exe themain.o thedll.lib -Wl,--base-file -Wl,themain.base
189 # Run this tool over the DLL's .def file and generate an exports file
190 # which includes the relocations from the base file.
192 dlltool --def thedll.def --base-file themain.base --output-exp thedll.exp
194 # Build the dll with file1.o, file2.o and the export table
196 ld -o thedll.dll thedll.exp file1.o file2.o */
198 /* .idata section description
200 The .idata section is the import table. It is a collection of several
201 subsections used to keep the pieces for each dll together: .idata$[234567].
202 IE: Each dll's .idata$2's are catenated together, each .idata$3's, etc.
204 .idata$2 = Import Directory Table
205 = array of IMAGE_IMPORT_DESCRIPTOR's.
207 DWORD Import Lookup Table; - pointer to .idata$4
208 DWORD TimeDateStamp; - currently always 0
209 DWORD ForwarderChain; - currently always 0
210 DWORD Name; - pointer to dll's name
211 PIMAGE_THUNK_DATA FirstThunk; - pointer to .idata$5
213 .idata$3 = null terminating entry for .idata$2.
215 .idata$4 = Import Lookup Table
216 = array of array of pointers to hint name table.
217 There is one for each dll being imported from, and each dll's set is
218 terminated by a trailing NULL.
220 .idata$5 = Import Address Table
221 = array of array of pointers to hint name table.
222 There is one for each dll being imported from, and each dll's set is
223 terminated by a trailing NULL.
224 Initially, this table is identical to the Import Lookup Table. However,
225 at load time, the loader overwrites the entries with the address of the
228 .idata$6 = Hint Name Table
229 = Array of { short, asciz } entries, one for each imported function.
230 The `short' is the function's ordinal number.
232 .idata$7 = dll name (eg: "kernel32.dll"). (.idata$6 for ppc). */
236 #include "libiberty.h"
238 #include "demangle.h"
239 #include "dyn-string.h"
242 #include "safe-ctype.h"
248 #include "coff/arm.h"
249 #include "coff/internal.h"
251 #ifdef DLLTOOL_DEFAULT_MX86_64
252 #include "coff/x86_64.h"
254 #ifdef DLLTOOL_DEFAULT_I386
255 #include "coff/i386.h"
258 #ifndef COFF_PAGE_SIZE
259 #define COFF_PAGE_SIZE ((bfd_vma) 4096)
263 #define PAGE_MASK ((bfd_vma) (- COFF_PAGE_SIZE))
266 /* Get current BFD error message. */
267 #define bfd_get_errmsg() (bfd_errmsg (bfd_get_error ()))
269 /* Forward references. */
270 static char *look_for_prog (const char *, const char *, int);
271 static char *deduce_name (const char *);
273 #ifdef DLLTOOL_MCORE_ELF
274 static void mcore_elf_cache_filename (const char *);
275 static void mcore_elf_gen_out_file (void);
278 #ifdef HAVE_SYS_WAIT_H
279 #include <sys/wait.h>
280 #else /* ! HAVE_SYS_WAIT_H */
281 #if ! defined (_WIN32) || defined (__CYGWIN32__)
283 #define WIFEXITED(w) (((w) & 0377) == 0)
286 #define WIFSIGNALED(w) (((w) & 0377) != 0177 && ((w) & ~0377) == 0)
289 #define WTERMSIG(w) ((w) & 0177)
292 #define WEXITSTATUS(w) (((w) >> 8) & 0377)
294 #else /* defined (_WIN32) && ! defined (__CYGWIN32__) */
296 #define WIFEXITED(w) (((w) & 0xff) == 0)
299 #define WIFSIGNALED(w) (((w) & 0xff) != 0 && ((w) & 0xff) != 0x7f)
302 #define WTERMSIG(w) ((w) & 0x7f)
305 #define WEXITSTATUS(w) (((w) & 0xff00) >> 8)
307 #endif /* defined (_WIN32) && ! defined (__CYGWIN32__) */
308 #endif /* ! HAVE_SYS_WAIT_H */
310 #define show_allnames 0
312 /* ifunc and ihead data structures: ttk@cygnus.com 1997
314 When IMPORT declarations are encountered in a .def file the
315 function import information is stored in a structure referenced by
316 the global variable IMPORT_LIST. The structure is a linked list
317 containing the names of the dll files each function is imported
318 from and a linked list of functions being imported from that dll
319 file. This roughly parallels the structure of the .idata section
320 in the PE object file.
322 The contents of .def file are interpreted from within the
323 process_def_file function. Every time an IMPORT declaration is
324 encountered, it is broken up into its component parts and passed to
325 def_import. IMPORT_LIST is initialized to NULL in function main. */
327 typedef struct ifunct
329 char * name; /* Name of function being imported. */
330 char * its_name; /* Optional import table symbol name. */
331 int ord; /* Two-byte ordinal value associated with function. */
335 typedef struct iheadt
337 char * dllname; /* Name of dll file imported from. */
338 long nfuncs; /* Number of functions in list. */
339 struct ifunct *funchead; /* First function in list. */
340 struct ifunct *functail; /* Last function in list. */
341 struct iheadt *next; /* Next dll file in list. */
344 /* Structure containing all import information as defined in .def file
345 (qv "ihead structure"). */
347 static iheadtype *import_list = NULL;
348 static char *as_name = NULL;
349 static char * as_flags = "";
350 static char *tmp_prefix;
351 static int no_idata4;
352 static int no_idata5;
353 static char *exp_name;
354 static char *imp_name;
355 static char *delayimp_name;
356 static char *identify_imp_name;
357 static bfd_boolean identify_strict;
359 /* Types used to implement a linked list of dllnames associated
360 with the specified import lib. Used by the identify_* code.
361 The head entry is acts as a sentinal node and is always empty
362 (head->dllname is NULL). */
363 typedef struct dll_name_list_node_t
366 struct dll_name_list_node_t * next;
367 } dll_name_list_node_type;
369 typedef struct dll_name_list_t
371 dll_name_list_node_type * head;
372 dll_name_list_node_type * tail;
373 } dll_name_list_type;
375 /* Types used to pass data to iterator functions. */
376 typedef struct symname_search_data_t
378 const char * symname;
380 } symname_search_data_type;
382 typedef struct identify_data_t
384 dll_name_list_type * list;
385 bfd_boolean ms_style_implib;
386 } identify_data_type;
389 static char *head_label;
390 static char *imp_name_lab;
391 static char *dll_name;
392 static int dll_name_set_by_exp_name;
393 static int add_indirect = 0;
394 static int add_underscore = 0;
395 static int add_stdcall_underscore = 0;
396 /* This variable can hold three different values. The value
397 -1 (default) means that default underscoring should be used,
398 zero means that no underscoring should be done, and one
399 indicates that underscoring should be done. */
400 static int leading_underscore = -1;
401 static int dontdeltemps = 0;
403 /* TRUE if we should export all symbols. Otherwise, we only export
404 symbols listed in .drectve sections or in the def file. */
405 static bfd_boolean export_all_symbols;
407 /* TRUE if we should exclude the symbols in DEFAULT_EXCLUDES when
408 exporting all symbols. */
409 static bfd_boolean do_default_excludes = TRUE;
411 static bfd_boolean use_nul_prefixed_import_tables = FALSE;
413 /* Default symbols to exclude when exporting all the symbols. */
414 static const char *default_excludes = "DllMain@12,DllEntryPoint@0,impure_ptr";
416 /* TRUE if we should add __imp_<SYMBOL> to import libraries for backward
417 compatibility to old Cygwin releases. */
418 static bfd_boolean create_compat_implib;
420 /* TRUE if we have to write PE+ import libraries. */
421 static bfd_boolean create_for_pep;
423 static char *def_file;
425 extern char * program_name;
429 static int add_stdcall_alias;
430 static const char *ext_prefix_alias;
432 static FILE *output_def;
433 static FILE *base_file;
435 #ifdef DLLTOOL_DEFAULT_ARM
436 static const char *mname = "arm";
439 #ifdef DLLTOOL_DEFAULT_ARM_EPOC
440 static const char *mname = "arm-epoc";
443 #ifdef DLLTOOL_DEFAULT_ARM_WINCE
444 static const char *mname = "arm-wince";
447 #ifdef DLLTOOL_DEFAULT_I386
448 static const char *mname = "i386";
451 #ifdef DLLTOOL_DEFAULT_MX86_64
452 static const char *mname = "i386:x86-64";
455 #ifdef DLLTOOL_DEFAULT_PPC
456 static const char *mname = "ppc";
459 #ifdef DLLTOOL_DEFAULT_SH
460 static const char *mname = "sh";
463 #ifdef DLLTOOL_DEFAULT_MIPS
464 static const char *mname = "mips";
467 #ifdef DLLTOOL_DEFAULT_MCORE
468 static const char * mname = "mcore-le";
471 #ifdef DLLTOOL_DEFAULT_MCORE_ELF
472 static const char * mname = "mcore-elf";
473 static char * mcore_elf_out_file = NULL;
474 static char * mcore_elf_linker = NULL;
475 static char * mcore_elf_linker_flags = NULL;
477 #define DRECTVE_SECTION_NAME ((machine == MMCORE_ELF || machine == MMCORE_ELF_LE) ? ".exports" : ".drectve")
480 #ifndef DRECTVE_SECTION_NAME
481 #define DRECTVE_SECTION_NAME ".drectve"
484 /* What's the right name for this ? */
487 /* External name alias numbering starts here. */
488 #define PREFIX_ALIAS_BASE 20000
491 char *tmp_head_s_buf;
492 char *tmp_head_o_buf;
493 char *tmp_tail_s_buf;
494 char *tmp_tail_o_buf;
497 #define TMP_ASM dlltmp (&tmp_asm_buf, "%sc.s")
498 #define TMP_HEAD_S dlltmp (&tmp_head_s_buf, "%sh.s")
499 #define TMP_HEAD_O dlltmp (&tmp_head_o_buf, "%sh.o")
500 #define TMP_TAIL_S dlltmp (&tmp_tail_s_buf, "%st.s")
501 #define TMP_TAIL_O dlltmp (&tmp_tail_o_buf, "%st.o")
502 #define TMP_STUB dlltmp (&tmp_stub_buf, "%ss")
504 /* This bit of assembly does jmp * .... */
505 static const unsigned char i386_jtab[] =
507 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
510 static const unsigned char i386_dljtab[] =
512 0xFF, 0x25, 0x00, 0x00, 0x00, 0x00, /* jmp __imp__function */
513 0xB8, 0x00, 0x00, 0x00, 0x00, /* mov eax, offset __imp__function */
514 0xE9, 0x00, 0x00, 0x00, 0x00 /* jmp __tailMerge__dllname */
517 static const unsigned char i386_x64_dljtab[] =
519 0xFF, 0x25, 0x00, 0x00, 0x00, 0x00, /* jmp __imp__function */
520 0x48, 0x8d, 0x05, /* leaq rax, (__imp__function) */
521 0x00, 0x00, 0x00, 0x00,
522 0xE9, 0x00, 0x00, 0x00, 0x00 /* jmp __tailMerge__dllname */
525 static const unsigned char arm_jtab[] =
527 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
528 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
532 static const unsigned char arm_interwork_jtab[] =
534 0x04, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
535 0x00, 0xc0, 0x9c, 0xe5, /* ldr ip, [ip] */
536 0x1c, 0xff, 0x2f, 0xe1, /* bx ip */
540 static const unsigned char thumb_jtab[] =
542 0x40, 0xb4, /* push {r6} */
543 0x02, 0x4e, /* ldr r6, [pc, #8] */
544 0x36, 0x68, /* ldr r6, [r6] */
545 0xb4, 0x46, /* mov ip, r6 */
546 0x40, 0xbc, /* pop {r6} */
547 0x60, 0x47, /* bx ip */
551 static const unsigned char mcore_be_jtab[] =
553 0x71, 0x02, /* lrw r1,2 */
554 0x81, 0x01, /* ld.w r1,(r1,0) */
555 0x00, 0xC1, /* jmp r1 */
556 0x12, 0x00, /* nop */
557 0x00, 0x00, 0x00, 0x00 /* <address> */
560 static const unsigned char mcore_le_jtab[] =
562 0x02, 0x71, /* lrw r1,2 */
563 0x01, 0x81, /* ld.w r1,(r1,0) */
564 0xC1, 0x00, /* jmp r1 */
565 0x00, 0x12, /* nop */
566 0x00, 0x00, 0x00, 0x00 /* <address> */
569 /* This is the glue sequence for PowerPC PE. There is a
570 tocrel16-tocdefn reloc against the first instruction.
571 We also need a IMGLUE reloc against the glue function
572 to restore the toc saved by the third instruction in
574 static const unsigned char ppc_jtab[] =
576 0x00, 0x00, 0x62, 0x81, /* lwz r11,0(r2) */
577 /* Reloc TOCREL16 __imp_xxx */
578 0x00, 0x00, 0x8B, 0x81, /* lwz r12,0(r11) */
579 0x04, 0x00, 0x41, 0x90, /* stw r2,4(r1) */
580 0xA6, 0x03, 0x89, 0x7D, /* mtctr r12 */
581 0x04, 0x00, 0x4B, 0x80, /* lwz r2,4(r11) */
582 0x20, 0x04, 0x80, 0x4E /* bctr */
586 /* The glue instruction, picks up the toc from the stw in
587 the above code: "lwz r2,4(r1)". */
588 static bfd_vma ppc_glue_insn = 0x80410004;
591 static const char i386_trampoline[] =
595 "\tpushl $__DELAY_IMPORT_DESCRIPTOR_%s\n"
596 "\tcall ___delayLoadHelper2@8\n"
601 static const char i386_x64_trampoline[] =
606 "\tsubq $40, %%rsp\n"
607 "\tmovq %%rax, %%rdx\n"
608 "\tleaq __DELAY_IMPORT_DESCRIPTOR_%s(%%rip), %%rcx\n"
609 "\tcall __delayLoadHelper2\n"
610 "\taddq $40, %%rsp\n"
620 const char *how_byte;
621 const char *how_short;
622 const char *how_long;
623 const char *how_asciz;
624 const char *how_comment;
625 const char *how_jump;
626 const char *how_global;
627 const char *how_space;
628 const char *how_align_short;
629 const char *how_align_long;
630 const char *how_default_as_switches;
631 const char *how_bfd_target;
632 enum bfd_architecture how_bfd_arch;
633 const unsigned char *how_jtab;
634 int how_jtab_size; /* Size of the jtab entry. */
635 int how_jtab_roff; /* Offset into it for the ind 32 reloc into idata 5. */
636 const unsigned char *how_dljtab;
637 int how_dljtab_size; /* Size of the dljtab entry. */
638 int how_dljtab_roff1; /* Offset for the ind 32 reloc into idata 5. */
639 int how_dljtab_roff2; /* Offset for the ind 32 reloc into idata 5. */
640 int how_dljtab_roff3; /* Offset for the ind 32 reloc into idata 5. */
641 const char *trampoline;
644 static const struct mac
649 "arm", ".byte", ".short", ".long", ".asciz", "@",
650 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
651 ".global", ".space", ".align\t2",".align\t4", "-mapcs-32",
652 "pe-arm-little", bfd_arch_arm,
653 arm_jtab, sizeof (arm_jtab), 8,
659 "i386", ".byte", ".short", ".long", ".asciz", "#",
660 "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
661 "pe-i386",bfd_arch_i386,
662 i386_jtab, sizeof (i386_jtab), 2,
663 i386_dljtab, sizeof (i386_dljtab), 2, 7, 12, i386_trampoline
668 "ppc", ".byte", ".short", ".long", ".asciz", "#",
669 "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
670 "pe-powerpcle",bfd_arch_powerpc,
671 ppc_jtab, sizeof (ppc_jtab), 0,
677 "thumb", ".byte", ".short", ".long", ".asciz", "@",
678 "push\t{r6}\n\tldr\tr6, [pc, #8]\n\tldr\tr6, [r6]\n\tmov\tip, r6\n\tpop\t{r6}\n\tbx\tip",
679 ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
680 "pe-arm-little", bfd_arch_arm,
681 thumb_jtab, sizeof (thumb_jtab), 12,
685 #define MARM_INTERWORK 4
687 "arm_interwork", ".byte", ".short", ".long", ".asciz", "@",
688 "ldr\tip,[pc]\n\tldr\tip,[ip]\n\tbx\tip\n\t.long",
689 ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
690 "pe-arm-little", bfd_arch_arm,
691 arm_interwork_jtab, sizeof (arm_interwork_jtab), 12,
697 "mcore-be", ".byte", ".short", ".long", ".asciz", "//",
698 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
699 ".global", ".space", ".align\t2",".align\t4", "",
700 "pe-mcore-big", bfd_arch_mcore,
701 mcore_be_jtab, sizeof (mcore_be_jtab), 8,
707 "mcore-le", ".byte", ".short", ".long", ".asciz", "//",
708 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
709 ".global", ".space", ".align\t2",".align\t4", "-EL",
710 "pe-mcore-little", bfd_arch_mcore,
711 mcore_le_jtab, sizeof (mcore_le_jtab), 8,
717 "mcore-elf-be", ".byte", ".short", ".long", ".asciz", "//",
718 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
719 ".global", ".space", ".align\t2",".align\t4", "",
720 "elf32-mcore-big", bfd_arch_mcore,
721 mcore_be_jtab, sizeof (mcore_be_jtab), 8,
726 #define MMCORE_ELF_LE 8
727 "mcore-elf-le", ".byte", ".short", ".long", ".asciz", "//",
728 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
729 ".global", ".space", ".align\t2",".align\t4", "-EL",
730 "elf32-mcore-little", bfd_arch_mcore,
731 mcore_le_jtab, sizeof (mcore_le_jtab), 8,
737 "arm-epoc", ".byte", ".short", ".long", ".asciz", "@",
738 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
739 ".global", ".space", ".align\t2",".align\t4", "",
740 "epoc-pe-arm-little", bfd_arch_arm,
741 arm_jtab, sizeof (arm_jtab), 8,
746 #define MARM_WINCE 10
747 "arm-wince", ".byte", ".short", ".long", ".asciz", "@",
748 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
749 ".global", ".space", ".align\t2",".align\t4", "-mapcs-32",
750 "pe-arm-wince-little", bfd_arch_arm,
751 arm_jtab, sizeof (arm_jtab), 8,
757 "i386:x86-64", ".byte", ".short", ".long", ".asciz", "#",
758 "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
759 "pe-x86-64",bfd_arch_i386,
760 i386_jtab, sizeof (i386_jtab), 2,
761 i386_x64_dljtab, sizeof (i386_x64_dljtab), 2, 9, 14, i386_x64_trampoline
764 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
774 typedef struct export
777 const char *internal_name;
778 const char *import_name;
779 const char *its_name;
782 int noname; /* Don't put name in image file. */
783 int private; /* Don't put reference in import lib. */
786 int forward; /* Number of forward label, 0 means no forward. */
791 /* A list of symbols which we should not export. */
795 struct string_list *next;
799 static struct string_list *excludes;
801 static const char *rvaafter (int);
802 static const char *rvabefore (int);
803 static const char *asm_prefix (int, const char *);
804 static void process_def_file (const char *);
805 static void new_directive (char *);
806 static void append_import (const char *, const char *, int, const char *);
807 static void run (const char *, char *);
808 static void scan_drectve_symbols (bfd *);
809 static void scan_filtered_symbols (bfd *, void *, long, unsigned int);
810 static void add_excludes (const char *);
811 static bfd_boolean match_exclude (const char *);
812 static void set_default_excludes (void);
813 static long filter_symbols (bfd *, void *, long, unsigned int);
814 static void scan_all_symbols (bfd *);
815 static void scan_open_obj_file (bfd *);
816 static void scan_obj_file (const char *);
817 static void dump_def_info (FILE *);
818 static int sfunc (const void *, const void *);
819 static void flush_page (FILE *, bfd_vma *, bfd_vma, int);
820 static void gen_def_file (void);
821 static void generate_idata_ofile (FILE *);
822 static void assemble_file (const char *, const char *);
823 static void gen_exp_file (void);
824 static const char *xlate (const char *);
825 static char *make_label (const char *, const char *);
826 static char *make_imp_label (const char *, const char *);
827 static bfd *make_one_lib_file (export_type *, int, int);
828 static bfd *make_head (void);
829 static bfd *make_tail (void);
830 static bfd *make_delay_head (void);
831 static void gen_lib_file (int);
832 static void dll_name_list_append (dll_name_list_type *, bfd_byte *);
833 static int dll_name_list_count (dll_name_list_type *);
834 static void dll_name_list_print (dll_name_list_type *);
835 static void dll_name_list_free_contents (dll_name_list_node_type *);
836 static void dll_name_list_free (dll_name_list_type *);
837 static dll_name_list_type * dll_name_list_create (void);
838 static void identify_dll_for_implib (void);
839 static void identify_search_archive
840 (bfd *, void (*) (bfd *, bfd *, void *), void *);
841 static void identify_search_member (bfd *, bfd *, void *);
842 static bfd_boolean identify_process_section_p (asection *, bfd_boolean);
843 static void identify_search_section (bfd *, asection *, void *);
844 static void identify_member_contains_symname (bfd *, bfd *, void *);
846 static int pfunc (const void *, const void *);
847 static int nfunc (const void *, const void *);
848 static void remove_null_names (export_type **);
849 static void process_duplicates (export_type **);
850 static void fill_ordinals (export_type **);
851 static void mangle_defs (void);
852 static void usage (FILE *, int);
853 static void inform (const char *, ...) ATTRIBUTE_PRINTF_1;
854 static void set_dll_name_from_def (const char *name, char is_dll);
857 prefix_encode (char *start, unsigned code)
859 static char alpha[26] = "abcdefghijklmnopqrstuvwxyz";
863 p = strchr (buf, '\0');
865 *p++ = alpha[code % sizeof (alpha)];
866 while ((code /= sizeof (alpha)) != 0);
872 dlltmp (char **buf, const char *fmt)
876 *buf = malloc (strlen (tmp_prefix) + 64);
877 sprintf (*buf, fmt, tmp_prefix);
883 inform (const char * message, ...)
887 va_start (args, message);
892 report (message, args);
916 /* xgettext:c-format */
917 fatal (_("Internal error: Unknown machine type: %d"), mach);
942 /* xgettext:c-format */
943 fatal (_("Internal error: Unknown machine type: %d"), mach);
950 asm_prefix (int mach, const char *name)
967 /* Symbol names starting with ? do not have a leading underscore. */
968 if ((name && *name == '?') || leading_underscore == 0)
973 /* xgettext:c-format */
974 fatal (_("Internal error: Unknown machine type: %d"), mach);
980 #define ASM_BYTE mtable[machine].how_byte
981 #define ASM_SHORT mtable[machine].how_short
982 #define ASM_LONG mtable[machine].how_long
983 #define ASM_TEXT mtable[machine].how_asciz
984 #define ASM_C mtable[machine].how_comment
985 #define ASM_JUMP mtable[machine].how_jump
986 #define ASM_GLOBAL mtable[machine].how_global
987 #define ASM_SPACE mtable[machine].how_space
988 #define ASM_ALIGN_SHORT mtable[machine].how_align_short
989 #define ASM_RVA_BEFORE rvabefore (machine)
990 #define ASM_RVA_AFTER rvaafter (machine)
991 #define ASM_PREFIX(NAME) asm_prefix (machine, (NAME))
992 #define ASM_ALIGN_LONG mtable[machine].how_align_long
993 #define HOW_BFD_READ_TARGET 0 /* Always default. */
994 #define HOW_BFD_WRITE_TARGET mtable[machine].how_bfd_target
995 #define HOW_BFD_ARCH mtable[machine].how_bfd_arch
996 #define HOW_JTAB (delay ? mtable[machine].how_dljtab \
997 : mtable[machine].how_jtab)
998 #define HOW_JTAB_SIZE (delay ? mtable[machine].how_dljtab_size \
999 : mtable[machine].how_jtab_size)
1000 #define HOW_JTAB_ROFF (delay ? mtable[machine].how_dljtab_roff1 \
1001 : mtable[machine].how_jtab_roff)
1002 #define HOW_JTAB_ROFF2 (delay ? mtable[machine].how_dljtab_roff2 : 0)
1003 #define HOW_JTAB_ROFF3 (delay ? mtable[machine].how_dljtab_roff3 : 0)
1004 #define ASM_SWITCHES mtable[machine].how_default_as_switches
1009 process_def_file (const char *name)
1011 FILE *f = fopen (name, FOPEN_RT);
1014 /* xgettext:c-format */
1015 fatal (_("Can't open def file: %s"), name);
1019 /* xgettext:c-format */
1020 inform (_("Processing def file: %s"), name);
1024 inform (_("Processed def file"));
1027 /**********************************************************************/
1029 /* Communications with the parser. */
1031 static int d_nfuncs; /* Number of functions exported. */
1032 static int d_named_nfuncs; /* Number of named functions exported. */
1033 static int d_low_ord; /* Lowest ordinal index. */
1034 static int d_high_ord; /* Highest ordinal index. */
1035 static export_type *d_exports; /* List of exported functions. */
1036 static export_type **d_exports_lexically; /* Vector of exported functions in alpha order. */
1037 static dlist_type *d_list; /* Descriptions. */
1038 static dlist_type *a_list; /* Stuff to go in directives. */
1039 static int d_nforwards = 0; /* Number of forwarded exports. */
1041 static int d_is_dll;
1042 static int d_is_exe;
1045 yyerror (const char * err ATTRIBUTE_UNUSED)
1047 /* xgettext:c-format */
1048 non_fatal (_("Syntax error in def file %s:%d"), def_file, linenumber);
1054 def_exports (const char *name, const char *internal_name, int ordinal,
1055 int noname, int constant, int data, int private,
1056 const char *its_name)
1058 struct export *p = (struct export *) xmalloc (sizeof (*p));
1061 p->internal_name = internal_name ? internal_name : name;
1062 p->its_name = its_name;
1063 p->import_name = name;
1064 p->ordinal = ordinal;
1065 p->constant = constant;
1067 p->private = private;
1069 p->next = d_exports;
1073 if ((internal_name != NULL)
1074 && (strchr (internal_name, '.') != NULL))
1075 p->forward = ++d_nforwards;
1077 p->forward = 0; /* no forward */
1081 set_dll_name_from_def (const char *name, char is_dll)
1083 const char *image_basename = lbasename (name);
1084 if (image_basename != name)
1085 non_fatal (_("%s: Path components stripped from image name, '%s'."),
1087 /* Append the default suffix, if none specified. */
1088 if (strchr (image_basename, '.') == 0)
1090 const char * suffix = is_dll ? ".dll" : ".exe";
1092 dll_name = xmalloc (strlen (image_basename) + strlen (suffix) + 1);
1093 sprintf (dll_name, "%s%s", image_basename, suffix);
1096 dll_name = xstrdup (image_basename);
1100 def_name (const char *name, int base)
1102 /* xgettext:c-format */
1103 inform (_("NAME: %s base: %x"), name, base);
1106 non_fatal (_("Can't have LIBRARY and NAME"));
1108 if (dll_name_set_by_exp_name && name && *name != 0)
1111 dll_name_set_by_exp_name = 0;
1113 /* If --dllname not provided, use the one in the DEF file.
1114 FIXME: Is this appropriate for executables? */
1116 set_dll_name_from_def (name, 0);
1121 def_library (const char *name, int base)
1123 /* xgettext:c-format */
1124 inform (_("LIBRARY: %s base: %x"), name, base);
1127 non_fatal (_("Can't have LIBRARY and NAME"));
1129 if (dll_name_set_by_exp_name && name && *name != 0)
1132 dll_name_set_by_exp_name = 0;
1135 /* If --dllname not provided, use the one in the DEF file. */
1137 set_dll_name_from_def (name, 1);
1142 def_description (const char *desc)
1144 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
1145 d->text = xstrdup (desc);
1151 new_directive (char *dir)
1153 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
1154 d->text = xstrdup (dir);
1160 def_heapsize (int reserve, int commit)
1164 sprintf (b, "-heap 0x%x,0x%x ", reserve, commit);
1166 sprintf (b, "-heap 0x%x ", reserve);
1167 new_directive (xstrdup (b));
1171 def_stacksize (int reserve, int commit)
1175 sprintf (b, "-stack 0x%x,0x%x ", reserve, commit);
1177 sprintf (b, "-stack 0x%x ", reserve);
1178 new_directive (xstrdup (b));
1181 /* append_import simply adds the given import definition to the global
1182 import_list. It is used by def_import. */
1185 append_import (const char *symbol_name, const char *dllname, int func_ordinal,
1186 const char *its_name)
1191 for (pq = &import_list; *pq != NULL; pq = &(*pq)->next)
1193 if (strcmp ((*pq)->dllname, dllname) == 0)
1196 q->functail->next = xmalloc (sizeof (ifunctype));
1197 q->functail = q->functail->next;
1198 q->functail->ord = func_ordinal;
1199 q->functail->name = xstrdup (symbol_name);
1200 q->functail->its_name = (its_name ? xstrdup (its_name) : NULL);
1201 q->functail->next = NULL;
1207 q = xmalloc (sizeof (iheadtype));
1208 q->dllname = xstrdup (dllname);
1210 q->funchead = xmalloc (sizeof (ifunctype));
1211 q->functail = q->funchead;
1213 q->functail->name = xstrdup (symbol_name);
1214 q->functail->its_name = (its_name ? xstrdup (its_name) : NULL);
1215 q->functail->ord = func_ordinal;
1216 q->functail->next = NULL;
1221 /* def_import is called from within defparse.y when an IMPORT
1222 declaration is encountered. Depending on the form of the
1223 declaration, the module name may or may not need ".dll" to be
1224 appended to it, the name of the function may be stored in internal
1225 or entry, and there may or may not be an ordinal value associated
1228 /* A note regarding the parse modes:
1229 In defparse.y we have to accept import declarations which follow
1230 any one of the following forms:
1231 <func_name_in_app> = <dll_name>.<func_name_in_dll>
1232 <func_name_in_app> = <dll_name>.<number>
1233 <dll_name>.<func_name_in_dll>
1235 Furthermore, the dll's name may or may not end with ".dll", which
1236 complicates the parsing a little. Normally the dll's name is
1237 passed to def_import() in the "module" parameter, but when it ends
1238 with ".dll" it gets passed in "module" sans ".dll" and that needs
1241 def_import gets five parameters:
1242 APP_NAME - the name of the function in the application, if
1243 present, or NULL if not present.
1244 MODULE - the name of the dll, possibly sans extension (ie, '.dll').
1245 DLLEXT - the extension of the dll, if present, NULL if not present.
1246 ENTRY - the name of the function in the dll, if present, or NULL.
1247 ORD_VAL - the numerical tag of the function in the dll, if present,
1248 or NULL. Exactly one of <entry> or <ord_val> must be
1249 present (i.e., not NULL). */
1252 def_import (const char *app_name, const char *module, const char *dllext,
1253 const char *entry, int ord_val, const char *its_name)
1255 const char *application_name;
1259 application_name = entry;
1262 if (app_name != NULL)
1263 application_name = app_name;
1265 application_name = "";
1269 module = buf = concat (module, ".", dllext, NULL);
1271 append_import (application_name, module, ord_val, its_name);
1278 def_version (int major, int minor)
1280 printf (_("VERSION %d.%d\n"), major, minor);
1284 def_section (const char *name, int attr)
1299 sprintf (buf, "-attr %s %s", name, atts);
1300 new_directive (xstrdup (buf));
1307 def_section ("CODE", attr);
1313 def_section ("DATA", attr);
1316 /**********************************************************************/
1319 run (const char *what, char *args)
1322 int pid, wait_status;
1325 char *errmsg_fmt, *errmsg_arg;
1326 char *temp_base = choose_temp_base ();
1328 inform (_("run: %s %s"), what, args);
1330 /* Count the args */
1332 for (s = args; *s; s++)
1336 argv = xmalloc (sizeof (char *) * (i + 3));
1345 while (*s != ' ' && *s != 0)
1353 pid = pexecute (argv[0], (char * const *) argv, program_name, temp_base,
1354 &errmsg_fmt, &errmsg_arg, PEXECUTE_ONE | PEXECUTE_SEARCH);
1359 inform ("%s", strerror (errno));
1361 fatal (errmsg_fmt, errmsg_arg);
1364 pid = pwait (pid, & wait_status, 0);
1368 /* xgettext:c-format */
1369 fatal (_("wait: %s"), strerror (errno));
1371 else if (WIFSIGNALED (wait_status))
1373 /* xgettext:c-format */
1374 fatal (_("subprocess got fatal signal %d"), WTERMSIG (wait_status));
1376 else if (WIFEXITED (wait_status))
1378 if (WEXITSTATUS (wait_status) != 0)
1379 /* xgettext:c-format */
1380 non_fatal (_("%s exited with status %d"),
1381 what, WEXITSTATUS (wait_status));
1387 /* Look for a list of symbols to export in the .drectve section of
1388 ABFD. Pass each one to def_exports. */
1391 scan_drectve_symbols (bfd *abfd)
1399 /* Look for .drectve's */
1400 s = bfd_get_section_by_name (abfd, DRECTVE_SECTION_NAME);
1405 size = bfd_get_section_size (s);
1406 buf = xmalloc (size);
1408 bfd_get_section_contents (abfd, s, buf, 0, size);
1410 /* xgettext:c-format */
1411 inform (_("Sucking in info from %s section in %s"),
1412 DRECTVE_SECTION_NAME, bfd_get_filename (abfd));
1414 /* Search for -export: strings. The exported symbols can optionally
1415 have type tags (eg., -export:foo,data), so handle those as well.
1416 Currently only data tag is supported. */
1422 && CONST_STRNEQ (p, "-export:"))
1426 flagword flags = BSF_FUNCTION;
1429 /* Do we have a quoted export? */
1434 while (p < e && *p != '"')
1440 while (p < e && *p != ',' && *p != ' ' && *p != '-')
1443 c = xmalloc (p - name + 1);
1444 memcpy (c, name, p - name);
1446 /* Advance over trailing quote. */
1447 if (p < e && *p == '"')
1449 if (p < e && *p == ',') /* found type tag. */
1451 char *tag_start = ++p;
1452 while (p < e && *p != ' ' && *p != '-')
1454 if (CONST_STRNEQ (tag_start, "data"))
1455 flags &= ~BSF_FUNCTION;
1458 /* FIXME: The 5th arg is for the `constant' field.
1459 What should it be? Not that it matters since it's not
1460 currently useful. */
1461 def_exports (c, 0, -1, 0, 0, ! (flags & BSF_FUNCTION), 0, NULL);
1463 if (add_stdcall_alias && strchr (c, '@'))
1465 int lead_at = (*c == '@') ;
1466 char *exported_name = xstrdup (c + lead_at);
1467 char *atsym = strchr (exported_name, '@');
1469 /* Note: stdcall alias symbols can never be data. */
1470 def_exports (exported_name, xstrdup (c), -1, 0, 0, 0, 0, NULL);
1479 /* Look through the symbols in MINISYMS, and add each one to list of
1480 symbols to export. */
1483 scan_filtered_symbols (bfd *abfd, void *minisyms, long symcount,
1487 bfd_byte *from, *fromend;
1489 store = bfd_make_empty_symbol (abfd);
1491 bfd_fatal (bfd_get_filename (abfd));
1493 from = (bfd_byte *) minisyms;
1494 fromend = from + symcount * size;
1495 for (; from < fromend; from += size)
1498 const char *symbol_name;
1500 sym = bfd_minisymbol_to_symbol (abfd, FALSE, from, store);
1502 bfd_fatal (bfd_get_filename (abfd));
1504 symbol_name = bfd_asymbol_name (sym);
1505 if (bfd_get_symbol_leading_char (abfd) == symbol_name[0])
1508 def_exports (xstrdup (symbol_name) , 0, -1, 0, 0,
1509 ! (sym->flags & BSF_FUNCTION), 0, NULL);
1511 if (add_stdcall_alias && strchr (symbol_name, '@'))
1513 int lead_at = (*symbol_name == '@');
1514 char *exported_name = xstrdup (symbol_name + lead_at);
1515 char *atsym = strchr (exported_name, '@');
1517 /* Note: stdcall alias symbols can never be data. */
1518 def_exports (exported_name, xstrdup (symbol_name), -1, 0, 0, 0, 0, NULL);
1523 /* Add a list of symbols to exclude. */
1526 add_excludes (const char *new_excludes)
1529 char *exclude_string;
1531 local_copy = xstrdup (new_excludes);
1533 exclude_string = strtok (local_copy, ",:");
1534 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
1536 struct string_list *new_exclude;
1538 new_exclude = ((struct string_list *)
1539 xmalloc (sizeof (struct string_list)));
1540 new_exclude->string = (char *) xmalloc (strlen (exclude_string) + 2);
1541 /* Don't add a leading underscore for fastcall symbols. */
1542 if (*exclude_string == '@')
1543 sprintf (new_exclude->string, "%s", exclude_string);
1545 sprintf (new_exclude->string, "%s%s", (!leading_underscore ? "" : "_"),
1547 new_exclude->next = excludes;
1548 excludes = new_exclude;
1550 /* xgettext:c-format */
1551 inform (_("Excluding symbol: %s"), exclude_string);
1557 /* See if STRING is on the list of symbols to exclude. */
1560 match_exclude (const char *string)
1562 struct string_list *excl_item;
1564 for (excl_item = excludes; excl_item; excl_item = excl_item->next)
1565 if (strcmp (string, excl_item->string) == 0)
1570 /* Add the default list of symbols to exclude. */
1573 set_default_excludes (void)
1575 add_excludes (default_excludes);
1578 /* Choose which symbols to export. */
1581 filter_symbols (bfd *abfd, void *minisyms, long symcount, unsigned int size)
1583 bfd_byte *from, *fromend, *to;
1586 store = bfd_make_empty_symbol (abfd);
1588 bfd_fatal (bfd_get_filename (abfd));
1590 from = (bfd_byte *) minisyms;
1591 fromend = from + symcount * size;
1592 to = (bfd_byte *) minisyms;
1594 for (; from < fromend; from += size)
1599 sym = bfd_minisymbol_to_symbol (abfd, FALSE, (const void *) from, store);
1601 bfd_fatal (bfd_get_filename (abfd));
1603 /* Check for external and defined only symbols. */
1604 keep = (((sym->flags & BSF_GLOBAL) != 0
1605 || (sym->flags & BSF_WEAK) != 0
1606 || bfd_is_com_section (sym->section))
1607 && ! bfd_is_und_section (sym->section));
1609 keep = keep && ! match_exclude (sym->name);
1613 memcpy (to, from, size);
1618 return (to - (bfd_byte *) minisyms) / size;
1621 /* Export all symbols in ABFD, except for ones we were told not to
1625 scan_all_symbols (bfd *abfd)
1631 /* Ignore bfds with an import descriptor table. We assume that any
1632 such BFD contains symbols which are exported from another DLL,
1633 and we don't want to reexport them from here. */
1634 if (bfd_get_section_by_name (abfd, ".idata$4"))
1637 if (! (bfd_get_file_flags (abfd) & HAS_SYMS))
1639 /* xgettext:c-format */
1640 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1644 symcount = bfd_read_minisymbols (abfd, FALSE, &minisyms, &size);
1646 bfd_fatal (bfd_get_filename (abfd));
1650 /* xgettext:c-format */
1651 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1655 /* Discard the symbols we don't want to export. It's OK to do this
1656 in place; we'll free the storage anyway. */
1658 symcount = filter_symbols (abfd, minisyms, symcount, size);
1659 scan_filtered_symbols (abfd, minisyms, symcount, size);
1664 /* Look at the object file to decide which symbols to export. */
1667 scan_open_obj_file (bfd *abfd)
1669 if (export_all_symbols)
1670 scan_all_symbols (abfd);
1672 scan_drectve_symbols (abfd);
1674 /* FIXME: we ought to read in and block out the base relocations. */
1676 /* xgettext:c-format */
1677 inform (_("Done reading %s"), bfd_get_filename (abfd));
1681 scan_obj_file (const char *filename)
1683 bfd * f = bfd_openr (filename, 0);
1686 /* xgettext:c-format */
1687 fatal (_("Unable to open object file: %s: %s"), filename, bfd_get_errmsg ());
1689 /* xgettext:c-format */
1690 inform (_("Scanning object file %s"), filename);
1692 if (bfd_check_format (f, bfd_archive))
1694 bfd *arfile = bfd_openr_next_archived_file (f, 0);
1698 if (bfd_check_format (arfile, bfd_object))
1699 scan_open_obj_file (arfile);
1700 next = bfd_openr_next_archived_file (f, arfile);
1702 /* PR 17512: file: 58715298. */
1708 #ifdef DLLTOOL_MCORE_ELF
1709 if (mcore_elf_out_file)
1710 inform (_("Cannot produce mcore-elf dll from archive file: %s"), filename);
1713 else if (bfd_check_format (f, bfd_object))
1715 scan_open_obj_file (f);
1717 #ifdef DLLTOOL_MCORE_ELF
1718 if (mcore_elf_out_file)
1719 mcore_elf_cache_filename (filename);
1729 dump_def_info (FILE *f)
1733 fprintf (f, "%s ", ASM_C);
1734 for (i = 0; oav[i]; i++)
1735 fprintf (f, "%s ", oav[i]);
1737 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1739 fprintf (f, "%s %d = %s %s @ %d %s%s%s%s%s%s\n",
1745 exp->noname ? "NONAME " : "",
1746 exp->private ? "PRIVATE " : "",
1747 exp->constant ? "CONSTANT" : "",
1748 exp->data ? "DATA" : "",
1749 exp->its_name ? " ==" : "",
1750 exp->its_name ? exp->its_name : "");
1754 /* Generate the .exp file. */
1757 sfunc (const void *a, const void *b)
1759 if (*(const bfd_vma *) a == *(const bfd_vma *) b)
1762 return ((*(const bfd_vma *) a > *(const bfd_vma *) b) ? 1 : -1);
1766 flush_page (FILE *f, bfd_vma *need, bfd_vma page_addr, int on_page)
1770 /* Flush this page. */
1771 fprintf (f, "\t%s\t0x%08x\t%s Starting RVA for chunk\n",
1775 fprintf (f, "\t%s\t0x%x\t%s Size of block\n",
1777 (on_page * 2) + (on_page & 1) * 2 + 8,
1780 for (i = 0; i < on_page; i++)
1782 bfd_vma needed = need[i];
1786 if (!create_for_pep)
1788 /* Relocation via HIGHLOW. */
1789 needed = ((needed - page_addr) | 0x3000) & 0xffff;
1793 /* Relocation via DIR64. */
1794 needed = ((needed - page_addr) | 0xa000) & 0xffff;
1798 fprintf (f, "\t%s\t0x%lx\n", ASM_SHORT, (long) needed);
1803 fprintf (f, "\t%s\t0x%x\n", ASM_SHORT, 0 | 0x0000);
1812 inform (_("Adding exports to output file"));
1814 fprintf (output_def, ";");
1815 for (i = 0; oav[i]; i++)
1816 fprintf (output_def, " %s", oav[i]);
1818 fprintf (output_def, "\nEXPORTS\n");
1820 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1822 char *quote = strchr (exp->name, '.') ? "\"" : "";
1823 char *res = cplus_demangle (exp->internal_name, DMGL_ANSI | DMGL_PARAMS);
1827 fprintf (output_def,";\t%s\n", res);
1831 if (strcmp (exp->name, exp->internal_name) == 0)
1833 fprintf (output_def, "\t%s%s%s @ %d%s%s%s%s%s\n",
1838 exp->noname ? " NONAME" : "",
1839 exp->private ? "PRIVATE " : "",
1840 exp->data ? " DATA" : "",
1841 exp->its_name ? " ==" : "",
1842 exp->its_name ? exp->its_name : "");
1846 char * quote1 = strchr (exp->internal_name, '.') ? "\"" : "";
1848 fprintf (output_def, "\t%s%s%s = %s%s%s @ %d%s%s%s%s%s\n",
1856 exp->noname ? " NONAME" : "",
1857 exp->private ? "PRIVATE " : "",
1858 exp->data ? " DATA" : "",
1859 exp->its_name ? " ==" : "",
1860 exp->its_name ? exp->its_name : "");
1864 inform (_("Added exports to output file"));
1867 /* generate_idata_ofile generates the portable assembly source code
1868 for the idata sections. It appends the source code to the end of
1872 generate_idata_ofile (FILE *filvar)
1880 if (import_list == NULL)
1883 fprintf (filvar, "%s Import data sections\n", ASM_C);
1884 fprintf (filvar, "\n\t.section\t.idata$2\n");
1885 fprintf (filvar, "\t%s\tdoi_idata\n", ASM_GLOBAL);
1886 fprintf (filvar, "doi_idata:\n");
1889 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1891 fprintf (filvar, "\t%slistone%d%s\t%s %s\n",
1892 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER,
1893 ASM_C, headptr->dllname);
1894 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1895 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1896 fprintf (filvar, "\t%sdllname%d%s\n",
1897 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1898 fprintf (filvar, "\t%slisttwo%d%s\n\n",
1899 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1903 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL record at */
1904 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* end of idata$2 */
1905 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* section */
1906 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1907 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1909 fprintf (filvar, "\n\t.section\t.idata$4\n");
1911 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1913 fprintf (filvar, "listone%d:\n", headindex);
1914 for (funcindex = 0; funcindex < headptr->nfuncs; funcindex++)
1917 fprintf (filvar, "\t%sfuncptr%d_%d%s\n%s\t0\n",
1918 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER,
1921 fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1922 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1925 fprintf (filvar, "\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
1927 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list. */
1931 fprintf (filvar, "\n\t.section\t.idata$5\n");
1933 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1935 fprintf (filvar, "listtwo%d:\n", headindex);
1936 for (funcindex = 0; funcindex < headptr->nfuncs; funcindex++)
1939 fprintf (filvar, "\t%sfuncptr%d_%d%s\n%s\t0\n",
1940 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER,
1943 fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1944 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1947 fprintf (filvar, "\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
1949 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list. */
1953 fprintf (filvar, "\n\t.section\t.idata$6\n");
1955 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1958 for (funcptr = headptr->funchead; funcptr != NULL;
1959 funcptr = funcptr->next)
1961 fprintf (filvar,"funcptr%d_%d:\n", headindex, funcindex);
1962 fprintf (filvar,"\t%s\t%d\n", ASM_SHORT,
1963 ((funcptr->ord) & 0xFFFF));
1964 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT,
1965 (funcptr->its_name ? funcptr->its_name : funcptr->name));
1966 fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1972 fprintf (filvar, "\n\t.section\t.idata$7\n");
1974 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1976 fprintf (filvar,"dllname%d:\n", headindex);
1977 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, headptr->dllname);
1978 fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1983 /* Assemble the specified file. */
1985 assemble_file (const char * source, const char * dest)
1989 cmd = xmalloc (strlen (ASM_SWITCHES) + strlen (as_flags)
1990 + strlen (source) + strlen (dest) + 50);
1992 sprintf (cmd, "%s %s -o %s %s", ASM_SWITCHES, as_flags, dest, source);
1998 static const char * temp_file_to_remove[5];
1999 #define TEMP_EXPORT_FILE 0
2000 #define TEMP_HEAD_FILE 1
2001 #define TEMP_TAIL_FILE 2
2002 #define TEMP_HEAD_O_FILE 3
2003 #define TEMP_TAIL_O_FILE 4
2006 unlink_temp_files (void)
2010 if (dontdeltemps > 0)
2013 for (i = 0; i < ARRAY_SIZE (temp_file_to_remove); i++)
2015 if (temp_file_to_remove[i])
2017 unlink (temp_file_to_remove[i]);
2018 temp_file_to_remove[i] = NULL;
2031 /* xgettext:c-format */
2032 inform (_("Generating export file: %s"), exp_name);
2034 f = fopen (TMP_ASM, FOPEN_WT);
2036 /* xgettext:c-format */
2037 fatal (_("Unable to open temporary assembler file: %s"), TMP_ASM);
2039 temp_file_to_remove[TEMP_EXPORT_FILE] = TMP_ASM;
2041 /* xgettext:c-format */
2042 inform (_("Opened temporary file: %s"), TMP_ASM);
2048 fprintf (f, "\t.section .edata\n\n");
2049 fprintf (f, "\t%s 0 %s Allways 0\n", ASM_LONG, ASM_C);
2050 fprintf (f, "\t%s 0x%lx %s Time and date\n", ASM_LONG,
2051 (unsigned long) time(0), ASM_C);
2052 fprintf (f, "\t%s 0 %s Major and Minor version\n", ASM_LONG, ASM_C);
2053 fprintf (f, "\t%sname%s %s Ptr to name of dll\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
2054 fprintf (f, "\t%s %d %s Starting ordinal of exports\n", ASM_LONG, d_low_ord, ASM_C);
2057 fprintf (f, "\t%s %d %s Number of functions\n", ASM_LONG, d_high_ord - d_low_ord + 1, ASM_C);
2058 fprintf(f,"\t%s named funcs %d, low ord %d, high ord %d\n",
2060 d_named_nfuncs, d_low_ord, d_high_ord);
2061 fprintf (f, "\t%s %d %s Number of names\n", ASM_LONG,
2062 show_allnames ? d_high_ord - d_low_ord + 1 : d_named_nfuncs, ASM_C);
2063 fprintf (f, "\t%safuncs%s %s Address of functions\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
2065 fprintf (f, "\t%sanames%s %s Address of Name Pointer Table\n",
2066 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
2068 fprintf (f, "\t%sanords%s %s Address of ordinals\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
2070 fprintf (f, "name: %s \"%s\"\n", ASM_TEXT, dll_name);
2073 fprintf(f,"%s Export address Table\n", ASM_C);
2074 fprintf(f,"\t%s\n", ASM_ALIGN_LONG);
2075 fprintf (f, "afuncs:\n");
2078 for (exp = d_exports; exp; exp = exp->next)
2080 if (exp->ordinal != i)
2082 while (i < exp->ordinal)
2084 fprintf(f,"\t%s\t0\n", ASM_LONG);
2089 if (exp->forward == 0)
2091 if (exp->internal_name[0] == '@')
2092 fprintf (f, "\t%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
2093 exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
2095 fprintf (f, "\t%s%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
2096 ASM_PREFIX (exp->internal_name),
2097 exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
2100 fprintf (f, "\t%sf%d%s\t%s %d\n", ASM_RVA_BEFORE,
2101 exp->forward, ASM_RVA_AFTER, ASM_C, exp->ordinal);
2105 fprintf (f,"%s Export Name Pointer Table\n", ASM_C);
2106 fprintf (f, "anames:\n");
2108 for (i = 0; (exp = d_exports_lexically[i]); i++)
2110 if (!exp->noname || show_allnames)
2111 fprintf (f, "\t%sn%d%s\n",
2112 ASM_RVA_BEFORE, exp->ordinal, ASM_RVA_AFTER);
2115 fprintf (f,"%s Export Ordinal Table\n", ASM_C);
2116 fprintf (f, "anords:\n");
2117 for (i = 0; (exp = d_exports_lexically[i]); i++)
2119 if (!exp->noname || show_allnames)
2120 fprintf (f, "\t%s %d\n", ASM_SHORT, exp->ordinal - d_low_ord);
2123 fprintf(f,"%s Export Name Table\n", ASM_C);
2124 for (i = 0; (exp = d_exports_lexically[i]); i++)
2126 if (!exp->noname || show_allnames)
2127 fprintf (f, "n%d: %s \"%s\"\n",
2128 exp->ordinal, ASM_TEXT,
2129 (exp->its_name ? exp->its_name : xlate (exp->name)));
2130 if (exp->forward != 0)
2131 fprintf (f, "f%d: %s \"%s\"\n",
2132 exp->forward, ASM_TEXT, exp->internal_name);
2137 fprintf (f, "\t.section %s\n", DRECTVE_SECTION_NAME);
2138 for (dl = a_list; dl; dl = dl->next)
2140 fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, dl->text);
2146 fprintf (f, "\t.section .rdata\n");
2147 for (dl = d_list; dl; dl = dl->next)
2152 /* We don't output as ascii because there can
2153 be quote characters in the string. */
2155 for (p = dl->text; *p; p++)
2158 fprintf (f, "\t%s\t", ASM_BYTE);
2161 fprintf (f, "%d", *p);
2164 fprintf (f, ",0\n");
2177 /* Add to the output file a way of getting to the exported names
2178 without using the import library. */
2181 fprintf (f, "\t.section\t.rdata\n");
2182 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
2183 if (!exp->noname || show_allnames)
2185 /* We use a single underscore for MS compatibility, and a
2186 double underscore for backward compatibility with old
2188 if (create_compat_implib)
2189 fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name);
2190 fprintf (f, "\t%s\t_imp_%s%s\n", ASM_GLOBAL,
2191 (!leading_underscore ? "" : "_"), exp->name);
2192 if (create_compat_implib)
2193 fprintf (f, "__imp_%s:\n", exp->name);
2194 fprintf (f, "_imp_%s%s:\n", (!leading_underscore ? "" : "_"), exp->name);
2195 fprintf (f, "\t%s\t%s\n", ASM_LONG, exp->name);
2199 /* Dump the reloc section if a base file is provided. */
2203 bfd_vma need[COFF_PAGE_SIZE];
2205 bfd_size_type numbytes;
2210 fprintf (f, "\t.section\t.init\n");
2211 fprintf (f, "lab:\n");
2213 fseek (base_file, 0, SEEK_END);
2214 numbytes = ftell (base_file);
2215 fseek (base_file, 0, SEEK_SET);
2216 copy = xmalloc (numbytes);
2217 if (fread (copy, 1, numbytes, base_file) < numbytes)
2218 fatal (_("failed to read the number of entries from base file"));
2219 num_entries = numbytes / sizeof (bfd_vma);
2222 fprintf (f, "\t.section\t.reloc\n");
2227 bfd_vma last = (bfd_vma) -1;
2228 qsort (copy, num_entries, sizeof (bfd_vma), sfunc);
2229 /* Delete duplicates */
2230 for (src = 0; src < num_entries; src++)
2232 if (last != copy[src])
2233 last = copy[dst++] = copy[src];
2237 page_addr = addr & PAGE_MASK; /* work out the page addr */
2239 for (j = 0; j < num_entries; j++)
2242 if ((addr & PAGE_MASK) != page_addr)
2244 flush_page (f, need, page_addr, on_page);
2246 page_addr = addr & PAGE_MASK;
2248 need[on_page++] = addr;
2250 flush_page (f, need, page_addr, on_page);
2252 /* fprintf (f, "\t%s\t0,0\t%s End\n", ASM_LONG, ASM_C);*/
2256 generate_idata_ofile (f);
2260 /* Assemble the file. */
2261 assemble_file (TMP_ASM, exp_name);
2263 if (dontdeltemps == 0)
2265 temp_file_to_remove[TEMP_EXPORT_FILE] = NULL;
2269 inform (_("Generated exports file"));
2273 xlate (const char *name)
2275 int lead_at = (*name == '@');
2276 int is_stdcall = (!lead_at && strchr (name, '@') != NULL);
2278 if (!lead_at && (add_underscore
2279 || (add_stdcall_underscore && is_stdcall)))
2281 char *copy = xmalloc (strlen (name) + 2);
2284 strcpy (copy + 1, name);
2293 /* PR 9766: Look for the last @ sign in the name. */
2294 p = strrchr (name, '@');
2295 if (p && ISDIGIT (p[1]))
2311 unsigned char *data;
2314 #define INIT_SEC_DATA(id, name, flags, align) \
2315 { id, name, flags, align, NULL, NULL, NULL, 0, NULL }
2329 #define TEXT_SEC_FLAGS \
2330 (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY | SEC_HAS_CONTENTS)
2331 #define DATA_SEC_FLAGS (SEC_ALLOC | SEC_LOAD | SEC_DATA)
2332 #define BSS_SEC_FLAGS SEC_ALLOC
2334 static sinfo secdata[NSECS] =
2336 INIT_SEC_DATA (TEXT, ".text", TEXT_SEC_FLAGS, 2),
2337 INIT_SEC_DATA (DATA, ".data", DATA_SEC_FLAGS, 2),
2338 INIT_SEC_DATA (BSS, ".bss", BSS_SEC_FLAGS, 2),
2339 INIT_SEC_DATA (IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2),
2340 INIT_SEC_DATA (IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2),
2341 INIT_SEC_DATA (IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2),
2342 INIT_SEC_DATA (IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1)
2347 /* Sections numbered to make the order the same as other PowerPC NT
2348 compilers. This also keeps funny alignment thingies from happening. */
2361 static sinfo secdata[NSECS] =
2363 INIT_SEC_DATA (TEXT, ".text", SEC_CODE | SEC_HAS_CONTENTS, 3),
2364 INIT_SEC_DATA (PDATA, ".pdata", SEC_HAS_CONTENTS, 2),
2365 INIT_SEC_DATA (RDATA, ".reldata", SEC_HAS_CONTENTS, 2),
2366 INIT_SEC_DATA (IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2),
2367 INIT_SEC_DATA (IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2),
2368 INIT_SEC_DATA (IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1),
2369 INIT_SEC_DATA (IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2),
2370 INIT_SEC_DATA (DATA, ".data", SEC_DATA, 2),
2371 INIT_SEC_DATA (BSS, ".bss", 0, 2)
2376 /* This is what we're trying to make. We generate the imp symbols with
2377 both single and double underscores, for compatibility.
2380 .global _GetFileVersionInfoSizeW@8
2381 .global __imp_GetFileVersionInfoSizeW@8
2382 _GetFileVersionInfoSizeW@8:
2383 jmp * __imp_GetFileVersionInfoSizeW@8
2384 .section .idata$7 # To force loading of head
2385 .long __version_a_head
2386 # Import Address Table
2388 __imp_GetFileVersionInfoSizeW@8:
2391 # Import Lookup Table
2397 .asciz "GetFileVersionInfoSizeW"
2400 For the PowerPC, here's the variation on the above scheme:
2402 # Rather than a simple "jmp *", the code to get to the dll function
2405 lwz r11,[tocv]__imp_function_name(r2)
2406 # RELOC: 00000000 TOCREL16,TOCDEFN __imp_function_name
2414 make_label (const char *prefix, const char *name)
2416 int len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name);
2417 char *copy = xmalloc (len + 1);
2419 strcpy (copy, ASM_PREFIX (name));
2420 strcat (copy, prefix);
2421 strcat (copy, name);
2426 make_imp_label (const char *prefix, const char *name)
2433 len = strlen (prefix) + strlen (name);
2434 copy = xmalloc (len + 1);
2435 strcpy (copy, prefix);
2436 strcat (copy, name);
2440 len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name);
2441 copy = xmalloc (len + 1);
2442 strcpy (copy, prefix);
2443 strcat (copy, ASM_PREFIX (name));
2444 strcat (copy, name);
2450 make_one_lib_file (export_type *exp, int i, int delay)
2453 asymbol * exp_label;
2454 asymbol * iname = 0;
2456 asymbol * iname_lab;
2457 asymbol ** iname_lab_pp;
2458 asymbol ** iname_pp;
2467 asymbol * ptrs[NSECS + 4 + EXTRA + 1];
2468 flagword applicable;
2469 char * outname = xmalloc (strlen (TMP_STUB) + 10);
2473 sprintf (outname, "%s%05d.o", TMP_STUB, i);
2475 abfd = bfd_openw (outname, HOW_BFD_WRITE_TARGET);
2478 /* xgettext:c-format */
2479 fatal (_("bfd_open failed open stub file: %s: %s"),
2480 outname, bfd_get_errmsg ());
2482 /* xgettext:c-format */
2483 inform (_("Creating stub file: %s"), outname);
2485 bfd_set_format (abfd, bfd_object);
2486 bfd_set_arch_mach (abfd, HOW_BFD_ARCH, 0);
2489 if (machine == MARM_INTERWORK || machine == MTHUMB)
2490 bfd_set_private_flags (abfd, F_INTERWORK);
2493 applicable = bfd_applicable_section_flags (abfd);
2495 /* First make symbols for the sections. */
2496 for (i = 0; i < NSECS; i++)
2498 sinfo *si = secdata + i;
2502 si->sec = bfd_make_section_old_way (abfd, si->name);
2503 bfd_set_section_flags (abfd,
2505 si->flags & applicable);
2507 bfd_set_section_alignment(abfd, si->sec, si->align);
2508 si->sec->output_section = si->sec;
2509 si->sym = bfd_make_empty_symbol(abfd);
2510 si->sym->name = si->sec->name;
2511 si->sym->section = si->sec;
2512 si->sym->flags = BSF_LOCAL;
2514 ptrs[oidx] = si->sym;
2515 si->sympp = ptrs + oidx;
2524 exp_label = bfd_make_empty_symbol (abfd);
2525 exp_label->name = make_imp_label ("", exp->name);
2527 /* On PowerPC, the function name points to a descriptor in
2528 the rdata section, the first element of which is a
2529 pointer to the code (..function_name), and the second
2530 points to the .toc. */
2532 if (machine == MPPC)
2533 exp_label->section = secdata[RDATA].sec;
2536 exp_label->section = secdata[TEXT].sec;
2538 exp_label->flags = BSF_GLOBAL;
2539 exp_label->value = 0;
2542 if (machine == MTHUMB)
2543 bfd_coff_set_symbol_class (abfd, exp_label, C_THUMBEXTFUNC);
2545 ptrs[oidx++] = exp_label;
2548 /* Generate imp symbols with one underscore for Microsoft
2549 compatibility, and with two underscores for backward
2550 compatibility with old versions of cygwin. */
2551 if (create_compat_implib)
2553 iname = bfd_make_empty_symbol (abfd);
2554 iname->name = make_imp_label ("___imp", exp->name);
2555 iname->section = secdata[IDATA5].sec;
2556 iname->flags = BSF_GLOBAL;
2560 iname2 = bfd_make_empty_symbol (abfd);
2561 iname2->name = make_imp_label ("__imp_", exp->name);
2562 iname2->section = secdata[IDATA5].sec;
2563 iname2->flags = BSF_GLOBAL;
2566 iname_lab = bfd_make_empty_symbol (abfd);
2568 iname_lab->name = head_label;
2569 iname_lab->section = bfd_und_section_ptr;
2570 iname_lab->flags = 0;
2571 iname_lab->value = 0;
2573 iname_pp = ptrs + oidx;
2574 if (create_compat_implib)
2575 ptrs[oidx++] = iname;
2576 ptrs[oidx++] = iname2;
2578 iname_lab_pp = ptrs + oidx;
2579 ptrs[oidx++] = iname_lab;
2582 /* The symbol referring to the code (.text). */
2584 asymbol *function_name;
2586 function_name = bfd_make_empty_symbol(abfd);
2587 function_name->name = make_label ("..", exp->name);
2588 function_name->section = secdata[TEXT].sec;
2589 function_name->flags = BSF_GLOBAL;
2590 function_name->value = 0;
2592 fn_pp = ptrs + oidx;
2593 ptrs[oidx++] = function_name;
2596 /* The .toc symbol. */
2598 asymbol *toc_symbol;
2600 toc_symbol = bfd_make_empty_symbol (abfd);
2601 toc_symbol->name = make_label (".", "toc");
2602 toc_symbol->section = bfd_und_section_ptr;
2603 toc_symbol->flags = BSF_GLOBAL;
2604 toc_symbol->value = 0;
2606 toc_pp = ptrs + oidx;
2607 ptrs[oidx++] = toc_symbol;
2613 for (i = 0; i < NSECS; i++)
2615 sinfo *si = secdata + i;
2616 asection *sec = si->sec;
2617 arelent *rel, *rel2 = 0, *rel3 = 0;
2625 si->size = HOW_JTAB_SIZE;
2626 si->data = xmalloc (HOW_JTAB_SIZE);
2627 memcpy (si->data, HOW_JTAB, HOW_JTAB_SIZE);
2629 /* Add the reloc into idata$5. */
2630 rel = xmalloc (sizeof (arelent));
2632 rpp = xmalloc (sizeof (arelent *) * (delay ? 4 : 2));
2636 rel->address = HOW_JTAB_ROFF;
2641 rel2 = xmalloc (sizeof (arelent));
2643 rel2->address = HOW_JTAB_ROFF2;
2645 rel3 = xmalloc (sizeof (arelent));
2647 rel3->address = HOW_JTAB_ROFF3;
2652 if (machine == MPPC)
2654 rel->howto = bfd_reloc_type_lookup (abfd,
2655 BFD_RELOC_16_GOTOFF);
2656 rel->sym_ptr_ptr = iname_pp;
2658 else if (machine == MX86)
2660 rel->howto = bfd_reloc_type_lookup (abfd,
2661 BFD_RELOC_32_PCREL);
2662 rel->sym_ptr_ptr = iname_pp;
2666 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2667 rel->sym_ptr_ptr = secdata[IDATA5].sympp;
2672 if (machine == MX86)
2673 rel2->howto = bfd_reloc_type_lookup (abfd,
2674 BFD_RELOC_32_PCREL);
2676 rel2->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2677 rel2->sym_ptr_ptr = rel->sym_ptr_ptr;
2678 rel3->howto = bfd_reloc_type_lookup (abfd,
2679 BFD_RELOC_32_PCREL);
2680 rel3->sym_ptr_ptr = iname_lab_pp;
2683 sec->orelocation = rpp;
2684 sec->reloc_count = delay ? 3 : 1;
2691 si->size = create_for_pep ? 8 : 4;
2692 si->data = xmalloc (si->size);
2693 sec->reloc_count = 1;
2694 memset (si->data, 0, si->size);
2695 /* Point after jmp [__imp_...] instruction. */
2697 rel = xmalloc (sizeof (arelent));
2698 rpp = xmalloc (sizeof (arelent *) * 2);
2704 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_64);
2706 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2707 rel->sym_ptr_ptr = secdata[TEXT].sympp;
2708 sec->orelocation = rpp;
2714 /* An idata$4 or idata$5 is one word long, and has an
2719 si->data = xmalloc (8);
2723 si->data[0] = exp->ordinal ;
2724 si->data[1] = exp->ordinal >> 8;
2725 si->data[2] = exp->ordinal >> 16;
2726 si->data[3] = exp->ordinal >> 24;
2734 sec->reloc_count = 1;
2735 memset (si->data, 0, si->size);
2736 rel = xmalloc (sizeof (arelent));
2737 rpp = xmalloc (sizeof (arelent *) * 2);
2742 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2743 rel->sym_ptr_ptr = secdata[IDATA6].sympp;
2744 sec->orelocation = rpp;
2749 si->data = xmalloc (4);
2754 si->data[0] = exp->ordinal ;
2755 si->data[1] = exp->ordinal >> 8;
2756 si->data[2] = exp->ordinal >> 16;
2761 sec->reloc_count = 1;
2762 memset (si->data, 0, si->size);
2763 rel = xmalloc (sizeof (arelent));
2764 rpp = xmalloc (sizeof (arelent *) * 2);
2769 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2770 rel->sym_ptr_ptr = secdata[IDATA6].sympp;
2771 sec->orelocation = rpp;
2779 /* This used to add 1 to exp->hint. I don't know
2780 why it did that, and it does not match what I see
2781 in programs compiled with the MS tools. */
2782 int idx = exp->hint;
2784 si->size = strlen (exp->its_name) + 3;
2786 si->size = strlen (xlate (exp->import_name)) + 3;
2787 si->data = xmalloc (si->size);
2788 memset (si->data, 0, si->size);
2789 si->data[0] = idx & 0xff;
2790 si->data[1] = idx >> 8;
2792 strcpy ((char *) si->data + 2, exp->its_name);
2794 strcpy ((char *) si->data + 2, xlate (exp->import_name));
2801 si->data = xmalloc (4);
2802 memset (si->data, 0, si->size);
2803 rel = xmalloc (sizeof (arelent));
2804 rpp = xmalloc (sizeof (arelent *) * 2);
2808 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2809 rel->sym_ptr_ptr = iname_lab_pp;
2810 sec->orelocation = rpp;
2811 sec->reloc_count = 1;
2817 /* The .pdata section is 5 words long.
2821 bfd_vma BeginAddress, [0x00]
2823 ExceptionHandler, [0x08]
2825 PrologEndAddress; [0x10]
2828 /* So this pdata section setups up this as a glue linkage to
2829 a dll routine. There are a number of house keeping things
2832 1. In the name of glue trickery, the ADDR32 relocs for 0,
2833 4, and 0x10 are set to point to the same place:
2835 2. There is one more reloc needed in the pdata section.
2836 The actual glue instruction to restore the toc on
2837 return is saved as the offset in an IMGLUE reloc.
2838 So we need a total of four relocs for this section.
2840 3. Lastly, the HandlerData field is set to 0x03, to indicate
2841 that this is a glue routine. */
2842 arelent *imglue, *ba_rel, *ea_rel, *pea_rel;
2844 /* Alignment must be set to 2**2 or you get extra stuff. */
2845 bfd_set_section_alignment(abfd, sec, 2);
2848 si->data = xmalloc (si->size);
2849 memset (si->data, 0, si->size);
2850 rpp = xmalloc (sizeof (arelent *) * 5);
2851 rpp[0] = imglue = xmalloc (sizeof (arelent));
2852 rpp[1] = ba_rel = xmalloc (sizeof (arelent));
2853 rpp[2] = ea_rel = xmalloc (sizeof (arelent));
2854 rpp[3] = pea_rel = xmalloc (sizeof (arelent));
2857 /* Stick the toc reload instruction in the glue reloc. */
2858 bfd_put_32(abfd, ppc_glue_insn, (char *) &imglue->address);
2861 imglue->howto = bfd_reloc_type_lookup (abfd,
2862 BFD_RELOC_32_GOTOFF);
2863 imglue->sym_ptr_ptr = fn_pp;
2865 ba_rel->address = 0;
2867 ba_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2868 ba_rel->sym_ptr_ptr = fn_pp;
2870 bfd_put_32 (abfd, 0x18, si->data + 0x04);
2871 ea_rel->address = 4;
2873 ea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2874 ea_rel->sym_ptr_ptr = fn_pp;
2876 /* Mark it as glue. */
2877 bfd_put_32 (abfd, 0x03, si->data + 0x0c);
2879 /* Mark the prolog end address. */
2880 bfd_put_32 (abfd, 0x0D, si->data + 0x10);
2881 pea_rel->address = 0x10;
2882 pea_rel->addend = 0;
2883 pea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2884 pea_rel->sym_ptr_ptr = fn_pp;
2886 sec->orelocation = rpp;
2887 sec->reloc_count = 4;
2891 /* Each external function in a PowerPC PE file has a two word
2892 descriptor consisting of:
2893 1. The address of the code.
2894 2. The address of the appropriate .toc
2895 We use relocs to build this. */
2897 si->data = xmalloc (8);
2898 memset (si->data, 0, si->size);
2900 rpp = xmalloc (sizeof (arelent *) * 3);
2901 rpp[0] = rel = xmalloc (sizeof (arelent));
2902 rpp[1] = xmalloc (sizeof (arelent));
2907 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2908 rel->sym_ptr_ptr = fn_pp;
2914 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2915 rel->sym_ptr_ptr = toc_pp;
2917 sec->orelocation = rpp;
2918 sec->reloc_count = 2;
2920 #endif /* DLLTOOL_PPC */
2926 /* Size up all the sections. */
2927 for (i = 0; i < NSECS; i++)
2929 sinfo *si = secdata + i;
2931 bfd_set_section_size (abfd, si->sec, si->size);
2932 bfd_set_section_vma (abfd, si->sec, vma);
2935 /* Write them out. */
2936 for (i = 0; i < NSECS; i++)
2938 sinfo *si = secdata + i;
2940 if (i == IDATA5 && no_idata5)
2943 if (i == IDATA4 && no_idata4)
2946 bfd_set_section_contents (abfd, si->sec,
2951 bfd_set_symtab (abfd, ptrs, oidx);
2953 abfd = bfd_openr (outname, HOW_BFD_READ_TARGET);
2955 /* xgettext:c-format */
2956 fatal (_("bfd_open failed reopen stub file: %s: %s"),
2957 outname, bfd_get_errmsg ());
2965 FILE *f = fopen (TMP_HEAD_S, FOPEN_WT);
2970 fatal (_("failed to open temporary head file: %s"), TMP_HEAD_S);
2974 temp_file_to_remove[TEMP_HEAD_FILE] = TMP_HEAD_S;
2976 fprintf (f, "%s IMAGE_IMPORT_DESCRIPTOR\n", ASM_C);
2977 fprintf (f, "\t.section\t.idata$2\n");
2979 fprintf (f,"\t%s\t%s\n", ASM_GLOBAL, head_label);
2981 fprintf (f, "%s:\n", head_label);
2983 fprintf (f, "\t%shname%s\t%sPtr to image import by name list\n",
2984 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
2986 fprintf (f, "\t%sthis should be the timestamp, but NT sometimes\n", ASM_C);
2987 fprintf (f, "\t%sdoesn't load DLLs when this is set.\n", ASM_C);
2988 fprintf (f, "\t%s\t0\t%s loaded time\n", ASM_LONG, ASM_C);
2989 fprintf (f, "\t%s\t0\t%s Forwarder chain\n", ASM_LONG, ASM_C);
2990 fprintf (f, "\t%s__%s_iname%s\t%s imported dll's name\n",
2995 fprintf (f, "\t%sfthunk%s\t%s pointer to firstthunk\n",
2997 ASM_RVA_AFTER, ASM_C);
2999 fprintf (f, "%sStuff for compatibility\n", ASM_C);
3003 fprintf (f, "\t.section\t.idata$5\n");
3004 if (use_nul_prefixed_import_tables)
3007 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
3009 fprintf (f,"\t%s\t0\n", ASM_LONG);
3011 fprintf (f, "fthunk:\n");
3016 fprintf (f, "\t.section\t.idata$4\n");
3017 if (use_nul_prefixed_import_tables)
3020 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
3022 fprintf (f,"\t%s\t0\n", ASM_LONG);
3024 fprintf (f, "hname:\n");
3029 assemble_file (TMP_HEAD_S, TMP_HEAD_O);
3031 abfd = bfd_openr (TMP_HEAD_O, HOW_BFD_READ_TARGET);
3033 /* xgettext:c-format */
3034 fatal (_("failed to open temporary head file: %s: %s"),
3035 TMP_HEAD_O, bfd_get_errmsg ());
3037 temp_file_to_remove[TEMP_HEAD_O_FILE] = TMP_HEAD_O;
3042 make_delay_head (void)
3044 FILE *f = fopen (TMP_HEAD_S, FOPEN_WT);
3049 fatal (_("failed to open temporary head file: %s"), TMP_HEAD_S);
3053 temp_file_to_remove[TEMP_HEAD_FILE] = TMP_HEAD_S;
3055 /* Output the __tailMerge__xxx function */
3056 fprintf (f, "%s Import trampoline\n", ASM_C);
3057 fprintf (f, "\t.section\t.text\n");
3058 fprintf(f,"\t%s\t%s\n", ASM_GLOBAL, head_label);
3059 fprintf (f, "%s:\n", head_label);
3060 fprintf (f, mtable[machine].trampoline, imp_name_lab);
3062 /* Output the delay import descriptor */
3063 fprintf (f, "\n%s DELAY_IMPORT_DESCRIPTOR\n", ASM_C);
3064 fprintf (f, ".section\t.text$2\n");
3065 fprintf (f,"%s __DELAY_IMPORT_DESCRIPTOR_%s\n", ASM_GLOBAL,imp_name_lab);
3066 fprintf (f, "__DELAY_IMPORT_DESCRIPTOR_%s:\n", imp_name_lab);
3067 fprintf (f, "\t%s 1\t%s grAttrs\n", ASM_LONG, ASM_C);
3068 fprintf (f, "\t%s__%s_iname%s\t%s rvaDLLName\n",
3069 ASM_RVA_BEFORE, imp_name_lab, ASM_RVA_AFTER, ASM_C);
3070 fprintf (f, "\t%s__DLL_HANDLE_%s%s\t%s rvaHmod\n",
3071 ASM_RVA_BEFORE, imp_name_lab, ASM_RVA_AFTER, ASM_C);
3072 fprintf (f, "\t%s__IAT_%s%s\t%s rvaIAT\n",
3073 ASM_RVA_BEFORE, imp_name_lab, ASM_RVA_AFTER, ASM_C);
3074 fprintf (f, "\t%s__INT_%s%s\t%s rvaINT\n",
3075 ASM_RVA_BEFORE, imp_name_lab, ASM_RVA_AFTER, ASM_C);
3076 fprintf (f, "\t%s\t0\t%s rvaBoundIAT\n", ASM_LONG, ASM_C);
3077 fprintf (f, "\t%s\t0\t%s rvaUnloadIAT\n", ASM_LONG, ASM_C);
3078 fprintf (f, "\t%s\t0\t%s dwTimeStamp\n", ASM_LONG, ASM_C);
3080 /* Output the dll_handle */
3081 fprintf (f, "\n.section .data\n");
3082 fprintf (f, "__DLL_HANDLE_%s:\n", imp_name_lab);
3083 fprintf (f, "\t%s\t0\t%s Handle\n", ASM_LONG, ASM_C);
3085 fprintf (f, "\t%s\t0\n", ASM_LONG);
3088 fprintf (f, "%sStuff for compatibility\n", ASM_C);
3092 fprintf (f, "\t.section\t.idata$5\n");
3093 /* NULL terminating list. */
3095 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
3097 fprintf (f,"\t%s\t0\n", ASM_LONG);
3098 fprintf (f, "__IAT_%s:\n", imp_name_lab);
3103 fprintf (f, "\t.section\t.idata$4\n");
3104 fprintf (f, "\t%s\t0\n", ASM_LONG);
3106 fprintf (f, "\t%s\t0\n", ASM_LONG);
3107 fprintf (f, "\t.section\t.idata$4\n");
3108 fprintf (f, "__INT_%s:\n", imp_name_lab);
3111 fprintf (f, "\t.section\t.idata$2\n");
3115 assemble_file (TMP_HEAD_S, TMP_HEAD_O);
3117 abfd = bfd_openr (TMP_HEAD_O, HOW_BFD_READ_TARGET);
3119 /* xgettext:c-format */
3120 fatal (_("failed to open temporary head file: %s: %s"),
3121 TMP_HEAD_O, bfd_get_errmsg ());
3123 temp_file_to_remove[TEMP_HEAD_O_FILE] = TMP_HEAD_O;
3130 FILE *f = fopen (TMP_TAIL_S, FOPEN_WT);
3135 fatal (_("failed to open temporary tail file: %s"), TMP_TAIL_S);
3139 temp_file_to_remove[TEMP_TAIL_FILE] = TMP_TAIL_S;
3143 fprintf (f, "\t.section\t.idata$4\n");
3145 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
3147 fprintf (f,"\t%s\t0\n", ASM_LONG); /* NULL terminating list. */
3152 fprintf (f, "\t.section\t.idata$5\n");
3154 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
3156 fprintf (f,"\t%s\t0\n", ASM_LONG); /* NULL terminating list. */
3160 /* Normally, we need to see a null descriptor built in idata$3 to
3161 act as the terminator for the list. The ideal way, I suppose,
3162 would be to mark this section as a comdat type 2 section, so
3163 only one would appear in the final .exe (if our linker supported
3164 comdat, that is) or cause it to be inserted by something else (say
3167 fprintf (f, "\t.section\t.idata$3\n");
3168 fprintf (f, "\t%s\t0\n", ASM_LONG);
3169 fprintf (f, "\t%s\t0\n", ASM_LONG);
3170 fprintf (f, "\t%s\t0\n", ASM_LONG);
3171 fprintf (f, "\t%s\t0\n", ASM_LONG);
3172 fprintf (f, "\t%s\t0\n", ASM_LONG);
3176 /* Other PowerPC NT compilers use idata$6 for the dllname, so I
3177 do too. Original, huh? */
3178 fprintf (f, "\t.section\t.idata$6\n");
3180 fprintf (f, "\t.section\t.idata$7\n");
3183 fprintf (f, "\t%s\t__%s_iname\n", ASM_GLOBAL, imp_name_lab);
3184 fprintf (f, "__%s_iname:\t%s\t\"%s\"\n",
3185 imp_name_lab, ASM_TEXT, dll_name);
3189 assemble_file (TMP_TAIL_S, TMP_TAIL_O);
3191 abfd = bfd_openr (TMP_TAIL_O, HOW_BFD_READ_TARGET);
3193 /* xgettext:c-format */
3194 fatal (_("failed to open temporary tail file: %s: %s"),
3195 TMP_TAIL_O, bfd_get_errmsg ());
3197 temp_file_to_remove[TEMP_TAIL_O_FILE] = TMP_TAIL_O;
3202 gen_lib_file (int delay)
3213 outarch = bfd_openw (imp_name, HOW_BFD_WRITE_TARGET);
3216 /* xgettext:c-format */
3217 fatal (_("Can't create .lib file: %s: %s"),
3218 imp_name, bfd_get_errmsg ());
3220 /* xgettext:c-format */
3221 inform (_("Creating library file: %s"), imp_name);
3223 xatexit (unlink_temp_files);
3225 bfd_set_format (outarch, bfd_archive);
3226 outarch->has_armap = 1;
3227 outarch->is_thin_archive = 0;
3229 /* Work out a reasonable size of things to put onto one line. */
3232 ar_head = make_delay_head ();
3236 ar_head = make_head ();
3238 ar_tail = make_tail();
3240 if (ar_head == NULL || ar_tail == NULL)
3243 for (i = 0; (exp = d_exports_lexically[i]); i++)
3246 /* Don't add PRIVATE entries to import lib. */
3249 n = make_one_lib_file (exp, i, delay);
3250 n->archive_next = head;
3252 if (ext_prefix_alias)
3254 export_type alias_exp;
3256 assert (i < PREFIX_ALIAS_BASE);
3257 alias_exp.name = make_imp_label (ext_prefix_alias, exp->name);
3258 alias_exp.internal_name = exp->internal_name;
3259 alias_exp.its_name = exp->its_name;
3260 alias_exp.import_name = exp->name;
3261 alias_exp.ordinal = exp->ordinal;
3262 alias_exp.constant = exp->constant;
3263 alias_exp.noname = exp->noname;
3264 alias_exp.private = exp->private;
3265 alias_exp.data = exp->data;
3266 alias_exp.hint = exp->hint;
3267 alias_exp.forward = exp->forward;
3268 alias_exp.next = exp->next;
3269 n = make_one_lib_file (&alias_exp, i + PREFIX_ALIAS_BASE, delay);
3270 n->archive_next = head;
3275 /* Now stick them all into the archive. */
3276 ar_head->archive_next = head;
3277 ar_tail->archive_next = ar_head;
3280 if (! bfd_set_archive_head (outarch, head))
3281 bfd_fatal ("bfd_set_archive_head");
3283 if (! bfd_close (outarch))
3284 bfd_fatal (imp_name);
3286 while (head != NULL)
3288 bfd *n = head->archive_next;
3293 /* Delete all the temp files. */
3294 unlink_temp_files ();
3296 if (dontdeltemps < 2)
3300 name = xmalloc (strlen (TMP_STUB) + 10);
3301 for (i = 0; (exp = d_exports_lexically[i]); i++)
3303 /* Don't delete non-existent stubs for PRIVATE entries. */
3306 sprintf (name, "%s%05d.o", TMP_STUB, i);
3307 if (unlink (name) < 0)
3308 /* xgettext:c-format */
3309 non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
3310 if (ext_prefix_alias)
3312 sprintf (name, "%s%05d.o", TMP_STUB, i + PREFIX_ALIAS_BASE);
3313 if (unlink (name) < 0)
3314 /* xgettext:c-format */
3315 non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
3321 inform (_("Created lib file"));
3324 /* Append a copy of data (cast to char *) to list. */
3327 dll_name_list_append (dll_name_list_type * list, bfd_byte * data)
3329 dll_name_list_node_type * entry;
3331 /* Error checking. */
3332 if (! list || ! list->tail)
3335 /* Allocate new node. */
3336 entry = ((dll_name_list_node_type *)
3337 xmalloc (sizeof (dll_name_list_node_type)));
3339 /* Initialize its values. */
3340 entry->dllname = xstrdup ((char *) data);
3343 /* Add to tail, and move tail. */
3344 list->tail->next = entry;
3348 /* Count the number of entries in list. */
3351 dll_name_list_count (dll_name_list_type * list)
3353 dll_name_list_node_type * p;
3356 /* Error checking. */
3357 if (! list || ! list->head)
3362 while (p && p->next)
3370 /* Print each entry in list to stdout. */
3373 dll_name_list_print (dll_name_list_type * list)
3375 dll_name_list_node_type * p;
3377 /* Error checking. */
3378 if (! list || ! list->head)
3383 while (p && p->next && p->next->dllname && *(p->next->dllname))
3385 printf ("%s\n", p->next->dllname);
3390 /* Free all entries in list, and list itself. */
3393 dll_name_list_free (dll_name_list_type * list)
3397 dll_name_list_free_contents (list->head);
3404 /* Recursive function to free all nodes entry->next->next...
3405 as well as entry itself. */
3408 dll_name_list_free_contents (dll_name_list_node_type * entry)
3414 dll_name_list_free_contents (entry->next);
3419 free (entry->dllname);
3420 entry->dllname = NULL;
3426 /* Allocate and initialize a dll_name_list_type object,
3427 including its sentinel node. Caller is responsible
3428 for calling dll_name_list_free when finished with
3431 static dll_name_list_type *
3432 dll_name_list_create (void)
3434 /* Allocate list. */
3435 dll_name_list_type * list = xmalloc (sizeof (dll_name_list_type));
3437 /* Allocate and initialize sentinel node. */
3438 list->head = xmalloc (sizeof (dll_name_list_node_type));
3439 list->head->dllname = NULL;
3440 list->head->next = NULL;
3442 /* Bookkeeping for empty list. */
3443 list->tail = list->head;
3448 /* Search the symbol table of the suppled BFD for a symbol whose name matches
3449 OBJ (where obj is cast to const char *). If found, set global variable
3450 identify_member_contains_symname_result TRUE. It is the caller's
3451 responsibility to set the result variable FALSE before iterating with
3455 identify_member_contains_symname (bfd * abfd,
3456 bfd * archive_bfd ATTRIBUTE_UNUSED,
3459 long storage_needed;
3460 asymbol ** symbol_table;
3461 long number_of_symbols;
3463 symname_search_data_type * search_data = (symname_search_data_type *) obj;
3465 /* If we already found the symbol in a different member,
3467 if (search_data->found)
3470 storage_needed = bfd_get_symtab_upper_bound (abfd);
3471 if (storage_needed <= 0)
3474 symbol_table = xmalloc (storage_needed);
3475 number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
3476 if (number_of_symbols < 0)
3478 free (symbol_table);
3482 for (i = 0; i < number_of_symbols; i++)
3484 if (strncmp (symbol_table[i]->name,
3485 search_data->symname,
3486 strlen (search_data->symname)) == 0)
3488 search_data->found = TRUE;
3492 free (symbol_table);
3495 /* This is the main implementation for the --identify option.
3496 Given the name of an import library in identify_imp_name, first determine
3497 if the import library is a GNU binutils-style one (where the DLL name is
3498 stored in an .idata$7 (.idata$6 on PPC) section, or if it is a MS-style
3499 one (where the DLL name, along with much other data, is stored in the
3500 .idata$6 section). We determine the style of import library by searching
3501 for the DLL-structure symbol inserted by MS tools:
3502 __NULL_IMPORT_DESCRIPTOR.
3504 Once we know which section to search, evaluate each section for the
3505 appropriate properties that indicate it may contain the name of the
3506 associated DLL (this differs depending on the style). Add the contents
3507 of all sections which meet the criteria to a linked list of dll names.
3509 Finally, print them all to stdout. (If --identify-strict, an error is
3510 reported if more than one match was found). */
3513 identify_dll_for_implib (void)
3517 identify_data_type identify_data;
3518 symname_search_data_type search_data;
3520 /* Initialize identify_data. */
3521 identify_data.list = dll_name_list_create ();
3522 identify_data.ms_style_implib = FALSE;
3524 /* Initialize search_data. */
3525 search_data.symname = "__NULL_IMPORT_DESCRIPTOR";
3526 search_data.found = FALSE;
3530 abfd = bfd_openr (identify_imp_name, 0);
3532 /* xgettext:c-format */
3533 fatal (_("Can't open .lib file: %s: %s"),
3534 identify_imp_name, bfd_get_errmsg ());
3536 if (! bfd_check_format (abfd, bfd_archive))
3538 if (! bfd_close (abfd))
3539 bfd_fatal (identify_imp_name);
3541 fatal (_("%s is not a library"), identify_imp_name);
3544 /* Detect if this a Microsoft import library. */
3545 identify_search_archive (abfd,
3546 identify_member_contains_symname,
3547 (void *)(& search_data));
3548 if (search_data.found)
3549 identify_data.ms_style_implib = TRUE;
3551 /* Rewind the bfd. */
3552 if (! bfd_close (abfd))
3553 bfd_fatal (identify_imp_name);
3554 abfd = bfd_openr (identify_imp_name, 0);
3556 bfd_fatal (identify_imp_name);
3558 if (!bfd_check_format (abfd, bfd_archive))
3560 if (!bfd_close (abfd))
3561 bfd_fatal (identify_imp_name);
3563 fatal (_("%s is not a library"), identify_imp_name);
3566 /* Now search for the dll name. */
3567 identify_search_archive (abfd,
3568 identify_search_member,
3569 (void *)(& identify_data));
3571 if (! bfd_close (abfd))
3572 bfd_fatal (identify_imp_name);
3574 count = dll_name_list_count (identify_data.list);
3577 if (identify_strict && count > 1)
3579 dll_name_list_free (identify_data.list);
3580 identify_data.list = NULL;
3581 fatal (_("Import library `%s' specifies two or more dlls"),
3584 dll_name_list_print (identify_data.list);
3585 dll_name_list_free (identify_data.list);
3586 identify_data.list = NULL;
3590 dll_name_list_free (identify_data.list);
3591 identify_data.list = NULL;
3592 fatal (_("Unable to determine dll name for `%s' (not an import library?)"),
3597 /* Loop over all members of the archive, applying the supplied function to
3598 each member that is a bfd_object. The function will be called as if:
3599 func (member_bfd, abfd, user_storage) */
3602 identify_search_archive (bfd * abfd,
3603 void (* operation) (bfd *, bfd *, void *),
3604 void * user_storage)
3606 bfd * arfile = NULL;
3607 bfd * last_arfile = NULL;
3612 arfile = bfd_openr_next_archived_file (abfd, arfile);
3616 if (bfd_get_error () != bfd_error_no_more_archived_files)
3617 bfd_fatal (bfd_get_filename (abfd));
3621 if (bfd_check_format_matches (arfile, bfd_object, &matching))
3622 (*operation) (arfile, abfd, user_storage);
3625 bfd_nonfatal (bfd_get_filename (arfile));
3629 if (last_arfile != NULL)
3631 bfd_close (last_arfile);
3632 /* PR 17512: file: 8b2168d4. */
3633 if (last_arfile == arfile)
3640 last_arfile = arfile;
3643 if (last_arfile != NULL)
3645 bfd_close (last_arfile);
3649 /* Call the identify_search_section() function for each section of this
3653 identify_search_member (bfd *abfd,
3654 bfd *archive_bfd ATTRIBUTE_UNUSED,
3657 bfd_map_over_sections (abfd, identify_search_section, obj);
3660 /* This predicate returns true if section->name matches the desired value.
3661 By default, this is .idata$7 (.idata$6 on PPC, or if the import
3662 library is ms-style). */
3665 identify_process_section_p (asection * section, bfd_boolean ms_style_implib)
3667 static const char * SECTION_NAME =
3669 /* dllname is stored in idata$6 on PPC */
3674 static const char * MS_SECTION_NAME = ".idata$6";
3676 const char * section_name =
3677 (ms_style_implib ? MS_SECTION_NAME : SECTION_NAME);
3679 if (strcmp (section_name, section->name) == 0)
3684 /* If *section has contents and its name is .idata$7 (.data$6 on PPC or if
3685 import lib ms-generated) -- and it satisfies several other constraints
3686 -- then add the contents of the section to obj->list. */
3689 identify_search_section (bfd * abfd, asection * section, void * obj)
3692 bfd_size_type datasize;
3693 identify_data_type * identify_data = (identify_data_type *)obj;
3694 bfd_boolean ms_style = identify_data->ms_style_implib;
3696 if ((section->flags & SEC_HAS_CONTENTS) == 0)
3699 if (! identify_process_section_p (section, ms_style))
3702 /* Binutils import libs seem distinguish the .idata$7 section that contains
3703 the DLL name from other .idata$7 sections by the absence of the
3705 if (!ms_style && ((section->flags & SEC_RELOC) == SEC_RELOC))
3708 /* MS import libs seem to distinguish the .idata$6 section
3709 that contains the DLL name from other .idata$6 sections
3710 by the presence of the SEC_DATA flag. */
3711 if (ms_style && ((section->flags & SEC_DATA) == 0))
3714 if ((datasize = bfd_section_size (abfd, section)) == 0)
3717 data = (bfd_byte *) xmalloc (datasize + 1);
3720 bfd_get_section_contents (abfd, section, data, 0, datasize);
3721 data[datasize] = '\0';
3723 /* Use a heuristic to determine if data is a dll name.
3724 Possible to defeat this if (a) the library has MANY
3725 (more than 0x302f) imports, (b) it is an ms-style
3726 import library, but (c) it is buggy, in that the SEC_DATA
3727 flag is set on the "wrong" sections. This heuristic might
3728 also fail to record a valid dll name if the dllname uses
3729 a multibyte or unicode character set (is that valid?).
3731 This heuristic is based on the fact that symbols names in
3732 the chosen section -- as opposed to the dll name -- begin
3733 at offset 2 in the data. The first two bytes are a 16bit
3734 little-endian count, and start at 0x0000. However, the dll
3735 name begins at offset 0 in the data. We assume that the
3736 dll name does not contain unprintable characters. */
3737 if (data[0] != '\0' && ISPRINT (data[0])
3738 && ((datasize < 2) || ISPRINT (data[1])))
3739 dll_name_list_append (identify_data->list, data);
3744 /* Run through the information gathered from the .o files and the
3745 .def file and work out the best stuff. */
3748 pfunc (const void *a, const void *b)
3750 export_type *ap = *(export_type **) a;
3751 export_type *bp = *(export_type **) b;
3753 if (ap->ordinal == bp->ordinal)
3756 /* Unset ordinals go to the bottom. */
3757 if (ap->ordinal == -1)
3759 if (bp->ordinal == -1)
3761 return (ap->ordinal - bp->ordinal);
3765 nfunc (const void *a, const void *b)
3767 export_type *ap = *(export_type **) a;
3768 export_type *bp = *(export_type **) b;
3769 const char *an = ap->name;
3770 const char *bn = bp->name;
3777 an = (an[0] == '@') ? an + 1 : an;
3778 bn = (bn[0] == '@') ? bn + 1 : bn;
3781 return (strcmp (an, bn));
3785 remove_null_names (export_type **ptr)
3790 for (dst = src = 0; src < d_nfuncs; src++)
3794 ptr[dst] = ptr[src];
3802 process_duplicates (export_type **d_export_vec)
3810 /* Remove duplicates. */
3811 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), nfunc);
3813 for (i = 0; i < d_nfuncs - 1; i++)
3815 if (strcmp (d_export_vec[i]->name,
3816 d_export_vec[i + 1]->name) == 0)
3818 export_type *a = d_export_vec[i];
3819 export_type *b = d_export_vec[i + 1];
3823 /* xgettext:c-format */
3824 inform (_("Warning, ignoring duplicate EXPORT %s %d,%d"),
3825 a->name, a->ordinal, b->ordinal);
3827 if (a->ordinal != -1
3828 && b->ordinal != -1)
3829 /* xgettext:c-format */
3830 fatal (_("Error, duplicate EXPORT with ordinals: %s"),
3833 /* Merge attributes. */
3834 b->ordinal = a->ordinal > 0 ? a->ordinal : b->ordinal;
3835 b->constant |= a->constant;
3836 b->noname |= a->noname;
3838 d_export_vec[i] = 0;
3841 remove_null_names (d_export_vec);
3845 /* Count the names. */
3846 for (i = 0; i < d_nfuncs; i++)
3847 if (!d_export_vec[i]->noname)
3852 fill_ordinals (export_type **d_export_vec)
3859 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
3861 /* Fill in the unset ordinals with ones from our range. */
3862 ptr = (char *) xmalloc (size);
3864 memset (ptr, 0, size);
3866 /* Mark in our large vector all the numbers that are taken. */
3867 for (i = 0; i < d_nfuncs; i++)
3869 if (d_export_vec[i]->ordinal != -1)
3871 ptr[d_export_vec[i]->ordinal] = 1;
3873 if (lowest == -1 || d_export_vec[i]->ordinal < lowest)
3874 lowest = d_export_vec[i]->ordinal;
3878 /* Start at 1 for compatibility with MS toolchain. */
3882 /* Now fill in ordinals where the user wants us to choose. */
3883 for (i = 0; i < d_nfuncs; i++)
3885 if (d_export_vec[i]->ordinal == -1)
3889 /* First try within or after any user supplied range. */
3890 for (j = lowest; j < size; j++)
3894 d_export_vec[i]->ordinal = j;
3898 /* Then try before the range. */
3899 for (j = lowest; j >0; j--)
3903 d_export_vec[i]->ordinal = j;
3913 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
3915 /* Work out the lowest and highest ordinal numbers. */
3918 if (d_export_vec[0])
3919 d_low_ord = d_export_vec[0]->ordinal;
3920 if (d_export_vec[d_nfuncs-1])
3921 d_high_ord = d_export_vec[d_nfuncs-1]->ordinal;
3928 /* First work out the minimum ordinal chosen. */
3933 export_type **d_export_vec = xmalloc (sizeof (export_type *) * d_nfuncs);
3935 inform (_("Processing definitions"));
3937 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3938 d_export_vec[i] = exp;
3940 process_duplicates (d_export_vec);
3941 fill_ordinals (d_export_vec);
3943 /* Put back the list in the new order. */
3945 for (i = d_nfuncs - 1; i >= 0; i--)
3947 d_export_vec[i]->next = d_exports;
3948 d_exports = d_export_vec[i];
3951 /* Build list in alpha order. */
3952 d_exports_lexically = (export_type **)
3953 xmalloc (sizeof (export_type *) * (d_nfuncs + 1));
3955 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3956 d_exports_lexically[i] = exp;
3958 d_exports_lexically[i] = 0;
3960 qsort (d_exports_lexically, i, sizeof (export_type *), nfunc);
3962 /* Fill exp entries with their hint values. */
3963 for (i = 0; i < d_nfuncs; i++)
3964 if (!d_exports_lexically[i]->noname || show_allnames)
3965 d_exports_lexically[i]->hint = hint++;
3967 inform (_("Processed definitions"));
3971 usage (FILE *file, int status)
3973 /* xgetext:c-format */
3974 fprintf (file, _("Usage %s <option(s)> <object-file(s)>\n"), program_name);
3975 /* xgetext:c-format */
3976 fprintf (file, _(" -m --machine <machine> Create as DLL for <machine>. [default: %s]\n"), mname);
3977 fprintf (file, _(" possible <machine>: arm[_interwork], i386, mcore[-elf]{-le|-be}, ppc, thumb\n"));
3978 fprintf (file, _(" -e --output-exp <outname> Generate an export file.\n"));
3979 fprintf (file, _(" -l --output-lib <outname> Generate an interface library.\n"));
3980 fprintf (file, _(" -y --output-delaylib <outname> Create a delay-import library.\n"));
3981 fprintf (file, _(" -a --add-indirect Add dll indirects to export file.\n"));
3982 fprintf (file, _(" -D --dllname <name> Name of input dll to put into interface lib.\n"));
3983 fprintf (file, _(" -d --input-def <deffile> Name of .def file to be read in.\n"));
3984 fprintf (file, _(" -z --output-def <deffile> Name of .def file to be created.\n"));
3985 fprintf (file, _(" --export-all-symbols Export all symbols to .def\n"));
3986 fprintf (file, _(" --no-export-all-symbols Only export listed symbols\n"));
3987 fprintf (file, _(" --exclude-symbols <list> Don't export <list>\n"));
3988 fprintf (file, _(" --no-default-excludes Clear default exclude symbols\n"));
3989 fprintf (file, _(" -b --base-file <basefile> Read linker generated base file.\n"));
3990 fprintf (file, _(" -x --no-idata4 Don't generate idata$4 section.\n"));
3991 fprintf (file, _(" -c --no-idata5 Don't generate idata$5 section.\n"));
3992 fprintf (file, _(" --use-nul-prefixed-import-tables Use zero prefixed idata$4 and idata$5.\n"));
3993 fprintf (file, _(" -U --add-underscore Add underscores to all symbols in interface library.\n"));
3994 fprintf (file, _(" --add-stdcall-underscore Add underscores to stdcall symbols in interface library.\n"));
3995 fprintf (file, _(" --no-leading-underscore All symbols shouldn't be prefixed by an underscore.\n"));
3996 fprintf (file, _(" --leading-underscore All symbols should be prefixed by an underscore.\n"));
3997 fprintf (file, _(" -k --kill-at Kill @<n> from exported names.\n"));
3998 fprintf (file, _(" -A --add-stdcall-alias Add aliases without @<n>.\n"));
3999 fprintf (file, _(" -p --ext-prefix-alias <prefix> Add aliases with <prefix>.\n"));
4000 fprintf (file, _(" -S --as <name> Use <name> for assembler.\n"));
4001 fprintf (file, _(" -f --as-flags <flags> Pass <flags> to the assembler.\n"));
4002 fprintf (file, _(" -C --compat-implib Create backward compatible import library.\n"));
4003 fprintf (file, _(" -n --no-delete Keep temp files (repeat for extra preservation).\n"));
4004 fprintf (file, _(" -t --temp-prefix <prefix> Use <prefix> to construct temp file names.\n"));
4005 fprintf (file, _(" -I --identify <implib> Report the name of the DLL associated with <implib>.\n"));
4006 fprintf (file, _(" --identify-strict Causes --identify to report error when multiple DLLs.\n"));
4007 fprintf (file, _(" -v --verbose Be verbose.\n"));
4008 fprintf (file, _(" -V --version Display the program version.\n"));
4009 fprintf (file, _(" -h --help Display this information.\n"));
4010 fprintf (file, _(" @<file> Read options from <file>.\n"));
4011 #ifdef DLLTOOL_MCORE_ELF
4012 fprintf (file, _(" -M --mcore-elf <outname> Process mcore-elf object files into <outname>.\n"));
4013 fprintf (file, _(" -L --linker <name> Use <name> as the linker.\n"));
4014 fprintf (file, _(" -F --linker-flags <flags> Pass <flags> to the linker.\n"));
4016 if (REPORT_BUGS_TO[0] && status == 0)
4017 fprintf (file, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4021 #define OPTION_EXPORT_ALL_SYMS 150
4022 #define OPTION_NO_EXPORT_ALL_SYMS (OPTION_EXPORT_ALL_SYMS + 1)
4023 #define OPTION_EXCLUDE_SYMS (OPTION_NO_EXPORT_ALL_SYMS + 1)
4024 #define OPTION_NO_DEFAULT_EXCLUDES (OPTION_EXCLUDE_SYMS + 1)
4025 #define OPTION_ADD_STDCALL_UNDERSCORE (OPTION_NO_DEFAULT_EXCLUDES + 1)
4026 #define OPTION_USE_NUL_PREFIXED_IMPORT_TABLES \
4027 (OPTION_ADD_STDCALL_UNDERSCORE + 1)
4028 #define OPTION_IDENTIFY_STRICT (OPTION_USE_NUL_PREFIXED_IMPORT_TABLES + 1)
4029 #define OPTION_NO_LEADING_UNDERSCORE (OPTION_IDENTIFY_STRICT + 1)
4030 #define OPTION_LEADING_UNDERSCORE (OPTION_NO_LEADING_UNDERSCORE + 1)
4032 static const struct option long_options[] =
4034 {"no-delete", no_argument, NULL, 'n'},
4035 {"dllname", required_argument, NULL, 'D'},
4036 {"no-idata4", no_argument, NULL, 'x'},
4037 {"no-idata5", no_argument, NULL, 'c'},
4038 {"use-nul-prefixed-import-tables", no_argument, NULL,
4039 OPTION_USE_NUL_PREFIXED_IMPORT_TABLES},
4040 {"output-exp", required_argument, NULL, 'e'},
4041 {"output-def", required_argument, NULL, 'z'},
4042 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL_SYMS},
4043 {"no-export-all-symbols", no_argument, NULL, OPTION_NO_EXPORT_ALL_SYMS},
4044 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMS},
4045 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
4046 {"output-lib", required_argument, NULL, 'l'},
4047 {"def", required_argument, NULL, 'd'}, /* for compatibility with older versions */
4048 {"input-def", required_argument, NULL, 'd'},
4049 {"add-underscore", no_argument, NULL, 'U'},
4050 {"add-stdcall-underscore", no_argument, NULL, OPTION_ADD_STDCALL_UNDERSCORE},
4051 {"no-leading-underscore", no_argument, NULL, OPTION_NO_LEADING_UNDERSCORE},
4052 {"leading-underscore", no_argument, NULL, OPTION_LEADING_UNDERSCORE},
4053 {"kill-at", no_argument, NULL, 'k'},
4054 {"add-stdcall-alias", no_argument, NULL, 'A'},
4055 {"ext-prefix-alias", required_argument, NULL, 'p'},
4056 {"identify", required_argument, NULL, 'I'},
4057 {"identify-strict", no_argument, NULL, OPTION_IDENTIFY_STRICT},
4058 {"verbose", no_argument, NULL, 'v'},
4059 {"version", no_argument, NULL, 'V'},
4060 {"help", no_argument, NULL, 'h'},
4061 {"machine", required_argument, NULL, 'm'},
4062 {"add-indirect", no_argument, NULL, 'a'},
4063 {"base-file", required_argument, NULL, 'b'},
4064 {"as", required_argument, NULL, 'S'},
4065 {"as-flags", required_argument, NULL, 'f'},
4066 {"mcore-elf", required_argument, NULL, 'M'},
4067 {"compat-implib", no_argument, NULL, 'C'},
4068 {"temp-prefix", required_argument, NULL, 't'},
4069 {"output-delaylib", required_argument, NULL, 'y'},
4073 int main (int, char **);
4076 main (int ac, char **av)
4081 program_name = av[0];
4084 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
4085 setlocale (LC_MESSAGES, "");
4087 #if defined (HAVE_SETLOCALE)
4088 setlocale (LC_CTYPE, "");
4090 bindtextdomain (PACKAGE, LOCALEDIR);
4091 textdomain (PACKAGE);
4093 bfd_set_error_program_name (program_name);
4094 expandargv (&ac, &av);
4096 while ((c = getopt_long (ac, av,
4097 #ifdef DLLTOOL_MCORE_ELF
4098 "m:e:l:aD:d:z:b:xp:cCuUkAS:t:f:nI:vVHhM:L:F:",
4100 "m:e:l:y:aD:d:z:b:xp:cCuUkAS:t:f:nI:vVHh",
4107 case OPTION_EXPORT_ALL_SYMS:
4108 export_all_symbols = TRUE;
4110 case OPTION_NO_EXPORT_ALL_SYMS:
4111 export_all_symbols = FALSE;
4113 case OPTION_EXCLUDE_SYMS:
4114 add_excludes (optarg);
4116 case OPTION_NO_DEFAULT_EXCLUDES:
4117 do_default_excludes = FALSE;
4119 case OPTION_USE_NUL_PREFIXED_IMPORT_TABLES:
4120 use_nul_prefixed_import_tables = TRUE;
4122 case OPTION_ADD_STDCALL_UNDERSCORE:
4123 add_stdcall_underscore = 1;
4125 case OPTION_NO_LEADING_UNDERSCORE:
4126 leading_underscore = 0;
4128 case OPTION_LEADING_UNDERSCORE:
4129 leading_underscore = 1;
4131 case OPTION_IDENTIFY_STRICT:
4132 identify_strict = 1;
4144 tmp_prefix = optarg;
4150 /* Ignored for compatibility. */
4157 output_def = fopen (optarg, FOPEN_WT);
4159 /* xgettext:c-format */
4160 fatal (_("Unable to open def-file: %s"), optarg);
4163 dll_name = (char*) lbasename (optarg);
4164 if (dll_name != optarg)
4165 non_fatal (_("Path components stripped from dllname, '%s'."),
4182 identify_imp_name = optarg;
4188 print_version (program_name);
4197 add_stdcall_alias = 1;
4200 ext_prefix_alias = optarg;
4209 base_file = fopen (optarg, FOPEN_RB);
4212 /* xgettext:c-format */
4213 fatal (_("Unable to open base-file: %s"), optarg);
4216 #ifdef DLLTOOL_MCORE_ELF
4218 mcore_elf_out_file = optarg;
4221 mcore_elf_linker = optarg;
4224 mcore_elf_linker_flags = optarg;
4228 create_compat_implib = 1;
4231 delayimp_name = optarg;
4240 tmp_prefix = prefix_encode ("d", getpid ());
4242 for (i = 0; mtable[i].type; i++)
4243 if (strcmp (mtable[i].type, mname) == 0)
4246 if (!mtable[i].type)
4247 /* xgettext:c-format */
4248 fatal (_("Machine '%s' not supported"), mname);
4252 /* Check if we generated PE+. */
4253 create_for_pep = strcmp (mname, "i386:x86-64") == 0;
4256 /* Check the default underscore */
4257 int u = leading_underscore; /* Underscoring mode. -1 for use default. */
4259 bfd_get_target_info (mtable[machine].how_bfd_target, NULL,
4262 leading_underscore = (u != 0 ? TRUE : FALSE);
4265 if (!dll_name && exp_name)
4267 /* If we are inferring dll_name from exp_name,
4268 strip off any path components, without emitting
4270 const char* exp_basename = lbasename (exp_name);
4271 const int len = strlen (exp_basename) + 5;
4272 dll_name = xmalloc (len);
4273 strcpy (dll_name, exp_basename);
4274 strcat (dll_name, ".dll");
4275 dll_name_set_by_exp_name = 1;
4278 if (as_name == NULL)
4279 as_name = deduce_name ("as");
4281 /* Don't use the default exclude list if we're reading only the
4282 symbols in the .drectve section. The default excludes are meant
4283 to avoid exporting DLL entry point and Cygwin32 impure_ptr. */
4284 if (! export_all_symbols)
4285 do_default_excludes = FALSE;
4287 if (do_default_excludes)
4288 set_default_excludes ();
4291 process_def_file (def_file);
4296 firstarg = av[optind];
4297 scan_obj_file (av[optind]);
4308 /* Make imp_name safe for use as a label. */
4311 imp_name_lab = xstrdup (imp_name);
4312 for (p = imp_name_lab; *p; p++)
4317 head_label = make_label("_head_", imp_name_lab);
4323 /* Make delayimp_name safe for use as a label. */
4326 if (mtable[machine].how_dljtab == 0)
4328 inform (_("Warning, machine type (%d) not supported for "
4329 "delayimport."), machine);
4334 imp_name = delayimp_name;
4335 imp_name_lab = xstrdup (imp_name);
4336 for (p = imp_name_lab; *p; p++)
4341 head_label = make_label("__tailMerge_", imp_name_lab);
4349 if (identify_imp_name)
4351 identify_dll_for_implib ();
4354 #ifdef DLLTOOL_MCORE_ELF
4355 if (mcore_elf_out_file)
4356 mcore_elf_gen_out_file ();
4362 /* Look for the program formed by concatenating PROG_NAME and the
4363 string running from PREFIX to END_PREFIX. If the concatenated
4364 string contains a '/', try appending EXECUTABLE_SUFFIX if it is
4368 look_for_prog (const char *prog_name, const char *prefix, int end_prefix)
4373 cmd = xmalloc (strlen (prefix)
4374 + strlen (prog_name)
4375 #ifdef HAVE_EXECUTABLE_SUFFIX
4376 + strlen (EXECUTABLE_SUFFIX)
4379 strcpy (cmd, prefix);
4381 sprintf (cmd + end_prefix, "%s", prog_name);
4383 if (strchr (cmd, '/') != NULL)
4387 found = (stat (cmd, &s) == 0
4388 #ifdef HAVE_EXECUTABLE_SUFFIX
4389 || stat (strcat (cmd, EXECUTABLE_SUFFIX), &s) == 0
4395 /* xgettext:c-format */
4396 inform (_("Tried file: %s"), cmd);
4402 /* xgettext:c-format */
4403 inform (_("Using file: %s"), cmd);
4408 /* Deduce the name of the program we are want to invoke.
4409 PROG_NAME is the basic name of the program we want to run,
4410 eg "as" or "ld". The catch is that we might want actually
4411 run "i386-pe-as" or "ppc-pe-ld".
4413 If argv[0] contains the full path, then try to find the program
4414 in the same place, with and then without a target-like prefix.
4416 Given, argv[0] = /usr/local/bin/i586-cygwin32-dlltool,
4417 deduce_name("as") uses the following search order:
4419 /usr/local/bin/i586-cygwin32-as
4423 If there's an EXECUTABLE_SUFFIX, it'll use that as well; for each
4424 name, it'll try without and then with EXECUTABLE_SUFFIX.
4426 Given, argv[0] = i586-cygwin32-dlltool, it will not even try "as"
4427 as the fallback, but rather return i586-cygwin32-as.
4429 Oh, and given, argv[0] = dlltool, it'll return "as".
4431 Returns a dynamically allocated string. */
4434 deduce_name (const char *prog_name)
4437 char *dash, *slash, *cp;
4441 for (cp = program_name; *cp != '\0'; ++cp)
4446 #if defined(__DJGPP__) || defined (__CYGWIN__) || defined(__WIN32__)
4447 *cp == ':' || *cp == '\\' ||
4460 /* First, try looking for a prefixed PROG_NAME in the
4461 PROGRAM_NAME directory, with the same prefix as PROGRAM_NAME. */
4462 cmd = look_for_prog (prog_name, program_name, dash - program_name + 1);
4465 if (slash != NULL && cmd == NULL)
4467 /* Next, try looking for a PROG_NAME in the same directory as
4468 that of this program. */
4469 cmd = look_for_prog (prog_name, program_name, slash - program_name + 1);
4474 /* Just return PROG_NAME as is. */
4475 cmd = xstrdup (prog_name);
4481 #ifdef DLLTOOL_MCORE_ELF
4482 typedef struct fname_cache
4484 const char * filename;
4485 struct fname_cache * next;
4489 static fname_cache fnames;
4492 mcore_elf_cache_filename (const char * filename)
4498 while (ptr->next != NULL)
4501 ptr->filename = filename;
4502 ptr->next = (fname_cache *) malloc (sizeof (fname_cache));
4503 if (ptr->next != NULL)
4504 ptr->next->next = NULL;
4507 #define MCORE_ELF_TMP_OBJ "mcoreelf.o"
4508 #define MCORE_ELF_TMP_EXP "mcoreelf.exp"
4509 #define MCORE_ELF_TMP_LIB "mcoreelf.lib"
4512 mcore_elf_gen_out_file (void)
4517 /* Step one. Run 'ld -r' on the input object files in order to resolve
4518 any internal references and to generate a single .exports section. */
4521 ds = dyn_string_new (100);
4522 dyn_string_append_cstr (ds, "-r ");
4524 if (mcore_elf_linker_flags != NULL)
4525 dyn_string_append_cstr (ds, mcore_elf_linker_flags);
4527 while (ptr->next != NULL)
4529 dyn_string_append_cstr (ds, ptr->filename);
4530 dyn_string_append_cstr (ds, " ");
4535 dyn_string_append_cstr (ds, "-o ");
4536 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
4538 if (mcore_elf_linker == NULL)
4539 mcore_elf_linker = deduce_name ("ld");
4541 run (mcore_elf_linker, ds->s);
4543 dyn_string_delete (ds);
4545 /* Step two. Create a .exp file and a .lib file from the temporary file.
4546 Do this by recursively invoking dlltool... */
4547 ds = dyn_string_new (100);
4549 dyn_string_append_cstr (ds, "-S ");
4550 dyn_string_append_cstr (ds, as_name);
4552 dyn_string_append_cstr (ds, " -e ");
4553 dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP);
4554 dyn_string_append_cstr (ds, " -l ");
4555 dyn_string_append_cstr (ds, MCORE_ELF_TMP_LIB);
4556 dyn_string_append_cstr (ds, " " );
4557 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
4560 dyn_string_append_cstr (ds, " -v");
4564 dyn_string_append_cstr (ds, " -n");
4566 if (dontdeltemps > 1)
4567 dyn_string_append_cstr (ds, " -n");
4570 /* XXX - FIME: ought to check/copy other command line options as well. */
4571 run (program_name, ds->s);
4573 dyn_string_delete (ds);
4575 /* Step four. Feed the .exp and object files to ld -shared to create the dll. */
4576 ds = dyn_string_new (100);
4578 dyn_string_append_cstr (ds, "-shared ");
4580 if (mcore_elf_linker_flags)
4581 dyn_string_append_cstr (ds, mcore_elf_linker_flags);
4583 dyn_string_append_cstr (ds, " ");
4584 dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP);
4585 dyn_string_append_cstr (ds, " ");
4586 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
4587 dyn_string_append_cstr (ds, " -o ");
4588 dyn_string_append_cstr (ds, mcore_elf_out_file);
4590 run (mcore_elf_linker, ds->s);
4592 dyn_string_delete (ds);
4594 if (dontdeltemps == 0)
4595 unlink (MCORE_ELF_TMP_EXP);
4597 if (dontdeltemps < 2)
4598 unlink (MCORE_ELF_TMP_OBJ);
4600 #endif /* DLLTOOL_MCORE_ELF */