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