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