projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* COPYING: Update to current
[deliverable/binutils-gdb.git] / binutils / dlltool.c
CommitLineData
252b5132 1/* dlltool.c -- tool to generate stuff for PE style DLLs
fda8e7c4 2 Copyright (C) 1995, 96, 97, 98, 99, 2000 Free Software Foundation, Inc.
252b5132
RH		 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 2 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., 59 Temple Place - Suite 330, Boston, MA
19 02111-1307, USA. */
20
21
22/*
23 This program allows you to build the files necessary to create
24 DLLs to run on a system which understands PE format image files.
25 (eg, Windows NT)
26
27 See "Peering Inside the PE: A Tour of the Win32 Portable Executable
28 File Format", MSJ 1994, Volume 9 for more information.
29 Also see "Microsoft Portable Executable and Common Object File Format,
30 Specification 4.1" for more information.
31
32 A DLL contains an export table which contains the information
33 which the runtime loader needs to tie up references from a
34 referencing program.
35
36 The export table is generated by this program by reading
37 in a .DEF file or scanning the .a and .o files which will be in the
38 DLL. A .o file can contain information in special ".drectve" sections
39 with export information.
40
41 A DEF file contains any number of the following commands:
42
43
44 NAME <name> [ , <base> ]
45 The result is going to be <name>.EXE
46
47 LIBRARY <name> [ , <base> ]
48 The result is going to be <name>.DLL
49
50 EXPORTS ( <name1> [ = <name2> ] [ @ <integer> ] [ NONAME ] [CONSTANT] [DATA] ) *
51 Declares name1 as an exported symbol from the
52 DLL, with optional ordinal number <integer>
53
54 IMPORTS ( ( <internal-name> = <module-name> . <integer> )
55 | ( [ <internal-name> = ] <module-name> . <external-name> )) *
56 Declares that <external-name> or the exported function whoes ordinal number
57 is <integer> is to be imported from the file <module-name>. If
58 <internal-name> is specified then this is the name that the imported
59 function will be refered to in the body of the DLL.
60
61 DESCRIPTION <string>
62 Puts <string> into output .exp file in the .rdata section
63
64 [STACKSIZE|HEAPSIZE] <number-reserve> [ , <number-commit> ]
65 Generates --stack|--heap <number-reserve>,<number-commit>
66 in the output .drectve section. The linker will
67 see this and act upon it.
68
69 [CODE|DATA] <attr>+
70 SECTIONS ( <sectionname> <attr>+ )*
71 <attr> = READ | WRITE | EXECUTE | SHARED
72 Generates --attr <sectionname> <attr> in the output
73 .drectve section. The linker will see this and act
74 upon it.
75
76
77 A -export:<name> in a .drectve section in an input .o or .a
78 file to this program is equivalent to a EXPORTS <name>
79 in a .DEF file.
80
81
82
83 The program generates output files with the prefix supplied
84 on the command line, or in the def file, or taken from the first
85 supplied argument.
86
87 The .exp.s file contains the information necessary to export
88 the routines in the DLL. The .lib.s file contains the information
89 necessary to use the DLL's routines from a referencing program.
90
91
92
93 Example:
94
95 file1.c:
96 asm (".section .drectve");
97 asm (".ascii \"-export:adef\"");
98
99 void adef (char * s)
100 {
101 printf ("hello from the dll %s\n", s);
102 }
103
104 void bdef (char * s)
105 {
106 printf ("hello from the dll and the other entry point %s\n", s);
107 }
108
109 file2.c:
110 asm (".section .drectve");
111 asm (".ascii \"-export:cdef\"");
112 asm (".ascii \"-export:ddef\"");
113
114 void cdef (char * s)
115 {
116 printf ("hello from the dll %s\n", s);
117 }
118
119 void ddef (char * s)
120 {
121 printf ("hello from the dll and the other entry point %s\n", s);
122 }
123
661016bb 124 int printf (void)
252b5132
RH		 125 {
126 return 9;
127 }
128
661016bb
NC		 129 themain.c:
130 int main (void)
252b5132 131 {
661016bb
NC		 132 cdef ();
133 return 0;
252b5132
RH		 134 }
135
136 thedll.def
137
138 LIBRARY thedll
139 HEAPSIZE 0x40000, 0x2000
140 EXPORTS bdef @ 20
141 cdef @ 30 NONAME
142
143 SECTIONS donkey READ WRITE
144 aardvark EXECUTE
145
6e7d8205 146 # Compile up the parts of the dll and the program
252b5132 147
6e7d8205 148 gcc -c file1.c file2.c themain.c
252b5132 149
6e7d8205
NC		 150 # Optional: put the dll objects into a library
151 # (you don't have to, you could name all the object
152 # files on the dlltool line)
252b5132
RH		 153
154 ar qcv thedll.in file1.o file2.o
155 ranlib thedll.in
156
6e7d8205
NC		 157 # Run this tool over the DLL's .def file and generate an exports
158 # file (thedll.o) and an imports file (thedll.a).
159 # (You may have to use -S to tell dlltool where to find the assembler).
160
aff05906 161 dlltool --def thedll.def --output-exp thedll.o --output-lib thedll.a
252b5132 162
aff05906
NC		 163 # Build the dll with the library and the export table
164
252b5132
RH		 165 ld -o thedll.dll thedll.o thedll.in
166
6e7d8205 167 # Link the executable with the import library
aff05906 168
661016bb 169 gcc -o themain.exe themain.o thedll.a
252b5132 170
aff05906
NC		 171 This example can be extended if relocations are needed in the DLL:
172
173 # Compile up the parts of the dll and the program
174
175 gcc -c file1.c file2.c themain.c
176
177 # Run this tool over the DLL's .def file and generate an imports file.
178
179 dlltool --def thedll.def --output-lib thedll.lib
180
181 # Link the executable with the import library and generate a base file
182 # at the same time
183
184 gcc -o themain.exe themain.o thedll.lib -Wl,--base-file -Wl,themain.base
185
186 # Run this tool over the DLL's .def file and generate an exports file
187 # which includes the relocations from the base file.
188
189 dlltool --def thedll.def --base-file themain.base --output-exp thedll.exp
190
191 # Build the dll with file1.o, file2.o and the export table
192
193 ld -o thedll.dll thedll.exp file1.o file2.o
252b5132
RH		 194 */
195
196/* .idata section description
197
198 The .idata section is the import table. It is a collection of several
199 subsections used to keep the pieces for each dll together: .idata$[234567].
200 IE: Each dll's .idata$2's are catenated together, each .idata$3's, etc.
201
202 .idata$2 = Import Directory Table
203 = array of IMAGE_IMPORT_DESCRIPTOR's.
204
205 DWORD Import Lookup Table; - pointer to .idata$4
206 DWORD TimeDateStamp; - currently always 0
207 DWORD ForwarderChain; - currently always 0
208 DWORD Name; - pointer to dll's name
209 PIMAGE_THUNK_DATA FirstThunk; - pointer to .idata$5
210
211 .idata$3 = null terminating entry for .idata$2.
212
213 .idata$4 = Import Lookup Table
214 = array of array of pointers to hint name table.
215 There is one for each dll being imported from, and each dll's set is
216 terminated by a trailing NULL.
217
218 .idata$5 = Import Address Table
219 = array of array of pointers to hint name table.
220 There is one for each dll being imported from, and each dll's set is
221 terminated by a trailing NULL.
222 Initially, this table is identical to the Import Lookup Table. However,
223 at load time, the loader overwrites the entries with the address of the
224 function.
225
226 .idata$6 = Hint Name Table
227 = Array of { short, asciz } entries, one for each imported function.
228 The `short' is the function's ordinal number.
229
230 .idata$7 = dll name (eg: "kernel32.dll"). (.idata$6 for ppc)
231*/
232
233/* AIX requires this to be the first thing in the file. */
234#ifndef __GNUC__
235# ifdef _AIX
236 #pragma alloca
237#endif
238#endif
239
240#define show_allnames 0
241
242#define PAGE_SIZE 4096
243#define PAGE_MASK (-PAGE_SIZE)
244#include "bfd.h"
245#include "libiberty.h"
246#include "bucomm.h"
247#include "getopt.h"
248#include "demangle.h"
bb0cb4db 249#include "dyn-string.h"
252b5132
RH		 250#include "dlltool.h"
251
252#include <ctype.h>
253#include <time.h>
bb0cb4db
ILT		 254#include <sys/stat.h>
255
256#ifdef ANSI_PROTOTYPES
252b5132
RH		 257#include <stdarg.h>
258#else
259#include <varargs.h>
260#endif
261
262#ifdef DLLTOOL_ARM
263#include "coff/arm.h"
264#include "coff/internal.h"
265#endif
266
49e315b1 267/* Forward references. */
bb0cb4db
ILT		 268static char *look_for_prog PARAMS ((const char *, const char *, int));
269static char *deduce_name PARAMS ((const char *));
49e315b1
NC		 270
271#ifdef DLLTOOL_MCORE_ELF
272static void mcore_elf_cache_filename (char *);
273static void mcore_elf_gen_out_file (void);
274#endif
275
252b5132
RH		 276#ifdef HAVE_SYS_WAIT_H
277#include <sys/wait.h>
278#else /* ! HAVE_SYS_WAIT_H */
279#if ! defined (_WIN32) || defined (__CYGWIN32__)
280#ifndef WIFEXITED
281#define WIFEXITED(w) (((w)&0377) == 0)
282#endif
283#ifndef WIFSIGNALED
284#define WIFSIGNALED(w) (((w)&0377) != 0177 && ((w)&~0377) == 0)
285#endif
286#ifndef WTERMSIG
287#define WTERMSIG(w) ((w) & 0177)
288#endif
289#ifndef WEXITSTATUS
290#define WEXITSTATUS(w) (((w) >> 8) & 0377)
291#endif
292#else /* defined (_WIN32) && ! defined (__CYGWIN32__) */
293#ifndef WIFEXITED
294#define WIFEXITED(w) (((w) & 0xff) == 0)
295#endif
296#ifndef WIFSIGNALED
297#define WIFSIGNALED(w) (((w) & 0xff) != 0 && ((w) & 0xff) != 0x7f)
298#endif
299#ifndef WTERMSIG
300#define WTERMSIG(w) ((w) & 0x7f)
301#endif
302#ifndef WEXITSTATUS
303#define WEXITSTATUS(w) (((w) & 0xff00) >> 8)
304#endif
305#endif /* defined (_WIN32) && ! defined (__CYGWIN32__) */
306#endif /* ! HAVE_SYS_WAIT_H */
307
308/* ifunc and ihead data structures: ttk@cygnus.com 1997
309
310 When IMPORT declarations are encountered in a .def file the
311 function import information is stored in a structure referenced by
312 the global variable IMPORT_LIST. The structure is a linked list
313 containing the names of the dll files each function is imported
314 from and a linked list of functions being imported from that dll
315 file. This roughly parallels the structure of the .idata section
316 in the PE object file.
317
318 The contents of .def file are interpreted from within the
319 process_def_file function. Every time an IMPORT declaration is
320 encountered, it is broken up into its component parts and passed to
321 def_import. IMPORT_LIST is initialized to NULL in function main. */
322
323typedef struct ifunct
324{
325 char *name; /* name of function being imported */
326 int ord; /* two-byte ordinal value associated with function */
327 struct ifunct *next;
328} ifunctype;
329
330typedef struct iheadt
331{
332 char *dllname; /* name of dll file imported from */
333 long nfuncs; /* number of functions in list */
334 struct ifunct *funchead; /* first function in list */
335 struct ifunct *functail; /* last function in list */
336 struct iheadt *next; /* next dll file in list */
337} iheadtype;
338
339/* Structure containing all import information as defined in .def file
340 (qv "ihead structure"). */
341
342static iheadtype *import_list = NULL;
343
49e315b1 344static char *as_name = NULL;
252b5132
RH		 345static char * as_flags = "";
346
347static int no_idata4;
348static int no_idata5;
349static char *exp_name;
350static char *imp_name;
351static char *head_label;
352static char *imp_name_lab;
353static char *dll_name;
354
355static int add_indirect = 0;
356static int add_underscore = 0;
357static int dontdeltemps = 0;
358
252b5132
RH		 359/* True if we should export all symbols. Otherwise, we only export
360 symbols listed in .drectve sections or in the def file. */
361static boolean export_all_symbols;
362
363/* True if we should exclude the symbols in DEFAULT_EXCLUDES when
364 exporting all symbols. */
365static boolean do_default_excludes;
366
367/* Default symbols to exclude when exporting all the symbols. */
368static const char *default_excludes = "DllMain@12,DllEntryPoint@0,impure_ptr";
369
5f0f29c3
NC		 370/* True if we should add __imp_<SYMBOL> to import libraries for backward
371 compatibility to old Cygwin releases. */
372static boolean create_compat_implib;
373
252b5132
RH		 374static char *def_file;
375
376extern char * program_name;
377
378static int machine;
379static int killat;
380static int add_stdcall_alias;
381static int verbose;
382static FILE *output_def;
383static FILE *base_file;
384
252b5132
RH		 385#ifdef DLLTOOL_ARM
386static const char *mname = "arm";
387#endif
388
389#ifdef DLLTOOL_I386
390static const char *mname = "i386";
391#endif
392
393#ifdef DLLTOOL_PPC
394static const char *mname = "ppc";
395#endif
396
8a0e0f38
NC		 397#ifdef DLLTOOL_SH
398static const char *mname = "sh";
399#endif
400
401#ifdef DLLTOOL_MIPS
402static const char *mname = "mips";
403#endif
404
661016bb 405#ifdef DLLTOOL_MCORE
7e301c9c 406static const char * mname = "mcore-le";
661016bb
NC		 407#endif
408
409#ifdef DLLTOOL_MCORE_ELF
410static const char * mname = "mcore-elf";
49e315b1
NC		 411static char * mcore_elf_out_file = NULL;
412static char * mcore_elf_linker = NULL;
413static char * mcore_elf_linker_flags = NULL;
414
661016bb
NC		 415#define DRECTVE_SECTION_NAME ((machine == MMCORE_ELF || machine == MMCORE_ELF_LE) ? ".exports" : ".drectve")
416#endif
417
418#ifndef DRECTVE_SECTION_NAME
419#define DRECTVE_SECTION_NAME ".drectve"
420#endif
421
252b5132
RH		 422#define PATHMAX 250 /* What's the right name for this ? */
423
424#define TMP_ASM "dc.s"
425#define TMP_HEAD_S "dh.s"
426#define TMP_HEAD_O "dh.o"
427#define TMP_TAIL_S "dt.s"
428#define TMP_TAIL_O "dt.o"
429#define TMP_STUB "ds"
430
661016bb 431/* This bit of assemly does jmp * .... */
252b5132
RH		 432static const unsigned char i386_jtab[] =
433{
434 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
435};
436
437static const unsigned char arm_jtab[] =
438{
b890a735
CM		 439 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
440 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
441 0, 0, 0, 0
442};
443
444static const unsigned char arm_interwork_jtab[] =
445{
446 0x04, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
447 0x00, 0xc0, 0x9c, 0xe5, /* ldr ip, [ip] */
448 0x1c, 0xff, 0x2f, 0xe1, /* bx ip */
252b5132
RH		 449 0, 0, 0, 0
450};
451
452static const unsigned char thumb_jtab[] =
453{
b890a735
CM		 454 0x40, 0xb4, /* push {r6} */
455 0x02, 0x4e, /* ldr r6, [pc, #8] */
456 0x36, 0x68, /* ldr r6, [r6] */
457 0xb4, 0x46, /* mov ip, r6 */
458 0x40, 0xbc, /* pop {r6} */
459 0x60, 0x47, /* bx ip */
252b5132
RH		 460 0, 0, 0, 0
461};
462
661016bb
NC		 463static const unsigned char mcore_be_jtab[] =
464{
ba8c44fc
NC		 465 0x71, 0x02, /* lrw r1,2 */
466 0x81, 0x01, /* ld.w r1,(r1,0) */
467 0x00, 0xC1, /* jmp r1 */
468 0x12, 0x00, /* nop */
469 0x00, 0x00, 0x00, 0x00 /* <address> */
661016bb
NC		 470};
471
472static const unsigned char mcore_le_jtab[] =
473{
ba8c44fc
NC		 474 0x02, 0x71, /* lrw r1,2 */
475 0x01, 0x81, /* ld.w r1,(r1,0) */
476 0xC1, 0x00, /* jmp r1 */
477 0x00, 0x12, /* nop */
478 0x00, 0x00, 0x00, 0x00 /* <address> */
661016bb
NC		 479};
480
252b5132
RH		 481/* This is the glue sequence for PowerPC PE. There is a */
482/* tocrel16-tocdefn reloc against the first instruction. */
483/* We also need a IMGLUE reloc against the glue function */
484/* to restore the toc saved by the third instruction in */
485/* the glue. */
486static const unsigned char ppc_jtab[] =
487{
488 0x00, 0x00, 0x62, 0x81, /* lwz r11,0(r2) */
489 /* Reloc TOCREL16 __imp_xxx */
490 0x00, 0x00, 0x8B, 0x81, /* lwz r12,0(r11) */
491 0x04, 0x00, 0x41, 0x90, /* stw r2,4(r1) */
492 0xA6, 0x03, 0x89, 0x7D, /* mtctr r12 */
493 0x04, 0x00, 0x4B, 0x80, /* lwz r2,4(r11) */
494 0x20, 0x04, 0x80, 0x4E /* bctr */
495};
496
497#ifdef DLLTOOL_PPC
498/* the glue instruction, picks up the toc from the stw in */
499/* the above code: "lwz r2,4(r1)" */
500static bfd_vma ppc_glue_insn = 0x80410004;
501#endif
502
252b5132
RH		 503struct mac
504 {
505 const char *type;
506 const char *how_byte;
507 const char *how_short;
508 const char *how_long;
509 const char *how_asciz;
510 const char *how_comment;
511 const char *how_jump;
512 const char *how_global;
513 const char *how_space;
514 const char *how_align_short;
515 const char *how_align_long;
49c24507 516 const char *how_default_as_switches;
252b5132
RH		 517 const char *how_bfd_target;
518 enum bfd_architecture how_bfd_arch;
519 const unsigned char *how_jtab;
520 int how_jtab_size; /* size of the jtab entry */
521 int how_jtab_roff; /* offset into it for the ind 32 reloc into idata 5 */
522 };
523
524static const struct mac
525mtable[] =
526{
527 {
528#define MARM 0
529 "arm", ".byte", ".short", ".long", ".asciz", "@",
530 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
eaeaa15c 531 ".global", ".space", ".align\t2",".align\t4", "-mapcs-32",
49c24507 532 "pe-arm-little", bfd_arch_arm,
252b5132
RH		 533 arm_jtab, sizeof (arm_jtab), 8
534 }
535 ,
536 {
537#define M386 1
49c24507
NC		 538 "i386", ".byte", ".short", ".long", ".asciz", "#",
539 "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
540 "pe-i386",bfd_arch_i386,
541 i386_jtab, sizeof (i386_jtab), 2
252b5132
RH		 542 }
543 ,
544 {
545#define MPPC 2
49c24507
NC		 546 "ppc", ".byte", ".short", ".long", ".asciz", "#",
547 "jmp *", ".global", ".space", ".align\t2",".align\t4", "",
548 "pe-powerpcle",bfd_arch_powerpc,
549 ppc_jtab, sizeof (ppc_jtab), 0
252b5132
RH		 550 }
551 ,
552 {
553#define MTHUMB 3
554 "thumb", ".byte", ".short", ".long", ".asciz", "@",
b890a735 555 "push\t{r6}\n\tldr\tr6, [pc, #8]\n\tldr\tr6, [r6]\n\tmov\tip, r6\n\tpop\t{r6}\n\tbx\tip",
a2186dfe 556 ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
49c24507 557 "pe-arm-little", bfd_arch_arm,
252b5132
RH		 558 thumb_jtab, sizeof (thumb_jtab), 12
559 }
560 ,
b890a735
CM		 561#define MARM_INTERWORK 4
562 {
563 "arm_interwork", ".byte", ".short", ".long", ".asciz", "@",
564 "ldr\tip,[pc]\n\tldr\tip,[ip]\n\tbx\tip\n\t.long",
49c24507
NC		 565 ".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
566 "pe-arm-little", bfd_arch_arm,
b890a735
CM		 567 arm_interwork_jtab, sizeof (arm_interwork_jtab), 12
568 }
569 ,
661016bb
NC		 570 {
571#define MMCORE_BE 5
7e301c9c 572 "mcore-be", ".byte", ".short", ".long", ".asciz", "//",
ba8c44fc 573 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
49c24507
NC		 574 ".global", ".space", ".align\t2",".align\t4", "",
575 "pe-mcore-big", bfd_arch_mcore,
ba8c44fc 576 mcore_be_jtab, sizeof (mcore_be_jtab), 8
661016bb
NC		 577 }
578 ,
579 {
580#define MMCORE_LE 6
581 "mcore-le", ".byte", ".short", ".long", ".asciz", "//",
ba8c44fc 582 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
49c24507
NC		 583 ".global", ".space", ".align\t2",".align\t4", "-EL",
584 "pe-mcore-little", bfd_arch_mcore,
ba8c44fc 585 mcore_le_jtab, sizeof (mcore_le_jtab), 8
661016bb
NC		 586 }
587 ,
588 {
589#define MMCORE_ELF 7
7e301c9c 590 "mcore-elf-be", ".byte", ".short", ".long", ".asciz", "//",
ba8c44fc 591 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
49c24507
NC		 592 ".global", ".space", ".align\t2",".align\t4", "",
593 "elf32-mcore-big", bfd_arch_mcore,
ba8c44fc 594 mcore_be_jtab, sizeof (mcore_be_jtab), 8
661016bb
NC		 595 }
596 ,
597 {
598#define MMCORE_ELF_LE 8
599 "mcore-elf-le", ".byte", ".short", ".long", ".asciz", "//",
ba8c44fc 600 "lrw r1,[1f]\n\tld.w r1,(r1,0)\n\tjmp r1\n\tnop\n1:.long",
49c24507
NC		 601 ".global", ".space", ".align\t2",".align\t4", "-EL",
602 "elf32-mcore-little", bfd_arch_mcore,
ba8c44fc 603 mcore_le_jtab, sizeof (mcore_le_jtab), 8
661016bb
NC		 604 }
605 ,
a2186dfe
NC		 606 {
607#define MARM_EPOC 9
608 "arm", ".byte", ".short", ".long", ".asciz", "@",
609 "ldr\tip,[pc]\n\tldr\tpc,[ip]\n\t.long",
610 ".global", ".space", ".align\t2",".align\t4", "",
611 "epoc-pe-arm-little", bfd_arch_arm,
612 arm_jtab, sizeof (arm_jtab), 8
613 }
614 ,
5ea695ed 615 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
252b5132
RH		 616};
617
618typedef struct dlist
619{
620 char *text;
621 struct dlist *next;
622}
623dlist_type;
624
625typedef struct export
626 {
627 const char *name;
628 const char *internal_name;
629 int ordinal;
630 int constant;
631 int noname;
632 int data;
633 int hint;
634 struct export *next;
635 }
636export_type;
637
638/* A list of symbols which we should not export. */
639
640struct string_list
641{
642 struct string_list *next;
643 char *string;
644};
645
646static struct string_list *excludes;
647
648static const char *rvaafter PARAMS ((int));
649static const char *rvabefore PARAMS ((int));
650static const char *asm_prefix PARAMS ((int));
651static void append_import PARAMS ((const char *, const char *, int));
652static void run PARAMS ((const char *, char *));
653static void scan_drectve_symbols PARAMS ((bfd *));
654static void scan_filtered_symbols PARAMS ((bfd *, PTR, long, unsigned int));
655static void add_excludes PARAMS ((const char *));
656static boolean match_exclude PARAMS ((const char *));
657static void set_default_excludes PARAMS ((void));
658static long filter_symbols PARAMS ((bfd *, PTR, long, unsigned int));
659static void scan_all_symbols PARAMS ((bfd *));
660static void scan_open_obj_file PARAMS ((bfd *));
661static void scan_obj_file PARAMS ((const char *));
662static void dump_def_info PARAMS ((FILE *));
663static int sfunc PARAMS ((const void *, const void *));
664static void flush_page PARAMS ((FILE *, long *, int, int));
665static void gen_def_file PARAMS ((void));
666static void generate_idata_ofile PARAMS ((FILE *));
667static void gen_exp_file PARAMS ((void));
668static const char *xlate PARAMS ((const char *));
669#if 0
670static void dump_iat PARAMS ((FILE *, export_type *));
671#endif
672static char *make_label PARAMS ((const char *, const char *));
673static bfd *make_one_lib_file PARAMS ((export_type *, int));
674static bfd *make_head PARAMS ((void));
675static bfd *make_tail PARAMS ((void));
676static void gen_lib_file PARAMS ((void));
677static int pfunc PARAMS ((const void *, const void *));
678static int nfunc PARAMS ((const void *, const void *));
679static void remove_null_names PARAMS ((export_type **));
680static void dtab PARAMS ((export_type **));
681static void process_duplicates PARAMS ((export_type **));
682static void fill_ordinals PARAMS ((export_type **));
683static int alphafunc PARAMS ((const void *, const void *));
684static void mangle_defs PARAMS ((void));
685static void usage PARAMS ((FILE *, int));
252b5132 686static void inform PARAMS ((const char *, ...));
252b5132
RH		 687
688
689static void
690#ifdef __STDC__
691inform (const char * message, ...)
692#else
693inform (message, va_alist)
694 const char * message;
695 va_dcl
696#endif
697{
698 va_list args;
699
700 if (!verbose)
701 return;
702
703#ifdef __STDC__
704 va_start (args, message);
705#else
706 va_start (args);
707#endif
708
37cc8ec1 709 report (message, args);
252b5132
RH		 710
711 va_end (args);
712}
713
252b5132
RH		 714static const char *
715rvaafter (machine)
716 int machine;
717{
718 switch (machine)
719 {
720 case MARM:
721 case M386:
722 case MPPC:
723 case MTHUMB:
b890a735 724 case MARM_INTERWORK:
661016bb
NC		 725 case MMCORE_BE:
726 case MMCORE_LE:
727 case MMCORE_ELF:
728 case MMCORE_ELF_LE:
252b5132
RH		 729 break;
730 default:
731 /* xgettext:c-format */
37cc8ec1 732 fatal (_("Internal error: Unknown machine type: %d"), machine);
252b5132
RH		 733 break;
734 }
735 return "";
736}
737
738static const char *
739rvabefore (machine)
740 int machine;
741{
742 switch (machine)
743 {
744 case MARM:
745 case M386:
746 case MPPC:
747 case MTHUMB:
b890a735 748 case MARM_INTERWORK:
661016bb
NC		 749 case MMCORE_BE:
750 case MMCORE_LE:
751 case MMCORE_ELF:
752 case MMCORE_ELF_LE:
252b5132
RH		 753 return ".rva\t";
754 default:
755 /* xgettext:c-format */
37cc8ec1 756 fatal (_("Internal error: Unknown machine type: %d"), machine);
252b5132
RH		 757 break;
758 }
759 return "";
760}
761
762static const char *
763asm_prefix (machine)
764 int machine;
765{
766 switch (machine)
767 {
768 case MARM:
769 case MPPC:
770 case MTHUMB:
b890a735 771 case MARM_INTERWORK:
661016bb
NC		 772 case MMCORE_BE:
773 case MMCORE_LE:
774 case MMCORE_ELF:
775 case MMCORE_ELF_LE:
252b5132
RH		 776 break;
777 case M386:
778 return "_";
779 default:
780 /* xgettext:c-format */
37cc8ec1 781 fatal (_("Internal error: Unknown machine type: %d"), machine);
252b5132
RH		 782 break;
783 }
784 return "";
785}
786
787#define ASM_BYTE mtable[machine].how_byte
788#define ASM_SHORT mtable[machine].how_short
789#define ASM_LONG mtable[machine].how_long
790#define ASM_TEXT mtable[machine].how_asciz
791#define ASM_C mtable[machine].how_comment
792#define ASM_JUMP mtable[machine].how_jump
793#define ASM_GLOBAL mtable[machine].how_global
794#define ASM_SPACE mtable[machine].how_space
795#define ASM_ALIGN_SHORT mtable[machine].how_align_short
796#define ASM_RVA_BEFORE rvabefore(machine)
797#define ASM_RVA_AFTER rvaafter(machine)
798#define ASM_PREFIX asm_prefix(machine)
661016bb 799#define ASM_ALIGN_LONG mtable[machine].how_align_long
49c24507
NC		 800#define HOW_BFD_READ_TARGET 0 /* always default*/
801#define HOW_BFD_WRITE_TARGET mtable[machine].how_bfd_target
661016bb
NC		 802#define HOW_BFD_ARCH mtable[machine].how_bfd_arch
803#define HOW_JTAB mtable[machine].how_jtab
804#define HOW_JTAB_SIZE mtable[machine].how_jtab_size
805#define HOW_JTAB_ROFF mtable[machine].how_jtab_roff
49c24507
NC		 806#define ASM_SWITCHES mtable[machine].how_default_as_switches
807
252b5132
RH		 808static char **oav;
809
810void
811process_def_file (name)
812 const char *name;
813{
814 FILE *f = fopen (name, FOPEN_RT);
815
816 if (!f)
817 /* xgettext:c-format */
818 fatal (_("Can't open def file: %s"), name);
819
820 yyin = f;
821
822 /* xgettext:c-format */
823 inform (_("Processing def file: %s"), name);
824
825 yyparse ();
826
827 inform (_("Processed def file"));
828}
829
830/**********************************************************************/
831
832/* Communications with the parser */
833
834static const char *d_name; /* Arg to NAME or LIBRARY */
835static int d_nfuncs; /* Number of functions exported */
836static int d_named_nfuncs; /* Number of named functions exported */
837static int d_low_ord; /* Lowest ordinal index */
838static int d_high_ord; /* Highest ordinal index */
839static export_type *d_exports; /*list of exported functions */
840static export_type **d_exports_lexically; /* vector of exported functions in alpha order */
841static dlist_type *d_list; /* Descriptions */
842static dlist_type *a_list; /* Stuff to go in directives */
843
844static int d_is_dll;
845static int d_is_exe;
846
847int
848yyerror (err)
5ea695ed 849 const char * err ATTRIBUTE_UNUSED;
252b5132
RH		 850{
851 /* xgettext:c-format */
37cc8ec1 852 non_fatal (_("Syntax error in def file %s:%d"), def_file, linenumber);
252b5132
RH		 853
854 return 0;
855}
856
857void
858def_exports (name, internal_name, ordinal, noname, constant, data)
859 const char *name;
860 const char *internal_name;
861 int ordinal;
862 int noname;
863 int constant;
864 int data;
865{
866 struct export *p = (struct export *) xmalloc (sizeof (*p));
867
868 p->name = name;
869 p->internal_name = internal_name ? internal_name : name;
870 p->ordinal = ordinal;
871 p->constant = constant;
872 p->noname = noname;
873 p->data = data;
874 p->next = d_exports;
875 d_exports = p;
876 d_nfuncs++;
877}
878
879void
880def_name (name, base)
881 const char *name;
882 int base;
883{
884 /* xgettext:c-format */
885 inform (_("NAME: %s base: %x"), name, base);
886
887 if (d_is_dll)
37cc8ec1 888 non_fatal (_("Can't have LIBRARY and NAME"));
252b5132
RH		 889
890 d_name = name;
891 /* if --dllname not provided, use the one in the DEF file.
892 FIXME: Is this appropriate for executables? */
893 if (! dll_name)
894 dll_name = xstrdup (name);
895 d_is_exe = 1;
896}
897
898void
899def_library (name, base)
900 const char *name;
901 int base;
902{
903 /* xgettext:c-format */
904 inform (_("LIBRARY: %s base: %x"), name, base);
905
906 if (d_is_exe)
37cc8ec1 907 non_fatal (_("Can't have LIBRARY and NAME"));
252b5132
RH		 908
909 d_name = name;
910 /* if --dllname not provided, use the one in the DEF file. */
911 if (! dll_name)
912 dll_name = xstrdup (name);
913 d_is_dll = 1;
914}
915
916void
917def_description (desc)
918 const char *desc;
919{
920 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
921 d->text = xstrdup (desc);
922 d->next = d_list;
923 d_list = d;
924}
925
926void
927new_directive (dir)
928 char *dir;
929{
930 dlist_type *d = (dlist_type *) xmalloc (sizeof (dlist_type));
931 d->text = xstrdup (dir);
932 d->next = a_list;
933 a_list = d;
934}
935
936void
937def_heapsize (reserve, commit)
938 int reserve;
939 int commit;
940{
941 char b[200];
942 if (commit > 0)
943 sprintf (b, "-heap 0x%x,0x%x ", reserve, commit);
944 else
945 sprintf (b, "-heap 0x%x ", reserve);
946 new_directive (xstrdup (b));
947}
948
949void
950def_stacksize (reserve, commit)
951 int reserve;
952 int commit;
953{
954 char b[200];
955 if (commit > 0)
956 sprintf (b, "-stack 0x%x,0x%x ", reserve, commit);
957 else
958 sprintf (b, "-stack 0x%x ", reserve);
959 new_directive (xstrdup (b));
960}
961
962/* append_import simply adds the given import definition to the global
963 import_list. It is used by def_import. */
964
965static void
966append_import (symbol_name, dll_name, func_ordinal)
967 const char *symbol_name;
968 const char *dll_name;
969 int func_ordinal;
970{
971 iheadtype **pq;
972 iheadtype *q;
973
974 for (pq = &import_list; *pq != NULL; pq = &(*pq)->next)
975 {
976 if (strcmp ((*pq)->dllname, dll_name) == 0)
977 {
978 q = *pq;
979 q->functail->next = xmalloc (sizeof (ifunctype));
980 q->functail = q->functail->next;
981 q->functail->ord = func_ordinal;
982 q->functail->name = xstrdup (symbol_name);
983 q->functail->next = NULL;
984 q->nfuncs++;
985 return;
986 }
987 }
988
989 q = xmalloc (sizeof (iheadtype));
990 q->dllname = xstrdup (dll_name);
991 q->nfuncs = 1;
992 q->funchead = xmalloc (sizeof (ifunctype));
993 q->functail = q->funchead;
994 q->next = NULL;
995 q->functail->name = xstrdup (symbol_name);
996 q->functail->ord = func_ordinal;
997 q->functail->next = NULL;
998
999 *pq = q;
1000}
1001
1002/* def_import is called from within defparse.y when an IMPORT
1003 declaration is encountered. Depending on the form of the
1004 declaration, the module name may or may not need ".dll" to be
1005 appended to it, the name of the function may be stored in internal
1006 or entry, and there may or may not be an ordinal value associated
1007 with it. */
1008
1009/* A note regarding the parse modes:
1010 In defparse.y we have to accept import declarations which follow
1011 any one of the following forms:
1012 <func_name_in_app> = <dll_name>.<func_name_in_dll>
1013 <func_name_in_app> = <dll_name>.<number>
1014 <dll_name>.<func_name_in_dll>
1015 <dll_name>.<number>
1016 Furthermore, the dll's name may or may not end with ".dll", which
1017 complicates the parsing a little. Normally the dll's name is
1018 passed to def_import() in the "module" parameter, but when it ends
1019 with ".dll" it gets passed in "module" sans ".dll" and that needs
1020 to be reappended.
1021
1022 def_import gets five parameters:
1023 APP_NAME - the name of the function in the application, if
1024 present, or NULL if not present.
1025 MODULE - the name of the dll, possibly sans extension (ie, '.dll').
1026 DLLEXT - the extension of the dll, if present, NULL if not present.
1027 ENTRY - the name of the function in the dll, if present, or NULL.
1028 ORD_VAL - the numerical tag of the function in the dll, if present,
1029 or NULL. Exactly one of <entry> or <ord_val> must be
1030 present (i.e., not NULL). */
1031
1032void
1033def_import (app_name, module, dllext, entry, ord_val)
1034 const char *app_name;
1035 const char *module;
1036 const char *dllext;
1037 const char *entry;
1038 int ord_val;
1039{
1040 const char *application_name;
1041 char *buf;
1042
1043 if (entry != NULL)
1044 application_name = entry;
1045 else
1046 {
1047 if (app_name != NULL)
1048 application_name = app_name;
1049 else
1050 application_name = "";
1051 }
1052
1053 if (dllext != NULL)
1054 {
1055 buf = (char *) alloca (strlen (module) + strlen (dllext) + 2);
1056 sprintf (buf, "%s.%s", module, dllext);
1057 module = buf;
1058 }
1059
1060 append_import (application_name, module, ord_val);
1061}
1062
1063void
1064def_version (major, minor)
1065 int major;
1066 int minor;
1067{
1068 printf ("VERSION %d.%d\n", major, minor);
1069}
1070
1071void
1072def_section (name, attr)
1073 const char *name;
1074 int attr;
1075{
1076 char buf[200];
1077 char atts[5];
1078 char *d = atts;
1079 if (attr & 1)
1080 *d++ = 'R';
1081
1082 if (attr & 2)
1083 *d++ = 'W';
1084 if (attr & 4)
1085 *d++ = 'X';
1086 if (attr & 8)
1087 *d++ = 'S';
1088 *d++ = 0;
1089 sprintf (buf, "-attr %s %s", name, atts);
1090 new_directive (xstrdup (buf));
1091}
1092
1093void
1094def_code (attr)
1095 int attr;
1096{
1097
1098 def_section ("CODE", attr);
1099}
1100
1101void
1102def_data (attr)
1103 int attr;
1104{
1105 def_section ("DATA", attr);
1106}
1107
1108/**********************************************************************/
1109
1110static void
1111run (what, args)
1112 const char *what;
1113 char *args;
1114{
1115 char *s;
1116 int pid, wait_status;
1117 int i;
1118 const char **argv;
1119 char *errmsg_fmt, *errmsg_arg;
1120 char *temp_base = choose_temp_base ();
1121
37cc8ec1 1122 inform ("run: %s %s", what, args);
252b5132
RH		 1123
1124 /* Count the args */
1125 i = 0;
1126 for (s = args; *s; s++)
1127 if (*s == ' ')
1128 i++;
1129 i++;
1130 argv = alloca (sizeof (char *) * (i + 3));
1131 i = 0;
1132 argv[i++] = what;
1133 s = args;
1134 while (1)
1135 {
1136 while (*s == ' ')
1137 ++s;
1138 argv[i++] = s;
1139 while (*s != ' ' && *s != 0)
1140 s++;
1141 if (*s == 0)
1142 break;
1143 *s++ = 0;
1144 }
1145 argv[i++] = NULL;
1146
1147 pid = pexecute (argv[0], (char * const *) argv, program_name, temp_base,
1148 &errmsg_fmt, &errmsg_arg, PEXECUTE_ONE | PEXECUTE_SEARCH);
1149
1150 if (pid == -1)
1151 {
1152 inform (strerror (errno));
1153
1154 fatal (errmsg_fmt, errmsg_arg);
1155 }
1156
1157 pid = pwait (pid, & wait_status, 0);
1158
1159 if (pid == -1)
1160 {
1161 /* xgettext:c-format */
1162 fatal (_("wait: %s"), strerror (errno));
1163 }
1164 else if (WIFSIGNALED (wait_status))
1165 {
1166 /* xgettext:c-format */
1167 fatal (_("subprocess got fatal signal %d"), WTERMSIG (wait_status));
1168 }
1169 else if (WIFEXITED (wait_status))
1170 {
1171 if (WEXITSTATUS (wait_status) != 0)
1172 /* xgettext:c-format */
37cc8ec1
AM		 1173 non_fatal (_("%s exited with status %d"),
1174 what, WEXITSTATUS (wait_status));
252b5132
RH		 1175 }
1176 else
1177 abort ();
1178}
1179
1180/* Look for a list of symbols to export in the .drectve section of
1181 ABFD. Pass each one to def_exports. */
1182
1183static void
1184scan_drectve_symbols (abfd)
1185 bfd *abfd;
1186{
1187 asection * s;
1188 int size;
1189 char * buf;
1190 char * p;
1191 char * e;
661016bb 1192
252b5132 1193 /* Look for .drectve's */
661016bb 1194 s = bfd_get_section_by_name (abfd, DRECTVE_SECTION_NAME);
252b5132
RH		 1195
1196 if (s == NULL)
1197 return;
1198
1199 size = bfd_get_section_size_before_reloc (s);
1200 buf = xmalloc (size);
1201
1202 bfd_get_section_contents (abfd, s, buf, 0, size);
1203
1204 /* xgettext:c-format */
37cc8ec1 1205 inform (_("Sucking in info from %s section in %s"),
661016bb 1206 DRECTVE_SECTION_NAME, bfd_get_filename (abfd));
252b5132 1207
ce195b42
DD		 1208 /* Search for -export: strings. The exported symbols can optionally
1209 have type tags (eg., -export:foo,data), so handle those as well.
5f0f29c3 1210 Currently only data tag is supported. */
252b5132
RH		 1211 p = buf;
1212 e = buf + size;
1213 while (p < e)
1214 {
1215 if (p[0] == '-'
1216 && strncmp (p, "-export:", 8) == 0)
1217 {
1218 char * name;
1219 char * c;
ce195b42 1220 flagword flags = BSF_FUNCTION;
252b5132
RH		 1221
1222 p += 8;
1223 name = p;
ce195b42 1224 while (p < e && *p != ',' && *p != ' ' && *p != '-')
252b5132
RH		 1225 p++;
1226 c = xmalloc (p - name + 1);
1227 memcpy (c, name, p - name);
1228 c[p - name] = 0;
ce195b42
DD		 1229 if (p < e && *p == ',') /* found type tag. */
1230 {
1231 char *tag_start = ++p;
1232 while (p < e && *p != ' ' && *p != '-')
1233 p++;
1234 if (strncmp (tag_start, "data", 4) == 0)
1235 flags &= ~BSF_FUNCTION;
1236 }
1237
252b5132
RH		 1238 /* FIXME: The 5th arg is for the `constant' field.
1239 What should it be? Not that it matters since it's not
1240 currently useful. */
ce195b42 1241 def_exports (c, 0, -1, 0, 0, ! (flags & BSF_FUNCTION));
252b5132
RH		 1242
1243 if (add_stdcall_alias && strchr (c, '@'))
1244 {
1245 char *exported_name = xstrdup (c);
1246 char *atsym = strchr (exported_name, '@');
1247 *atsym = '\0';
5f0f29c3 1248 /* Note: stdcall alias symbols can never be data. */
252b5132
RH		 1249 def_exports (exported_name, xstrdup (c), -1, 0, 0, 0);
1250 }
1251 }
1252 else
1253 p++;
1254 }
1255 free (buf);
1256}
1257
1258/* Look through the symbols in MINISYMS, and add each one to list of
1259 symbols to export. */
1260
1261static void
1262scan_filtered_symbols (abfd, minisyms, symcount, size)
1263 bfd *abfd;
1264 PTR minisyms;
1265 long symcount;
1266 unsigned int size;
1267{
1268 asymbol *store;
1269 bfd_byte *from, *fromend;
1270
1271 store = bfd_make_empty_symbol (abfd);
1272 if (store == NULL)
1273 bfd_fatal (bfd_get_filename (abfd));
1274
1275 from = (bfd_byte *) minisyms;
1276 fromend = from + symcount * size;
1277 for (; from < fromend; from += size)
1278 {
1279 asymbol *sym;
1280 const char *symbol_name;
1281
1282 sym = bfd_minisymbol_to_symbol (abfd, false, from, store);
1283 if (sym == NULL)
1284 bfd_fatal (bfd_get_filename (abfd));
1285
1286 symbol_name = bfd_asymbol_name (sym);
1287 if (bfd_get_symbol_leading_char (abfd) == symbol_name[0])
1288 ++symbol_name;
1289
ce195b42 1290 def_exports (xstrdup (symbol_name) , 0, -1, 0, 0,
a2186dfe 1291 ! (sym->flags & BSF_FUNCTION));
252b5132
RH		 1292
1293 if (add_stdcall_alias && strchr (symbol_name, '@'))
1294 {
1295 char *exported_name = xstrdup (symbol_name);
1296 char *atsym = strchr (exported_name, '@');
1297 *atsym = '\0';
ce195b42 1298 /* Note: stdcall alias symbols can never be data. */
252b5132
RH		 1299 def_exports (exported_name, xstrdup (symbol_name), -1, 0, 0, 0);
1300 }
1301 }
1302}
1303
1304/* Add a list of symbols to exclude. */
1305
1306static void
1307add_excludes (new_excludes)
1308 const char *new_excludes;
1309{
1310 char *local_copy;
1311 char *exclude_string;
1312
1313 local_copy = xstrdup (new_excludes);
1314
1315 exclude_string = strtok (local_copy, ",:");
1316 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
1317 {
1318 struct string_list *new_exclude;
1319
1320 new_exclude = ((struct string_list *)
1321 xmalloc (sizeof (struct string_list)));
1322 new_exclude->string = (char *) xmalloc (strlen (exclude_string) + 2);
1323 /* FIXME: Is it always right to add a leading underscore? */
1324 sprintf (new_exclude->string, "_%s", exclude_string);
1325 new_exclude->next = excludes;
1326 excludes = new_exclude;
1327
1328 /* xgettext:c-format */
37cc8ec1 1329 inform (_("Excluding symbol: %s"), exclude_string);
252b5132
RH		 1330 }
1331
1332 free (local_copy);
1333}
1334
1335/* See if STRING is on the list of symbols to exclude. */
1336
1337static boolean
1338match_exclude (string)
1339 const char *string;
1340{
1341 struct string_list *excl_item;
1342
1343 for (excl_item = excludes; excl_item; excl_item = excl_item->next)
1344 if (strcmp (string, excl_item->string) == 0)
1345 return true;
1346 return false;
1347}
1348
1349/* Add the default list of symbols to exclude. */
1350
1351static void
1352set_default_excludes (void)
1353{
1354 add_excludes (default_excludes);
1355}
1356
1357/* Choose which symbols to export. */
1358
1359static long
1360filter_symbols (abfd, minisyms, symcount, size)
1361 bfd *abfd;
1362 PTR minisyms;
1363 long symcount;
1364 unsigned int size;
1365{
1366 bfd_byte *from, *fromend, *to;
1367 asymbol *store;
1368
1369 store = bfd_make_empty_symbol (abfd);
1370 if (store == NULL)
1371 bfd_fatal (bfd_get_filename (abfd));
1372
1373 from = (bfd_byte *) minisyms;
1374 fromend = from + symcount * size;
1375 to = (bfd_byte *) minisyms;
1376
1377 for (; from < fromend; from += size)
1378 {
1379 int keep = 0;
1380 asymbol *sym;
1381
1382 sym = bfd_minisymbol_to_symbol (abfd, false, (const PTR) from, store);
1383 if (sym == NULL)
1384 bfd_fatal (bfd_get_filename (abfd));
1385
1386 /* Check for external and defined only symbols. */
1387 keep = (((sym->flags & BSF_GLOBAL) != 0
1388 || (sym->flags & BSF_WEAK) != 0
1389 || bfd_is_com_section (sym->section))
1390 && ! bfd_is_und_section (sym->section));
1391
1392 keep = keep && ! match_exclude (sym->name);
1393
1394 if (keep)
1395 {
1396 memcpy (to, from, size);
1397 to += size;
1398 }
1399 }
1400
1401 return (to - (bfd_byte *) minisyms) / size;
1402}
1403
1404/* Export all symbols in ABFD, except for ones we were told not to
1405 export. */
1406
1407static void
1408scan_all_symbols (abfd)
1409 bfd *abfd;
1410{
1411 long symcount;
1412 PTR minisyms;
1413 unsigned int size;
1414
1415 /* Ignore bfds with an import descriptor table. We assume that any
1416 such BFD contains symbols which are exported from another DLL,
1417 and we don't want to reexport them from here. */
1418 if (bfd_get_section_by_name (abfd, ".idata$4"))
1419 return;
1420
1421 if (! (bfd_get_file_flags (abfd) & HAS_SYMS))
1422 {
1423 /* xgettext:c-format */
37cc8ec1 1424 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
252b5132
RH		 1425 return;
1426 }
1427
1428 symcount = bfd_read_minisymbols (abfd, false, &minisyms, &size);
1429 if (symcount < 0)
1430 bfd_fatal (bfd_get_filename (abfd));
1431
1432 if (symcount == 0)
1433 {
1434 /* xgettext:c-format */
37cc8ec1 1435 non_fatal (_("%s: no symbols"), bfd_get_filename (abfd));
252b5132
RH		 1436 return;
1437 }
1438
1439 /* Discard the symbols we don't want to export. It's OK to do this
1440 in place; we'll free the storage anyway. */
1441
1442 symcount = filter_symbols (abfd, minisyms, symcount, size);
1443 scan_filtered_symbols (abfd, minisyms, symcount, size);
1444
1445 free (minisyms);
1446}
1447
1448/* Look at the object file to decide which symbols to export. */
1449
1450static void
1451scan_open_obj_file (abfd)
1452 bfd *abfd;
1453{
1454 if (export_all_symbols)
1455 scan_all_symbols (abfd);
1456 else
1457 scan_drectve_symbols (abfd);
1458
1459 /* FIXME: we ought to read in and block out the base relocations */
1460
1461 /* xgettext:c-format */
37cc8ec1 1462 inform (_("Done reading %s"), bfd_get_filename (abfd));
252b5132
RH		 1463}
1464
1465static void
1466scan_obj_file (filename)
1467 const char *filename;
1468{
1469 bfd * f = bfd_openr (filename, 0);
1470
1471 if (!f)
1472 /* xgettext:c-format */
1473 fatal (_("Unable to open object file: %s"), filename);
1474
1475 /* xgettext:c-format */
1476 inform (_("Scanning object file %s"), filename);
1477
1478 if (bfd_check_format (f, bfd_archive))
1479 {
1480 bfd *arfile = bfd_openr_next_archived_file (f, 0);
1481 while (arfile)
1482 {
1483 if (bfd_check_format (arfile, bfd_object))
1484 scan_open_obj_file (arfile);
1485 bfd_close (arfile);
1486 arfile = bfd_openr_next_archived_file (f, arfile);
1487 }
49e315b1
NC		 1488
1489#ifdef DLLTOOL_MCORE_ELF
1490 if (mcore_elf_out_file)
1491 inform (_("Cannot produce mcore-elf dll from archive file: %s"), filename);
1492#endif
252b5132
RH		 1493 }
1494 else if (bfd_check_format (f, bfd_object))
1495 {
1496 scan_open_obj_file (f);
49e315b1
NC		 1497
1498#ifdef DLLTOOL_MCORE_ELF
1499 if (mcore_elf_out_file)
1500 mcore_elf_cache_filename ((char *) filename);
1501#endif
252b5132
RH		 1502 }
1503
1504 bfd_close (f);
1505}
1506
1507/**********************************************************************/
1508
1509static void
1510dump_def_info (f)
1511 FILE *f;
1512{
1513 int i;
1514 export_type *exp;
1515 fprintf (f, "%s ", ASM_C);
1516 for (i = 0; oav[i]; i++)
1517 fprintf (f, "%s ", oav[i]);
1518 fprintf (f, "\n");
1519 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1520 {
1521 fprintf (f, "%s %d = %s %s @ %d %s%s%s\n",
1522 ASM_C,
1523 i,
1524 exp->name,
1525 exp->internal_name,
1526 exp->ordinal,
1527 exp->noname ? "NONAME " : "",
1528 exp->constant ? "CONSTANT" : "",
1529 exp->data ? "DATA" : "");
1530 }
1531}
1532
1533/* Generate the .exp file */
1534
1535static int
1536sfunc (a, b)
1537 const void *a;
1538 const void *b;
1539{
1540 return *(const long *) a - *(const long *) b;
1541}
1542
1543static void
1544flush_page (f, need, page_addr, on_page)
1545 FILE *f;
1546 long *need;
1547 int page_addr;
1548 int on_page;
1549{
1550 int i;
1551
1552 /* Flush this page */
1553 fprintf (f, "\t%s\t0x%08x\t%s Starting RVA for chunk\n",
1554 ASM_LONG,
1555 page_addr,
1556 ASM_C);
1557 fprintf (f, "\t%s\t0x%x\t%s Size of block\n",
1558 ASM_LONG,
1559 (on_page * 2) + (on_page & 1) * 2 + 8,
1560 ASM_C);
f932f8e1 1561
252b5132 1562 for (i = 0; i < on_page; i++)
a2186dfe
NC		 1563 {
1564 long needed = need[i];
1565
1566 if (needed)
1567 needed = ((needed - page_addr) | 0x3000) & 0xffff;
1568
1569 fprintf (f, "\t%s\t0x%lx\n", ASM_SHORT, needed);
1570 }
1571
252b5132
RH		 1572 /* And padding */
1573 if (on_page & 1)
1574 fprintf (f, "\t%s\t0x%x\n", ASM_SHORT, 0 | 0x0000);
1575}
1576
1577static void
1578gen_def_file ()
1579{
1580 int i;
1581 export_type *exp;
1582
1583 inform (_("Adding exports to output file"));
1584
1585 fprintf (output_def, ";");
1586 for (i = 0; oav[i]; i++)
1587 fprintf (output_def, " %s", oav[i]);
1588
1589 fprintf (output_def, "\nEXPORTS\n");
1590
1591 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1592 {
1593 char *quote = strchr (exp->name, '.') ? "\"" : "";
1594 char *res = cplus_demangle (exp->internal_name, DMGL_ANSI | DMGL_PARAMS);
1595
1596 if (strcmp (exp->name, exp->internal_name) == 0)
1597 {
1598
1599 fprintf (output_def, "\t%s%s%s @ %d%s%s ; %s\n",
1600 quote,
1601 exp->name,
1602 quote,
1603 exp->ordinal,
1604 exp->noname ? " NONAME" : "",
1605 exp->data ? " DATA" : "",
1606 res ? res : "");
1607 }
1608 else
1609 {
1610 char *quote1 = strchr (exp->internal_name, '.') ? "\"" : "";
1611 /* char *alias = */
1612 fprintf (output_def, "\t%s%s%s = %s%s%s @ %d%s%s ; %s\n",
1613 quote,
1614 exp->name,
1615 quote,
1616 quote1,
1617 exp->internal_name,
1618 quote1,
1619 exp->ordinal,
1620 exp->noname ? " NONAME" : "",
1621 exp->data ? " DATA" : "",
1622 res ? res : "");
1623 }
1624 if (res)
1625 free (res);
1626 }
1627
1628 inform (_("Added exports to output file"));
1629}
1630
1631/* generate_idata_ofile generates the portable assembly source code
1632 for the idata sections. It appends the source code to the end of
1633 the file. */
1634
1635static void
1636generate_idata_ofile (filvar)
1637 FILE *filvar;
1638{
1639 iheadtype *headptr;
1640 ifunctype *funcptr;
1641 int headindex;
1642 int funcindex;
1643 int nheads;
1644
1645 if (import_list == NULL)
1646 return;
1647
1648 fprintf (filvar, "%s Import data sections\n", ASM_C);
1649 fprintf (filvar, "\n\t.section\t.idata$2\n");
1650 fprintf (filvar, "\t%s\tdoi_idata\n", ASM_GLOBAL);
1651 fprintf (filvar, "doi_idata:\n");
1652
1653 nheads = 0;
1654 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1655 {
1656 fprintf (filvar, "\t%slistone%d%s\t%s %s\n",
1657 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER,
1658 ASM_C, headptr->dllname);
1659 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1660 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1661 fprintf (filvar, "\t%sdllname%d%s\n",
1662 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1663 fprintf (filvar, "\t%slisttwo%d%s\n\n",
1664 ASM_RVA_BEFORE, nheads, ASM_RVA_AFTER);
1665 nheads++;
1666 }
1667
1668 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL record at */
1669 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* end of idata$2 */
1670 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* section */
1671 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1672 fprintf (filvar, "\t%s\t0\n", ASM_LONG);
1673
1674 fprintf (filvar, "\n\t.section\t.idata$4\n");
1675 headindex = 0;
1676 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1677 {
1678 fprintf (filvar, "listone%d:\n", headindex);
1679 for ( funcindex = 0; funcindex < headptr->nfuncs; funcindex++ )
1680 fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1681 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1682 fprintf (filvar,"\t%s\t0\n", ASM_LONG); /* NULL terminating list */
1683 headindex++;
1684 }
1685
1686 fprintf (filvar, "\n\t.section\t.idata$5\n");
1687 headindex = 0;
1688 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1689 {
1690 fprintf (filvar, "listtwo%d:\n", headindex);
1691 for ( funcindex = 0; funcindex < headptr->nfuncs; funcindex++ )
1692 fprintf (filvar, "\t%sfuncptr%d_%d%s\n",
1693 ASM_RVA_BEFORE, headindex, funcindex, ASM_RVA_AFTER);
1694 fprintf (filvar, "\t%s\t0\n", ASM_LONG); /* NULL terminating list */
1695 headindex++;
1696 }
1697
1698 fprintf (filvar, "\n\t.section\t.idata$6\n");
1699 headindex = 0;
1700 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1701 {
1702 funcindex = 0;
1703 for (funcptr = headptr->funchead; funcptr != NULL;
1704 funcptr = funcptr->next)
1705 {
1706 fprintf (filvar,"funcptr%d_%d:\n", headindex, funcindex);
1707 fprintf (filvar,"\t%s\t%d\n", ASM_SHORT,
1708 ((funcptr->ord) & 0xFFFF));
1709 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, funcptr->name);
1710 fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1711 funcindex++;
1712 }
1713 headindex++;
1714 }
1715
1716 fprintf (filvar, "\n\t.section\t.idata$7\n");
1717 headindex = 0;
1718 for (headptr = import_list; headptr != NULL; headptr = headptr->next)
1719 {
1720 fprintf (filvar,"dllname%d:\n", headindex);
1721 fprintf (filvar,"\t%s\t\"%s\"\n", ASM_TEXT, headptr->dllname);
1722 fprintf (filvar,"\t%s\t0\n", ASM_BYTE);
1723 headindex++;
1724 }
1725}
1726
49c24507
NC		 1727/* Assemble the specified file. */
1728static void
1729assemble_file (source, dest)
1730 const char * source;
1731 const char * dest;
1732{
1733 char * cmd;
1734
1735 cmd = (char *) alloca (strlen (ASM_SWITCHES) + strlen (as_flags)
96925346 1736 + strlen (source) + strlen (dest) + 50);
49c24507
NC		 1737
1738 sprintf (cmd, "%s %s -o %s %s", ASM_SWITCHES, as_flags, dest, source);
1739
1740 run (as_name, cmd);
1741}
1742
252b5132
RH		 1743static void
1744gen_exp_file ()
1745{
1746 FILE *f;
1747 int i;
1748 export_type *exp;
1749 dlist_type *dl;
1750
1751 /* xgettext:c-format */
37cc8ec1 1752 inform (_("Generating export file: %s"), exp_name);
252b5132
RH		 1753
1754 f = fopen (TMP_ASM, FOPEN_WT);
1755 if (!f)
1756 /* xgettext:c-format */
1757 fatal (_("Unable to open temporary assembler file: %s"), TMP_ASM);
1758
1759 /* xgettext:c-format */
1760 inform (_("Opened temporary file: %s"), TMP_ASM);
1761
1762 dump_def_info (f);
1763
1764 if (d_exports)
1765 {
1766 fprintf (f, "\t.section .edata\n\n");
1767 fprintf (f, "\t%s 0 %s Allways 0\n", ASM_LONG, ASM_C);
1768 fprintf (f, "\t%s 0x%lx %s Time and date\n", ASM_LONG, (long) time(0),
1769 ASM_C);
1770 fprintf (f, "\t%s 0 %s Major and Minor version\n", ASM_LONG, ASM_C);
1771 fprintf (f, "\t%sname%s %s Ptr to name of dll\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1772 fprintf (f, "\t%s %d %s Starting ordinal of exports\n", ASM_LONG, d_low_ord, ASM_C);
1773
1774
1775 fprintf (f, "\t%s %d %s Number of functions\n", ASM_LONG, d_high_ord - d_low_ord + 1, ASM_C);
1776 fprintf(f,"\t%s named funcs %d, low ord %d, high ord %d\n",
1777 ASM_C,
1778 d_named_nfuncs, d_low_ord, d_high_ord);
1779 fprintf (f, "\t%s %d %s Number of names\n", ASM_LONG,
1780 show_allnames ? d_high_ord - d_low_ord + 1 : d_named_nfuncs, ASM_C);
1781 fprintf (f, "\t%safuncs%s %s Address of functions\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1782
1783 fprintf (f, "\t%sanames%s %s Address of Name Pointer Table\n",
1784 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1785
1786 fprintf (f, "\t%sanords%s %s Address of ordinals\n", ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
1787
1788 fprintf (f, "name: %s \"%s\"\n", ASM_TEXT, dll_name);
1789
1790
1791 fprintf(f,"%s Export address Table\n", ASM_C);
1792 fprintf(f,"\t%s\n", ASM_ALIGN_LONG);
1793 fprintf (f, "afuncs:\n");
1794 i = d_low_ord;
1795
1796 for (exp = d_exports; exp; exp = exp->next)
1797 {
1798 if (exp->ordinal != i)
1799 {
1800#if 0
1801 fprintf (f, "\t%s\t%d\t%s %d..%d missing\n",
1802 ASM_SPACE,
1803 (exp->ordinal - i) * 4,
1804 ASM_C,
1805 i, exp->ordinal - 1);
1806 i = exp->ordinal;
1807#endif
1808 while (i < exp->ordinal)
1809 {
1810 fprintf(f,"\t%s\t0\n", ASM_LONG);
1811 i++;
1812 }
1813 }
1814 fprintf (f, "\t%s%s%s%s\t%s %d\n", ASM_RVA_BEFORE,
b890a735
CM		 1815 ASM_PREFIX,
1816 exp->internal_name, ASM_RVA_AFTER, ASM_C, exp->ordinal);
252b5132
RH		 1817 i++;
1818 }
1819
1820 fprintf (f,"%s Export Name Pointer Table\n", ASM_C);
1821 fprintf (f, "anames:\n");
1822
1823 for (i = 0; (exp = d_exports_lexically[i]); i++)
1824 {
1825 if (!exp->noname || show_allnames)
1826 fprintf (f, "\t%sn%d%s\n",
1827 ASM_RVA_BEFORE, exp->ordinal, ASM_RVA_AFTER);
1828 }
1829
1830 fprintf (f,"%s Export Oridinal Table\n", ASM_C);
1831 fprintf (f, "anords:\n");
1832 for (i = 0; (exp = d_exports_lexically[i]); i++)
1833 {
1834 if (!exp->noname || show_allnames)
1835 fprintf (f, "\t%s %d\n", ASM_SHORT, exp->ordinal - d_low_ord);
1836 }
1837
1838 fprintf(f,"%s Export Name Table\n", ASM_C);
1839 for (i = 0; (exp = d_exports_lexically[i]); i++)
1840 if (!exp->noname || show_allnames)
1841 fprintf (f, "n%d: %s \"%s\"\n",
1842 exp->ordinal, ASM_TEXT, exp->name);
1843
1844 if (a_list)
1845 {
661016bb 1846 fprintf (f, "\t.section %s\n", DRECTVE_SECTION_NAME);
252b5132
RH		 1847 for (dl = a_list; dl; dl = dl->next)
1848 {
1849 fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, dl->text);
1850 }
1851 }
661016bb 1852
252b5132
RH		 1853 if (d_list)
1854 {
1855 fprintf (f, "\t.section .rdata\n");
1856 for (dl = d_list; dl; dl = dl->next)
1857 {
1858 char *p;
1859 int l;
5f0f29c3
NC		 1860
1861 /* We don't output as ascii because there can
1862 be quote characters in the string. */
252b5132
RH		 1863 l = 0;
1864 for (p = dl->text; *p; p++)
1865 {
1866 if (l == 0)
1867 fprintf (f, "\t%s\t", ASM_BYTE);
1868 else
1869 fprintf (f, ",");
1870 fprintf (f, "%d", *p);
1871 if (p[1] == 0)
1872 {
1873 fprintf (f, ",0\n");
1874 break;
1875 }
1876 if (++l == 10)
1877 {
1878 fprintf (f, "\n");
1879 l = 0;
1880 }
1881 }
1882 }
1883 }
1884 }
1885
1886
1887 /* Add to the output file a way of getting to the exported names
5f0f29c3 1888 without using the import library. */
252b5132
RH		 1889 if (add_indirect)
1890 {
1891 fprintf (f, "\t.section\t.rdata\n");
1892 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
1893 if (!exp->noname || show_allnames)
1894 {
1895 /* We use a single underscore for MS compatibility, and a
1896 double underscore for backward compatibility with old
1897 cygwin releases. */
5f0f29c3
NC		 1898 if (create_compat_implib)
1899 fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name);
252b5132 1900 fprintf (f, "\t%s\t_imp__%s\n", ASM_GLOBAL, exp->name);
5f0f29c3
NC		 1901 if (create_compat_implib)
1902 fprintf (f, "__imp_%s:\n", exp->name);
252b5132
RH		 1903 fprintf (f, "_imp__%s:\n", exp->name);
1904 fprintf (f, "\t%s\t%s\n", ASM_LONG, exp->name);
1905 }
1906 }
1907
1908 /* Dump the reloc section if a base file is provided */
1909 if (base_file)
1910 {
1911 int addr;
1912 long need[PAGE_SIZE];
1913 long page_addr;
1914 int numbytes;
1915 int num_entries;
1916 long *copy;
1917 int j;
1918 int on_page;
1919 fprintf (f, "\t.section\t.init\n");
1920 fprintf (f, "lab:\n");
1921
1922 fseek (base_file, 0, SEEK_END);
1923 numbytes = ftell (base_file);
1924 fseek (base_file, 0, SEEK_SET);
1925 copy = xmalloc (numbytes);
1926 fread (copy, 1, numbytes, base_file);
1927 num_entries = numbytes / sizeof (long);
1928
1929
1930 fprintf (f, "\t.section\t.reloc\n");
1931 if (num_entries)
1932 {
1933 int src;
1934 int dst = 0;
1935 int last = -1;
252b5132
RH		 1936 qsort (copy, num_entries, sizeof (long), sfunc);
1937 /* Delete duplcates */
1938 for (src = 0; src < num_entries; src++)
1939 {
1940 if (last != copy[src])
1941 last = copy[dst++] = copy[src];
1942 }
1943 num_entries = dst;
1944 addr = copy[0];
1945 page_addr = addr & PAGE_MASK; /* work out the page addr */
1946 on_page = 0;
1947 for (j = 0; j < num_entries; j++)
1948 {
252b5132
RH		 1949 addr = copy[j];
1950 if ((addr & PAGE_MASK) != page_addr)
1951 {
252b5132
RH		 1952 flush_page (f, need, page_addr, on_page);
1953 on_page = 0;
1954 page_addr = addr & PAGE_MASK;
1955 }
1956 need[on_page++] = addr;
1957 }
252b5132
RH		 1958 flush_page (f, need, page_addr, on_page);
1959
d8bcc1ac 1960/* fprintf (f, "\t%s\t0,0\t%s End\n", ASM_LONG, ASM_C);*/
252b5132
RH		 1961 }
1962 }
1963
1964 generate_idata_ofile (f);
1965
1966 fclose (f);
1967
1968 /* assemble the file */
49c24507 1969 assemble_file (TMP_ASM, exp_name);
bb0cb4db 1970
252b5132
RH		 1971 if (dontdeltemps == 0)
1972 unlink (TMP_ASM);
1973
1974 inform (_("Generated exports file"));
1975}
1976
1977static const char *
1978xlate (name)
1979 const char *name;
1980{
1981 if (add_underscore)
1982 {
1983 char *copy = xmalloc (strlen (name) + 2);
1984 copy[0] = '_';
1985 strcpy (copy + 1, name);
1986 name = copy;
1987 }
1988
1989 if (killat)
1990 {
1991 char *p;
1992 p = strchr (name, '@');
1993 if (p)
1994 *p = 0;
1995 }
1996 return name;
1997}
1998
1999/**********************************************************************/
2000
2001#if 0
2002
2003static void
2004dump_iat (f, exp)
2005 FILE *f;
2006 export_type *exp;
2007{
2008 if (exp->noname && !show_allnames )
2009 {
2010 fprintf (f, "\t%s\t0x%08x\n",
2011 ASM_LONG,
2012 exp->ordinal | 0x80000000); /* hint or orindal ?? */
2013 }
2014 else
2015 {
2016 fprintf (f, "\t%sID%d%s\n", ASM_RVA_BEFORE,
2017 exp->ordinal,
2018 ASM_RVA_AFTER);
2019 }
2020}
2021
2022#endif
2023
2024typedef struct
2025{
2026 int id;
2027 const char *name;
2028 int flags;
2029 int align;
2030 asection *sec;
2031 asymbol *sym;
2032 asymbol **sympp;
2033 int size;
2034 unsigned char *data;
2035} sinfo;
2036
2037#ifndef DLLTOOL_PPC
2038
2039#define TEXT 0
2040#define DATA 1
2041#define BSS 2
2042#define IDATA7 3
2043#define IDATA5 4
2044#define IDATA4 5
2045#define IDATA6 6
2046
2047#define NSECS 7
2048
5ea695ed 2049#define INIT_SEC_DATA(id, name, flags, align) { id, name, flags, align, NULL, NULL, NULL, 0, NULL }
252b5132
RH		 2050static sinfo secdata[NSECS] =
2051{
5ea695ed
NC		 2052 INIT_SEC_DATA (TEXT, ".text", SEC_CODE | SEC_HAS_CONTENTS, 2),
2053 INIT_SEC_DATA (DATA, ".data", SEC_DATA, 2),
2054 INIT_SEC_DATA (BSS, ".bss", 0, 2),
2055 INIT_SEC_DATA (IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2),
2056 INIT_SEC_DATA (IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2),
2057 INIT_SEC_DATA (IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2),
2058 INIT_SEC_DATA (IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1)
252b5132
RH		 2059};
2060
2061#else
2062
2063/* Sections numbered to make the order the same as other PowerPC NT */
2064/* compilers. This also keeps funny alignment thingies from happening. */
2065#define TEXT 0
2066#define PDATA 1
2067#define RDATA 2
2068#define IDATA5 3
2069#define IDATA4 4
2070#define IDATA6 5
2071#define IDATA7 6
2072#define DATA 7
2073#define BSS 8
2074
2075#define NSECS 9
2076
2077static sinfo secdata[NSECS] =
2078{
2079 { TEXT, ".text", SEC_CODE | SEC_HAS_CONTENTS, 3},
2080 { PDATA, ".pdata", SEC_HAS_CONTENTS, 2},
2081 { RDATA, ".reldata", SEC_HAS_CONTENTS, 2},
2082 { IDATA5, ".idata$5", SEC_HAS_CONTENTS, 2},
2083 { IDATA4, ".idata$4", SEC_HAS_CONTENTS, 2},
2084 { IDATA6, ".idata$6", SEC_HAS_CONTENTS, 1},
2085 { IDATA7, ".idata$7", SEC_HAS_CONTENTS, 2},
2086 { DATA, ".data", SEC_DATA, 2},
2087 { BSS, ".bss", 0, 2}
2088};
2089
2090#endif
2091
2092/*
2093This is what we're trying to make. We generate the imp symbols with
2094both single and double underscores, for compatibility.
2095
2096 .text
2097 .global _GetFileVersionInfoSizeW@8
2098 .global __imp_GetFileVersionInfoSizeW@8
2099_GetFileVersionInfoSizeW@8:
2100 jmp * __imp_GetFileVersionInfoSizeW@8
2101 .section .idata$7 # To force loading of head
2102 .long __version_a_head
2103# Import Address Table
2104 .section .idata$5
2105__imp_GetFileVersionInfoSizeW@8:
2106 .rva ID2
2107
2108# Import Lookup Table
2109 .section .idata$4
2110 .rva ID2
2111# Hint/Name table
2112 .section .idata$6
2113ID2: .short 2
2114 .asciz "GetFileVersionInfoSizeW"
2115
2116
2117For the PowerPC, here's the variation on the above scheme:
2118
2119# Rather than a simple "jmp *", the code to get to the dll function
2120# looks like:
2121 .text
2122 lwz r11,[tocv]__imp_function_name(r2)
2123# RELOC: 00000000 TOCREL16,TOCDEFN __imp_function_name
2124 lwz r12,0(r11)
2125 stw r2,4(r1)
2126 mtctr r12
2127 lwz r2,4(r11)
2128 bctr
2129*/
2130
2131static char *
2132make_label (prefix, name)
2133 const char *prefix;
2134 const char *name;
2135{
2136 int len = strlen (ASM_PREFIX) + strlen (prefix) + strlen (name);
2137 char *copy = xmalloc (len +1 );
2138 strcpy (copy, ASM_PREFIX);
2139 strcat (copy, prefix);
2140 strcat (copy, name);
2141 return copy;
2142}
2143
2144static bfd *
2145make_one_lib_file (exp, i)
2146 export_type *exp;
2147 int i;
2148{
2149#if 0
2150 {
bb0cb4db 2151 char *name;
252b5132 2152 FILE *f;
bb0cb4db 2153 const char *prefix = "d";
49c24507 2154 char *dest;
bb0cb4db
ILT		 2155
2156 name = (char *) alloca (strlen (prefix) + 10);
2157 sprintf (name, "%ss%05d.s", prefix, i);
2158 f = fopen (name, FOPEN_WT);
252b5132
RH		 2159 fprintf (f, "\t.text\n");
2160 fprintf (f, "\t%s\t%s%s\n", ASM_GLOBAL, ASM_PREFIX, exp->name);
5f0f29c3
NC		 2161 if (create_compat_implib)
2162 fprintf (f, "\t%s\t__imp_%s\n", ASM_GLOBAL, exp->name);
252b5132 2163 fprintf (f, "\t%s\t_imp__%s\n", ASM_GLOBAL, exp->name);
5f0f29c3
NC		 2164 if (create_compat_implib)
2165 fprintf (f, "%s%s:\n\t%s\t__imp_%s\n", ASM_PREFIX,
2166 exp->name, ASM_JUMP, exp->name);
252b5132
RH		 2167
2168 fprintf (f, "\t.section\t.idata$7\t%s To force loading of head\n", ASM_C);
2169 fprintf (f, "\t%s\t%s\n", ASM_LONG, head_label);
2170
2171
2172 fprintf (f,"%s Import Address Table\n", ASM_C);
2173
2174 fprintf (f, "\t.section .idata$5\n");
5f0f29c3
NC		 2175 if (create_compat_implib)
2176 fprintf (f, "__imp_%s:\n", exp->name);
252b5132
RH		 2177 fprintf (f, "_imp__%s:\n", exp->name);
2178
2179 dump_iat (f, exp);
2180
2181 fprintf (f, "\n%s Import Lookup Table\n", ASM_C);
2182 fprintf (f, "\t.section .idata$4\n");
2183
2184 dump_iat (f, exp);
2185
2186 if(!exp->noname || show_allnames)
2187 {
2188 fprintf (f, "%s Hint/Name table\n", ASM_C);
2189 fprintf (f, "\t.section .idata$6\n");
2190 fprintf (f, "ID%d:\t%s\t%d\n", exp->ordinal, ASM_SHORT, exp->hint);
2191 fprintf (f, "\t%s\t\"%s\"\n", ASM_TEXT, xlate (exp->name));
2192 }
2193
2194 fclose (f);
2195
49c24507
NC		 2196 dest = (char *) alloca (strlen (prefix) + 10);
2197 sprintf (dest, "%ss%05d.o", prefix, i);
2198 assemble_file (name, dest);
252b5132
RH		 2199 }
2200#else /* if 0 */
2201 {
2202 bfd * abfd;
2203 asymbol * exp_label;
2204 asymbol * iname;
2205 asymbol * iname2;
2206 asymbol * iname_lab;
2207 asymbol ** iname_lab_pp;
2208 asymbol ** iname_pp;
2209#ifdef DLLTOOL_PPC
2210 asymbol ** fn_pp;
2211 asymbol ** toc_pp;
2212#define EXTRA 2
2213#endif
2214#ifndef EXTRA
2215#define EXTRA 0
2216#endif
2217 asymbol * ptrs[NSECS + 4 + EXTRA + 1];
2218
2219 char * outname = xmalloc (10);
2220 int oidx = 0;
2221
2222
2223 sprintf (outname, "%s%05d.o", TMP_STUB, i);
2224
49c24507 2225 abfd = bfd_openw (outname, HOW_BFD_WRITE_TARGET);
252b5132
RH		 2226
2227 if (!abfd)
2228 /* xgettext:c-format */
2229 fatal (_("bfd_open failed open stub file: %s"), outname);
2230
2231 /* xgettext:c-format */
2232 inform (_("Creating stub file: %s"), outname);
2233
2234 bfd_set_format (abfd, bfd_object);
2235 bfd_set_arch_mach (abfd, HOW_BFD_ARCH, 0);
2236
2237#ifdef DLLTOOL_ARM
b890a735 2238 if (machine == MARM_INTERWORK || machine == MTHUMB)
252b5132
RH		 2239 bfd_set_private_flags (abfd, F_INTERWORK);
2240#endif
2241
2242 /* First make symbols for the sections */
2243 for (i = 0; i < NSECS; i++)
2244 {
2245 sinfo *si = secdata + i;
2246 if (si->id != i)
2247 abort();
2248 si->sec = bfd_make_section_old_way (abfd, si->name);
2249 bfd_set_section_flags (abfd,
2250 si->sec,
2251 si->flags);
2252
2253 bfd_set_section_alignment(abfd, si->sec, si->align);
2254 si->sec->output_section = si->sec;
2255 si->sym = bfd_make_empty_symbol(abfd);
2256 si->sym->name = si->sec->name;
2257 si->sym->section = si->sec;
2258 si->sym->flags = BSF_LOCAL;
2259 si->sym->value = 0;
2260 ptrs[oidx] = si->sym;
2261 si->sympp = ptrs + oidx;
2262 si->size = 0;
2263 si->data = NULL;
2264
2265 oidx++;
2266 }
2267
2268 if (! exp->data)
2269 {
2270 exp_label = bfd_make_empty_symbol (abfd);
2271 exp_label->name = make_label ("", exp->name);
2272
2273 /* On PowerPC, the function name points to a descriptor in
2274 the rdata section, the first element of which is a
2275 pointer to the code (..function_name), and the second
2276 points to the .toc */
2277#ifdef DLLTOOL_PPC
2278 if (machine == MPPC)
2279 exp_label->section = secdata[RDATA].sec;
2280 else
2281#endif
2282 exp_label->section = secdata[TEXT].sec;
2283
2284 exp_label->flags = BSF_GLOBAL;
2285 exp_label->value = 0;
2286
2287#ifdef DLLTOOL_ARM
2288 if (machine == MTHUMB)
2289 bfd_coff_set_symbol_class (abfd, exp_label, C_THUMBEXTFUNC);
2290#endif
2291 ptrs[oidx++] = exp_label;
2292 }
2293
2294 /* Generate imp symbols with one underscore for Microsoft
2295 compatibility, and with two underscores for backward
2296 compatibility with old versions of cygwin. */
5f0f29c3
NC		 2297 if (create_compat_implib)
2298 {
2299 iname = bfd_make_empty_symbol (abfd);
2300 iname->name = make_label ("__imp_", exp->name);
2301 iname->section = secdata[IDATA5].sec;
2302 iname->flags = BSF_GLOBAL;
2303 iname->value = 0;
2304 }
252b5132 2305
5f0f29c3 2306 iname2 = bfd_make_empty_symbol (abfd);
252b5132
RH		 2307 iname2->name = make_label ("_imp__", exp->name);
2308 iname2->section = secdata[IDATA5].sec;
2309 iname2->flags = BSF_GLOBAL;
2310 iname2->value = 0;
2311
2312 iname_lab = bfd_make_empty_symbol(abfd);
2313
2314 iname_lab->name = head_label;
2315 iname_lab->section = (asection *)&bfd_und_section;
2316 iname_lab->flags = 0;
2317 iname_lab->value = 0;
2318
2319
2320 iname_pp = ptrs + oidx;
5f0f29c3
NC		 2321 if (create_compat_implib)
2322 ptrs[oidx++] = iname;
252b5132
RH		 2323 ptrs[oidx++] = iname2;
2324
2325 iname_lab_pp = ptrs + oidx;
2326 ptrs[oidx++] = iname_lab;
2327
2328#ifdef DLLTOOL_PPC
2329 /* The symbol refering to the code (.text) */
2330 {
2331 asymbol *function_name;
2332
2333 function_name = bfd_make_empty_symbol(abfd);
2334 function_name->name = make_label ("..", exp->name);
2335 function_name->section = secdata[TEXT].sec;
2336 function_name->flags = BSF_GLOBAL;
2337 function_name->value = 0;
2338
2339 fn_pp = ptrs + oidx;
2340 ptrs[oidx++] = function_name;
2341 }
2342
2343 /* The .toc symbol */
2344 {
2345 asymbol *toc_symbol; /* The .toc symbol */
2346
2347 toc_symbol = bfd_make_empty_symbol (abfd);
2348 toc_symbol->name = make_label (".", "toc");
2349 toc_symbol->section = (asection *)&bfd_und_section;
2350 toc_symbol->flags = BSF_GLOBAL;
2351 toc_symbol->value = 0;
2352
2353 toc_pp = ptrs + oidx;
2354 ptrs[oidx++] = toc_symbol;
2355 }
2356#endif
2357
2358 ptrs[oidx] = 0;
2359
2360 for (i = 0; i < NSECS; i++)
2361 {
2362 sinfo *si = secdata + i;
2363 asection *sec = si->sec;
2364 arelent *rel;
2365 arelent **rpp;
2366
2367 switch (i)
2368 {
2369 case TEXT:
2370 if (! exp->data)
2371 {
2372 si->size = HOW_JTAB_SIZE;
2373 si->data = xmalloc (HOW_JTAB_SIZE);
2374 memcpy (si->data, HOW_JTAB, HOW_JTAB_SIZE);
2375
2376 /* add the reloc into idata$5 */
2377 rel = xmalloc (sizeof (arelent));
2378
2379 rpp = xmalloc (sizeof (arelent *) * 2);
2380 rpp[0] = rel;
2381 rpp[1] = 0;
2382
2383 rel->address = HOW_JTAB_ROFF;
2384 rel->addend = 0;
2385
2386 if (machine == MPPC)
2387 {
2388 rel->howto = bfd_reloc_type_lookup (abfd,
2389 BFD_RELOC_16_GOTOFF);
2390 rel->sym_ptr_ptr = iname_pp;
2391 }
2392 else
2393 {
2394 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2395 rel->sym_ptr_ptr = secdata[IDATA5].sympp;
2396 }
2397 sec->orelocation = rpp;
2398 sec->reloc_count = 1;
2399 }
2400 break;
2401 case IDATA4:
2402 case IDATA5:
2403 /* An idata$4 or idata$5 is one word long, and has an
2404 rva to idata$6 */
2405
2406 si->data = xmalloc (4);
2407 si->size = 4;
2408
2409 if (exp->noname)
2410 {
2411 si->data[0] = exp->ordinal ;
2412 si->data[1] = exp->ordinal >> 8;
2413 si->data[2] = exp->ordinal >> 16;
2414 si->data[3] = 0x80;
2415 }
2416 else
2417 {
2418 sec->reloc_count = 1;
2419 memset (si->data, 0, si->size);
2420 rel = xmalloc (sizeof (arelent));
2421 rpp = xmalloc (sizeof (arelent *) * 2);
2422 rpp[0] = rel;
2423 rpp[1] = 0;
2424 rel->address = 0;
2425 rel->addend = 0;
2426 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2427 rel->sym_ptr_ptr = secdata[IDATA6].sympp;
2428 sec->orelocation = rpp;
2429 }
2430
2431 break;
2432
2433 case IDATA6:
2434 if (!exp->noname)
2435 {
2436 /* This used to add 1 to exp->hint. I don't know
2437 why it did that, and it does not match what I see
2438 in programs compiled with the MS tools. */
2439 int idx = exp->hint;
2440 si->size = strlen (xlate (exp->name)) + 3;
2441 si->data = xmalloc (si->size);
2442 si->data[0] = idx & 0xff;
2443 si->data[1] = idx >> 8;
2444 strcpy (si->data + 2, xlate (exp->name));
2445 }
2446 break;
2447 case IDATA7:
2448 si->size = 4;
2449 si->data =xmalloc(4);
2450 memset (si->data, 0, si->size);
2451 rel = xmalloc (sizeof (arelent));
2452 rpp = xmalloc (sizeof (arelent *) * 2);
2453 rpp[0] = rel;
2454 rel->address = 0;
2455 rel->addend = 0;
2456 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_RVA);
2457 rel->sym_ptr_ptr = iname_lab_pp;
2458 sec->orelocation = rpp;
2459 sec->reloc_count = 1;
2460 break;
2461
2462#ifdef DLLTOOL_PPC
2463 case PDATA:
2464 {
2465 /* The .pdata section is 5 words long. */
2466 /* Think of it as: */
2467 /* struct */
2468 /* { */
2469 /* bfd_vma BeginAddress, [0x00] */
2470 /* EndAddress, [0x04] */
2471 /* ExceptionHandler, [0x08] */
2472 /* HandlerData, [0x0c] */
2473 /* PrologEndAddress; [0x10] */
2474 /* }; */
2475
2476 /* So this pdata section setups up this as a glue linkage to
2477 a dll routine. There are a number of house keeping things
2478 we need to do:
2479
2480 1. In the name of glue trickery, the ADDR32 relocs for 0,
2481 4, and 0x10 are set to point to the same place:
2482 "..function_name".
2483 2. There is one more reloc needed in the pdata section.
2484 The actual glue instruction to restore the toc on
2485 return is saved as the offset in an IMGLUE reloc.
2486 So we need a total of four relocs for this section.
2487
2488 3. Lastly, the HandlerData field is set to 0x03, to indicate
2489 that this is a glue routine.
2490 */
2491 arelent *imglue, *ba_rel, *ea_rel, *pea_rel;
2492
2493 /* alignment must be set to 2**2 or you get extra stuff */
2494 bfd_set_section_alignment(abfd, sec, 2);
2495
2496 si->size = 4 * 5;
2497 si->data =xmalloc(4 * 5);
2498 memset (si->data, 0, si->size);
2499 rpp = xmalloc (sizeof (arelent *) * 5);
2500 rpp[0] = imglue = xmalloc (sizeof (arelent));
2501 rpp[1] = ba_rel = xmalloc (sizeof (arelent));
2502 rpp[2] = ea_rel = xmalloc (sizeof (arelent));
2503 rpp[3] = pea_rel = xmalloc (sizeof (arelent));
2504 rpp[4] = 0;
2505
2506 /* stick the toc reload instruction in the glue reloc */
2507 bfd_put_32(abfd, ppc_glue_insn, (char *) &imglue->address);
2508
2509 imglue->addend = 0;
2510 imglue->howto = bfd_reloc_type_lookup (abfd,
2511 BFD_RELOC_32_GOTOFF);
2512 imglue->sym_ptr_ptr = fn_pp;
2513
2514 ba_rel->address = 0;
2515 ba_rel->addend = 0;
2516 ba_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2517 ba_rel->sym_ptr_ptr = fn_pp;
2518
2519 bfd_put_32(abfd, 0x18, si->data + 0x04);
2520 ea_rel->address = 4;
2521 ea_rel->addend = 0;
2522 ea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2523 ea_rel->sym_ptr_ptr = fn_pp;
2524
2525 /* mark it as glue */
2526 bfd_put_32(abfd, 0x03, si->data + 0x0c);
2527
2528 /* mark the prolog end address */
2529 bfd_put_32(abfd, 0x0D, si->data + 0x10);
2530 pea_rel->address = 0x10;
2531 pea_rel->addend = 0;
2532 pea_rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2533 pea_rel->sym_ptr_ptr = fn_pp;
2534
2535 sec->orelocation = rpp;
2536 sec->reloc_count = 4;
2537 break;
2538 }
2539 case RDATA:
2540 /* Each external function in a PowerPC PE file has a two word
2541 descriptor consisting of:
2542 1. The address of the code.
2543 2. The address of the appropriate .toc
2544 We use relocs to build this.
2545 */
2546
2547 si->size = 8;
2548 si->data = xmalloc (8);
2549 memset (si->data, 0, si->size);
2550
2551 rpp = xmalloc (sizeof (arelent *) * 3);
2552 rpp[0] = rel = xmalloc (sizeof (arelent));
2553 rpp[1] = xmalloc (sizeof (arelent));
2554 rpp[2] = 0;
2555
2556 rel->address = 0;
2557 rel->addend = 0;
2558 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2559 rel->sym_ptr_ptr = fn_pp;
2560
2561 rel = rpp[1];
2562
2563 rel->address = 4;
2564 rel->addend = 0;
2565 rel->howto = bfd_reloc_type_lookup (abfd, BFD_RELOC_32);
2566 rel->sym_ptr_ptr = toc_pp;
2567
2568 sec->orelocation = rpp;
2569 sec->reloc_count = 2;
2570 break;
2571#endif /* DLLTOOL_PPC */
2572 }
2573 }
2574
2575 {
2576 bfd_vma vma = 0;
2577 /* Size up all the sections */
2578 for (i = 0; i < NSECS; i++)
2579 {
2580 sinfo *si = secdata + i;
2581
2582 bfd_set_section_size (abfd, si->sec, si->size);
2583 bfd_set_section_vma (abfd, si->sec, vma);
2584
2585/* vma += si->size;*/
2586 }
2587 }
2588 /* Write them out */
2589 for (i = 0; i < NSECS; i++)
2590 {
2591 sinfo *si = secdata + i;
2592
2593 if (i == IDATA5 && no_idata5)
2594 continue;
2595
2596 if (i == IDATA4 && no_idata4)
2597 continue;
2598
2599 bfd_set_section_contents (abfd, si->sec,
2600 si->data, 0,
2601 si->size);
2602 }
2603
2604 bfd_set_symtab (abfd, ptrs, oidx);
2605 bfd_close (abfd);
49c24507 2606 abfd = bfd_openr (outname, HOW_BFD_READ_TARGET);
252b5132
RH		 2607 return abfd;
2608 }
2609#endif
2610}
2611
2612static bfd *
2613make_head ()
2614{
bb0cb4db 2615 FILE *f = fopen (TMP_HEAD_S, FOPEN_WT);
252b5132 2616
661016bb
NC		 2617 if (f == NULL)
2618 {
2619 fatal (_("failed to open temporary head file: %s"), TMP_HEAD_S);
2620 return NULL;
2621 }
2622
252b5132
RH		 2623 fprintf (f, "%s IMAGE_IMPORT_DESCRIPTOR\n", ASM_C);
2624 fprintf (f, "\t.section .idata$2\n");
2625
2626 fprintf(f,"\t%s\t%s\n", ASM_GLOBAL,head_label);
2627
2628 fprintf (f, "%s:\n", head_label);
2629
2630 fprintf (f, "\t%shname%s\t%sPtr to image import by name list\n",
2631 ASM_RVA_BEFORE, ASM_RVA_AFTER, ASM_C);
2632
2633 fprintf (f, "\t%sthis should be the timestamp, but NT sometimes\n", ASM_C);
2634 fprintf (f, "\t%sdoesn't load DLLs when this is set.\n", ASM_C);
2635 fprintf (f, "\t%s\t0\t%s loaded time\n", ASM_LONG, ASM_C);
2636 fprintf (f, "\t%s\t0\t%s Forwarder chain\n", ASM_LONG, ASM_C);
2637 fprintf (f, "\t%s__%s_iname%s\t%s imported dll's name\n",
2638 ASM_RVA_BEFORE,
2639 imp_name_lab,
2640 ASM_RVA_AFTER,
2641 ASM_C);
2642 fprintf (f, "\t%sfthunk%s\t%s pointer to firstthunk\n",
2643 ASM_RVA_BEFORE,
2644 ASM_RVA_AFTER, ASM_C);
2645
2646 fprintf (f, "%sStuff for compatibility\n", ASM_C);
2647
2648 if (!no_idata5)
2649 {
2650 fprintf (f, "\t.section\t.idata$5\n");
2651 fprintf (f, "\t%s\t0\n", ASM_LONG);
2652 fprintf (f, "fthunk:\n");
2653 }
661016bb 2654
252b5132
RH		 2655 if (!no_idata4)
2656 {
2657 fprintf (f, "\t.section\t.idata$4\n");
2658
2659 fprintf (f, "\t%s\t0\n", ASM_LONG);
2660 fprintf (f, "\t.section .idata$4\n");
2661 fprintf (f, "hname:\n");
2662 }
661016bb 2663
252b5132
RH		 2664 fclose (f);
2665
49c24507 2666 assemble_file (TMP_HEAD_S, TMP_HEAD_O);
252b5132 2667
49c24507 2668 return bfd_openr (TMP_HEAD_O, HOW_BFD_READ_TARGET);
252b5132
RH		 2669}
2670
2671static bfd *
2672make_tail ()
2673{
bb0cb4db 2674 FILE *f = fopen (TMP_TAIL_S, FOPEN_WT);
252b5132 2675
661016bb
NC		 2676 if (f == NULL)
2677 {
2678 fatal (_("failed to open temporary tail file: %s"), TMP_TAIL_S);
2679 return NULL;
2680 }
2681
252b5132
RH		 2682 if (!no_idata4)
2683 {
2684 fprintf (f, "\t.section .idata$4\n");
2685 fprintf (f, "\t%s\t0\n", ASM_LONG);
2686 }
661016bb 2687
252b5132
RH		 2688 if (!no_idata5)
2689 {
2690 fprintf (f, "\t.section .idata$5\n");
2691 fprintf (f, "\t%s\t0\n", ASM_LONG);
2692 }
2693
2694#ifdef DLLTOOL_PPC
2695 /* Normally, we need to see a null descriptor built in idata$3 to
2696 act as the terminator for the list. The ideal way, I suppose,
2697 would be to mark this section as a comdat type 2 section, so
2698 only one would appear in the final .exe (if our linker supported
2699 comdat, that is) or cause it to be inserted by something else (say
2700 crt0)
2701 */
2702
2703 fprintf (f, "\t.section .idata$3\n");
2704 fprintf (f, "\t%s\t0\n", ASM_LONG);
2705 fprintf (f, "\t%s\t0\n", ASM_LONG);
2706 fprintf (f, "\t%s\t0\n", ASM_LONG);
2707 fprintf (f, "\t%s\t0\n", ASM_LONG);
2708 fprintf (f, "\t%s\t0\n", ASM_LONG);
2709#endif
2710
2711#ifdef DLLTOOL_PPC
2712 /* Other PowerPC NT compilers use idata$6 for the dllname, so I
2713 do too. Original, huh? */
2714 fprintf (f, "\t.section .idata$6\n");
2715#else
2716 fprintf (f, "\t.section .idata$7\n");
2717#endif
2718
2719 fprintf (f, "\t%s\t__%s_iname\n", ASM_GLOBAL, imp_name_lab);
2720 fprintf (f, "__%s_iname:\t%s\t\"%s\"\n",
2721 imp_name_lab, ASM_TEXT, dll_name);
2722
2723 fclose (f);
2724
49c24507 2725 assemble_file (TMP_TAIL_S, TMP_TAIL_O);
252b5132 2726
49c24507 2727 return bfd_openr (TMP_TAIL_O, HOW_BFD_READ_TARGET);
252b5132
RH		 2728}
2729
2730static void
2731gen_lib_file ()
2732{
2733 int i;
2734 export_type *exp;
2735 bfd *ar_head;
2736 bfd *ar_tail;
2737 bfd *outarch;
2738 bfd * head = 0;
2739
2740 unlink (imp_name);
2741
49c24507 2742 outarch = bfd_openw (imp_name, HOW_BFD_WRITE_TARGET);
252b5132
RH		 2743
2744 if (!outarch)
2745 /* xgettext:c-format */
2746 fatal (_("Can't open .lib file: %s"), imp_name);
2747
2748 /* xgettext:c-format */
37cc8ec1 2749 inform (_("Creating library file: %s"), imp_name);
252b5132
RH		 2750
2751 bfd_set_format (outarch, bfd_archive);
2752 outarch->has_armap = 1;
2753
2754 /* Work out a reasonable size of things to put onto one line. */
2755
2756 ar_head = make_head ();
2757 ar_tail = make_tail();
2758
2759 if (ar_head == NULL || ar_tail == NULL)
2760 return;
2761
2762 for (i = 0; (exp = d_exports_lexically[i]); i++)
2763 {
2764 bfd *n = make_one_lib_file (exp, i);
2765 n->next = head;
2766 head = n;
2767 }
2768
2769 /* Now stick them all into the archive */
2770
2771 ar_head->next = head;
2772 ar_tail->next = ar_head;
2773 head = ar_tail;
2774
2775 if (! bfd_set_archive_head (outarch, head))
2776 bfd_fatal ("bfd_set_archive_head");
2777
2778 if (! bfd_close (outarch))
2779 bfd_fatal (imp_name);
2780
2781 while (head != NULL)
2782 {
2783 bfd *n = head->next;
2784 bfd_close (head);
2785 head = n;
2786 }
2787
2788 /* Delete all the temp files */
2789
2790 if (dontdeltemps == 0)
2791 {
2792 unlink (TMP_HEAD_O);
2793 unlink (TMP_HEAD_S);
2794 unlink (TMP_TAIL_O);
2795 unlink (TMP_TAIL_S);
2796 }
2797
2798 if (dontdeltemps < 2)
2799 {
bb0cb4db
ILT		 2800 char *name;
2801
2802 name = (char *) alloca (sizeof TMP_STUB + 10);
252b5132
RH		 2803 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
2804 {
bb0cb4db
ILT		 2805 sprintf (name, "%s%05d.o", TMP_STUB, i);
2806 if (unlink (name) < 0)
252b5132 2807 /* xgettext:c-format */
37cc8ec1 2808 non_fatal (_("cannot delete %s: %s"), name, strerror (errno));
252b5132
RH		 2809 }
2810 }
2811
2812 inform (_("Created lib file"));
2813}
2814
2815/**********************************************************************/
2816
2817/* Run through the information gathered from the .o files and the
2818 .def file and work out the best stuff */
2819static int
2820pfunc (a, b)
2821 const void *a;
2822 const void *b;
2823{
2824 export_type *ap = *(export_type **) a;
2825 export_type *bp = *(export_type **) b;
2826 if (ap->ordinal == bp->ordinal)
2827 return 0;
2828
2829 /* unset ordinals go to the bottom */
2830 if (ap->ordinal == -1)
2831 return 1;
2832 if (bp->ordinal == -1)
2833 return -1;
2834 return (ap->ordinal - bp->ordinal);
2835}
2836
2837static int
2838nfunc (a, b)
2839 const void *a;
2840 const void *b;
2841{
2842 export_type *ap = *(export_type **) a;
2843 export_type *bp = *(export_type **) b;
2844
2845 return (strcmp (ap->name, bp->name));
2846}
2847
2848static void
2849remove_null_names (ptr)
2850 export_type **ptr;
2851{
2852 int src;
2853 int dst;
2854 for (dst = src = 0; src < d_nfuncs; src++)
2855 {
2856 if (ptr[src])
2857 {
2858 ptr[dst] = ptr[src];
2859 dst++;
2860 }
2861 }
2862 d_nfuncs = dst;
2863}
2864
2865static void
2866dtab (ptr)
5ea695ed
NC		 2867 export_type ** ptr
2868#ifndef SACDEBUG
2869ATTRIBUTE_UNUSED
2870#endif
2871 ;
252b5132
RH		 2872{
2873#ifdef SACDEBUG
2874 int i;
2875 for (i = 0; i < d_nfuncs; i++)
2876 {
2877 if (ptr[i])
2878 {
2879 printf ("%d %s @ %d %s%s%s\n",
2880 i, ptr[i]->name, ptr[i]->ordinal,
2881 ptr[i]->noname ? "NONAME " : "",
2882 ptr[i]->constant ? "CONSTANT" : "",
2883 ptr[i]->data ? "DATA" : "");
2884 }
2885 else
2886 printf ("empty\n");
2887 }
2888#endif
2889}
2890
2891static void
2892process_duplicates (d_export_vec)
2893 export_type **d_export_vec;
2894{
2895 int more = 1;
2896 int i;
2897 while (more)
2898 {
2899
2900 more = 0;
2901 /* Remove duplicates */
2902 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), nfunc);
2903
2904 dtab (d_export_vec);
2905 for (i = 0; i < d_nfuncs - 1; i++)
2906 {
2907 if (strcmp (d_export_vec[i]->name,
2908 d_export_vec[i + 1]->name) == 0)
2909 {
2910
2911 export_type *a = d_export_vec[i];
2912 export_type *b = d_export_vec[i + 1];
2913
2914 more = 1;
2915
2916 /* xgettext:c-format */
37cc8ec1 2917 inform (_("Warning, ignoring duplicate EXPORT %s %d,%d"),
252b5132
RH		 2918 a->name, a->ordinal, b->ordinal);
2919
2920 if (a->ordinal != -1
2921 && b->ordinal != -1)
2922 /* xgettext:c-format */
2923 fatal (_("Error, duplicate EXPORT with oridinals: %s"),
2924 a->name);
2925
2926 /* Merge attributes */
2927 b->ordinal = a->ordinal > 0 ? a->ordinal : b->ordinal;
2928 b->constant |= a->constant;
2929 b->noname |= a->noname;
2930 b->data |= a->data;
2931 d_export_vec[i] = 0;
2932 }
2933
2934 dtab (d_export_vec);
2935 remove_null_names (d_export_vec);
2936 dtab (d_export_vec);
2937 }
2938 }
2939
2940
2941 /* Count the names */
2942 for (i = 0; i < d_nfuncs; i++)
2943 {
2944 if (!d_export_vec[i]->noname)
2945 d_named_nfuncs++;
2946 }
2947}
2948
2949static void
2950fill_ordinals (d_export_vec)
2951 export_type **d_export_vec;
2952{
2953 int lowest = -1;
2954 int i;
2955 char *ptr;
2956 int size = 65536;
2957
2958 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
2959
2960 /* fill in the unset ordinals with ones from our range */
2961
2962 ptr = (char *) xmalloc (size);
2963
2964 memset (ptr, 0, size);
2965
2966 /* Mark in our large vector all the numbers that are taken */
2967 for (i = 0; i < d_nfuncs; i++)
2968 {
2969 if (d_export_vec[i]->ordinal != -1)
2970 {
2971 ptr[d_export_vec[i]->ordinal] = 1;
2972 if (lowest == -1 || d_export_vec[i]->ordinal < lowest)
2973 {
2974 lowest = d_export_vec[i]->ordinal;
2975 }
2976 }
2977 }
2978
2979 /* Start at 1 for compatibility with MS toolchain. */
2980 if (lowest == -1)
2981 lowest = 1;
2982
2983 /* Now fill in ordinals where the user wants us to choose. */
2984 for (i = 0; i < d_nfuncs; i++)
2985 {
2986 if (d_export_vec[i]->ordinal == -1)
2987 {
2988 register int j;
2989
2990 /* First try within or after any user supplied range. */
2991 for (j = lowest; j < size; j++)
2992 if (ptr[j] == 0)
2993 {
2994 ptr[j] = 1;
2995 d_export_vec[i]->ordinal = j;
2996 goto done;
2997 }
2998
2999 /* Then try before the range. */
3000 for (j = lowest; j >0; j--)
3001 if (ptr[j] == 0)
3002 {
3003 ptr[j] = 1;
3004 d_export_vec[i]->ordinal = j;
3005 goto done;
3006 }
3007 done:;
3008 }
3009 }
3010
3011 free (ptr);
3012
3013 /* And resort */
3014
3015 qsort (d_export_vec, d_nfuncs, sizeof (export_type *), pfunc);
3016
3017 /* Work out the lowest and highest ordinal numbers. */
3018 if (d_nfuncs)
3019 {
3020 if (d_export_vec[0])
3021 d_low_ord = d_export_vec[0]->ordinal;
3022 if (d_export_vec[d_nfuncs-1])
3023 d_high_ord = d_export_vec[d_nfuncs-1]->ordinal;
3024 }
3025}
3026
3027static int
3028alphafunc (av,bv)
3029 const void *av;
3030 const void *bv;
3031{
3032 const export_type **a = (const export_type **) av;
3033 const export_type **b = (const export_type **) bv;
3034
3035 return strcmp ((*a)->name, (*b)->name);
3036}
3037
3038static void
3039mangle_defs ()
3040{
3041 /* First work out the minimum ordinal chosen */
3042
3043 export_type *exp;
3044
3045 int i;
3046 int hint = 0;
3047 export_type **d_export_vec
3048 = (export_type **) xmalloc (sizeof (export_type *) * d_nfuncs);
3049
3050 inform (_("Processing definitions"));
3051
3052 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3053 {
3054 d_export_vec[i] = exp;
3055 }
3056
3057 process_duplicates (d_export_vec);
3058 fill_ordinals (d_export_vec);
3059
3060 /* Put back the list in the new order */
3061 d_exports = 0;
3062 for (i = d_nfuncs - 1; i >= 0; i--)
3063 {
3064 d_export_vec[i]->next = d_exports;
3065 d_exports = d_export_vec[i];
3066 }
3067
3068 /* Build list in alpha order */
3069 d_exports_lexically = (export_type **)
3070 xmalloc (sizeof (export_type *) * (d_nfuncs + 1));
3071
3072 for (i = 0, exp = d_exports; exp; i++, exp = exp->next)
3073 {
3074 d_exports_lexically[i] = exp;
3075 }
3076 d_exports_lexically[i] = 0;
3077
3078 qsort (d_exports_lexically, i, sizeof (export_type *), alphafunc);
3079
3080 /* Fill exp entries with their hint values */
3081
3082 for (i = 0; i < d_nfuncs; i++)
3083 {
3084 if (!d_exports_lexically[i]->noname || show_allnames)
3085 d_exports_lexically[i]->hint = hint++;
3086 }
3087
3088 inform (_("Processed definitions"));
3089}
3090
3091/**********************************************************************/
3092
3093static void
3094usage (file, status)
3095 FILE *file;
3096 int status;
3097{
3098 /* xgetext:c-format */
3099 fprintf (file, _("Usage %s <options> <object-files>\n"), program_name);
3100 /* xgetext:c-format */
661016bb 3101 fprintf (file, _(" -m --machine <machine> Create as DLL for <machine>. [default: %s]\n"), mname);
7e301c9c 3102 fprintf (file, _(" possible <machine>: arm[_interwork], i386, mcore[-elf]{-le|-be}, ppc, thumb\n"));
252b5132
RH		 3103 fprintf (file, _(" -e --output-exp <outname> Generate an export file.\n"));
3104 fprintf (file, _(" -l --output-lib <outname> Generate an interface library.\n"));
3105 fprintf (file, _(" -a --add-indirect Add dll indirects to export file.\n"));
3106 fprintf (file, _(" -D --dllname <name> Name of input dll to put into interface lib.\n"));
3107 fprintf (file, _(" -d --input-def <deffile> Name of .def file to be read in.\n"));
3108 fprintf (file, _(" -z --output-def <deffile> Name of .def file to be created.\n"));
661016bb
NC		 3109 fprintf (file, _(" --export-all-symbols Export all symbols to .def\n"));
3110 fprintf (file, _(" --no-export-all-symbols Only export listed symbols\n"));
3111 fprintf (file, _(" --exclude-symbols <list> Don't export <list>\n"));
3112 fprintf (file, _(" --no-default-excludes Clear default exclude symbols\n"));
252b5132
RH		 3113 fprintf (file, _(" -b --base-file <basefile> Read linker generated base file.\n"));
3114 fprintf (file, _(" -x --no-idata4 Don't generate idata$4 section.\n"));
3115 fprintf (file, _(" -c --no-idata5 Don't generate idata$5 section.\n"));
3116 fprintf (file, _(" -U --add-underscore Add underscores to symbols in interface library.\n"));
3117 fprintf (file, _(" -k --kill-at Kill @<n> from exported names.\n"));
3118 fprintf (file, _(" -A --add-stdcall-alias Add aliases without @<n>.\n"));
3119 fprintf (file, _(" -S --as <name> Use <name> for assembler.\n"));
3120 fprintf (file, _(" -f --as-flags <flags> Pass <flags> to the assembler.\n"));
5f0f29c3 3121 fprintf (file, _(" -C --compat-implib Create backward compatible import library.\n"));
252b5132
RH		 3122 fprintf (file, _(" -n --no-delete Keep temp files (repeat for extra preservation).\n"));
3123 fprintf (file, _(" -v --verbose Be verbose.\n"));
3124 fprintf (file, _(" -V --version Display the program version.\n"));
3125 fprintf (file, _(" -h --help Display this information.\n"));
49e315b1
NC		 3126#ifdef DLLTOOL_MCORE_ELF
3127 fprintf (file, _(" -M --mcore-elf <outname> Process mcore-elf object files into <outname>.\n"));
3128 fprintf (file, _(" -L --linker <name> Use <name> as the linker.\n"));
3129 fprintf (file, _(" -F --linker-flags <flags> Pass <flags> to the linker.\n"));
3130#endif
252b5132
RH		 3131 exit (status);
3132}
3133
3134#define OPTION_EXPORT_ALL_SYMS 150
3135#define OPTION_NO_EXPORT_ALL_SYMS (OPTION_EXPORT_ALL_SYMS + 1)
3136#define OPTION_EXCLUDE_SYMS (OPTION_NO_EXPORT_ALL_SYMS + 1)
3137#define OPTION_NO_DEFAULT_EXCLUDES (OPTION_EXCLUDE_SYMS + 1)
252b5132
RH		 3138
3139static const struct option long_options[] =
3140{
3141 {"no-delete", no_argument, NULL, 'n'},
3142 {"dllname", required_argument, NULL, 'D'},
49e315b1
NC		 3143 {"no-idata4", no_argument, NULL, 'x'},
3144 {"no-idata5", no_argument, NULL, 'c'},
252b5132
RH		 3145 {"output-exp", required_argument, NULL, 'e'},
3146 {"output-def", required_argument, NULL, 'z'},
3147 {"export-all-symbols", no_argument, NULL, OPTION_EXPORT_ALL_SYMS},
3148 {"no-export-all-symbols", no_argument, NULL, OPTION_NO_EXPORT_ALL_SYMS},
3149 {"exclude-symbols", required_argument, NULL, OPTION_EXCLUDE_SYMS},
3150 {"no-default-excludes", no_argument, NULL, OPTION_NO_DEFAULT_EXCLUDES},
3151 {"output-lib", required_argument, NULL, 'l'},
3152 {"def", required_argument, NULL, 'd'}, /* for compatiblity with older versions */
3153 {"input-def", required_argument, NULL, 'd'},
3154 {"add-underscore", no_argument, NULL, 'U'},
3155 {"kill-at", no_argument, NULL, 'k'},
3156 {"add-stdcall-alias", no_argument, NULL, 'A'},
3157 {"verbose", no_argument, NULL, 'v'},
3158 {"version", no_argument, NULL, 'V'},
3159 {"help", no_argument, NULL, 'h'},
3160 {"machine", required_argument, NULL, 'm'},
3161 {"add-indirect", no_argument, NULL, 'a'},
3162 {"base-file", required_argument, NULL, 'b'},
3163 {"as", required_argument, NULL, 'S'},
3164 {"as-flags", required_argument, NULL, 'f'},
49e315b1 3165 {"mcore-elf", required_argument, NULL, 'M'},
5f0f29c3 3166 {"compat-implib", no_argument, NULL, 'C'},
5ea695ed 3167 {NULL,0,NULL,0}
252b5132
RH		 3168};
3169
3170int
3171main (ac, av)
3172 int ac;
3173 char **av;
3174{
3175 int c;
3176 int i;
3177 char *firstarg = 0;
3178 program_name = av[0];
3179 oav = av;
3180
3181#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
3182 setlocale (LC_MESSAGES, "");
3183#endif
3184 bindtextdomain (PACKAGE, LOCALEDIR);
3185 textdomain (PACKAGE);
3186
49e315b1
NC		 3187 while ((c = getopt_long (ac, av,
3188#ifdef DLLTOOL_MCORE_ELF
5f0f29c3 3189 "m:e:l:aD:d:z:b:xcCuUkAS:f:nvVhM:L:F:",
49e315b1 3190#else
5f0f29c3 3191 "m:e:l:aD:d:z:b:xcCuUkAS:f:nvVh",
49e315b1 3192#endif
252b5132
RH		 3193 long_options, 0))
3194 != EOF)
3195 {
3196 switch (c)
3197 {
252b5132
RH		 3198 case OPTION_EXPORT_ALL_SYMS:
3199 export_all_symbols = true;
3200 break;
3201 case OPTION_NO_EXPORT_ALL_SYMS:
3202 export_all_symbols = false;
3203 break;
3204 case OPTION_EXCLUDE_SYMS:
3205 add_excludes (optarg);
3206 break;
3207 case OPTION_NO_DEFAULT_EXCLUDES:
3208 do_default_excludes = false;
3209 break;
49e315b1
NC		 3210 case 'x':
3211 no_idata4 = 1;
3212 break;
3213 case 'c':
3214 no_idata5 = 1;
3215 break;
252b5132
RH		 3216 case 'S':
3217 as_name = optarg;
3218 break;
3219 case 'f':
3220 as_flags = optarg;
3221 break;
3222
3223 /* ignored for compatibility */
3224 case 'u':
3225 break;
3226 case 'a':
3227 add_indirect = 1;
3228 break;
3229 case 'z':
3230 output_def = fopen (optarg, FOPEN_WT);
3231 break;
3232 case 'D':
3233 dll_name = optarg;
3234 break;
3235 case 'l':
3236 imp_name = optarg;
3237 break;
3238 case 'e':
3239 exp_name = optarg;
3240 break;
3241 case 'h':
3242 usage (stdout, 0);
3243 break;
3244 case 'm':
3245 mname = optarg;
3246 break;
3247 case 'v':
3248 verbose = 1;
3249 break;
3250 case 'V':
3251 print_version (program_name);
3252 break;
252b5132
RH		 3253 case 'U':
3254 add_underscore = 1;
3255 break;
3256 case 'k':
3257 killat = 1;
3258 break;
3259 case 'A':
3260 add_stdcall_alias = 1;
3261 break;
3262 case 'd':
3263 def_file = optarg;
3264 break;
3265 case 'n':
3266 dontdeltemps++;
3267 break;
3268 case 'b':
3269 base_file = fopen (optarg, FOPEN_RB);
3270
3271 if (!base_file)
3272 /* xgettext:c-format */
3273 fatal (_("Unable to open base-file: %s"), optarg);
3274
3275 break;
49e315b1
NC		 3276#ifdef DLLTOOL_MCORE_ELF
3277 case 'M':
3278 mcore_elf_out_file = optarg;
3279 break;
3280 case 'L':
3281 mcore_elf_linker = optarg;
3282 break;
3283 case 'F':
3284 mcore_elf_linker_flags = optarg;
3285 break;
3286#endif
5f0f29c3
NC		 3287 case 'C':
3288 create_compat_implib = 1;
3289 break;
252b5132
RH		 3290 default:
3291 usage (stderr, 1);
3292 break;
3293 }
3294 }
3295
3296 for (i = 0; mtable[i].type; i++)
762100ed
NC		 3297 if (strcmp (mtable[i].type, mname) == 0)
3298 break;
252b5132
RH		 3299
3300 if (!mtable[i].type)
3301 /* xgettext:c-format */
3302 fatal (_("Machine '%s' not supported"), mname);
3303
3304 machine = i;
3305
252b5132
RH		 3306 if (!dll_name && exp_name)
3307 {
3308 int len = strlen (exp_name) + 5;
3309 dll_name = xmalloc (len);
3310 strcpy (dll_name, exp_name);
3311 strcat (dll_name, ".dll");
3312 }
3313
49e315b1
NC		 3314 if (as_name == NULL)
3315 as_name = deduce_name ("as");
3316
252b5132
RH		 3317 /* Don't use the default exclude list if we're reading only the
3318 symbols in the .drectve section. The default excludes are meant
3319 to avoid exporting DLL entry point and Cygwin32 impure_ptr. */
3320 if (! export_all_symbols)
3321 do_default_excludes = false;
3322
3323 if (do_default_excludes)
3324 set_default_excludes ();
3325
3326 if (def_file)
3327 process_def_file (def_file);
3328
3329 while (optind < ac)
3330 {
3331 if (!firstarg)
3332 firstarg = av[optind];
3333 scan_obj_file (av[optind]);
3334 optind++;
3335 }
3336
3337 mangle_defs ();
3338
3339 if (exp_name)
3340 gen_exp_file ();
3341
3342 if (imp_name)
3343 {
3344 /* Make imp_name safe for use as a label. */
3345 char *p;
3346
3347 imp_name_lab = xstrdup (imp_name);
3348 for (p = imp_name_lab; *p; p++)
3349 {
3350 if (!isalpha ((unsigned char) *p) && !isdigit ((unsigned char) *p))
3351 *p = '_';
3352 }
3353 head_label = make_label("_head_", imp_name_lab);
3354 gen_lib_file ();
3355 }
3356
3357 if (output_def)
3358 gen_def_file ();
762100ed 3359
49e315b1
NC		 3360#ifdef DLLTOOL_MCORE_ELF
3361 if (mcore_elf_out_file)
3362 mcore_elf_gen_out_file ();
3363#endif
3364
252b5132
RH		 3365 return 0;
3366}
49e315b1 3367
bb0cb4db
ILT		 3368/* Look for the program formed by concatenating PROG_NAME and the
3369 string running from PREFIX to END_PREFIX. If the concatenated
3370 string contains a '/', try appending EXECUTABLE_SUFFIX if it is
2481e6a2 3371 appropriate. */
bb0cb4db
ILT		 3372
3373static char *
3374look_for_prog (prog_name, prefix, end_prefix)
3375 const char *prog_name;
3376 const char *prefix;
3377 int end_prefix;
3378{
3379 struct stat s;
3380 char *cmd;
3381
3382 cmd = xmalloc (strlen (prefix)
3383 + strlen (prog_name)
2481e6a2 3384#ifdef HAVE_EXECUTABLE_SUFFIX
bb0cb4db
ILT		 3385 + strlen (EXECUTABLE_SUFFIX)
3386#endif
3387 + 10);
3388 strcpy (cmd, prefix);
3389
3390 sprintf (cmd + end_prefix, "%s", prog_name);
3391
3392 if (strchr (cmd, '/') != NULL)
3393 {
3394 int found;
3395
3396 found = (stat (cmd, &s) == 0
2481e6a2 3397#ifdef HAVE_EXECUTABLE_SUFFIX
bb0cb4db
ILT		 3398 || stat (strcat (cmd, EXECUTABLE_SUFFIX), &s) == 0
3399#endif
3400 );
3401
3402 if (! found)
3403 {
3404 /* xgettext:c-format */
3405 inform (_("Tried file: %s"), cmd);
3406 free (cmd);
3407 return NULL;
3408 }
3409 }
3410
3411 /* xgettext:c-format */
3412 inform (_("Using file: %s"), cmd);
3413
3414 return cmd;
3415}
3416
49e315b1
NC		 3417/* Deduce the name of the program we are want to invoke.
3418 PROG_NAME is the basic name of the program we want to run,
3419 eg "as" or "ld". The catch is that we might want actually
bb0cb4db
ILT		 3420 run "i386-pe-as" or "ppc-pe-ld".
3421
3422 If argv[0] contains the full path, then try to find the program
3423 in the same place, with and then without a target-like prefix.
3424
3425 Given, argv[0] = /usr/local/bin/i586-cygwin32-dlltool,
3426 deduce_name("as") uses the following search order:
3427
3428 /usr/local/bin/i586-cygwin32-as
3429 /usr/local/bin/as
3430 as
3431
3432 If there's an EXECUTABLE_SUFFIX, it'll use that as well; for each
3433 name, it'll try without and then with EXECUTABLE_SUFFIX.
3434
3435 Given, argv[0] = i586-cygwin32-dlltool, it will not even try "as"
3436 as the fallback, but rather return i586-cygwin32-as.
3437
3438 Oh, and given, argv[0] = dlltool, it'll return "as".
3439
3440 Returns a dynamically allocated string. */
3441
49e315b1 3442static char *
bb0cb4db
ILT		 3443deduce_name (prog_name)
3444 const char *prog_name;
49e315b1 3445{
bb0cb4db
ILT		 3446 char *cmd;
3447 char *dash, *slash, *cp;
49e315b1 3448
bb0cb4db
ILT		 3449 dash = NULL;
3450 slash = NULL;
3451 for (cp = program_name; *cp != '\0'; ++cp)
3452 {
3453 if (*cp == '-')
3454 dash = cp;
3455 if (
3456#if defined(__DJGPP__) || defined (__CYGWIN__) || defined(__WIN32__)
3457 *cp == ':' || *cp == '\\' ||
3458#endif
3459 *cp == '/')
3460 {
3461 slash = cp;
3462 dash = NULL;
3463 }
3464 }
49e315b1 3465
bb0cb4db 3466 cmd = NULL;
49e315b1 3467
bb0cb4db
ILT		 3468 if (dash != NULL)
3469 {
3470 /* First, try looking for a prefixed PROG_NAME in the
3471 PROGRAM_NAME directory, with the same prefix as PROGRAM_NAME. */
3472 cmd = look_for_prog (prog_name, program_name, dash - program_name + 1);
3473 }
49e315b1 3474
bb0cb4db
ILT		 3475 if (slash != NULL && cmd == NULL)
3476 {
3477 /* Next, try looking for a PROG_NAME in the same directory as
3478 that of this program. */
3479 cmd = look_for_prog (prog_name, program_name, slash - program_name + 1);
3480 }
3481
3482 if (cmd == NULL)
3483 {
3484 /* Just return PROG_NAME as is. */
3485 cmd = xstrdup (prog_name);
3486 }
3487
3488 return cmd;
49e315b1
NC		 3489}
3490
3491#ifdef DLLTOOL_MCORE_ELF
3492typedef struct fname_cache
3493{
3494 char * filename;
3495 struct fname_cache * next;
3496}
3497fname_cache;
3498
3499static fname_cache fnames;
3500
3501static void
3502mcore_elf_cache_filename (char * filename)
3503{
3504 fname_cache * ptr;
3505
3506 ptr = & fnames;
3507
3508 while (ptr->next != NULL)
3509 ptr = ptr->next;
3510
3511 ptr->filename = filename;
3512 ptr->next = (fname_cache *) malloc (sizeof (fname_cache));
3513 if (ptr->next != NULL)
3514 ptr->next->next = NULL;
3515}
3516
762100ed
NC		 3517#define MCORE_ELF_TMP_OBJ "mcoreelf.o"
3518#define MCORE_ELF_TMP_EXP "mcoreelf.exp"
3519#define MCORE_ELF_TMP_LIB "mcoreelf.lib"
3520
49e315b1
NC		 3521static void
3522mcore_elf_gen_out_file (void)
3523{
3524 fname_cache * ptr;
bb0cb4db 3525 dyn_string_t ds;
49e315b1
NC		 3526
3527 /* Step one. Run 'ld -r' on the input object files in order to resolve
3528 any internal references and to generate a single .exports section. */
3529 ptr = & fnames;
3530
bb0cb4db
ILT		 3531 ds = dyn_string_new (100);
3532 dyn_string_append (ds, "-r ");
49e315b1
NC		 3533
3534 if (mcore_elf_linker_flags != NULL)
bb0cb4db 3535 dyn_string_append (ds, mcore_elf_linker_flags);
49e315b1
NC		 3536
3537 while (ptr->next != NULL)
3538 {
bb0cb4db
ILT		 3539 dyn_string_append (ds, ptr->filename);
3540 dyn_string_append (ds, " ");
49e315b1
NC		 3541
3542 ptr = ptr->next;
3543 }
3544
bb0cb4db
ILT		 3545 dyn_string_append (ds, "-o ");
3546 dyn_string_append (ds, MCORE_ELF_TMP_OBJ);
49e315b1
NC		 3547
3548 if (mcore_elf_linker == NULL)
3549 mcore_elf_linker = deduce_name ("ld");
3550
bb0cb4db
ILT		 3551 run (mcore_elf_linker, ds->s);
3552
3553 dyn_string_delete (ds);
49e315b1
NC		 3554
3555 /* Step two. Create a .exp file and a .lib file from the temporary file.
3556 Do this by recursively invoking dlltool....*/
bb0cb4db
ILT		 3557 ds = dyn_string_new (100);
3558
3559 dyn_string_append (ds, "-S ");
3560 dyn_string_append (ds, as_name);
49e315b1 3561
bb0cb4db
ILT		 3562 dyn_string_append (ds, " -e ");
3563 dyn_string_append (ds, MCORE_ELF_TMP_EXP);
3564 dyn_string_append (ds, " -l ");
3565 dyn_string_append (ds, MCORE_ELF_TMP_LIB);
3566 dyn_string_append (ds, " " );
3567 dyn_string_append (ds, MCORE_ELF_TMP_OBJ);
49e315b1
NC		 3568
3569 if (verbose)
bb0cb4db 3570 dyn_string_append (ds, " -v");
49e315b1
NC		 3571
3572 if (dontdeltemps)
762100ed 3573 {
bb0cb4db 3574 dyn_string_append (ds, " -n");
49e315b1 3575
762100ed 3576 if (dontdeltemps > 1)
bb0cb4db 3577 dyn_string_append (ds, " -n");
762100ed 3578 }
49e315b1
NC		 3579
3580 /* XXX - FIME: ought to check/copy other command line options as well. */
3581
bb0cb4db
ILT		 3582 run (program_name, ds->s);
3583
3584 dyn_string_delete (ds);
49e315b1 3585
74479bd3 3586 /* Step four. Feed the .exp and object files to ld -shared to create the dll. */
bb0cb4db
ILT		 3587 ds = dyn_string_new (100);
3588
3589 dyn_string_append (ds, "-shared ");
49e315b1
NC		 3590
3591 if (mcore_elf_linker_flags)
bb0cb4db
ILT		 3592 dyn_string_append (ds, mcore_elf_linker_flags);
3593
3594 dyn_string_append (ds, " ");
3595 dyn_string_append (ds, MCORE_ELF_TMP_EXP);
3596 dyn_string_append (ds, " ");
3597 dyn_string_append (ds, MCORE_ELF_TMP_OBJ);
3598 dyn_string_append (ds, " -o ");
3599 dyn_string_append (ds, mcore_elf_out_file);
49e315b1 3600
bb0cb4db 3601 run (mcore_elf_linker, ds->s);
49e315b1 3602
bb0cb4db 3603 dyn_string_delete (ds);
762100ed
NC		 3604
3605 if (dontdeltemps == 0)
74479bd3 3606 unlink (MCORE_ELF_TMP_EXP);
762100ed
NC		 3607
3608 if (dontdeltemps < 2)
3609 unlink (MCORE_ELF_TMP_OBJ);
49e315b1
NC		 3610}
3611#endif /* DLLTOOL_MCORE_ELF */
GDB Binutils - Deliverables
This page took 0.211684 seconds and 4 git commands to generate.