1 /* dlltool.c -- tool to generate stuff for PE style DLLs
2 Copyright (C) 1995-2016 Free Software Foundation, Inc.
3
4 This file is part of GNU Binutils.
5
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.
10
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.
15
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
19 02110-1301, USA. */
20
21
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.
24 (eg, Windows NT)
25
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.
30
31 A DLL contains an export table which contains the information
32 which the runtime loader needs to tie up references from a
33 referencing program.
34
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.
39
40 A DEF file contains any number of the following commands:
41
42
43 NAME <name> [ , <base> ]
44 The result is going to be <name>.EXE
45
46 LIBRARY <name> [ , <base> ]
47 The result is going to be <name>.DLL
48
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>.
56
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.
63
64 DESCRIPTION <string>
65 Puts <string> into output .exp file in the .rdata section
66
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.
71
72 [CODE|DATA] <attr>+
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
77 upon it.
78
79
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>
82 in a .DEF file.
83
84
85
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
88 supplied argument.
89
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.
93
94
95
96 Example:
97
98 file1.c:
99 asm (".section .drectve");
100 asm (".ascii \"-export:adef\"");
101
102 void adef (char * s)
103 {
104 printf ("hello from the dll %s\n", s);
105 }
106
107 void bdef (char * s)
108 {
109 printf ("hello from the dll and the other entry point %s\n", s);
110 }
111
112 file2.c:
113 asm (".section .drectve");
114 asm (".ascii \"-export:cdef\"");
115 asm (".ascii \"-export:ddef\"");
116
117 void cdef (char * s)
118 {
119 printf ("hello from the dll %s\n", s);
120 }
121
122 void ddef (char * s)
123 {
124 printf ("hello from the dll and the other entry point %s\n", s);
125 }
126
127 int printf (void)
128 {
129 return 9;
130 }
131
132 themain.c:
133 int main (void)
134 {
135 cdef ();
136 return 0;
137 }
138
139 thedll.def
140
141 LIBRARY thedll
142 HEAPSIZE 0x40000, 0x2000
143 EXPORTS bdef @ 20
144 cdef @ 30 NONAME
145
146 SECTIONS donkey READ WRITE
147 aardvark EXECUTE
148
149 # Compile up the parts of the dll and the program
150
151 gcc -c file1.c file2.c themain.c
152
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)
156
157 ar qcv thedll.in file1.o file2.o
158 ranlib thedll.in
159
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).
163
164 dlltool --def thedll.def --output-exp thedll.o --output-lib thedll.a
165
166 # Build the dll with the library and the export table
167
168 ld -o thedll.dll thedll.o thedll.in
169
170 # Link the executable with the import library
171
172 gcc -o themain.exe themain.o thedll.a
173
174 This example can be extended if relocations are needed in the DLL:
175
176 # Compile up the parts of the dll and the program
177
178 gcc -c file1.c file2.c themain.c
179
180 # Run this tool over the DLL's .def file and generate an imports file.
181
182 dlltool --def thedll.def --output-lib thedll.lib
183
184 # Link the executable with the import library and generate a base file
185 # at the same time
186
187 gcc -o themain.exe themain.o thedll.lib -Wl,--base-file -Wl,themain.base
188
189 # Run this tool over the DLL's .def file and generate an exports file
190 # which includes the relocations from the base file.
191
192 dlltool --def thedll.def --base-file themain.base --output-exp thedll.exp
193
194 # Build the dll with file1.o, file2.o and the export table
195
196 ld -o thedll.dll thedll.exp file1.o file2.o */
197
198 /* .idata section description
199
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.
203
204 .idata$2 = Import Directory Table
205 = array of IMAGE_IMPORT_DESCRIPTOR's.
206
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
212
213 .idata$3 = null terminating entry for .idata$2.
214
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.
219
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
226 function.
227
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.
231
232 .idata$7 = dll name (eg: "kernel32.dll"). (.idata$6 for ppc). */
233
234 #include "sysdep.h"
235 #include "bfd.h"
236 #include "libiberty.h"
237 #include "getopt.h"
238 #include "demangle.h"
239 #include "dyn-string.h"
240 #include "bucomm.h"
241 #include "dlltool.h"
242 #include "safe-ctype.h"
243
244 #include <time.h>
245 #include <assert.h>
246
247 #ifdef DLLTOOL_ARM
248 #include "coff/arm.h"
249 #include "coff/internal.h"
250 #endif
251 #ifdef DLLTOOL_DEFAULT_MX86_64
252 #include "coff/x86_64.h"
253 #endif
254 #ifdef DLLTOOL_DEFAULT_I386
255 #include "coff/i386.h"
256 #endif
257
258 #ifndef COFF_PAGE_SIZE
259 #define COFF_PAGE_SIZE ((bfd_vma) 4096)
260 #endif
261
262 #ifndef PAGE_MASK
263 #define PAGE_MASK ((bfd_vma) (- COFF_PAGE_SIZE))
264 #endif
265
266 /* Get current BFD error message. */
267 #define bfd_get_errmsg() (bfd_errmsg (bfd_get_error ()))
268
269 /* Forward references. */
270 static char *look_for_prog (const char *, const char *, int);
271 static char *deduce_name (const char *);
272
273 #ifdef DLLTOOL_MCORE_ELF
274 static void mcore_elf_cache_filename (const char *);
275 static void mcore_elf_gen_out_file (void);
276 #endif
277
278 #ifdef HAVE_SYS_WAIT_H
279 #include <sys/wait.h>
280 #else /* ! HAVE_SYS_WAIT_H */
281 #if ! defined (_WIN32) || defined (__CYGWIN32__)
282 #ifndef WIFEXITED
283 #define WIFEXITED(w) (((w) & 0377) == 0)
284 #endif
285 #ifndef WIFSIGNALED
286 #define WIFSIGNALED(w) (((w) & 0377) != 0177 && ((w) & ~0377) == 0)
287 #endif
288 #ifndef WTERMSIG
289 #define WTERMSIG(w) ((w) & 0177)
290 #endif
291 #ifndef WEXITSTATUS
292 #define WEXITSTATUS(w) (((w) >> 8) & 0377)
293 #endif
294 #else /* defined (_WIN32) && ! defined (__CYGWIN32__) */
295 #ifndef WIFEXITED
296 #define WIFEXITED(w) (((w) & 0xff) == 0)
297 #endif
298 #ifndef WIFSIGNALED
299 #define WIFSIGNALED(w) (((w) & 0xff) != 0 && ((w) & 0xff) != 0x7f)
300 #endif
301 #ifndef WTERMSIG
302 #define WTERMSIG(w) ((w) & 0x7f)
303 #endif
304 #ifndef WEXITSTATUS
305 #define WEXITSTATUS(w) (((w) & 0xff00) >> 8)
306 #endif
307 #endif /* defined (_WIN32) && ! defined (__CYGWIN32__) */
308 #endif /* ! HAVE_SYS_WAIT_H */
309
310 #define show_allnames 0
311
312 /* ifunc and ihead data structures: ttk@cygnus.com 1997
313
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.
321
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. */
326
327 typedef struct ifunct
328 {
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. */
332 struct ifunct *next;
333 } ifunctype;
334
335 typedef struct iheadt
336 {
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. */
342 } iheadtype;
343
344 /* Structure containing all import information as defined in .def file
345 (qv "ihead structure"). */
346
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;
358
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
364 {
365 char * dllname;
366 struct dll_name_list_node_t * next;
367 } dll_name_list_node_type;
368
369 typedef struct dll_name_list_t
370 {
371 dll_name_list_node_type * head;
372 dll_name_list_node_type * tail;
373 } dll_name_list_type;
374
375 /* Types used to pass data to iterator functions. */
376 typedef struct symname_search_data_t
377 {
378 const char * symname;
379 bfd_boolean found;
380 } symname_search_data_type;
381
382 typedef struct identify_data_t
383 {
384 dll_name_list_type * list;
385 bfd_boolean ms_style_implib;
386 } identify_data_type;
387
388
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;
402
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;
406
407 /* TRUE if we should exclude the symbols in DEFAULT_EXCLUDES when
408 exporting all symbols. */
409 static bfd_boolean do_default_excludes = TRUE;
410
411 static bfd_boolean use_nul_prefixed_import_tables = FALSE;
412
413 /* Default symbols to exclude when exporting all the symbols. */
414 static const char *default_excludes = "DllMain@12,DllEntryPoint@0,impure_ptr";
415
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;
419
420 /* TRUE if we have to write PE+ import libraries. */
421 static bfd_boolean create_for_pep;
422
423 static char *def_file;
424
425 extern char * program_name;
426
427 static int machine;
428 static int killat;
429 static int add_stdcall_alias;
430 static const char *ext_prefix_alias;
431 static int verbose;
432 static FILE *output_def;
433 static FILE *base_file;
434
435 #ifdef DLLTOOL_DEFAULT_ARM
436 static const char *mname = "arm";
437 #endif
438
439 #ifdef DLLTOOL_DEFAULT_ARM_EPOC
440 static const char *mname = "arm-epoc";
441 #endif
442
443 #ifdef DLLTOOL_DEFAULT_ARM_WINCE
444 static const char *mname = "arm-wince";
445 #endif
446
447 #ifdef DLLTOOL_DEFAULT_I386
448 static const char *mname = "i386";
449 #endif
450
451 #ifdef DLLTOOL_DEFAULT_MX86_64
452 static const char *mname = "i386:x86-64";
453 #endif
454
455 #ifdef DLLTOOL_DEFAULT_PPC
456 static const char *mname = "ppc";
457 #endif
458
459 #ifdef DLLTOOL_DEFAULT_SH
460 static const char *mname = "sh";
461 #endif
462
463 #ifdef DLLTOOL_DEFAULT_MIPS
464 static const char *mname = "mips";
465 #endif
466
467 #ifdef DLLTOOL_DEFAULT_MCORE
468 static const char * mname = "mcore-le";
469 #endif
470
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;
476
477 #define DRECTVE_SECTION_NAME ((machine == MMCORE_ELF || machine == MMCORE_ELF_LE) ? ".exports" : ".drectve")
478 #endif
479
480 #ifndef DRECTVE_SECTION_NAME
481 #define DRECTVE_SECTION_NAME ".drectve"
482 #endif
483
484 /* What's the right name for this ? */
485 #define PATHMAX 250
486
487 /* External name alias numbering starts here. */
488 #define PREFIX_ALIAS_BASE 20000
489
490 char *tmp_asm_buf;
491 char *tmp_head_s_buf;
492 char *tmp_head_o_buf;
493 char *tmp_tail_s_buf;
494 char *tmp_tail_o_buf;
495 char *tmp_stub_buf;
496
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")
503
504 /* This bit of assembly does jmp * .... */
505 static const unsigned char i386_jtab[] =
506 {
507 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
508 };
509
510 static const unsigned char i386_dljtab[] =
511 {
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 */
515 };
516
517 static const unsigned char i386_x64_dljtab[] =
518 {
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 */
523 };
524
525 static const unsigned char arm_jtab[] =
526 {
527 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
528 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
529 0, 0, 0, 0
530 };
531
532 static const unsigned char arm_interwork_jtab[] =
533 {
534 0x04, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
535 0x00, 0xc0, 0x9c, 0xe5, /* ldr ip, [ip] */
536 0x1c, 0xff, 0x2f, 0xe1, /* bx ip */
537 0, 0, 0, 0
538 };
539
540 static const unsigned char thumb_jtab[] =
541 {
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 */
548 0, 0, 0, 0
549 };
550
551 static const unsigned char mcore_be_jtab[] =
552 {
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> */
558 };
559
560 static const unsigned char mcore_le_jtab[] =
561 {
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> */
567 };
568
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
573 the glue. */
574 static const unsigned char ppc_jtab[] =
575 {
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 */
583 };
584
585 #ifdef DLLTOOL_PPC
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;
589 #endif
590
591 static const char i386_trampoline[] =
592 "\tpushl %%ecx\n"
593 "\tpushl %%edx\n"
594 "\tpushl %%eax\n"
595 "\tpushl $__DELAY_IMPORT_DESCRIPTOR_%s\n"
596 "\tcall ___delayLoadHelper2@8\n"
597 "\tpopl %%edx\n"
598 "\tpopl %%ecx\n"
599 "\tjmp *%%eax\n";
600
601 static const char i386_x64_trampoline[] =
602 "\tpushq %%rcx\n"
603 "\tpushq %%rdx\n"
604 "\tpushq %%r8\n"
605 "\tpushq %%r9\n"
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"
611 "\tpopq %%r9\n"
612 "\tpopq %%r8\n"
613 "\tpopq %%rdx\n"
614 "\tpopq %%rcx\n"
615 "\tjmp *%%rax\n";
616
617 struct mac
618 {
619 const char *type;
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;
642 };
643
644 static const struct mac
645 mtable[] =
646 {
647 {
648 #define MARM 0
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,
654 0, 0, 0, 0, 0, 0
655 }
656 ,
657 {
658 #define M386 1
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
664 }
665 ,
666 {
667 #define MPPC 2
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,
672 0, 0, 0, 0, 0, 0
673 }
674 ,
675 {
676 #define MTHUMB 3
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,
682 0, 0, 0, 0, 0, 0
683 }
684 ,
685 #define MARM_INTERWORK 4
686 {
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,
692 0, 0, 0, 0, 0, 0
693 }
694 ,
695 {
696 #define MMCORE_BE 5
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,
702 0, 0, 0, 0, 0, 0
703 }
704 ,
705 {
706 #define MMCORE_LE 6
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,
712 0, 0, 0, 0, 0, 0
713 }
714 ,
715 {
716 #define MMCORE_ELF 7
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,
722 0, 0, 0, 0, 0, 0
723 }
724 ,
725 {
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,
732 0, 0, 0, 0, 0, 0
733 }
734 ,
735 {
736 #define MARM_EPOC 9
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,
742 0, 0, 0, 0, 0, 0
743 }
744 ,
745 {
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,
752 0, 0, 0, 0, 0, 0
753 }
754 ,
755 {
756 #define MX86 11
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
762 }
763 ,
764 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
765 };
766
767 typedef struct dlist
768 {
769 char *text;
770 struct dlist *next;
771 }
772 dlist_type;
773
774 typedef struct export
775 {
776 const char *name;
777 const char *internal_name;
778 const char *import_name;
779 const char *its_name;
780 int ordinal;
781 int constant;
782 int noname; /* Don't put name in image file. */
783 int private; /* Don't put reference in import lib. */
784 int data;
785 int hint;
786 int forward; /* Number of forward label, 0 means no forward. */
787 struct export *next;
788 }
789 export_type;
790
791 /* A list of symbols which we should not export. */
792
793 struct string_list
794 {
795 struct string_list *next;
796 char *string;
797 };
798
799 static struct string_list *excludes;
800
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 *);
845
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);
855
856 static char *
prefix_encode(char * start,unsigned code)857 prefix_encode (char *start, unsigned code)
858 {
859 static char alpha[26] = "abcdefghijklmnopqrstuvwxyz";
860 static char buf[32];
861 char *p;
862 strcpy (buf, start);
863 p = strchr (buf, '\0');
864 do
865 *p++ = alpha[code % sizeof (alpha)];
866 while ((code /= sizeof (alpha)) != 0);
867 *p = '\0';
868 return buf;
869 }
870
871 static char *
dlltmp(char ** buf,const char * fmt)872 dlltmp (char **buf, const char *fmt)
873 {
874 if (!*buf)
875 {
876 *buf = malloc (strlen (tmp_prefix) + 64);
877 sprintf (*buf, fmt, tmp_prefix);
878 }
879 return *buf;
880 }
881
882 static void
inform(const char * message,...)883 inform (const char * message, ...)
884 {
885 va_list args;
886
887 va_start (args, message);
888
889 if (!verbose)
890 return;
891
892 report (message, args);
893
894 va_end (args);
895 }
896
897 static const char *
rvaafter(int mach)898 rvaafter (int mach)
899 {
900 switch (mach)
901 {
902 case MARM:
903 case M386:
904 case MX86:
905 case MPPC:
906 case MTHUMB:
907 case MARM_INTERWORK:
908 case MMCORE_BE:
909 case MMCORE_LE:
910 case MMCORE_ELF:
911 case MMCORE_ELF_LE:
912 case MARM_EPOC:
913 case MARM_WINCE:
914 break;
915 default:
916 /* xgettext:c-format */
917 fatal (_("Internal error: Unknown machine type: %d"), mach);
918 break;
919 }
920 return "";
921 }
922
923 static const char *
rvabefore(int mach)924 rvabefore (int mach)
925 {
926 switch (mach)
927 {
928 case MARM:
929 case M386:
930 case MX86:
931 case MPPC:
932 case MTHUMB:
933 case MARM_INTERWORK:
934 case MMCORE_BE:
935 case MMCORE_LE:
936 case MMCORE_ELF:
937 case MMCORE_ELF_LE:
938 case MARM_EPOC:
939 case MARM_WINCE:
940 return ".rva\t";
941 default:
942 /* xgettext:c-format */
943 fatal (_("Internal error: Unknown machine type: %d"), mach);
944 break;
945 }
946 return "";
947 }
948
949 static const char *
asm_prefix(int mach,const char * name)950 asm_prefix (int mach, const char *name)
951 {
952 switch (mach)
953 {
954 case MARM:
955 case MPPC:
956 case MTHUMB:
957 case MARM_INTERWORK:
958 case MMCORE_BE:
959 case MMCORE_LE:
960 case MMCORE_ELF:
961 case MMCORE_ELF_LE:
962 case MARM_EPOC:
963 case MARM_WINCE:
964 break;
965 case M386:
966 case MX86:
967 /* Symbol names starting with ? do not have a leading underscore. */
968 if ((name && *name == '?') || leading_underscore == 0)
969 break;
970 else
971 return "_";
972 default:
973 /* xgettext:c-format */
974 fatal (_("Internal error: Unknown machine type: %d"), mach);
975 break;
976 }
977 return "";
978 }
979
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
1005
1006 static char **oav;
1007
1008 static void
process_def_file(const char * name)1009 process_def_file (const char *name)
1010 {
1011 FILE *f = fopen (name, FOPEN_RT);
1012
1013 if (!f)
1014 /* xgettext:c-format */
1015 fatal (_("Can't open def file: %s"), name);
1016
1017 yyin = f;
1018
1019 /* xgettext:c-format */
1020 inform (_("Processing def file: %s"), name);
1021
1022 yyparse ();
1023
1024 inform (_("Processed def file"));
1025 }
1026
1027 /**********************************************************************/
1028
1029 /* Communications with the parser. */
1030
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. */
1040
1041 static int d_is_dll;
1042 static int d_is_exe;
1043
1044 int
yyerror(const char * err ATTRIBUTE_UNUSED)1045 yyerror (const char * err ATTRIBUTE_UNUSED)
1046 {
1047 /* xgettext:c-format */
1048 non_fatal (_("Syntax error in def file %s:%d"), def_file, linenumber);
1049
1050 return 0;
1051 }
1052
1053 void
def_exports(const char * name,const char * internal_name,int ordinal,int noname,int constant,int data,int private,const char * its_name)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)
1057 {
1058 struct export *p = (struct export *) xmalloc (sizeof (*p));
1059
1060 p->name = name;
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;
1066 p->noname = noname;
1067 p->private = private;
1068 p->data = data;
1069 p->next = d_exports;
1070 d_exports = p;
1071 d_nfuncs++;
1072
1073 if ((internal_name != NULL)
1074 && (strchr (internal_name, '.') != NULL))
1075 p->forward = ++d_nforwards;
1076 else
1077 p->forward = 0; /* no forward */
1078 }
1079
1080 static void
set_dll_name_from_def(const char * name,char is_dll)1081 set_dll_name_from_def (const char *name, char is_dll)
1082 {
1083 const char *image_basename = lbasename (name);
1084 if (image_basename != name)
1085 non_fatal (_("%s: Path components stripped from image name, '%s'."),
1086 def_file, name);
1087 /* Append the default suffix, if none specified. */
1088 if (strchr (image_basename, '.') == 0)
1089 {
1090 const char * suffix = is_dll ? ".dll" : ".exe";
1091
1092 dll_name = xmalloc (strlen (image_basename) + strlen (suffix) + 1);
1093 sprintf (dll_name, "%s%s", image_basename, suffix);
1094 }
1095 else
1096 dll_name = xstrdup (image_basename);
1097 }
1098
1099 void
def_name(const char * name,int base)1100 def_name (const char *name, int base)
1101 {
1102 /* xgettext:c-format */
1103 inform (_("NAME: %s base: %x"), name, base);
1104
1105 if (d_is_dll)
1106 non_fatal (_("Can't have LIBRARY and NAME"));
1107
1108 if (dll_name_set_by_exp_name && name && *name != 0)
1109 {
1110 dll_name = NULL;
1111 dll_name_set_by_exp_name = 0;
1112 }
1113 /* If --dllname not provided, use the one in the DEF file.
1114 FIXME: Is this appropriate for executables? */
1115 if (!dll_name)
1116 set_dll_name_from_def (name, 0);
1117 d_is_exe = 1;
1118 }
1119
1120 void
def_library(const char * name,int base)1121 def_library (const char *name, int base)
1122 {
1123 /* xgettext:c-format */
1124 inform (_("LIBRARY: %s base: %x"), name, base);
1125
1126 if (d_is_exe)
1127 non_fatal (_("Can't have LIBRARY and NAME"));
1128
1129 if (dll_name_set_by_exp_name && name && *name != 0)
1130 {
1131 dll_name = NULL;
1132 dll_name_set_by_exp_name = 0;
1133 }
1134
1135 /* If --dllname not provided, use the one in the DEF file. */
1136 if (!dll_name)
1137 set_dll_name_from_def (name, 1);
1138 d_is_dll = 1;
1139 }
1140
1141 void
def_description(const char * desc)1142 def_description (const char *desc)
1143 {
1144 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
1145 d->text = xstrdup (desc);
1146 d->next = d_list;
1147 d_list = d;
1148 }
1149
1150 static void
new_directive(char * dir)1151 new_directive (char *dir)
1152 {
1153 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
1154 d->text = xstrdup (dir);
1155 d->next = a_list;
1156 a_list = d;
1157 }
1158
1159 void
def_heapsize(int reserve,int commit)1160 def_heapsize (int reserve, int commit)
1161 {
1162 char b[200];
1163 if (commit > 0)
1164 sprintf (b, "-heap 0x%x,0x%x ", reserve, commit);
1165 else
1166 sprintf (b, "-heap 0x%x ", reserve);
1167 new_directive (xstrdup (b));
1168 }
1169
1170 void
def_stacksize(int reserve,int commit)1171 def_stacksize (int reserve, int commit)
1172 {
1173 char b[200];
1174 if (commit > 0)
1175 sprintf (b, "-stack 0x%x,0x%x ", reserve, commit);
1176 else
1177 sprintf (b, "-stack 0x%x ", reserve);
1178 new_directive (xstrdup (b));
1179 }
1180
1181 /* append_import simply adds the given import definition to the global
1182 import_list. It is used by def_import. */
1183
1184 static void
append_import(const char * symbol_name,const char * dllname,int func_ordinal,const char * its_name)1185 append_import (const char *symbol_name, const char *dllname, int func_ordinal,
1186 const char *its_name)
1187 {
1188 iheadtype **pq;
1189 iheadtype *q;
1190
1191 for (pq = &import_list; *pq != NULL; pq = &(*pq)->next)
1192 {
1193 if (strcmp ((*pq)->dllname, dllname) == 0)
1194 {
1195 q = *pq;
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;
1202 q->nfuncs++;
1203 return;
1204 }
1205 }
1206
1207 q = xmalloc (sizeof (iheadtype));
1208 q->dllname = xstrdup (dllname);
1209 q->nfuncs = 1;
1210 q->funchead = xmalloc (sizeof (ifunctype));
1211 q->functail = q->funchead;
1212 q->next = NULL;
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;
1217
1218 *pq = q;
1219 }
1220
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
1226 with it. */
1227
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>
1234 <dll_name>.<number>
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
1239 to be reappended.
1240
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). */
1250
1251 void
def_import(const char * app_name,const char * module,const char * dllext,const char * entry,int ord_val,const char * its_name)1252 def_import (const char *app_name, const char *module, const char *dllext,
1253 const char *entry, int ord_val, const char *its_name)
1254 {
1255 const char *application_name;
1256 char *buf = NULL;
1257
1258 if (entry != NULL)
1259 application_name = entry;
1260 else
1261 {
1262 if (app_name != NULL)
1263 application_name = app_name;
1264 else
1265 application_name = "";
1266 }
1267
1268 if (dllext != NULL)
1269 module = buf = concat (module, ".", dllext, NULL);
1270
1271 append_import (application_name, module, ord_val, its_name);
1272
1273 if (buf)
1274 free (buf);
1275 }
1276
1277 void
def_version(int major,int minor)1278 def_version (int major, int minor)
1279 {
1280 printf (_("VERSION %d.%d\n"), major, minor);
1281 }
1282
1283 void
def_section(const char * name,int attr)1284 def_section (const char *name, int attr)
1285 {
1286 char buf[200];
1287 char atts[5];
1288 char *d = atts;
1289 if (attr & 1)
1290 *d++ = 'R';
1291
1292 if (attr & 2)
1293 *d++ = 'W';
1294 if (attr & 4)
1295 *d++ = 'X';
1296 if (attr & 8)
1297 *d++ = 'S';
1298 *d++ = 0;
1299 sprintf (buf, "-attr %s %s", name, atts);
1300 new_directive (xstrdup (buf));
1301 }
1302
1303 void
def_code(int attr)1304 def_code (int attr)
1305 {
1306
1307 def_section ("CODE", attr);
1308 }
1309
1310 void
def_data(int attr)1311 def_data (int attr)
1312 {
1313 def_section ("DATA", attr);
1314 }
1315
1316 /**********************************************************************/
1317
1318 static void
run(const char * what,char * args)1319 run (const char *what, char *args)
1320 {
1321 char *s;
1322 int pid, wait_status;
1323 int i;
1324 const char **argv;
1325 char *errmsg_fmt, *errmsg_arg;
1326 char *temp_base = choose_temp_base ();
1327
1328 inform (_("run: %s %s"), what, args);
1329
1330 /* Count the args */
1331 i = 0;
1332 for (s = args; *s; s++)
1333 if (*s == ' ')
1334 i++;
1335 i++;
1336 argv = xmalloc (sizeof (char *) * (i + 3));
1337 i = 0;
1338 argv[i++] = what;
1339 s = args;
1340 while (1)
1341 {
1342 while (*s == ' ')
1343 ++s;
1344 argv[i++] = s;
1345 while (*s != ' ' && *s != 0)
1346 s++;
1347 if (*s == 0)
1348 break;
1349 *s++ = 0;
1350 }
1351 argv[i++] = NULL;
1352
1353 pid = pexecute (argv[0], (char * const *) argv, program_name, temp_base,
1354 &errmsg_fmt, &errmsg_arg, PEXECUTE_ONE | PEXECUTE_SEARCH);
1355 free(argv);
1356
1357 if (pid == -1)
1358 {
1359 inform ("%s", strerror (errno));
1360
1361 fatal (errmsg_fmt, errmsg_arg);
1362 }
1363
1364 pid = pwait (pid, & wait_status, 0);
1365
1366 if (pid == -1)
1367 {
1368 /* xgettext:c-format */
1369 fatal (_("wait: %s"), strerror (errno));
1370 }
1371 else if (WIFSIGNALED (wait_status))
1372 {
1373 /* xgettext:c-format */
1374 fatal (_("subprocess got fatal signal %d"), WTERMSIG (wait_status));
1375 }
1376 else if (WIFEXITED (wait_status))
1377 {
1378 if (WEXITSTATUS (wait_status) != 0)
1379 /* xgettext:c-format */
1380 non_fatal (_("%s exited with status %d"),
1381 what, WEXITSTATUS (wait_status));
1382 }
1383 else
1384 abort ();
1385 }
1386
1387 /* Look for a list of symbols to export in the .drectve section of
1388 ABFD. Pass each one to def_exports. */
1389
1390 static void
scan_drectve_symbols(bfd * abfd)1391 scan_drectve_symbols (bfd *abfd)
1392 {
1393 asection * s;
1394 int size;
1395 char * buf;
1396 char * p;
1397 char * e;
1398
1399 /* Look for .drectve's */
1400 s = bfd_get_section_by_name (abfd, DRECTVE_SECTION_NAME);
1401
1402 if (s == NULL)
1403 return;
1404
1405 size = bfd_get_section_size (s);
1406 buf = xmalloc (size);
1407
1408 bfd_get_section_contents (abfd, s, buf, 0, size);
1409
1410 /* xgettext:c-format */
1411 inform (_("Sucking in info from %s section in %s"),
1412 DRECTVE_SECTION_NAME, bfd_get_filename (abfd));
1413
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. */
1417 p = buf;
1418 e = buf + size;
1419 while (p < e)
1420 {
1421 if (p[0] == '-'
1422 && CONST_STRNEQ (p, "-export:"))
1423 {
1424 char * name;
1425 char * c;
1426 flagword flags = BSF_FUNCTION;
1427
1428 p += 8;
1429 /* Do we have a quoted export? */
1430 if (*p == '"')
1431 {
1432 p++;
1433 name = p;
1434 while (p < e && *p != '"')
1435 ++p;
1436 }
1437 else
1438 {
1439 name = p;
1440 while (p < e && *p != ',' && *p != ' ' && *p != '-')
1441 p++;
1442 }
1443 c = xmalloc (p - name + 1);
1444 memcpy (c, name, p - name);
1445 c[p - name] = 0;
1446 /* Advance over trailing quote. */
1447 if (p < e && *p == '"')
1448 ++p;
1449 if (p < e && *p == ',') /* found type tag. */
1450 {
1451 char *tag_start = ++p;
1452 while (p < e && *p != ' ' && *p != '-')
1453 p++;
1454 if (CONST_STRNEQ (tag_start, "data"))
1455 flags &= ~BSF_FUNCTION;
1456 }
1457
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);
1462
1463 if (add_stdcall_alias && strchr (c, '@'))
1464 {
1465 int lead_at = (*c == '@') ;
1466 char *exported_name = xstrdup (c + lead_at);
1467 char *atsym = strchr (exported_name, '@');
1468 *atsym = '\0';
1469 /* Note: stdcall alias symbols can never be data. */
1470 def_exports (exported_name, xstrdup (c), -1, 0, 0, 0, 0, NULL);
1471 }
1472 }
1473 else
1474 p++;
1475 }
1476 free (buf);
1477 }
1478
1479 /* Look through the symbols in MINISYMS, and add each one to list of
1480 symbols to export. */
1481
1482 static void
scan_filtered_symbols(bfd * abfd,void * minisyms,long symcount,unsigned int size)1483 scan_filtered_symbols (bfd *abfd, void *minisyms, long symcount,
1484 unsigned int size)
1485 {
1486 asymbol *store;
1487 bfd_byte *from, *fromend;
1488
1489 store = bfd_make_empty_symbol (abfd);
1490 if (store == NULL)
1491 bfd_fatal (bfd_get_filename (abfd));
1492
1493 from = (bfd_byte *) minisyms;
1494 fromend = from + symcount * size;
1495 for (; from < fromend; from += size)
1496 {
1497 asymbol *sym;
1498 const char *symbol_name;
1499
1500 sym = bfd_minisymbol_to_symbol (abfd, FALSE, from, store);
1501 if (sym == NULL)
1502 bfd_fatal (bfd_get_filename (abfd));
1503
1504 symbol_name = bfd_asymbol_name (sym);
1505 if (bfd_get_symbol_leading_char (abfd) == symbol_name[0])
1506 ++symbol_name;
1507
1508 def_exports (xstrdup (symbol_name) , 0, -1, 0, 0,
1509 ! (sym->flags & BSF_FUNCTION), 0, NULL);
1510
1511 if (add_stdcall_alias && strchr (symbol_name, '@'))
1512 {
1513 int lead_at = (*symbol_name == '@');
1514 char *exported_name = xstrdup (symbol_name + lead_at);
1515 char *atsym = strchr (exported_name, '@');
1516 *atsym = '\0';
1517 /* Note: stdcall alias symbols can never be data. */
1518 def_exports (exported_name, xstrdup (symbol_name), -1, 0, 0, 0, 0, NULL);
1519 }
1520 }
1521 }
1522
1523 /* Add a list of symbols to exclude. */
1524
1525 static void
add_excludes(const char * new_excludes)1526 add_excludes (const char *new_excludes)
1527 {
1528 char *local_copy;
1529 char *exclude_string;
1530
1531 local_copy = xstrdup (new_excludes);
1532
1533 exclude_string = strtok (local_copy, ",:");
1534 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
1535 {
1536 struct string_list *new_exclude;
1537
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);
1544 else
1545 sprintf (new_exclude->string, "%s%s", (!leading_underscore ? "" : "_"),
1546 exclude_string);
1547 new_exclude->next = excludes;
1548 excludes = new_exclude;
1549
1550 /* xgettext:c-format */
1551 inform (_("Excluding symbol: %s"), exclude_string);
1552 }
1553
1554 free (local_copy);
1555 }
1556
1557 /* See if STRING is on the list of symbols to exclude. */
1558
1559 static bfd_boolean
match_exclude(const char * string)1560 match_exclude (const char *string)
1561 {
1562 struct string_list *excl_item;
1563
1564 for (excl_item = excludes; excl_item; excl_item = excl_item->next)
1565 if (strcmp (string, excl_item->string) == 0)
1566 return TRUE;
1567 return FALSE;
1568 }
1569
1570 /* Add the default list of symbols to exclude. */
1571
1572 static void
set_default_excludes(void)1573 set_default_excludes (void)
1574 {
1575 add_excludes (default_excludes);
1576 }
1577
1578 /* Choose which symbols to export. */
1579
1580 static long
filter_symbols(bfd * abfd,void * minisyms,long symcount,unsigned int size)1581 filter_symbols (bfd *abfd, void *minisyms, long symcount, unsigned int size)
1582 {
1583 bfd_byte *from, *fromend, *to;
1584 asymbol *store;
1585
1586 store = bfd_make_empty_symbol (abfd);
1587 if (store == NULL)
1588 bfd_fatal (bfd_get_filename (abfd));
1589
1590 from = (bfd_byte *) minisyms;
1591 fromend = from + symcount * size;
1592 to = (bfd_byte *) minisyms;
1593
1594 for (; from < fromend; from += size)
1595 {
1596 int keep = 0;
1597 asymbol *sym;
1598
1599 sym = bfd_minisymbol_to_symbol (abfd, FALSE, (const void *) from, store);
1600 if (sym == NULL)
1601 bfd_fatal (bfd_get_filename (abfd));
1602
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));
1608
1609 keep = keep && ! match_exclude (sym->name);
1610
1611 if (keep)
1612 {
1613 memcpy (to, from, size);
1614 to += size;
1615 }
1616 }
1617
1618 return (to - (bfd_byte *) minisyms) / size;
1619 }
1620
1621 /* Export all symbols in ABFD, except for ones we were told not to
1622 export. */
1623
1624 static void
scan_all_symbols(bfd * abfd)1625 scan_all_symbols (bfd *abfd)
1626 {
1627 long symcount;
1628 void *minisyms;
1629 unsigned int size;
1630
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"))
1635 return;
1636
1637 if (! (bfd_get_file_flags (abfd) & HAS_SYMS))
1638 {
1639 /* xgettext:c-format */
1640 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1641 return;
1642 }
1643
1644 symcount = bfd_read_minisymbols (abfd, FALSE, &minisyms, &size);
1645 if (symcount < 0)
1646 bfd_fatal (bfd_get_filename (abfd));
1647
1648 if (symcount == 0)
1649 {
1650 /* xgettext:c-format */
1651 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
1652 return;
1653 }
1654
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. */
1657
1658 symcount = filter_symbols (abfd, minisyms, symcount, size);
1659 scan_filtered_symbols (abfd, minisyms, symcount, size);
1660
1661 free (minisyms);
1662 }
1663
1664 /* Look at the object file to decide which symbols to export. */
1665
1666 static void
scan_open_obj_file(bfd * abfd)1667 scan_open_obj_file (bfd *abfd)
1668 {
1669 if (export_all_symbols)
1670 scan_all_symbols (abfd);
1671 else
1672 scan_drectve_symbols (abfd);
1673
1674 /* FIXME: we ought to read in and block out the base relocations. */
1675
1676 /* xgettext:c-format */
1677 inform (_("Done reading %s"), bfd_get_filename (abfd));
1678 }
1679
1680 static void
scan_obj_file(const char * filename)1681 scan_obj_file (const char *filename)
1682 {
1683 bfd * f = bfd_openr (filename, 0);
1684
1685 if (!f)
1686 /* xgettext:c-format */
1687 fatal (_("Unable to open object file: %s: %s"), filename, bfd_get_errmsg ());
1688
1689 /* xgettext:c-format */
1690 inform (_("Scanning object file %s"), filename);
1691
1692 if (bfd_check_format (f, bfd_archive))
1693 {
1694 bfd *arfile = bfd_openr_next_archived_file (f, 0);
1695 while (arfile)
1696 {
1697 bfd *next;
1698 if (bfd_check_format (arfile, bfd_object))
1699 scan_open_obj_file (arfile);
1700 next = bfd_openr_next_archived_file (f, arfile);
1701 bfd_close (arfile);
1702 /* PR 17512: file: 58715298. */
1703 if (next == arfile)
1704 break;
1705 arfile = next;
1706 }
1707
1708 #ifdef DLLTOOL_MCORE_ELF
1709 if (mcore_elf_out_file)
1710 inform (_("Cannot produce mcore-elf dll from archive file: %s"), filename);
1711 #endif
1712 }
1713 else if (bfd_check_format (f, bfd_object))
1714 {
1715 scan_open_obj_file (f);
1716
1717 #ifdef DLLTOOL_MCORE_ELF
1718 if (mcore_elf_out_file)
1719 mcore_elf_cache_filename (filename);
1720 #endif
1721 }
1722
1723 bfd_close (f);
1724 }
1725
1726
1727
1728 static void
dump_def_info(FILE * f)1729 dump_def_info (FILE *f)
1730 {
1731 int i;
1732 export_type *exp;
1733 fprintf (f, "%s ", ASM_C);
1734 for (i = 0; oav[i]; i++)
1735 fprintf (f, "%s ", oav[i]);
1736 fprintf (f, "\n");
1737 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1738 {
1739 fprintf (f, "%s %d = %s %s @ %d %s%s%s%s%s%s\n",
1740 ASM_C,
1741 i,
1742 exp->name,
1743 exp->internal_name,
1744 exp->ordinal,
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 : "");
1751 }
1752 }
1753
1754 /* Generate the .exp file. */
1755
1756 static int
sfunc(const void * a,const void * b)1757 sfunc (const void *a, const void *b)
1758 {
1759 if (*(const bfd_vma *) a == *(const bfd_vma *) b)
1760 return 0;
1761
1762 return ((*(const bfd_vma *) a > *(const bfd_vma *) b) ? 1 : -1);
1763 }
1764
1765 static void
flush_page(FILE * f,bfd_vma * need,bfd_vma page_addr,int on_page)1766 flush_page (FILE *f, bfd_vma *need, bfd_vma page_addr, int on_page)
1767 {
1768 int i;
1769
1770 /* Flush this page. */
1771 fprintf (f, "\t%s\t0x%08x\t%s Starting RVA for chunk\n",
1772 ASM_LONG,
1773 (int) page_addr,
1774 ASM_C);
1775 fprintf (f, "\t%s\t0x%x\t%s Size of block\n",
1776 ASM_LONG,
1777 (on_page * 2) + (on_page & 1) * 2 + 8,
1778 ASM_C);
1779
1780 for (i = 0; i < on_page; i++)
1781 {
1782 bfd_vma needed = need[i];
1783
1784 if (needed)
1785 {
1786 if (!create_for_pep)
1787 {
1788 /* Relocation via HIGHLOW. */
1789 needed = ((needed - page_addr) | 0x3000) & 0xffff;
1790 }
1791 else
1792 {
1793 /* Relocation via DIR64. */
1794 needed = ((needed - page_addr) | 0xa000) & 0xffff;
1795 }
1796 }
1797
1798 fprintf (f, "\t%s\t0x%lx\n", ASM_SHORT, (long) needed);
1799 }
1800
1801 /* And padding */
1802 if (on_page & 1)
1803 fprintf (f, "\t%s\t0x%x\n", ASM_SHORT, 0 | 0x0000);
1804 }
1805
1806 static void
gen_def_file(void)1807 gen_def_file (void)
1808 {
1809 int i;
1810 export_type *exp;
1811
1812 inform (_("Adding exports to output file"));
1813
1814 fprintf (output_def, ";");
1815 for (i = 0; oav[i]; i++)
1816 fprintf (output_def, " %s", oav[i]);
1817
1818 fprintf (output_def, "\nEXPORTS\n");
1819
1820 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1821 {
1822 char *quote = strchr (exp->name, '.') ? "\"" : "";
1823 char *res = cplus_demangle (exp->internal_name, DMGL_ANSI | DMGL_PARAMS);
1824
1825 if (res)
1826 {
1827 fprintf (output_def,";\t%s\n", res);
1828 free (res);
1829 }
1830
1831 if (strcmp (exp->name, exp->internal_name) == 0)
1832 {
1833 fprintf (output_def, "\t%s%s%s @ %d%s%s%s%s%s\n",
1834 quote,
1835 exp->name,
1836 quote,
1837 exp->ordinal,
1838 exp->noname ? " NONAME" : "",
1839 exp->private ? "PRIVATE " : "",
1840 exp->data ? " DATA" : "",
1841 exp->its_name ? " ==" : "",
1842 exp->its_name ? exp->its_name : "");
1843 }
1844 else
1845 {
1846 char * quote1 = strchr (exp->internal_name, '.') ? "\"" : "";
1847 /* char *alias = */
1848 fprintf (output_def, "\t%s%s%s = %s%s%s @ %d%s%s%s%s%s\n",
1849 quote,
1850 exp->name,
1851 quote,
1852 quote1,
1853 exp->internal_name,
1854 quote1,
1855 exp->ordinal,
1856 exp->noname ? " NONAME" : "",
1857 exp->private ? "PRIVATE " : "",
1858 exp->data ? " DATA" : "",
1859 exp->its_name ? " ==" : "",
1860 exp->its_name ? exp->its_name : "");
1861 }
1862 }
1863
1864 inform (_("Added exports to output file"));
1865 }
1866
1867 /* generate_idata_ofile generates the portable assembly source code
1868 for the idata sections. It appends the source code to the end of
1869 the file. */
1870
1871 static void
generate_idata_ofile(FILE * filvar)1872 generate_idata_ofile (FILE *filvar)
1873 {
1874 iheadtype *headptr;
1875 ifunctype *funcptr;
1876 int headindex;
1877 int funcindex;
1878 int nheads;
1879
1880 if (import_list == NULL)
1881 return;
1882
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");
1887
1888 nheads = 0;
1889 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1890 {
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);
1900 nheads++;
1901 }
1902
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);
1908
1909 fprintf (filvar, "\n\t.section\t.idata$4\n");
1910 headindex = 0;
1911 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1912 {
1913 fprintf (filvar, "listone%d:\n", headindex);
1914 for (funcindex = 0; funcindex < headptr->nfuncs; funcindex++)
1915 {
1916 if (create_for_pep)
1917 fprintf (filvar, "\t%sfuncptr%d_%d%s\n%s\t0\n",
1918 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER,
1919 ASM_LONG);
1920 else
1921 fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1922 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1923 }
1924 if (create_for_pep)
1925 fprintf (filvar, "\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
1926 else
1927 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list. */
1928 headindex++;
1929 }
1930
1931 fprintf (filvar, "\n\t.section\t.idata$5\n");
1932 headindex = 0;
1933 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1934 {
1935 fprintf (filvar, "listtwo%d:\n", headindex);
1936 for (funcindex = 0; funcindex < headptr->nfuncs; funcindex++)
1937 {
1938 if (create_for_pep)
1939 fprintf (filvar, "\t%sfuncptr%d_%d%s\n%s\t0\n",
1940 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER,
1941 ASM_LONG);
1942 else
1943 fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1944 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1945 }
1946 if (create_for_pep)
1947 fprintf (filvar, "\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
1948 else
1949 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list. */
1950 headindex++;
1951 }
1952
1953 fprintf (filvar, "\n\t.section\t.idata$6\n");
1954 headindex = 0;
1955 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1956 {
1957 funcindex = 0;
1958 for (funcptr = headptr->funchead; funcptr != NULL;
1959 funcptr = funcptr->next)
1960 {
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);
1967 funcindex++;
1968 }
1969 headindex++;
1970 }
1971
1972 fprintf (filvar, "\n\t.section\t.idata$7\n");
1973 headindex = 0;
1974 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1975 {
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);
1979 headindex++;
1980 }
1981 }
1982
1983 /* Assemble the specified file. */
1984 static void
assemble_file(const char * source,const char * dest)1985 assemble_file (const char * source, const char * dest)
1986 {
1987 char * cmd;
1988
1989 cmd = xmalloc (strlen (ASM_SWITCHES) + strlen (as_flags)
1990 + strlen (source) + strlen (dest) + 50);
1991
1992 sprintf (cmd, "%s %s -o %s %s", ASM_SWITCHES, as_flags, dest, source);
1993
1994 run (as_name, cmd);
1995 free (cmd);
1996 }
1997
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
2004
2005 static void
unlink_temp_files(void)2006 unlink_temp_files (void)
2007 {
2008 unsigned i;
2009
2010 if (dontdeltemps > 0)
2011 return;
2012
2013 for (i = 0; i < ARRAY_SIZE (temp_file_to_remove); i++)
2014 {
2015 if (temp_file_to_remove[i])
2016 {
2017 unlink (temp_file_to_remove[i]);
2018 temp_file_to_remove[i] = NULL;
2019 }
2020 }
2021 }
2022
2023 static void
gen_exp_file(void)2024 gen_exp_file (void)
2025 {
2026 FILE *f;
2027 int i;
2028 export_type *exp;
2029 dlist_type *dl;
2030
2031 /* xgettext:c-format */
2032 inform (_("Generating export file: %s"), exp_name);
2033
2034 f = fopen (TMP_ASM, FOPEN_WT);
2035 if (!f)
2036 /* xgettext:c-format */
2037 fatal (_("Unable to open temporary assembler file: %s"), TMP_ASM);
2038
2039 temp_file_to_remove[TEMP_EXPORT_FILE] = TMP_ASM;
2040
2041 /* xgettext:c-format */
2042 inform (_("Opened temporary file: %s"), TMP_ASM);
2043
2044 dump_def_info (f);
2045
2046 if (d_exports)
2047 {
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);
2055
2056
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",
2059 ASM_C,
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);
2064
2065 fprintf (f, "\t%sanames%s %s Address of Name Pointer Table\n",
2066 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
2067
2068 fprintf (f, "\t%sanords%s %s Address of ordinals\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
2069
2070 fprintf (f, "name: %s \"%s\"\n", ASM_TEXT, dll_name);
2071
2072
2073 fprintf(f,"%s Export address Table\n", ASM_C);
2074 fprintf(f,"\t%s\n", ASM_ALIGN_LONG);
2075 fprintf (f, "afuncs:\n");
2076 i = d_low_ord;
2077
2078 for (exp = d_exports; exp; exp = exp->next)
2079 {
2080 if (exp->ordinal != i)
2081 {
2082 while (i < exp->ordinal)
2083 {
2084 fprintf(f,"\t%s\t0\n", ASM_LONG);
2085 i++;
2086 }
2087 }
2088
2089 if (exp->forward == 0)
2090 {
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);
2094 else
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);
2098 }
2099 else
2100 fprintf (f, "\t%sf%d%s\t%s %d\n", ASM_RVA_BEFORE,
2101 exp->forward, ASM_RVA_AFTER, ASM_C, exp->ordinal);
2102 i++;
2103 }
2104
2105 fprintf (f,"%s Export Name Pointer Table\n", ASM_C);
2106 fprintf (f, "anames:\n");
2107
2108 for (i = 0; (exp = d_exports_lexically[i]); i++)
2109 {
2110 if (!exp->noname || show_allnames)
2111 fprintf (f, "\t%sn%d%s\n",
2112 ASM_RVA_BEFORE, exp->ordinal, ASM_RVA_AFTER);
2113 }
2114
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++)
2118 {
2119 if (!exp->noname || show_allnames)
2120 fprintf (f, "\t%s %d\n", ASM_SHORT, exp->ordinal - d_low_ord);
2121 }
2122
2123 fprintf(f,"%s Export Name Table\n", ASM_C);
2124 for (i = 0; (exp = d_exports_lexically[i]); i++)
2125 {
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);
2133 }
2134
2135 if (a_list)
2136 {
2137 fprintf (f, "\t.section %s\n", DRECTVE_SECTION_NAME);
2138 for (dl = a_list; dl; dl = dl->next)
2139 {
2140 fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, dl->text);
2141 }
2142 }
2143
2144 if (d_list)
2145 {
2146 fprintf (f, "\t.section .rdata\n");
2147 for (dl = d_list; dl; dl = dl->next)
2148 {
2149 char *p;
2150 int l;
2151
2152 /* We don't output as ascii because there can
2153 be quote characters in the string. */
2154 l = 0;
2155 for (p = dl->text; *p; p++)
2156 {
2157 if (l == 0)
2158 fprintf (f, "\t%s\t", ASM_BYTE);
2159 else
2160 fprintf (f, ",");
2161 fprintf (f, "%d", *p);
2162 if (p[1] == 0)
2163 {
2164 fprintf (f, ",0\n");
2165 break;
2166 }
2167 if (++l == 10)
2168 {
2169 fprintf (f, "\n");
2170 l = 0;
2171 }
2172 }
2173 }
2174 }
2175 }
2176
2177 /* Add to the output file a way of getting to the exported names
2178 without using the import library. */
2179 if (add_indirect)
2180 {
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)
2184 {
2185 /* We use a single underscore for MS compatibility, and a
2186 double underscore for backward compatibility with old
2187 cygwin releases. */
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);
2196 }
2197 }
2198
2199 /* Dump the reloc section if a base file is provided. */
2200 if (base_file)
2201 {
2202 bfd_vma addr;
2203 bfd_vma need[COFF_PAGE_SIZE];
2204 bfd_vma page_addr;
2205 bfd_size_type numbytes;
2206 int num_entries;
2207 bfd_vma *copy;
2208 int j;
2209 int on_page;
2210 fprintf (f, "\t.section\t.init\n");
2211 fprintf (f, "lab:\n");
2212
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);
2220
2221
2222 fprintf (f, "\t.section\t.reloc\n");
2223 if (num_entries)
2224 {
2225 int src;
2226 int dst = 0;
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++)
2231 {
2232 if (last != copy[src])
2233 last = copy[dst++] = copy[src];
2234 }
2235 num_entries = dst;
2236 addr = copy[0];
2237 page_addr = addr & PAGE_MASK; /* work out the page addr */
2238 on_page = 0;
2239 for (j = 0; j < num_entries; j++)
2240 {
2241 addr = copy[j];
2242 if ((addr & PAGE_MASK) != page_addr)
2243 {
2244 flush_page (f, need, page_addr, on_page);
2245 on_page = 0;
2246 page_addr = addr & PAGE_MASK;
2247 }
2248 need[on_page++] = addr;
2249 }
2250 flush_page (f, need, page_addr, on_page);
2251
2252 /* fprintf (f, "\t%s\t0,0\t%s End\n", ASM_LONG, ASM_C);*/
2253 }
2254 }
2255
2256 generate_idata_ofile (f);
2257
2258 fclose (f);
2259
2260 /* Assemble the file. */
2261 assemble_file (TMP_ASM, exp_name);
2262
2263 if (dontdeltemps == 0)
2264 {
2265 temp_file_to_remove[TEMP_EXPORT_FILE] = NULL;
2266 unlink (TMP_ASM);
2267 }
2268
2269 inform (_("Generated exports file"));
2270 }
2271
2272 static const char *
xlate(const char * name)2273 xlate (const char *name)
2274 {
2275 int lead_at = (*name == '@');
2276 int is_stdcall = (!lead_at && strchr (name, '@') != NULL);
2277
2278 if (!lead_at && (add_underscore
2279 || (add_stdcall_underscore && is_stdcall)))
2280 {
2281 char *copy = xmalloc (strlen (name) + 2);
2282
2283 copy[0] = '_';
2284 strcpy (copy + 1, name);
2285 name = copy;
2286 }
2287
2288 if (killat)
2289 {
2290 char *p;
2291
2292 name += lead_at;
2293 /* PR 9766: Look for the last @ sign in the name. */
2294 p = strrchr (name, '@');
2295 if (p && ISDIGIT (p[1]))
2296 *p = 0;
2297 }
2298 return name;
2299 }
2300
2301 typedef struct
2302 {
2303 int id;
2304 const char *name;
2305 int flags;
2306 int align;
2307 asection *sec;
2308 asymbol *sym;
2309 asymbol **sympp;
2310 int size;
2311 unsigned char *data;
2312 } sinfo;
2313
2314 #define INIT_SEC_DATA(id, name, flags, align) \
2315 { id, name, flags, align, NULL, NULL, NULL, 0, NULL }
2316
2317 #ifndef DLLTOOL_PPC
2318
2319 #define TEXT 0
2320 #define DATA 1
2321 #define BSS 2
2322 #define IDATA7 3
2323 #define IDATA5 4
2324 #define IDATA4 5
2325 #define IDATA6 6
2326
2327 #define NSECS 7
2328
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
2333
2334 static sinfo secdata[NSECS] =
2335 {
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)
2343 };
2344
2345 #else
2346
2347 /* Sections numbered to make the order the same as other PowerPC NT
2348 compilers. This also keeps funny alignment thingies from happening. */
2349 #define TEXT 0
2350 #define PDATA 1
2351 #define RDATA 2
2352 #define IDATA5 3
2353 #define IDATA4 4
2354 #define IDATA6 5
2355 #define IDATA7 6
2356 #define DATA 7
2357 #define BSS 8
2358
2359 #define NSECS 9
2360
2361 static sinfo secdata[NSECS] =
2362 {
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)
2372 };
2373
2374 #endif
2375
2376 /* This is what we're trying to make. We generate the imp symbols with
2377 both single and double underscores, for compatibility.
2378
2379 .text
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
2387 .section .idata$5
2388 __imp_GetFileVersionInfoSizeW@8:
2389 .rva ID2
2390
2391 # Import Lookup Table
2392 .section .idata$4
2393 .rva ID2
2394 # Hint/Name table
2395 .section .idata$6
2396 ID2: .short 2
2397 .asciz "GetFileVersionInfoSizeW"
2398
2399
2400 For the PowerPC, here's the variation on the above scheme:
2401
2402 # Rather than a simple "jmp *", the code to get to the dll function
2403 # looks like:
2404 .text
2405 lwz r11,[tocv]__imp_function_name(r2)
2406 # RELOC: 00000000 TOCREL16,TOCDEFN __imp_function_name
2407 lwz r12,0(r11)
2408 stw r2,4(r1)
2409 mtctr r12
2410 lwz r2,4(r11)
2411 bctr */
2412
2413 static char *
make_label(const char * prefix,const char * name)2414 make_label (const char *prefix, const char *name)
2415 {
2416 int len = strlen (ASM_PREFIX (name)) + strlen (prefix) + strlen (name);
2417 char *copy = xmalloc (len + 1);
2418
2419 strcpy (copy, ASM_PREFIX (name));
2420 strcat (copy, prefix);
2421 strcat (copy, name);
2422 return copy;
2423 }
2424
2425 static char *
make_imp_label(const char * prefix,const char * name)2426 make_imp_label (const char *prefix, const char *name)
2427 {
2428 int len;
2429 char *copy;
2430
2431 if (name[0] == '@')
2432 {
2433 len = strlen (prefix) + strlen (name);
2434 copy = xmalloc (len + 1);
2435 strcpy (copy, prefix);
2436 strcat (copy, name);
2437 }
2438 else
2439 {
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);
2445 }
2446 return copy;
2447 }
2448
2449 static bfd *
make_one_lib_file(export_type * exp,int i,int delay)2450 make_one_lib_file (export_type *exp, int i, int delay)
2451 {
2452 bfd * abfd;
2453 asymbol * exp_label;
2454 asymbol * iname = 0;
2455 asymbol * iname2;
2456 asymbol * iname_lab;
2457 asymbol ** iname_lab_pp;
2458 asymbol ** iname_pp;
2459 #ifdef DLLTOOL_PPC
2460 asymbol ** fn_pp;
2461 asymbol ** toc_pp;
2462 #define EXTRA 2
2463 #endif
2464 #ifndef EXTRA
2465 #define EXTRA 0
2466 #endif
2467 asymbol * ptrs[NSECS + 4 + EXTRA + 1];
2468 flagword applicable;
2469 char * outname = xmalloc (strlen (TMP_STUB) + 10);
2470 int oidx = 0;
2471
2472
2473 sprintf (outname, "%s%05d.o", TMP_STUB, i);
2474
2475 abfd = bfd_openw (outname, HOW_BFD_WRITE_TARGET);
2476
2477 if (!abfd)
2478 /* xgettext:c-format */
2479 fatal (_("bfd_open failed open stub file: %s: %s"),
2480 outname, bfd_get_errmsg ());
2481
2482 /* xgettext:c-format */
2483 inform (_("Creating stub file: %s"), outname);
2484
2485 bfd_set_format (abfd, bfd_object);
2486 bfd_set_arch_mach (abfd, HOW_BFD_ARCH, 0);
2487
2488 #ifdef DLLTOOL_ARM
2489 if (machine == MARM_INTERWORK || machine == MTHUMB)
2490 bfd_set_private_flags (abfd, F_INTERWORK);
2491 #endif
2492
2493 applicable = bfd_applicable_section_flags (abfd);
2494
2495 /* First make symbols for the sections. */
2496 for (i = 0; i < NSECS; i++)
2497 {
2498 sinfo *si = secdata + i;
2499
2500 if (si->id != i)
2501 abort ();
2502 si->sec = bfd_make_section_old_way (abfd, si->name);
2503 bfd_set_section_flags (abfd,
2504 si->sec,
2505 si->flags & applicable);
2506
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;
2513 si->sym->value = 0;
2514 ptrs[oidx] = si->sym;
2515 si->sympp = ptrs + oidx;
2516 si->size = 0;
2517 si->data = NULL;
2518
2519 oidx++;
2520 }
2521
2522 if (! exp->data)
2523 {
2524 exp_label = bfd_make_empty_symbol (abfd);
2525 exp_label->name = make_imp_label ("", exp->name);
2526
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. */
2531 #ifdef DLLTOOL_PPC
2532 if (machine == MPPC)
2533 exp_label->section = secdata[RDATA].sec;
2534 else
2535 #endif
2536 exp_label->section = secdata[TEXT].sec;
2537
2538 exp_label->flags = BSF_GLOBAL;
2539 exp_label->value = 0;
2540
2541 #ifdef DLLTOOL_ARM
2542 if (machine == MTHUMB)
2543 bfd_coff_set_symbol_class (abfd, exp_label, C_THUMBEXTFUNC);
2544 #endif
2545 ptrs[oidx++] = exp_label;
2546 }
2547
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)
2552 {
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;
2557 iname->value = 0;
2558 }
2559
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;
2564 iname2->value = 0;
2565
2566 iname_lab = bfd_make_empty_symbol (abfd);
2567
2568 iname_lab->name = head_label;
2569 iname_lab->section = bfd_und_section_ptr;
2570 iname_lab->flags = 0;
2571 iname_lab->value = 0;
2572
2573 iname_pp = ptrs + oidx;
2574 if (create_compat_implib)
2575 ptrs[oidx++] = iname;
2576 ptrs[oidx++] = iname2;
2577
2578 iname_lab_pp = ptrs + oidx;
2579 ptrs[oidx++] = iname_lab;
2580
2581 #ifdef DLLTOOL_PPC
2582 /* The symbol referring to the code (.text). */
2583 {
2584 asymbol *function_name;
2585
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;
2591
2592 fn_pp = ptrs + oidx;
2593 ptrs[oidx++] = function_name;
2594 }
2595
2596 /* The .toc symbol. */
2597 {
2598 asymbol *toc_symbol;
2599
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;
2605
2606 toc_pp = ptrs + oidx;
2607 ptrs[oidx++] = toc_symbol;
2608 }
2609 #endif
2610
2611 ptrs[oidx] = 0;
2612
2613 for (i = 0; i < NSECS; i++)
2614 {
2615 sinfo *si = secdata + i;
2616 asection *sec = si->sec;
2617 arelent *rel, *rel2 = 0, *rel3 = 0;
2618 arelent **rpp;
2619
2620 switch (i)
2621 {
2622 case TEXT:
2623 if (! exp->data)
2624 {
2625 si->size = HOW_JTAB_SIZE;
2626 si->data = xmalloc (HOW_JTAB_SIZE);
2627 memcpy (si->data, HOW_JTAB, HOW_JTAB_SIZE);
2628
2629 /* Add the reloc into idata$5. */
2630 rel = xmalloc (sizeof (arelent));
2631
2632 rpp = xmalloc (sizeof (arelent *) * (delay ? 4 : 2));
2633 rpp[0] = rel;
2634 rpp[1] = 0;
2635
2636 rel->address = HOW_JTAB_ROFF;
2637 rel->addend = 0;
2638
2639 if (delay)
2640 {
2641 rel2 = xmalloc (sizeof (arelent));
2642 rpp[1] = rel2;
2643 rel2->address = HOW_JTAB_ROFF2;
2644 rel2->addend = 0;
2645 rel3 = xmalloc (sizeof (arelent));
2646 rpp[2] = rel3;
2647 rel3->address = HOW_JTAB_ROFF3;
2648 rel3->addend = 0;
2649 rpp[3] = 0;
2650 }
2651
2652 if (machine == MPPC)
2653 {
2654 rel->howto = bfd_reloc_type_lookup (abfd,
2655 BFD_RELOC_16_GOTOFF);
2656 rel->sym_ptr_ptr = iname_pp;
2657 }
2658 else if (machine == MX86)
2659 {
2660 rel->howto = bfd_reloc_type_lookup (abfd,
2661 BFD_RELOC_32_PCREL);
2662 rel->sym_ptr_ptr = iname_pp;
2663 }
2664 else
2665 {
2666 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2667 rel->sym_ptr_ptr = secdata[IDATA5].sympp;
2668 }
2669
2670 if (delay)
2671 {
2672 if (machine == MX86)
2673 rel2->howto = bfd_reloc_type_lookup (abfd,
2674 BFD_RELOC_32_PCREL);
2675 else
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;
2681 }
2682
2683 sec->orelocation = rpp;
2684 sec->reloc_count = delay ? 3 : 1;
2685 }
2686 break;
2687
2688 case IDATA5:
2689 if (delay)
2690 {
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. */
2696 si->data[0] = 6;
2697 rel = xmalloc (sizeof (arelent));
2698 rpp = xmalloc (sizeof (arelent *) * 2);
2699 rpp[0] = rel;
2700 rpp[1] = 0;
2701 rel->address = 0;
2702 rel->addend = 0;
2703 if (create_for_pep)
2704 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_64);
2705 else
2706 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2707 rel->sym_ptr_ptr = secdata[TEXT].sympp;
2708 sec->orelocation = rpp;
2709 break;
2710 }
2711 /* else fall through */
2712 case IDATA4:
2713 /* An idata$4 or idata$5 is one word long, and has an
2714 rva to idata$6. */
2715
2716 if (create_for_pep)
2717 {
2718 si->data = xmalloc (8);
2719 si->size = 8;
2720 if (exp->noname)
2721 {
2722 si->data[0] = exp->ordinal ;
2723 si->data[1] = exp->ordinal >> 8;
2724 si->data[2] = exp->ordinal >> 16;
2725 si->data[3] = exp->ordinal >> 24;
2726 si->data[4] = 0;
2727 si->data[5] = 0;
2728 si->data[6] = 0;
2729 si->data[7] = 0x80;
2730 }
2731 else
2732 {
2733 sec->reloc_count = 1;
2734 memset (si->data, 0, si->size);
2735 rel = xmalloc (sizeof (arelent));
2736 rpp = xmalloc (sizeof (arelent *) * 2);
2737 rpp[0] = rel;
2738 rpp[1] = 0;
2739 rel->address = 0;
2740 rel->addend = 0;
2741 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2742 rel->sym_ptr_ptr = secdata[IDATA6].sympp;
2743 sec->orelocation = rpp;
2744 }
2745 }
2746 else
2747 {
2748 si->data = xmalloc (4);
2749 si->size = 4;
2750
2751 if (exp->noname)
2752 {
2753 si->data[0] = exp->ordinal ;
2754 si->data[1] = exp->ordinal >> 8;
2755 si->data[2] = exp->ordinal >> 16;
2756 si->data[3] = 0x80;
2757 }
2758 else
2759 {
2760 sec->reloc_count = 1;
2761 memset (si->data, 0, si->size);
2762 rel = xmalloc (sizeof (arelent));
2763 rpp = xmalloc (sizeof (arelent *) * 2);
2764 rpp[0] = rel;
2765 rpp[1] = 0;
2766 rel->address = 0;
2767 rel->addend = 0;
2768 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2769 rel->sym_ptr_ptr = secdata[IDATA6].sympp;
2770 sec->orelocation = rpp;
2771 }
2772 }
2773 break;
2774
2775 case IDATA6:
2776 if (!exp->noname)
2777 {
2778 /* This used to add 1 to exp->hint. I don't know
2779 why it did that, and it does not match what I see
2780 in programs compiled with the MS tools. */
2781 int idx = exp->hint;
2782 if (exp->its_name)
2783 si->size = strlen (exp->its_name) + 3;
2784 else
2785 si->size = strlen (xlate (exp->import_name)) + 3;
2786 si->data = xmalloc (si->size);
2787 memset (si->data, 0, si->size);
2788 si->data[0] = idx & 0xff;
2789 si->data[1] = idx >> 8;
2790 if (exp->its_name)
2791 strcpy ((char *) si->data + 2, exp->its_name);
2792 else
2793 strcpy ((char *) si->data + 2, xlate (exp->import_name));
2794 }
2795 break;
2796 case IDATA7:
2797 if (delay)
2798 break;
2799 si->size = 4;
2800 si->data = xmalloc (4);
2801 memset (si->data, 0, si->size);
2802 rel = xmalloc (sizeof (arelent));
2803 rpp = xmalloc (sizeof (arelent *) * 2);
2804 rpp[0] = rel;
2805 rel->address = 0;
2806 rel->addend = 0;
2807 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2808 rel->sym_ptr_ptr = iname_lab_pp;
2809 sec->orelocation = rpp;
2810 sec->reloc_count = 1;
2811 break;
2812
2813 #ifdef DLLTOOL_PPC
2814 case PDATA:
2815 {
2816 /* The .pdata section is 5 words long.
2817 Think of it as:
2818 struct
2819 {
2820 bfd_vma BeginAddress, [0x00]
2821 EndAddress, [0x04]
2822 ExceptionHandler, [0x08]
2823 HandlerData, [0x0c]
2824 PrologEndAddress; [0x10]
2825 }; */
2826
2827 /* So this pdata section setups up this as a glue linkage to
2828 a dll routine. There are a number of house keeping things
2829 we need to do:
2830
2831 1. In the name of glue trickery, the ADDR32 relocs for 0,
2832 4, and 0x10 are set to point to the same place:
2833 "..function_name".
2834 2. There is one more reloc needed in the pdata section.
2835 The actual glue instruction to restore the toc on
2836 return is saved as the offset in an IMGLUE reloc.
2837 So we need a total of four relocs for this section.
2838
2839 3. Lastly, the HandlerData field is set to 0x03, to indicate
2840 that this is a glue routine. */
2841 arelent *imglue, *ba_rel, *ea_rel, *pea_rel;
2842
2843 /* Alignment must be set to 2**2 or you get extra stuff. */
2844 bfd_set_section_alignment(abfd, sec, 2);
2845
2846 si->size = 4 * 5;
2847 si->data = xmalloc (si->size);
2848 memset (si->data, 0, si->size);
2849 rpp = xmalloc (sizeof (arelent *) * 5);
2850 rpp[0] = imglue = xmalloc (sizeof (arelent));
2851 rpp[1] = ba_rel = xmalloc (sizeof (arelent));
2852 rpp[2] = ea_rel = xmalloc (sizeof (arelent));
2853 rpp[3] = pea_rel = xmalloc (sizeof (arelent));
2854 rpp[4] = 0;
2855
2856 /* Stick the toc reload instruction in the glue reloc. */
2857 bfd_put_32(abfd, ppc_glue_insn, (char *) &imglue->address);
2858
2859 imglue->addend = 0;
2860 imglue->howto = bfd_reloc_type_lookup (abfd,
2861 BFD_RELOC_32_GOTOFF);
2862 imglue->sym_ptr_ptr = fn_pp;
2863
2864 ba_rel->address = 0;
2865 ba_rel->addend = 0;
2866 ba_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2867 ba_rel->sym_ptr_ptr = fn_pp;
2868
2869 bfd_put_32 (abfd, 0x18, si->data + 0x04);
2870 ea_rel->address = 4;
2871 ea_rel->addend = 0;
2872 ea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2873 ea_rel->sym_ptr_ptr = fn_pp;
2874
2875 /* Mark it as glue. */
2876 bfd_put_32 (abfd, 0x03, si->data + 0x0c);
2877
2878 /* Mark the prolog end address. */
2879 bfd_put_32 (abfd, 0x0D, si->data + 0x10);
2880 pea_rel->address = 0x10;
2881 pea_rel->addend = 0;
2882 pea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2883 pea_rel->sym_ptr_ptr = fn_pp;
2884
2885 sec->orelocation = rpp;
2886 sec->reloc_count = 4;
2887 break;
2888 }
2889 case RDATA:
2890 /* Each external function in a PowerPC PE file has a two word
2891 descriptor consisting of:
2892 1. The address of the code.
2893 2. The address of the appropriate .toc
2894 We use relocs to build this. */
2895 si->size = 8;
2896 si->data = xmalloc (8);
2897 memset (si->data, 0, si->size);
2898
2899 rpp = xmalloc (sizeof (arelent *) * 3);
2900 rpp[0] = rel = xmalloc (sizeof (arelent));
2901 rpp[1] = xmalloc (sizeof (arelent));
2902 rpp[2] = 0;
2903
2904 rel->address = 0;
2905 rel->addend = 0;
2906 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2907 rel->sym_ptr_ptr = fn_pp;
2908
2909 rel = rpp[1];
2910
2911 rel->address = 4;
2912 rel->addend = 0;
2913 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2914 rel->sym_ptr_ptr = toc_pp;
2915
2916 sec->orelocation = rpp;
2917 sec->reloc_count = 2;
2918 break;
2919 #endif /* DLLTOOL_PPC */
2920 }
2921 }
2922
2923 {
2924 bfd_vma vma = 0;
2925 /* Size up all the sections. */
2926 for (i = 0; i < NSECS; i++)
2927 {
2928 sinfo *si = secdata + i;
2929
2930 bfd_set_section_size (abfd, si->sec, si->size);
2931 bfd_set_section_vma (abfd, si->sec, vma);
2932 }
2933 }
2934 /* Write them out. */
2935 for (i = 0; i < NSECS; i++)
2936 {
2937 sinfo *si = secdata + i;
2938
2939 if (i == IDATA5 && no_idata5)
2940 continue;
2941
2942 if (i == IDATA4 && no_idata4)
2943 continue;
2944
2945 bfd_set_section_contents (abfd, si->sec,
2946 si->data, 0,
2947 si->size);
2948 }
2949
2950 bfd_set_symtab (abfd, ptrs, oidx);
2951 bfd_close (abfd);
2952 abfd = bfd_openr (outname, HOW_BFD_READ_TARGET);
2953 if (!abfd)
2954 /* xgettext:c-format */
2955 fatal (_("bfd_open failed reopen stub file: %s: %s"),
2956 outname, bfd_get_errmsg ());
2957
2958 return abfd;
2959 }
2960
2961 static bfd *
make_head(void)2962 make_head (void)
2963 {
2964 FILE *f = fopen (TMP_HEAD_S, FOPEN_WT);
2965 bfd *abfd;
2966
2967 if (f == NULL)
2968 {
2969 fatal (_("failed to open temporary head file: %s"), TMP_HEAD_S);
2970 return NULL;
2971 }
2972
2973 temp_file_to_remove[TEMP_HEAD_FILE] = TMP_HEAD_S;
2974
2975 fprintf (f, "%s IMAGE_IMPORT_DESCRIPTOR\n", ASM_C);
2976 fprintf (f, "\t.section\t.idata$2\n");
2977
2978 fprintf (f,"\t%s\t%s\n", ASM_GLOBAL, head_label);
2979
2980 fprintf (f, "%s:\n", head_label);
2981
2982 fprintf (f, "\t%shname%s\t%sPtr to image import by name list\n",
2983 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
2984
2985 fprintf (f, "\t%sthis should be the timestamp, but NT sometimes\n", ASM_C);
2986 fprintf (f, "\t%sdoesn't load DLLs when this is set.\n", ASM_C);
2987 fprintf (f, "\t%s\t0\t%s loaded time\n", ASM_LONG, ASM_C);
2988 fprintf (f, "\t%s\t0\t%s Forwarder chain\n", ASM_LONG, ASM_C);
2989 fprintf (f, "\t%s__%s_iname%s\t%s imported dll's name\n",
2990 ASM_RVA_BEFORE,
2991 imp_name_lab,
2992 ASM_RVA_AFTER,
2993 ASM_C);
2994 fprintf (f, "\t%sfthunk%s\t%s pointer to firstthunk\n",
2995 ASM_RVA_BEFORE,
2996 ASM_RVA_AFTER, ASM_C);
2997
2998 fprintf (f, "%sStuff for compatibility\n", ASM_C);
2999
3000 if (!no_idata5)
3001 {
3002 fprintf (f, "\t.section\t.idata$5\n");
3003 if (use_nul_prefixed_import_tables)
3004 {
3005 if (create_for_pep)
3006 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
3007 else
3008 fprintf (f,"\t%s\t0\n", ASM_LONG);
3009 }
3010 fprintf (f, "fthunk:\n");
3011 }
3012
3013 if (!no_idata4)
3014 {
3015 fprintf (f, "\t.section\t.idata$4\n");
3016 if (use_nul_prefixed_import_tables)
3017 {
3018 if (create_for_pep)
3019 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
3020 else
3021 fprintf (f,"\t%s\t0\n", ASM_LONG);
3022 }
3023 fprintf (f, "hname:\n");
3024 }
3025
3026 fclose (f);
3027
3028 assemble_file (TMP_HEAD_S, TMP_HEAD_O);
3029
3030 abfd = bfd_openr (TMP_HEAD_O, HOW_BFD_READ_TARGET);
3031 if (abfd == NULL)
3032 /* xgettext:c-format */
3033 fatal (_("failed to open temporary head file: %s: %s"),
3034 TMP_HEAD_O, bfd_get_errmsg ());
3035
3036 temp_file_to_remove[TEMP_HEAD_O_FILE] = TMP_HEAD_O;
3037 return abfd;
3038 }
3039
3040 bfd *
make_delay_head(void)3041 make_delay_head (void)
3042 {
3043 FILE *f = fopen (TMP_HEAD_S, FOPEN_WT);
3044 bfd *abfd;
3045
3046 if (f == NULL)
3047 {
3048 fatal (_("failed to open temporary head file: %s"), TMP_HEAD_S);
3049 return NULL;
3050 }
3051
3052 temp_file_to_remove[TEMP_HEAD_FILE] = TMP_HEAD_S;
3053
3054 /* Output the __tailMerge__xxx function */
3055 fprintf (f, "%s Import trampoline\n", ASM_C);
3056 fprintf (f, "\t.section\t.text\n");
3057 fprintf(f,"\t%s\t%s\n", ASM_GLOBAL, head_label);
3058 fprintf (f, "%s:\n", head_label);
3059 fprintf (f, mtable[machine].trampoline, imp_name_lab);
3060
3061 /* Output the delay import descriptor */
3062 fprintf (f, "\n%s DELAY_IMPORT_DESCRIPTOR\n", ASM_C);
3063 fprintf (f, ".section\t.text$2\n");
3064 fprintf (f,"%s __DELAY_IMPORT_DESCRIPTOR_%s\n", ASM_GLOBAL,imp_name_lab);
3065 fprintf (f, "__DELAY_IMPORT_DESCRIPTOR_%s:\n", imp_name_lab);
3066 fprintf (f, "\t%s 1\t%s grAttrs\n", ASM_LONG, ASM_C);
3067 fprintf (f, "\t%s__%s_iname%s\t%s rvaDLLName\n",
3068 ASM_RVA_BEFORE, imp_name_lab, ASM_RVA_AFTER, ASM_C);
3069 fprintf (f, "\t%s__DLL_HANDLE_%s%s\t%s rvaHmod\n",
3070 ASM_RVA_BEFORE, imp_name_lab, ASM_RVA_AFTER, ASM_C);
3071 fprintf (f, "\t%s__IAT_%s%s\t%s rvaIAT\n",
3072 ASM_RVA_BEFORE, imp_name_lab, ASM_RVA_AFTER, ASM_C);
3073 fprintf (f, "\t%s__INT_%s%s\t%s rvaINT\n",
3074 ASM_RVA_BEFORE, imp_name_lab, ASM_RVA_AFTER, ASM_C);
3075 fprintf (f, "\t%s\t0\t%s rvaBoundIAT\n", ASM_LONG, ASM_C);
3076 fprintf (f, "\t%s\t0\t%s rvaUnloadIAT\n", ASM_LONG, ASM_C);
3077 fprintf (f, "\t%s\t0\t%s dwTimeStamp\n", ASM_LONG, ASM_C);
3078
3079 /* Output the dll_handle */
3080 fprintf (f, "\n.section .data\n");
3081 fprintf (f, "__DLL_HANDLE_%s:\n", imp_name_lab);
3082 fprintf (f, "\t%s\t0\t%s Handle\n", ASM_LONG, ASM_C);
3083 if (create_for_pep)
3084 fprintf (f, "\t%s\t0\n", ASM_LONG);
3085 fprintf (f, "\n");
3086
3087 fprintf (f, "%sStuff for compatibility\n", ASM_C);
3088
3089 if (!no_idata5)
3090 {
3091 fprintf (f, "\t.section\t.idata$5\n");
3092 /* NULL terminating list. */
3093 if (create_for_pep)
3094 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
3095 else
3096 fprintf (f,"\t%s\t0\n", ASM_LONG);
3097 fprintf (f, "__IAT_%s:\n", imp_name_lab);
3098 }
3099
3100 if (!no_idata4)
3101 {
3102 fprintf (f, "\t.section\t.idata$4\n");
3103 fprintf (f, "\t%s\t0\n", ASM_LONG);
3104 if (create_for_pep)
3105 fprintf (f, "\t%s\t0\n", ASM_LONG);
3106 fprintf (f, "\t.section\t.idata$4\n");
3107 fprintf (f, "__INT_%s:\n", imp_name_lab);
3108 }
3109
3110 fprintf (f, "\t.section\t.idata$2\n");
3111
3112 fclose (f);
3113
3114 assemble_file (TMP_HEAD_S, TMP_HEAD_O);
3115
3116 abfd = bfd_openr (TMP_HEAD_O, HOW_BFD_READ_TARGET);
3117 if (abfd == NULL)
3118 /* xgettext:c-format */
3119 fatal (_("failed to open temporary head file: %s: %s"),
3120 TMP_HEAD_O, bfd_get_errmsg ());
3121
3122 temp_file_to_remove[TEMP_HEAD_O_FILE] = TMP_HEAD_O;
3123 return abfd;
3124 }
3125
3126 static bfd *
make_tail(void)3127 make_tail (void)
3128 {
3129 FILE *f = fopen (TMP_TAIL_S, FOPEN_WT);
3130 bfd *abfd;
3131
3132 if (f == NULL)
3133 {
3134 fatal (_("failed to open temporary tail file: %s"), TMP_TAIL_S);
3135 return NULL;
3136 }
3137
3138 temp_file_to_remove[TEMP_TAIL_FILE] = TMP_TAIL_S;
3139
3140 if (!no_idata4)
3141 {
3142 fprintf (f, "\t.section\t.idata$4\n");
3143 if (create_for_pep)
3144 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
3145 else
3146 fprintf (f,"\t%s\t0\n", ASM_LONG); /* NULL terminating list. */
3147 }
3148
3149 if (!no_idata5)
3150 {
3151 fprintf (f, "\t.section\t.idata$5\n");
3152 if (create_for_pep)
3153 fprintf (f,"\t%s\t0\n\t%s\t0\n", ASM_LONG, ASM_LONG);
3154 else
3155 fprintf (f,"\t%s\t0\n", ASM_LONG); /* NULL terminating list. */
3156 }
3157
3158 #ifdef DLLTOOL_PPC
3159 /* Normally, we need to see a null descriptor built in idata$3 to
3160 act as the terminator for the list. The ideal way, I suppose,
3161 would be to mark this section as a comdat type 2 section, so
3162 only one would appear in the final .exe (if our linker supported
3163 comdat, that is) or cause it to be inserted by something else (say
3164 crt0). */
3165
3166 fprintf (f, "\t.section\t.idata$3\n");
3167 fprintf (f, "\t%s\t0\n", ASM_LONG);
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 #endif
3173
3174 #ifdef DLLTOOL_PPC
3175 /* Other PowerPC NT compilers use idata$6 for the dllname, so I
3176 do too. Original, huh? */
3177 fprintf (f, "\t.section\t.idata$6\n");
3178 #else
3179 fprintf (f, "\t.section\t.idata$7\n");
3180 #endif
3181
3182 fprintf (f, "\t%s\t__%s_iname\n", ASM_GLOBAL, imp_name_lab);
3183 fprintf (f, "__%s_iname:\t%s\t\"%s\"\n",
3184 imp_name_lab, ASM_TEXT, dll_name);
3185
3186 fclose (f);
3187
3188 assemble_file (TMP_TAIL_S, TMP_TAIL_O);
3189
3190 abfd = bfd_openr (TMP_TAIL_O, HOW_BFD_READ_TARGET);
3191 if (abfd == NULL)
3192 /* xgettext:c-format */
3193 fatal (_("failed to open temporary tail file: %s: %s"),
3194 TMP_TAIL_O, bfd_get_errmsg ());
3195
3196 temp_file_to_remove[TEMP_TAIL_O_FILE] = TMP_TAIL_O;
3197 return abfd;
3198 }
3199
3200 static void
gen_lib_file(int delay)3201 gen_lib_file (int delay)
3202 {
3203 int i;
3204 export_type *exp;
3205 bfd *ar_head;
3206 bfd *ar_tail;
3207 bfd *outarch;
3208 bfd * head = 0;
3209
3210 unlink (imp_name);
3211
3212 outarch = bfd_openw (imp_name, HOW_BFD_WRITE_TARGET);
3213
3214 if (!outarch)
3215 /* xgettext:c-format */
3216 fatal (_("Can't create .lib file: %s: %s"),
3217 imp_name, bfd_get_errmsg ());
3218
3219 /* xgettext:c-format */
3220 inform (_("Creating library file: %s"), imp_name);
3221
3222 xatexit (unlink_temp_files);
3223
3224 bfd_set_format (outarch, bfd_archive);
3225 outarch->has_armap = 1;
3226 outarch->is_thin_archive = 0;
3227
3228 /* Work out a reasonable size of things to put onto one line. */
3229 if (delay)
3230 {
3231 ar_head = make_delay_head ();
3232 }
3233 else
3234 {
3235 ar_head = make_head ();
3236 }
3237 ar_tail = make_tail();
3238
3239 if (ar_head == NULL || ar_tail == NULL)
3240 return;
3241
3242 for (i = 0; (exp = d_exports_lexically[i]); i++)
3243 {
3244 bfd *n;
3245 /* Don't add PRIVATE entries to import lib. */
3246 if (exp->private)
3247 continue;
3248 n = make_one_lib_file (exp, i, delay);
3249 n->archive_next = head;
3250 head = n;
3251 if (ext_prefix_alias)
3252 {
3253 export_type alias_exp;
3254
3255 assert (i < PREFIX_ALIAS_BASE);
3256 alias_exp.name = make_imp_label (ext_prefix_alias, exp->name);
3257 alias_exp.internal_name = exp->internal_name;
3258 alias_exp.its_name = exp->its_name;
3259 alias_exp.import_name = exp->name;
3260 alias_exp.ordinal = exp->ordinal;
3261 alias_exp.constant = exp->constant;
3262 alias_exp.noname = exp->noname;
3263 alias_exp.private = exp->private;
3264 alias_exp.data = exp->data;
3265 alias_exp.hint = exp->hint;
3266 alias_exp.forward = exp->forward;
3267 alias_exp.next = exp->next;
3268 n = make_one_lib_file (&alias_exp, i + PREFIX_ALIAS_BASE, delay);
3269 n->archive_next = head;
3270 head = n;
3271 }
3272 }
3273
3274 /* Now stick them all into the archive. */
3275 ar_head->archive_next = head;
3276 ar_tail->archive_next = ar_head;
3277 head = ar_tail;
3278
3279 if (! bfd_set_archive_head (outarch, head))
3280 bfd_fatal ("bfd_set_archive_head");
3281
3282 if (! bfd_close (outarch))
3283 bfd_fatal (imp_name);
3284
3285 while (head != NULL)
3286 {
3287 bfd *n = head->archive_next;
3288 bfd_close (head);
3289 head = n;
3290 }
3291
3292 /* Delete all the temp files. */
3293 unlink_temp_files ();
3294
3295 if (dontdeltemps < 2)
3296 {
3297 char *name;
3298
3299 name = xmalloc (strlen (TMP_STUB) + 10);
3300 for (i = 0; (exp = d_exports_lexically[i]); i++)
3301 {
3302 /* Don't delete non-existent stubs for PRIVATE entries. */
3303 if (exp->private)
3304 continue;
3305 sprintf (name, "%s%05d.o", TMP_STUB, i);
3306 if (unlink (name) < 0)
3307 /* xgettext:c-format */
3308 non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
3309 if (ext_prefix_alias)
3310 {
3311 sprintf (name, "%s%05d.o", TMP_STUB, i + PREFIX_ALIAS_BASE);
3312 if (unlink (name) < 0)
3313 /* xgettext:c-format */
3314 non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
3315 }
3316 }
3317 free (name);
3318 }
3319
3320 inform (_("Created lib file"));
3321 }
3322
3323 /* Append a copy of data (cast to char *) to list. */
3324
3325 static void
dll_name_list_append(dll_name_list_type * list,bfd_byte * data)3326 dll_name_list_append (dll_name_list_type * list, bfd_byte * data)
3327 {
3328 dll_name_list_node_type * entry;
3329
3330 /* Error checking. */
3331 if (! list || ! list->tail)
3332 return;
3333
3334 /* Allocate new node. */
3335 entry = ((dll_name_list_node_type *)
3336 xmalloc (sizeof (dll_name_list_node_type)));
3337
3338 /* Initialize its values. */
3339 entry->dllname = xstrdup ((char *) data);
3340 entry->next = NULL;
3341
3342 /* Add to tail, and move tail. */
3343 list->tail->next = entry;
3344 list->tail = entry;
3345 }
3346
3347 /* Count the number of entries in list. */
3348
3349 static int
dll_name_list_count(dll_name_list_type * list)3350 dll_name_list_count (dll_name_list_type * list)
3351 {
3352 dll_name_list_node_type * p;
3353 int count = 0;
3354
3355 /* Error checking. */
3356 if (! list || ! list->head)
3357 return 0;
3358
3359 p = list->head;
3360
3361 while (p && p->next)
3362 {
3363 count++;
3364 p = p->next;
3365 }
3366 return count;
3367 }
3368
3369 /* Print each entry in list to stdout. */
3370
3371 static void
dll_name_list_print(dll_name_list_type * list)3372 dll_name_list_print (dll_name_list_type * list)
3373 {
3374 dll_name_list_node_type * p;
3375
3376 /* Error checking. */
3377 if (! list || ! list->head)
3378 return;
3379
3380 p = list->head;
3381
3382 while (p && p->next && p->next->dllname && *(p->next->dllname))
3383 {
3384 printf ("%s\n", p->next->dllname);
3385 p = p->next;
3386 }
3387 }
3388
3389 /* Free all entries in list, and list itself. */
3390
3391 static void
dll_name_list_free(dll_name_list_type * list)3392 dll_name_list_free (dll_name_list_type * list)
3393 {
3394 if (list)
3395 {
3396 dll_name_list_free_contents (list->head);
3397 list->head = NULL;
3398 list->tail = NULL;
3399 free (list);
3400 }
3401 }
3402
3403 /* Recursive function to free all nodes entry->next->next...
3404 as well as entry itself. */
3405
3406 static void
dll_name_list_free_contents(dll_name_list_node_type * entry)3407 dll_name_list_free_contents (dll_name_list_node_type * entry)
3408 {
3409 if (entry)
3410 {
3411 if (entry->next)
3412 {
3413 dll_name_list_free_contents (entry->next);
3414 entry->next = NULL;
3415 }
3416 if (entry->dllname)
3417 {
3418 free (entry->dllname);
3419 entry->dllname = NULL;
3420 }
3421 free (entry);
3422 }
3423 }
3424
3425 /* Allocate and initialize a dll_name_list_type object,
3426 including its sentinel node. Caller is responsible
3427 for calling dll_name_list_free when finished with
3428 the list. */
3429
3430 static dll_name_list_type *
dll_name_list_create(void)3431 dll_name_list_create (void)
3432 {
3433 /* Allocate list. */
3434 dll_name_list_type * list = xmalloc (sizeof (dll_name_list_type));
3435
3436 /* Allocate and initialize sentinel node. */
3437 list->head = xmalloc (sizeof (dll_name_list_node_type));
3438 list->head->dllname = NULL;
3439 list->head->next = NULL;
3440
3441 /* Bookkeeping for empty list. */
3442 list->tail = list->head;
3443
3444 return list;
3445 }
3446
3447 /* Search the symbol table of the suppled BFD for a symbol whose name matches
3448 OBJ (where obj is cast to const char *). If found, set global variable
3449 identify_member_contains_symname_result TRUE. It is the caller's
3450 responsibility to set the result variable FALSE before iterating with
3451 this function. */
3452
3453 static void
identify_member_contains_symname(bfd * abfd,bfd * archive_bfd ATTRIBUTE_UNUSED,void * obj)3454 identify_member_contains_symname (bfd * abfd,
3455 bfd * archive_bfd ATTRIBUTE_UNUSED,
3456 void * obj)
3457 {
3458 long storage_needed;
3459 asymbol ** symbol_table;
3460 long number_of_symbols;
3461 long i;
3462 symname_search_data_type * search_data = (symname_search_data_type *) obj;
3463
3464 /* If we already found the symbol in a different member,
3465 short circuit. */
3466 if (search_data->found)
3467 return;
3468
3469 storage_needed = bfd_get_symtab_upper_bound (abfd);
3470 if (storage_needed <= 0)
3471 return;
3472
3473 symbol_table = xmalloc (storage_needed);
3474 number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
3475 if (number_of_symbols < 0)
3476 {
3477 free (symbol_table);
3478 return;
3479 }
3480
3481 for (i = 0; i < number_of_symbols; i++)
3482 {
3483 if (strncmp (symbol_table[i]->name,
3484 search_data->symname,
3485 strlen (search_data->symname)) == 0)
3486 {
3487 search_data->found = TRUE;
3488 break;
3489 }
3490 }
3491 free (symbol_table);
3492 }
3493
3494 /* This is the main implementation for the --identify option.
3495 Given the name of an import library in identify_imp_name, first determine
3496 if the import library is a GNU binutils-style one (where the DLL name is
3497 stored in an .idata$7 (.idata$6 on PPC) section, or if it is a MS-style
3498 one (where the DLL name, along with much other data, is stored in the
3499 .idata$6 section). We determine the style of import library by searching
3500 for the DLL-structure symbol inserted by MS tools:
3501 __NULL_IMPORT_DESCRIPTOR.
3502
3503 Once we know which section to search, evaluate each section for the
3504 appropriate properties that indicate it may contain the name of the
3505 associated DLL (this differs depending on the style). Add the contents
3506 of all sections which meet the criteria to a linked list of dll names.
3507
3508 Finally, print them all to stdout. (If --identify-strict, an error is
3509 reported if more than one match was found). */
3510
3511 static void
identify_dll_for_implib(void)3512 identify_dll_for_implib (void)
3513 {
3514 bfd * abfd = NULL;
3515 int count = 0;
3516 identify_data_type identify_data;
3517 symname_search_data_type search_data;
3518
3519 /* Initialize identify_data. */
3520 identify_data.list = dll_name_list_create ();
3521 identify_data.ms_style_implib = FALSE;
3522
3523 /* Initialize search_data. */
3524 search_data.symname = "__NULL_IMPORT_DESCRIPTOR";
3525 search_data.found = FALSE;
3526
3527 bfd_init ();
3528
3529 abfd = bfd_openr (identify_imp_name, 0);
3530 if (abfd == NULL)
3531 /* xgettext:c-format */
3532 fatal (_("Can't open .lib file: %s: %s"),
3533 identify_imp_name, bfd_get_errmsg ());
3534
3535 if (! bfd_check_format (abfd, bfd_archive))
3536 {
3537 if (! bfd_close (abfd))
3538 bfd_fatal (identify_imp_name);
3539
3540 fatal (_("%s is not a library"), identify_imp_name);
3541 }
3542
3543 /* Detect if this a Microsoft import library. */
3544 identify_search_archive (abfd,
3545 identify_member_contains_symname,
3546 (void *)(& search_data));
3547 if (search_data.found)
3548 identify_data.ms_style_implib = TRUE;
3549
3550 /* Rewind the bfd. */
3551 if (! bfd_close (abfd))
3552 bfd_fatal (identify_imp_name);
3553 abfd = bfd_openr (identify_imp_name, 0);
3554 if (abfd == NULL)
3555 bfd_fatal (identify_imp_name);
3556
3557 if (!bfd_check_format (abfd, bfd_archive))
3558 {
3559 if (!bfd_close (abfd))
3560 bfd_fatal (identify_imp_name);
3561
3562 fatal (_("%s is not a library"), identify_imp_name);
3563 }
3564
3565 /* Now search for the dll name. */
3566 identify_search_archive (abfd,
3567 identify_search_member,
3568 (void *)(& identify_data));
3569
3570 if (! bfd_close (abfd))
3571 bfd_fatal (identify_imp_name);
3572
3573 count = dll_name_list_count (identify_data.list);
3574 if (count > 0)
3575 {
3576 if (identify_strict && count > 1)
3577 {
3578 dll_name_list_free (identify_data.list);
3579 identify_data.list = NULL;
3580 fatal (_("Import library `%s' specifies two or more dlls"),
3581 identify_imp_name);
3582 }
3583 dll_name_list_print (identify_data.list);
3584 dll_name_list_free (identify_data.list);
3585 identify_data.list = NULL;
3586 }
3587 else
3588 {
3589 dll_name_list_free (identify_data.list);
3590 identify_data.list = NULL;
3591 fatal (_("Unable to determine dll name for `%s' (not an import library?)"),
3592 identify_imp_name);
3593 }
3594 }
3595
3596 /* Loop over all members of the archive, applying the supplied function to
3597 each member that is a bfd_object. The function will be called as if:
3598 func (member_bfd, abfd, user_storage) */
3599
3600 static void
identify_search_archive(bfd * abfd,void (* operation)(bfd *,bfd *,void *),void * user_storage)3601 identify_search_archive (bfd * abfd,
3602 void (* operation) (bfd *, bfd *, void *),
3603 void * user_storage)
3604 {
3605 bfd * arfile = NULL;
3606 bfd * last_arfile = NULL;
3607 char ** matching;
3608
3609 while (1)
3610 {
3611 arfile = bfd_openr_next_archived_file (abfd, arfile);
3612
3613 if (arfile == NULL)
3614 {
3615 if (bfd_get_error () != bfd_error_no_more_archived_files)
3616 bfd_fatal (bfd_get_filename (abfd));
3617 break;
3618 }
3619
3620 if (bfd_check_format_matches (arfile, bfd_object, &matching))
3621 (*operation) (arfile, abfd, user_storage);
3622 else
3623 {
3624 bfd_nonfatal (bfd_get_filename (arfile));
3625 free (matching);
3626 }
3627
3628 if (last_arfile != NULL)
3629 {
3630 bfd_close (last_arfile);
3631 /* PR 17512: file: 8b2168d4. */
3632 if (last_arfile == arfile)
3633 {
3634 last_arfile = NULL;
3635 break;
3636 }
3637 }
3638
3639 last_arfile = arfile;
3640 }
3641
3642 if (last_arfile != NULL)
3643 {
3644 bfd_close (last_arfile);
3645 }
3646 }
3647
3648 /* Call the identify_search_section() function for each section of this
3649 archive member. */
3650
3651 static void
identify_search_member(bfd * abfd,bfd * archive_bfd ATTRIBUTE_UNUSED,void * obj)3652 identify_search_member (bfd *abfd,
3653 bfd *archive_bfd ATTRIBUTE_UNUSED,
3654 void *obj)
3655 {
3656 bfd_map_over_sections (abfd, identify_search_section, obj);
3657 }
3658
3659 /* This predicate returns true if section->name matches the desired value.
3660 By default, this is .idata$7 (.idata$6 on PPC, or if the import
3661 library is ms-style). */
3662
3663 static bfd_boolean
identify_process_section_p(asection * section,bfd_boolean ms_style_implib)3664 identify_process_section_p (asection * section, bfd_boolean ms_style_implib)
3665 {
3666 static const char * SECTION_NAME =
3667 #ifdef DLLTOOL_PPC
3668 /* dllname is stored in idata$6 on PPC */
3669 ".idata$6";
3670 #else
3671 ".idata$7";
3672 #endif
3673 static const char * MS_SECTION_NAME = ".idata$6";
3674
3675 const char * section_name =
3676 (ms_style_implib ? MS_SECTION_NAME : SECTION_NAME);
3677
3678 if (strcmp (section_name, section->name) == 0)
3679 return TRUE;
3680 return FALSE;
3681 }
3682
3683 /* If *section has contents and its name is .idata$7 (.data$6 on PPC or if
3684 import lib ms-generated) -- and it satisfies several other constraints
3685 -- then add the contents of the section to obj->list. */
3686
3687 static void
identify_search_section(bfd * abfd,asection * section,void * obj)3688 identify_search_section (bfd * abfd, asection * section, void * obj)
3689 {
3690 bfd_byte *data = 0;
3691 bfd_size_type datasize;
3692 identify_data_type * identify_data = (identify_data_type *)obj;
3693 bfd_boolean ms_style = identify_data->ms_style_implib;
3694
3695 if ((section->flags & SEC_HAS_CONTENTS) == 0)
3696 return;
3697
3698 if (! identify_process_section_p (section, ms_style))
3699 return;
3700
3701 /* Binutils import libs seem distinguish the .idata$7 section that contains
3702 the DLL name from other .idata$7 sections by the absence of the
3703 SEC_RELOC flag. */
3704 if (!ms_style && ((section->flags & SEC_RELOC) == SEC_RELOC))
3705 return;
3706
3707 /* MS import libs seem to distinguish the .idata$6 section
3708 that contains the DLL name from other .idata$6 sections
3709 by the presence of the SEC_DATA flag. */
3710 if (ms_style && ((section->flags & SEC_DATA) == 0))
3711 return;
3712
3713 if ((datasize = bfd_section_size (abfd, section)) == 0)
3714 return;
3715
3716 data = (bfd_byte *) xmalloc (datasize + 1);
3717 data[0] = '\0';
3718
3719 bfd_get_section_contents (abfd, section, data, 0, datasize);
3720 data[datasize] = '\0';
3721
3722 /* Use a heuristic to determine if data is a dll name.
3723 Possible to defeat this if (a) the library has MANY
3724 (more than 0x302f) imports, (b) it is an ms-style
3725 import library, but (c) it is buggy, in that the SEC_DATA
3726 flag is set on the "wrong" sections. This heuristic might
3727 also fail to record a valid dll name if the dllname uses
3728 a multibyte or unicode character set (is that valid?).
3729
3730 This heuristic is based on the fact that symbols names in
3731 the chosen section -- as opposed to the dll name -- begin
3732 at offset 2 in the data. The first two bytes are a 16bit
3733 little-endian count, and start at 0x0000. However, the dll
3734 name begins at offset 0 in the data. We assume that the
3735 dll name does not contain unprintable characters. */
3736 if (data[0] != '\0' && ISPRINT (data[0])
3737 && ((datasize < 2) || ISPRINT (data[1])))
3738 dll_name_list_append (identify_data->list, data);
3739
3740 free (data);
3741 }
3742
3743 /* Run through the information gathered from the .o files and the
3744 .def file and work out the best stuff. */
3745
3746 static int
pfunc(const void * a,const void * b)3747 pfunc (const void *a, const void *b)
3748 {
3749 export_type *ap = *(export_type **) a;
3750 export_type *bp = *(export_type **) b;
3751
3752 if (ap->ordinal == bp->ordinal)
3753 return 0;
3754
3755 /* Unset ordinals go to the bottom. */
3756 if (ap->ordinal == -1)
3757 return 1;
3758 if (bp->ordinal == -1)
3759 return -1;
3760 return (ap->ordinal - bp->ordinal);
3761 }
3762
3763 static int
nfunc(const void * a,const void * b)3764 nfunc (const void *a, const void *b)
3765 {
3766 export_type *ap = *(export_type **) a;
3767 export_type *bp = *(export_type **) b;
3768 const char *an = ap->name;
3769 const char *bn = bp->name;
3770 if (ap->its_name)
3771 an = ap->its_name;
3772 if (bp->its_name)
3773 an = bp->its_name;
3774 if (killat)
3775 {
3776 an = (an[0] == '@') ? an + 1 : an;
3777 bn = (bn[0] == '@') ? bn + 1 : bn;
3778 }
3779
3780 return (strcmp (an, bn));
3781 }
3782
3783 static void
remove_null_names(export_type ** ptr)3784 remove_null_names (export_type **ptr)
3785 {
3786 int src;
3787 int dst;
3788
3789 for (dst = src = 0; src < d_nfuncs; src++)
3790 {
3791 if (ptr[src])
3792 {
3793 ptr[dst] = ptr[src];
3794 dst++;
3795 }
3796 }
3797 d_nfuncs = dst;
3798 }
3799
3800 static void
process_duplicates(export_type ** d_export_vec)3801 process_duplicates (export_type **d_export_vec)
3802 {
3803 int more = 1;
3804 int i;
3805
3806 while (more)
3807 {
3808 more = 0;
3809 /* Remove duplicates. */
3810 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), nfunc);
3811
3812 for (i = 0; i < d_nfuncs - 1; i++)
3813 {
3814 if (strcmp (d_export_vec[i]->name,
3815 d_export_vec[i + 1]->name) == 0)
3816 {
3817 export_type *a = d_export_vec[i];
3818 export_type *b = d_export_vec[i + 1];
3819
3820 more = 1;
3821
3822 /* xgettext:c-format */
3823 inform (_("Warning, ignoring duplicate EXPORT %s %d,%d"),
3824 a->name, a->ordinal, b->ordinal);
3825
3826 if (a->ordinal != -1
3827 && b->ordinal != -1)
3828 /* xgettext:c-format */
3829 fatal (_("Error, duplicate EXPORT with ordinals: %s"),
3830 a->name);
3831
3832 /* Merge attributes. */
3833 b->ordinal = a->ordinal > 0 ? a->ordinal : b->ordinal;
3834 b->constant |= a->constant;
3835 b->noname |= a->noname;
3836 b->data |= a->data;
3837 d_export_vec[i] = 0;
3838 }
3839
3840 remove_null_names (d_export_vec);
3841 }
3842 }
3843
3844 /* Count the names. */
3845 for (i = 0; i < d_nfuncs; i++)
3846 if (!d_export_vec[i]->noname)
3847 d_named_nfuncs++;
3848 }
3849
3850 static void
fill_ordinals(export_type ** d_export_vec)3851 fill_ordinals (export_type **d_export_vec)
3852 {
3853 int lowest = -1;
3854 int i;
3855 char *ptr;
3856 int size = 65536;
3857
3858 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
3859
3860 /* Fill in the unset ordinals with ones from our range. */
3861 ptr = (char *) xmalloc (size);
3862
3863 memset (ptr, 0, size);
3864
3865 /* Mark in our large vector all the numbers that are taken. */
3866 for (i = 0; i < d_nfuncs; i++)
3867 {
3868 if (d_export_vec[i]->ordinal != -1)
3869 {
3870 ptr[d_export_vec[i]->ordinal] = 1;
3871
3872 if (lowest == -1 || d_export_vec[i]->ordinal < lowest)
3873 lowest = d_export_vec[i]->ordinal;
3874 }
3875 }
3876
3877 /* Start at 1 for compatibility with MS toolchain. */
3878 if (lowest == -1)
3879 lowest = 1;
3880
3881 /* Now fill in ordinals where the user wants us to choose. */
3882 for (i = 0; i < d_nfuncs; i++)
3883 {
3884 if (d_export_vec[i]->ordinal == -1)
3885 {
3886 int j;
3887
3888 /* First try within or after any user supplied range. */
3889 for (j = lowest; j < size; j++)
3890 if (ptr[j] == 0)
3891 {
3892 ptr[j] = 1;
3893 d_export_vec[i]->ordinal = j;
3894 goto done;
3895 }
3896
3897 /* Then try before the range. */
3898 for (j = lowest; j >0; j--)
3899 if (ptr[j] == 0)
3900 {
3901 ptr[j] = 1;
3902 d_export_vec[i]->ordinal = j;
3903 goto done;
3904 }
3905 done:;
3906 }
3907 }
3908
3909 free (ptr);
3910
3911 /* And resort. */
3912 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
3913
3914 /* Work out the lowest and highest ordinal numbers. */
3915 if (d_nfuncs)
3916 {
3917 if (d_export_vec[0])
3918 d_low_ord = d_export_vec[0]->ordinal;
3919 if (d_export_vec[d_nfuncs-1])
3920 d_high_ord = d_export_vec[d_nfuncs-1]->ordinal;
3921 }
3922 }
3923
3924 static void
mangle_defs(void)3925 mangle_defs (void)
3926 {
3927 /* First work out the minimum ordinal chosen. */
3928 export_type *exp;
3929
3930 int i;
3931 int hint = 0;
3932 export_type **d_export_vec = xmalloc (sizeof (export_type *) * d_nfuncs);
3933
3934 inform (_("Processing definitions"));
3935
3936 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3937 d_export_vec[i] = exp;
3938
3939 process_duplicates (d_export_vec);
3940 fill_ordinals (d_export_vec);
3941
3942 /* Put back the list in the new order. */
3943 d_exports = 0;
3944 for (i = d_nfuncs - 1; i >= 0; i--)
3945 {
3946 d_export_vec[i]->next = d_exports;
3947 d_exports = d_export_vec[i];
3948 }
3949
3950 /* Build list in alpha order. */
3951 d_exports_lexically = (export_type **)
3952 xmalloc (sizeof (export_type *) * (d_nfuncs + 1));
3953
3954 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3955 d_exports_lexically[i] = exp;
3956
3957 d_exports_lexically[i] = 0;
3958
3959 qsort (d_exports_lexically, i, sizeof (export_type *), nfunc);
3960
3961 /* Fill exp entries with their hint values. */
3962 for (i = 0; i < d_nfuncs; i++)
3963 if (!d_exports_lexically[i]->noname || show_allnames)
3964 d_exports_lexically[i]->hint = hint++;
3965
3966 inform (_("Processed definitions"));
3967 }
3968
3969 static void
usage(FILE * file,int status)3970 usage (FILE *file, int status)
3971 {
3972 /* xgetext:c-format */
3973 fprintf (file, _("Usage %s <option(s)> <object-file(s)>\n"), program_name);
3974 /* xgetext:c-format */
3975 fprintf (file, _(" -m --machine <machine> Create as DLL for <machine>. [default: %s]\n"), mname);
3976 fprintf (file, _(" possible <machine>: arm[_interwork], i386, mcore[-elf]{-le|-be}, ppc, thumb\n"));
3977 fprintf (file, _(" -e --output-exp <outname> Generate an export file.\n"));
3978 fprintf (file, _(" -l --output-lib <outname> Generate an interface library.\n"));
3979 fprintf (file, _(" -y --output-delaylib <outname> Create a delay-import library.\n"));
3980 fprintf (file, _(" -a --add-indirect Add dll indirects to export file.\n"));
3981 fprintf (file, _(" -D --dllname <name> Name of input dll to put into interface lib.\n"));
3982 fprintf (file, _(" -d --input-def <deffile> Name of .def file to be read in.\n"));
3983 fprintf (file, _(" -z --output-def <deffile> Name of .def file to be created.\n"));
3984 fprintf (file, _(" --export-all-symbols Export all symbols to .def\n"));
3985 fprintf (file, _(" --no-export-all-symbols Only export listed symbols\n"));
3986 fprintf (file, _(" --exclude-symbols <list> Don't export <list>\n"));
3987 fprintf (file, _(" --no-default-excludes Clear default exclude symbols\n"));
3988 fprintf (file, _(" -b --base-file <basefile> Read linker generated base file.\n"));
3989 fprintf (file, _(" -x --no-idata4 Don't generate idata$4 section.\n"));
3990 fprintf (file, _(" -c --no-idata5 Don't generate idata$5 section.\n"));
3991 fprintf (file, _(" --use-nul-prefixed-import-tables Use zero prefixed idata$4 and idata$5.\n"));
3992 fprintf (file, _(" -U --add-underscore Add underscores to all symbols in interface library.\n"));
3993 fprintf (file, _(" --add-stdcall-underscore Add underscores to stdcall symbols in interface library.\n"));
3994 fprintf (file, _(" --no-leading-underscore All symbols shouldn't be prefixed by an underscore.\n"));
3995 fprintf (file, _(" --leading-underscore All symbols should be prefixed by an underscore.\n"));
3996 fprintf (file, _(" -k --kill-at Kill @<n> from exported names.\n"));
3997 fprintf (file, _(" -A --add-stdcall-alias Add aliases without @<n>.\n"));
3998 fprintf (file, _(" -p --ext-prefix-alias <prefix> Add aliases with <prefix>.\n"));
3999 fprintf (file, _(" -S --as <name> Use <name> for assembler.\n"));
4000 fprintf (file, _(" -f --as-flags <flags> Pass <flags> to the assembler.\n"));
4001 fprintf (file, _(" -C --compat-implib Create backward compatible import library.\n"));
4002 fprintf (file, _(" -n --no-delete Keep temp files (repeat for extra preservation).\n"));
4003 fprintf (file, _(" -t --temp-prefix <prefix> Use <prefix> to construct temp file names.\n"));
4004 fprintf (file, _(" -I --identify <implib> Report the name of the DLL associated with <implib>.\n"));
4005 fprintf (file, _(" --identify-strict Causes --identify to report error when multiple DLLs.\n"));
4006 fprintf (file, _(" -v --verbose Be verbose.\n"));
4007 fprintf (file, _(" -V --version Display the program version.\n"));
4008 fprintf (file, _(" -h --help Display this information.\n"));
4009 fprintf (file, _(" @<file> Read options from <file>.\n"));
4010 #ifdef DLLTOOL_MCORE_ELF
4011 fprintf (file, _(" -M --mcore-elf <outname> Process mcore-elf object files into <outname>.\n"));
4012 fprintf (file, _(" -L --linker <name> Use <name> as the linker.\n"));
4013 fprintf (file, _(" -F --linker-flags <flags> Pass <flags> to the linker.\n"));
4014 #endif
4015 if (REPORT_BUGS_TO[0] && status == 0)
4016 fprintf (file, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4017 exit (status);
4018 }
4019
4020 #define OPTION_EXPORT_ALL_SYMS 150
4021 #define OPTION_NO_EXPORT_ALL_SYMS (OPTION_EXPORT_ALL_SYMS + 1)
4022 #define OPTION_EXCLUDE_SYMS (OPTION_NO_EXPORT_ALL_SYMS + 1)
4023 #define OPTION_NO_DEFAULT_EXCLUDES (OPTION_EXCLUDE_SYMS + 1)
4024 #define OPTION_ADD_STDCALL_UNDERSCORE (OPTION_NO_DEFAULT_EXCLUDES + 1)
4025 #define OPTION_USE_NUL_PREFIXED_IMPORT_TABLES \
4026 (OPTION_ADD_STDCALL_UNDERSCORE + 1)
4027 #define OPTION_IDENTIFY_STRICT (OPTION_USE_NUL_PREFIXED_IMPORT_TABLES + 1)
4028 #define OPTION_NO_LEADING_UNDERSCORE (OPTION_IDENTIFY_STRICT + 1)
4029 #define OPTION_LEADING_UNDERSCORE (OPTION_NO_LEADING_UNDERSCORE + 1)
4030
4031 static const struct option long_options[] =
4032 {
4033 {"no-delete", no_argument, NULL, 'n'},
4034 {"dllname", required_argument, NULL, 'D'},
4035 {"no-idata4", no_argument, NULL, 'x'},
4036 {"no-idata5", no_argument, NULL, 'c'},
4037 {"use-nul-prefixed-import-tables", no_argument, NULL,
4038 OPTION_USE_NUL_PREFIXED_IMPORT_TABLES},
4039 {"output-exp", required_argument, NULL, 'e'},
4040 {"output-def", required_argument, NULL, 'z'},
4041 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL_SYMS},
4042 {"no-export-all-symbols", no_argument, NULL, OPTION_NO_EXPORT_ALL_SYMS},
4043 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMS},
4044 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
4045 {"output-lib", required_argument, NULL, 'l'},
4046 {"def", required_argument, NULL, 'd'}, /* for compatibility with older versions */
4047 {"input-def", required_argument, NULL, 'd'},
4048 {"add-underscore", no_argument, NULL, 'U'},
4049 {"add-stdcall-underscore", no_argument, NULL, OPTION_ADD_STDCALL_UNDERSCORE},
4050 {"no-leading-underscore", no_argument, NULL, OPTION_NO_LEADING_UNDERSCORE},
4051 {"leading-underscore", no_argument, NULL, OPTION_LEADING_UNDERSCORE},
4052 {"kill-at", no_argument, NULL, 'k'},
4053 {"add-stdcall-alias", no_argument, NULL, 'A'},
4054 {"ext-prefix-alias", required_argument, NULL, 'p'},
4055 {"identify", required_argument, NULL, 'I'},
4056 {"identify-strict", no_argument, NULL, OPTION_IDENTIFY_STRICT},
4057 {"verbose", no_argument, NULL, 'v'},
4058 {"version", no_argument, NULL, 'V'},
4059 {"help", no_argument, NULL, 'h'},
4060 {"machine", required_argument, NULL, 'm'},
4061 {"add-indirect", no_argument, NULL, 'a'},
4062 {"base-file", required_argument, NULL, 'b'},
4063 {"as", required_argument, NULL, 'S'},
4064 {"as-flags", required_argument, NULL, 'f'},
4065 {"mcore-elf", required_argument, NULL, 'M'},
4066 {"compat-implib", no_argument, NULL, 'C'},
4067 {"temp-prefix", required_argument, NULL, 't'},
4068 {"output-delaylib", required_argument, NULL, 'y'},
4069 {NULL,0,NULL,0}
4070 };
4071
4072 int main (int, char **);
4073
4074 int
main(int ac,char ** av)4075 main (int ac, char **av)
4076 {
4077 int c;
4078 int i;
4079 char *firstarg = 0;
4080 program_name = av[0];
4081 oav = av;
4082
4083 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
4084 setlocale (LC_MESSAGES, "");
4085 #endif
4086 #if defined (HAVE_SETLOCALE)
4087 setlocale (LC_CTYPE, "");
4088 #endif
4089 bindtextdomain (PACKAGE, LOCALEDIR);
4090 textdomain (PACKAGE);
4091
4092 bfd_set_error_program_name (program_name);
4093 expandargv (&ac, &av);
4094
4095 while ((c = getopt_long (ac, av,
4096 #ifdef DLLTOOL_MCORE_ELF
4097 "m:e:l:aD:d:z:b:xp:cCuUkAS:t:f:nI:vVHhM:L:F:",
4098 #else
4099 "m:e:l:y:aD:d:z:b:xp:cCuUkAS:t:f:nI:vVHh",
4100 #endif
4101 long_options, 0))
4102 != EOF)
4103 {
4104 switch (c)
4105 {
4106 case OPTION_EXPORT_ALL_SYMS:
4107 export_all_symbols = TRUE;
4108 break;
4109 case OPTION_NO_EXPORT_ALL_SYMS:
4110 export_all_symbols = FALSE;
4111 break;
4112 case OPTION_EXCLUDE_SYMS:
4113 add_excludes (optarg);
4114 break;
4115 case OPTION_NO_DEFAULT_EXCLUDES:
4116 do_default_excludes = FALSE;
4117 break;
4118 case OPTION_USE_NUL_PREFIXED_IMPORT_TABLES:
4119 use_nul_prefixed_import_tables = TRUE;
4120 break;
4121 case OPTION_ADD_STDCALL_UNDERSCORE:
4122 add_stdcall_underscore = 1;
4123 break;
4124 case OPTION_NO_LEADING_UNDERSCORE:
4125 leading_underscore = 0;
4126 break;
4127 case OPTION_LEADING_UNDERSCORE:
4128 leading_underscore = 1;
4129 break;
4130 case OPTION_IDENTIFY_STRICT:
4131 identify_strict = 1;
4132 break;
4133 case 'x':
4134 no_idata4 = 1;
4135 break;
4136 case 'c':
4137 no_idata5 = 1;
4138 break;
4139 case 'S':
4140 as_name = optarg;
4141 break;
4142 case 't':
4143 tmp_prefix = optarg;
4144 break;
4145 case 'f':
4146 as_flags = optarg;
4147 break;
4148
4149 /* Ignored for compatibility. */
4150 case 'u':
4151 break;
4152 case 'a':
4153 add_indirect = 1;
4154 break;
4155 case 'z':
4156 output_def = fopen (optarg, FOPEN_WT);
4157 if (!output_def)
4158 /* xgettext:c-format */
4159 fatal (_("Unable to open def-file: %s"), optarg);
4160 break;
4161 case 'D':
4162 dll_name = (char*) lbasename (optarg);
4163 if (dll_name != optarg)
4164 non_fatal (_("Path components stripped from dllname, '%s'."),
4165 optarg);
4166 break;
4167 case 'l':
4168 imp_name = optarg;
4169 break;
4170 case 'e':
4171 exp_name = optarg;
4172 break;
4173 case 'H':
4174 case 'h':
4175 usage (stdout, 0);
4176 break;
4177 case 'm':
4178 mname = optarg;
4179 break;
4180 case 'I':
4181 identify_imp_name = optarg;
4182 break;
4183 case 'v':
4184 verbose = 1;
4185 break;
4186 case 'V':
4187 print_version (program_name);
4188 break;
4189 case 'U':
4190 add_underscore = 1;
4191 break;
4192 case 'k':
4193 killat = 1;
4194 break;
4195 case 'A':
4196 add_stdcall_alias = 1;
4197 break;
4198 case 'p':
4199 ext_prefix_alias = optarg;
4200 break;
4201 case 'd':
4202 def_file = optarg;
4203 break;
4204 case 'n':
4205 dontdeltemps++;
4206 break;
4207 case 'b':
4208 base_file = fopen (optarg, FOPEN_RB);
4209
4210 if (!base_file)
4211 /* xgettext:c-format */
4212 fatal (_("Unable to open base-file: %s"), optarg);
4213
4214 break;
4215 #ifdef DLLTOOL_MCORE_ELF
4216 case 'M':
4217 mcore_elf_out_file = optarg;
4218 break;
4219 case 'L':
4220 mcore_elf_linker = optarg;
4221 break;
4222 case 'F':
4223 mcore_elf_linker_flags = optarg;
4224 break;
4225 #endif
4226 case 'C':
4227 create_compat_implib = 1;
4228 break;
4229 case 'y':
4230 delayimp_name = optarg;
4231 break;
4232 default:
4233 usage (stderr, 1);
4234 break;
4235 }
4236 }
4237
4238 if (!tmp_prefix)
4239 tmp_prefix = prefix_encode ("d", getpid ());
4240
4241 for (i = 0; mtable[i].type; i++)
4242 if (strcmp (mtable[i].type, mname) == 0)
4243 break;
4244
4245 if (!mtable[i].type)
4246 /* xgettext:c-format */
4247 fatal (_("Machine '%s' not supported"), mname);
4248
4249 machine = i;
4250
4251 /* Check if we generated PE+. */
4252 create_for_pep = strcmp (mname, "i386:x86-64") == 0;
4253
4254 {
4255 /* Check the default underscore */
4256 int u = leading_underscore; /* Underscoring mode. -1 for use default. */
4257 if (u == -1)
4258 bfd_get_target_info (mtable[machine].how_bfd_target, NULL,
4259 NULL, &u, NULL);
4260 if (u != -1)
4261 leading_underscore = (u != 0 ? TRUE : FALSE);
4262 }
4263
4264 if (!dll_name && exp_name)
4265 {
4266 /* If we are inferring dll_name from exp_name,
4267 strip off any path components, without emitting
4268 a warning. */
4269 const char* exp_basename = lbasename (exp_name);
4270 const int len = strlen (exp_basename) + 5;
4271 dll_name = xmalloc (len);
4272 strcpy (dll_name, exp_basename);
4273 strcat (dll_name, ".dll");
4274 dll_name_set_by_exp_name = 1;
4275 }
4276
4277 if (as_name == NULL)
4278 as_name = deduce_name ("as");
4279
4280 /* Don't use the default exclude list if we're reading only the
4281 symbols in the .drectve section. The default excludes are meant
4282 to avoid exporting DLL entry point and Cygwin32 impure_ptr. */
4283 if (! export_all_symbols)
4284 do_default_excludes = FALSE;
4285
4286 if (do_default_excludes)
4287 set_default_excludes ();
4288
4289 if (def_file)
4290 process_def_file (def_file);
4291
4292 while (optind < ac)
4293 {
4294 if (!firstarg)
4295 firstarg = av[optind];
4296 scan_obj_file (av[optind]);
4297 optind++;
4298 }
4299
4300 mangle_defs ();
4301
4302 if (exp_name)
4303 gen_exp_file ();
4304
4305 if (imp_name)
4306 {
4307 /* Make imp_name safe for use as a label. */
4308 char *p;
4309
4310 imp_name_lab = xstrdup (imp_name);
4311 for (p = imp_name_lab; *p; p++)
4312 {
4313 if (!ISALNUM (*p))
4314 *p = '_';
4315 }
4316 head_label = make_label("_head_", imp_name_lab);
4317 gen_lib_file (0);
4318 }
4319
4320 if (delayimp_name)
4321 {
4322 /* Make delayimp_name safe for use as a label. */
4323 char *p;
4324
4325 if (mtable[machine].how_dljtab == 0)
4326 {
4327 inform (_("Warning, machine type (%d) not supported for "
4328 "delayimport."), machine);
4329 }
4330 else
4331 {
4332 killat = 1;
4333 imp_name = delayimp_name;
4334 imp_name_lab = xstrdup (imp_name);
4335 for (p = imp_name_lab; *p; p++)
4336 {
4337 if (!ISALNUM (*p))
4338 *p = '_';
4339 }
4340 head_label = make_label("__tailMerge_", imp_name_lab);
4341 gen_lib_file (1);
4342 }
4343 }
4344
4345 if (output_def)
4346 gen_def_file ();
4347
4348 if (identify_imp_name)
4349 {
4350 identify_dll_for_implib ();
4351 }
4352
4353 #ifdef DLLTOOL_MCORE_ELF
4354 if (mcore_elf_out_file)
4355 mcore_elf_gen_out_file ();
4356 #endif
4357
4358 return 0;
4359 }
4360
4361 /* Look for the program formed by concatenating PROG_NAME and the
4362 string running from PREFIX to END_PREFIX. If the concatenated
4363 string contains a '/', try appending EXECUTABLE_SUFFIX if it is
4364 appropriate. */
4365
4366 static char *
look_for_prog(const char * prog_name,const char * prefix,int end_prefix)4367 look_for_prog (const char *prog_name, const char *prefix, int end_prefix)
4368 {
4369 struct stat s;
4370 char *cmd;
4371
4372 cmd = xmalloc (strlen (prefix)
4373 + strlen (prog_name)
4374 #ifdef HAVE_EXECUTABLE_SUFFIX
4375 + strlen (EXECUTABLE_SUFFIX)
4376 #endif
4377 + 10);
4378 strcpy (cmd, prefix);
4379
4380 sprintf (cmd + end_prefix, "%s", prog_name);
4381
4382 if (strchr (cmd, '/') != NULL)
4383 {
4384 int found;
4385
4386 found = (stat (cmd, &s) == 0
4387 #ifdef HAVE_EXECUTABLE_SUFFIX
4388 || stat (strcat (cmd, EXECUTABLE_SUFFIX), &s) == 0
4389 #endif
4390 );
4391
4392 if (! found)
4393 {
4394 /* xgettext:c-format */
4395 inform (_("Tried file: %s"), cmd);
4396 free (cmd);
4397 return NULL;
4398 }
4399 }
4400
4401 /* xgettext:c-format */
4402 inform (_("Using file: %s"), cmd);
4403
4404 return cmd;
4405 }
4406
4407 /* Deduce the name of the program we are want to invoke.
4408 PROG_NAME is the basic name of the program we want to run,
4409 eg "as" or "ld". The catch is that we might want actually
4410 run "i386-pe-as" or "ppc-pe-ld".
4411
4412 If argv[0] contains the full path, then try to find the program
4413 in the same place, with and then without a target-like prefix.
4414
4415 Given, argv[0] = /usr/local/bin/i586-cygwin32-dlltool,
4416 deduce_name("as") uses the following search order:
4417
4418 /usr/local/bin/i586-cygwin32-as
4419 /usr/local/bin/as
4420 as
4421
4422 If there's an EXECUTABLE_SUFFIX, it'll use that as well; for each
4423 name, it'll try without and then with EXECUTABLE_SUFFIX.
4424
4425 Given, argv[0] = i586-cygwin32-dlltool, it will not even try "as"
4426 as the fallback, but rather return i586-cygwin32-as.
4427
4428 Oh, and given, argv[0] = dlltool, it'll return "as".
4429
4430 Returns a dynamically allocated string. */
4431
4432 static char *
deduce_name(const char * prog_name)4433 deduce_name (const char *prog_name)
4434 {
4435 char *cmd;
4436 char *dash, *slash, *cp;
4437
4438 dash = NULL;
4439 slash = NULL;
4440 for (cp = program_name; *cp != '\0'; ++cp)
4441 {
4442 if (*cp == '-')
4443 dash = cp;
4444 if (
4445 #if defined(__DJGPP__) || defined (__CYGWIN__) || defined(__WIN32__)
4446 *cp == ':' || *cp == '\\' ||
4447 #endif
4448 *cp == '/')
4449 {
4450 slash = cp;
4451 dash = NULL;
4452 }
4453 }
4454
4455 cmd = NULL;
4456
4457 if (dash != NULL)
4458 {
4459 /* First, try looking for a prefixed PROG_NAME in the
4460 PROGRAM_NAME directory, with the same prefix as PROGRAM_NAME. */
4461 cmd = look_for_prog (prog_name, program_name, dash - program_name + 1);
4462 }
4463
4464 if (slash != NULL && cmd == NULL)
4465 {
4466 /* Next, try looking for a PROG_NAME in the same directory as
4467 that of this program. */
4468 cmd = look_for_prog (prog_name, program_name, slash - program_name + 1);
4469 }
4470
4471 if (cmd == NULL)
4472 {
4473 /* Just return PROG_NAME as is. */
4474 cmd = xstrdup (prog_name);
4475 }
4476
4477 return cmd;
4478 }
4479
4480 #ifdef DLLTOOL_MCORE_ELF
4481 typedef struct fname_cache
4482 {
4483 const char * filename;
4484 struct fname_cache * next;
4485 }
4486 fname_cache;
4487
4488 static fname_cache fnames;
4489
4490 static void
mcore_elf_cache_filename(const char * filename)4491 mcore_elf_cache_filename (const char * filename)
4492 {
4493 fname_cache * ptr;
4494
4495 ptr = & fnames;
4496
4497 while (ptr->next != NULL)
4498 ptr = ptr->next;
4499
4500 ptr->filename = filename;
4501 ptr->next = (fname_cache *) malloc (sizeof (fname_cache));
4502 if (ptr->next != NULL)
4503 ptr->next->next = NULL;
4504 }
4505
4506 #define MCORE_ELF_TMP_OBJ "mcoreelf.o"
4507 #define MCORE_ELF_TMP_EXP "mcoreelf.exp"
4508 #define MCORE_ELF_TMP_LIB "mcoreelf.lib"
4509
4510 static void
mcore_elf_gen_out_file(void)4511 mcore_elf_gen_out_file (void)
4512 {
4513 fname_cache * ptr;
4514 dyn_string_t ds;
4515
4516 /* Step one. Run 'ld -r' on the input object files in order to resolve
4517 any internal references and to generate a single .exports section. */
4518 ptr = & fnames;
4519
4520 ds = dyn_string_new (100);
4521 dyn_string_append_cstr (ds, "-r ");
4522
4523 if (mcore_elf_linker_flags != NULL)
4524 dyn_string_append_cstr (ds, mcore_elf_linker_flags);
4525
4526 while (ptr->next != NULL)
4527 {
4528 dyn_string_append_cstr (ds, ptr->filename);
4529 dyn_string_append_cstr (ds, " ");
4530
4531 ptr = ptr->next;
4532 }
4533
4534 dyn_string_append_cstr (ds, "-o ");
4535 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
4536
4537 if (mcore_elf_linker == NULL)
4538 mcore_elf_linker = deduce_name ("ld");
4539
4540 run (mcore_elf_linker, ds->s);
4541
4542 dyn_string_delete (ds);
4543
4544 /* Step two. Create a .exp file and a .lib file from the temporary file.
4545 Do this by recursively invoking dlltool... */
4546 ds = dyn_string_new (100);
4547
4548 dyn_string_append_cstr (ds, "-S ");
4549 dyn_string_append_cstr (ds, as_name);
4550
4551 dyn_string_append_cstr (ds, " -e ");
4552 dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP);
4553 dyn_string_append_cstr (ds, " -l ");
4554 dyn_string_append_cstr (ds, MCORE_ELF_TMP_LIB);
4555 dyn_string_append_cstr (ds, " " );
4556 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
4557
4558 if (verbose)
4559 dyn_string_append_cstr (ds, " -v");
4560
4561 if (dontdeltemps)
4562 {
4563 dyn_string_append_cstr (ds, " -n");
4564
4565 if (dontdeltemps > 1)
4566 dyn_string_append_cstr (ds, " -n");
4567 }
4568
4569 /* XXX - FIME: ought to check/copy other command line options as well. */
4570 run (program_name, ds->s);
4571
4572 dyn_string_delete (ds);
4573
4574 /* Step four. Feed the .exp and object files to ld -shared to create the dll. */
4575 ds = dyn_string_new (100);
4576
4577 dyn_string_append_cstr (ds, "-shared ");
4578
4579 if (mcore_elf_linker_flags)
4580 dyn_string_append_cstr (ds, mcore_elf_linker_flags);
4581
4582 dyn_string_append_cstr (ds, " ");
4583 dyn_string_append_cstr (ds, MCORE_ELF_TMP_EXP);
4584 dyn_string_append_cstr (ds, " ");
4585 dyn_string_append_cstr (ds, MCORE_ELF_TMP_OBJ);
4586 dyn_string_append_cstr (ds, " -o ");
4587 dyn_string_append_cstr (ds, mcore_elf_out_file);
4588
4589 run (mcore_elf_linker, ds->s);
4590
4591 dyn_string_delete (ds);
4592
4593 if (dontdeltemps == 0)
4594 unlink (MCORE_ELF_TMP_EXP);
4595
4596 if (dontdeltemps < 2)
4597 unlink (MCORE_ELF_TMP_OBJ);
4598 }
4599 #endif /* DLLTOOL_MCORE_ELF */
4600