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