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