ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Reserve space for the PE header at the start of the .so file. 

Store the export table inside the data section so that sections can be
properly aligned.
Build the relay function table directly in the .spec.c file.
Moved relay debugging functions to relay386.c.
This commit is contained in:
Alexandre Julliard 2000-05-10 03:48:00 +00:00
parent a1b2fc2a80
commit 246c360631
6 changed files with 490 additions and 443 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
include/builtin32.h
View File

@ -7,33 +7,21 @@
#ifndef __WINE_BUILTIN32_H #ifndef __WINE_BUILTIN32_H
#define __WINE_BUILTIN32_H #define __WINE_BUILTIN32_H
typedef void (*ENTRYPOINT32)();
typedef struct typedef struct
{ {
const char *name; /* DLL name */
const char* filename; /* DLL file name */ const char* filename; /* DLL file name */
int base; /* Ordinal base */
int nb_funcs; /* Number of functions */
int nb_names; /* Number of function names */
int nb_imports; /* Number of imported DLLs */ int nb_imports; /* Number of imported DLLs */
int fwd_size; /* Total size of forward names */ void *pe_header; /* Buffer for PE header */
const ENTRYPOINT32 *functions; /* Pointer to function table */ void *exports; /* Pointer to export directory */
const char * const *names; /* Pointer to names table */ unsigned int exports_size; /* Total size of export directory */
const unsigned short *ordinals; /* Pointer to ordinals table */
const unsigned char *args; /* Pointer to argument lengths */
const unsigned int *argtypes; /* Pointer to argument types bitmask */
const char * const *imports; /* Pointer to imports */ const char * const *imports; /* Pointer to imports */
const ENTRYPOINT32 dllentrypoint;/* Pointer to LibMain function */ void (*dllentrypoint)(); /* Pointer to entry point function */
int characteristics; int characteristics;
const void *rsrc; /* Resource descriptor */ void *rsrc; /* Resource descriptor */
} BUILTIN32_DESCRIPTOR; } BUILTIN32_DESCRIPTOR;
extern ENTRYPOINT32 BUILTIN32_GetEntryPoint( char *buffer, void *relay,
unsigned int *typemask );
extern void BUILTIN32_RegisterDLL( const BUILTIN32_DESCRIPTOR *descr ); extern void BUILTIN32_RegisterDLL( const BUILTIN32_DESCRIPTOR *descr );
extern void BUILTIN32_Unimplemented( const BUILTIN32_DESCRIPTOR *descr, extern void BUILTIN32_Unimplemented( const char *dllname, const char *funcname );
int ordinal ); extern void RELAY_SetupDLL( const char *module );
extern void BUILTIN32_SwitchRelayDebug(int onoff);
#endif /* __WINE_BUILTIN32_H */ #endif /* __WINE_BUILTIN32_H */

11
include/winnt.h
View File

@ -708,14 +708,19 @@ typedef HANDLE *PHANDLE;
".long " __ASM_NAME(#fn) "\n\t" \ ".long " __ASM_NAME(#fn) "\n\t" \
".byte " #args ", " #args ) ".byte " #args ", " #args )
#define DEFINE_REGS_ENTRYPOINT_0( name, fn ) \ #define DEFINE_REGS_ENTRYPOINT_0( name, fn ) \
extern void WINAPI name(void); \
_DEFINE_REGS_ENTRYPOINT( name, fn, 0 ) _DEFINE_REGS_ENTRYPOINT( name, fn, 0 )
#define DEFINE_REGS_ENTRYPOINT_1( name, fn, t1 ) \ #define DEFINE_REGS_ENTRYPOINT_1( name, fn, t1 ) \
extern void WINAPI name( t1 a1 ); \
_DEFINE_REGS_ENTRYPOINT( name, fn, 4 ) _DEFINE_REGS_ENTRYPOINT( name, fn, 4 )
#define DEFINE_REGS_ENTRYPOINT_2( name, fn, t1, t2 ) \ #define DEFINE_REGS_ENTRYPOINT_2( name, fn, t1, t2 ) \
extern void WINAPI name( t1 a1, t2 a2 ); \
_DEFINE_REGS_ENTRYPOINT( name, fn, 8 ) _DEFINE_REGS_ENTRYPOINT( name, fn, 8 )
#define DEFINE_REGS_ENTRYPOINT_3( name, fn, t1, t2, t3 ) \ #define DEFINE_REGS_ENTRYPOINT_3( name, fn, t1, t2, t3 ) \
extern void WINAPI name( t1 a1, t2 a2, t3 a3 ); \
_DEFINE_REGS_ENTRYPOINT( name, fn, 12 ) _DEFINE_REGS_ENTRYPOINT( name, fn, 12 )
#define DEFINE_REGS_ENTRYPOINT_4( name, fn, t1, t2, t3, t4 ) \ #define DEFINE_REGS_ENTRYPOINT_4( name, fn, t1, t2, t3, t4 ) \
extern void WINAPI name( t1 a1, t2 a2, t3 a3, t4 a4 ); \
_DEFINE_REGS_ENTRYPOINT( name, fn, 16 ) _DEFINE_REGS_ENTRYPOINT( name, fn, 16 )
#endif /* __i386__ */ #endif /* __i386__ */
@ -1619,9 +1624,9 @@ typedef struct _IMAGE_EXPORT_DIRECTORY {
DWORD Base; DWORD Base;
DWORD NumberOfFunctions; DWORD NumberOfFunctions;
DWORD NumberOfNames; DWORD NumberOfNames;
LPDWORD *AddressOfFunctions; DWORD AddressOfFunctions;
LPDWORD *AddressOfNames; DWORD AddressOfNames;
LPWORD *AddressOfNameOrdinals; DWORD AddressOfNameOrdinals;
} IMAGE_EXPORT_DIRECTORY,*PIMAGE_EXPORT_DIRECTORY; } IMAGE_EXPORT_DIRECTORY,*PIMAGE_EXPORT_DIRECTORY;
/* Import name entry */ /* Import name entry */

7
misc/main.c
View File

@ -22,7 +22,6 @@
#include "msdos.h" #include "msdos.h"
#include "color.h" #include "color.h"
#include "options.h" #include "options.h"
#include "builtin32.h"
#include "debugtools.h" #include "debugtools.h"
#include "debugdefs.h" #include "debugdefs.h"
#include "module.h" #include "module.h"
@ -111,7 +110,7 @@ void MAIN_ParseDebugOptions( const char *arg )
extern char **debug_snoop_excludelist; extern char **debug_snoop_excludelist;
int i; int i;
int l, cls, dotracerelay = TRACE_ON(relay); int l, cls;
char *options = strdup(arg); char *options = strdup(arg);
@ -214,10 +213,6 @@ void MAIN_ParseDebugOptions( const char *arg )
} }
while((*options==',')&&(*(++options))); while((*options==',')&&(*(++options)));
/* special handling for relay debugging */
if (dotracerelay != TRACE_ON(relay))
BUILTIN32_SwitchRelayDebug( TRACE_ON(relay) );
if (!*options) return; if (!*options) return;
error: error:

376
relay32/builtin32.c
View File

@ -13,6 +13,9 @@
#ifdef HAVE_DL_API #ifdef HAVE_DL_API
#include <dlfcn.h> #include <dlfcn.h>
#endif #endif
#ifdef HAVE_SYS_MMAN_H
#include <sys/mman.h>
#endif
#include "windef.h" #include "windef.h"
#include "wine/winbase16.h" #include "wine/winbase16.h"
@ -20,6 +23,8 @@
#include "winuser.h" #include "winuser.h"
#include "builtin32.h" #include "builtin32.h"
#include "elfdll.h" #include "elfdll.h"
#include "file.h"
#include "global.h"
#include "neexe.h" #include "neexe.h"
#include "heap.h" #include "heap.h"
#include "main.h" #include "main.h"
@ -34,18 +39,10 @@ DECLARE_DEBUG_CHANNEL(relay);
typedef struct typedef struct
{ {
BYTE call; /* 0xe8 call callfrom32 (relative) */ BYTE *restab;
DWORD callfrom32 WINE_PACKED; /* RELAY_CallFrom32 relative addr */ DWORD nresources;
BYTE ret; /* 0xc2 ret $n or 0xc3 ret */ DWORD restabsize;
WORD args; /* nb of args to remove from the stack */ IMAGE_RESOURCE_DATA_ENTRY *entries;
} DEBUG_ENTRY_POINT;
typedef struct
{
const BYTE *restab;
const DWORD nresources;
const DWORD restabsize;
const IMAGE_RESOURCE_DATA_ENTRY *entries;
} BUILTIN32_RESOURCE; } BUILTIN32_RESOURCE;
#define MAX_DLLS 60 #define MAX_DLLS 60
@ -54,8 +51,6 @@ static const BUILTIN32_DESCRIPTOR *builtin_dlls[MAX_DLLS];
static HMODULE dll_modules[MAX_DLLS]; static HMODULE dll_modules[MAX_DLLS];
static int nb_dlls; static int nb_dlls;
extern void RELAY_CallFrom32();
extern void RELAY_CallFrom32Regs();
/*********************************************************************** /***********************************************************************
* BUILTIN32_WarnSecondInstance * BUILTIN32_WarnSecondInstance
@ -66,7 +61,8 @@ extern void RELAY_CallFrom32Regs();
static void BUILTIN32_WarnSecondInstance( const char *name ) static void BUILTIN32_WarnSecondInstance( const char *name )
{ {
static const char * const warning_list[] = static const char * const warning_list[] =
{ "comctl32", "comdlg32", "crtdll", "imagehlp", "msacm32", "shell32", NULL }; { "comctl32.dll", "comdlg32.dll", "crtdll.dll",
"imagehlp.dll", "msacm32.dll", "shell32.dll", NULL };
const char * const *ptr = warning_list; const char * const *ptr = warning_list;
@ -111,10 +107,29 @@ void *BUILTIN32_dlopen( const char *name )
int BUILTIN32_dlclose( void *handle ) int BUILTIN32_dlclose( void *handle )
{ {
#ifdef HAVE_DL_API #ifdef HAVE_DL_API
return dlclose( handle ); /* FIXME: should unregister descriptors first */
/* return dlclose( handle ); */
#endif #endif
return 0;
} }
/***********************************************************************
* fixup_rva_ptrs
*
* Adjust an array of pointers to make them into RVAs.
*/
static inline void fixup_rva_ptrs( void *array, void *base, int count )
{
void **ptr = (void **)array;
while (count--)
{
if (*ptr) *ptr = (void *)((char *)*ptr - (char *)base);
ptr++;
}
}
/*********************************************************************** /***********************************************************************
* BUILTIN32_DoLoadImage * BUILTIN32_DoLoadImage
* *
@ -122,29 +137,23 @@ int BUILTIN32_dlclose( void *handle )
*/ */
static HMODULE BUILTIN32_DoLoadImage( const BUILTIN32_DESCRIPTOR *descr ) static HMODULE BUILTIN32_DoLoadImage( const BUILTIN32_DESCRIPTOR *descr )
{ {
IMAGE_DATA_DIRECTORY *dir; IMAGE_DATA_DIRECTORY *dir;
IMAGE_DOS_HEADER *dos; IMAGE_DOS_HEADER *dos;
IMAGE_NT_HEADERS *nt; IMAGE_NT_HEADERS *nt;
IMAGE_SECTION_HEADER *sec; IMAGE_SECTION_HEADER *sec;
IMAGE_EXPORT_DIRECTORY *exp;
IMAGE_IMPORT_DESCRIPTOR *imp; IMAGE_IMPORT_DESCRIPTOR *imp;
const BUILTIN32_RESOURCE *rsrc = descr->rsrc; IMAGE_EXPORT_DIRECTORY *exports = descr->exports;
LPVOID *funcs;
LPSTR *names;
LPSTR pfwd, rtab;
DEBUG_ENTRY_POINT *debug;
INT i, size, nb_sections; INT i, size, nb_sections;
BYTE *addr; BYTE *addr, *code_start, *data_start;
BYTE* xcnlnk; BYTE* xcnlnk;
DWORD xcnsize = 0; DWORD xcnsize = 0;
int page_size = VIRTUAL_GetPageSize();
/* Allocate the module */ /* Allocate the module */
nb_sections = 2; /* exports + code */ nb_sections = 2; /* code + data */
if (descr->nb_imports) nb_sections++;
if (!strcmp(descr->name, "KERNEL32")) { if (!strcmp(descr->filename, "kernel32.dll")) {
nb_sections++; nb_sections++;
xcnsize = sizeof(DWORD); xcnsize = sizeof(DWORD);
} }
@ -152,30 +161,33 @@ static HMODULE BUILTIN32_DoLoadImage( const BUILTIN32_DESCRIPTOR *descr )
+ sizeof(IMAGE_NT_HEADERS) + sizeof(IMAGE_NT_HEADERS)
+ nb_sections * sizeof(IMAGE_SECTION_HEADER) + nb_sections * sizeof(IMAGE_SECTION_HEADER)
+ (descr->nb_imports+1) * sizeof(IMAGE_IMPORT_DESCRIPTOR) + (descr->nb_imports+1) * sizeof(IMAGE_IMPORT_DESCRIPTOR)
+ sizeof(IMAGE_EXPORT_DIRECTORY)
+ descr->nb_funcs * sizeof(LPVOID)
+ descr->nb_names * sizeof(LPSTR)
+ descr->fwd_size
+ xcnsize); + xcnsize);
#ifdef __i386__ assert( size <= page_size );
if (WARN_ON(relay) || TRACE_ON(relay))
size += descr->nb_funcs * sizeof(DEBUG_ENTRY_POINT); if (descr->pe_header)
#endif {
if (rsrc) size += rsrc->restabsize; if ((addr = FILE_dommap( -1, descr->pe_header, 0, page_size, 0, 0,
addr = VirtualAlloc( NULL, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE ); PROT_READ|PROT_WRITE, MAP_FIXED )) != descr->pe_header)
if (!addr) return 0; {
dos = (IMAGE_DOS_HEADER *)addr; ERR("failed to map over PE header for %s at %p\n", descr->filename, descr->pe_header );
nt = (IMAGE_NT_HEADERS *)(dos + 1); return 0;
sec = (IMAGE_SECTION_HEADER *)(nt + 1); }
imp = (IMAGE_IMPORT_DESCRIPTOR *)(sec + nb_sections); }
exp = (IMAGE_EXPORT_DIRECTORY *)(imp + descr->nb_imports + 1); else
funcs = (LPVOID *)(exp + 1); {
names = (LPSTR *)(funcs + descr->nb_funcs); if (!(addr = VirtualAlloc( NULL, page_size, MEM_COMMIT, PAGE_READWRITE ))) return 0;
pfwd = (LPSTR)(names + descr->nb_names); }
xcnlnk= pfwd + descr->fwd_size;
rtab = xcnlnk + xcnsize; dos = (IMAGE_DOS_HEADER *)addr;
debug = (DEBUG_ENTRY_POINT *)(rtab + (rsrc ? rsrc->restabsize : 0)); nt = (IMAGE_NT_HEADERS *)(dos + 1);
sec = (IMAGE_SECTION_HEADER *)(nt + 1);
imp = (IMAGE_IMPORT_DESCRIPTOR *)(sec + nb_sections);
xcnlnk = (char *)(imp + descr->nb_imports + 1);
code_start = addr + page_size;
/* HACK! */
data_start = code_start + page_size;
/* Build the DOS and NT headers */ /* Build the DOS and NT headers */
@ -189,35 +201,41 @@ static HMODULE BUILTIN32_DoLoadImage( const BUILTIN32_DESCRIPTOR *descr )
nt->FileHeader.Characteristics = descr->characteristics; nt->FileHeader.Characteristics = descr->characteristics;
nt->OptionalHeader.Magic = IMAGE_NT_OPTIONAL_HDR_MAGIC; nt->OptionalHeader.Magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
nt->OptionalHeader.SizeOfCode = 0x1000; nt->OptionalHeader.SizeOfCode = data_start - code_start;
nt->OptionalHeader.SizeOfInitializedData = 0; nt->OptionalHeader.SizeOfInitializedData = 0;
nt->OptionalHeader.SizeOfUninitializedData = 0; nt->OptionalHeader.SizeOfUninitializedData = 0;
nt->OptionalHeader.ImageBase = (DWORD)addr; nt->OptionalHeader.ImageBase = (DWORD)addr;
nt->OptionalHeader.SectionAlignment = 0x1000; nt->OptionalHeader.SectionAlignment = page_size;
nt->OptionalHeader.FileAlignment = 0x1000; nt->OptionalHeader.FileAlignment = page_size;
nt->OptionalHeader.MajorOperatingSystemVersion = 1; nt->OptionalHeader.MajorOperatingSystemVersion = 1;
nt->OptionalHeader.MinorOperatingSystemVersion = 0; nt->OptionalHeader.MinorOperatingSystemVersion = 0;
nt->OptionalHeader.MajorSubsystemVersion = 4; nt->OptionalHeader.MajorSubsystemVersion = 4;
nt->OptionalHeader.MinorSubsystemVersion = 0; nt->OptionalHeader.MinorSubsystemVersion = 0;
nt->OptionalHeader.SizeOfImage = size; nt->OptionalHeader.SizeOfImage = page_size;
nt->OptionalHeader.SizeOfHeaders = (BYTE *)exp - addr; nt->OptionalHeader.SizeOfHeaders = page_size;
nt->OptionalHeader.NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES; nt->OptionalHeader.NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
if (descr->dllentrypoint) if (descr->dllentrypoint)
nt->OptionalHeader.AddressOfEntryPoint = (DWORD)descr->dllentrypoint - (DWORD)addr; nt->OptionalHeader.AddressOfEntryPoint = (DWORD)descr->dllentrypoint - (DWORD)addr;
/* Build the code section */ /* Build the code section */
strcpy( sec->Name, ".code" ); strcpy( sec->Name, ".text" );
sec->SizeOfRawData = 0; sec->SizeOfRawData = data_start - code_start;
#ifdef __i386__
if (WARN_ON(relay) || TRACE_ON(relay))
sec->SizeOfRawData += descr->nb_funcs * sizeof(DEBUG_ENTRY_POINT);
#endif
sec->Misc.VirtualSize = sec->SizeOfRawData; sec->Misc.VirtualSize = sec->SizeOfRawData;
sec->VirtualAddress = (BYTE *)debug - addr; sec->VirtualAddress = code_start - addr;
sec->PointerToRawData = (BYTE *)debug - addr; sec->PointerToRawData = code_start - addr;
sec->Characteristics = (IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ);
sec++;
/* Build the data section */
strcpy( sec->Name, ".data" );
sec->SizeOfRawData = 0;
sec->Misc.VirtualSize = sec->SizeOfRawData;
sec->VirtualAddress = data_start - addr;
sec->PointerToRawData = data_start - addr;
sec->Characteristics = (IMAGE_SCN_CNT_INITIALIZED_DATA | sec->Characteristics = (IMAGE_SCN_CNT_INITIALIZED_DATA |
IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ); IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_READ);
sec++; sec++;
/* Build the import directory */ /* Build the import directory */
@ -228,17 +246,6 @@ static HMODULE BUILTIN32_DoLoadImage( const BUILTIN32_DESCRIPTOR *descr )
dir->VirtualAddress = (BYTE *)imp - addr; dir->VirtualAddress = (BYTE *)imp - addr;
dir->Size = sizeof(*imp) * (descr->nb_imports + 1); dir->Size = sizeof(*imp) * (descr->nb_imports + 1);
/* Build the imports section */
strcpy( sec->Name, ".idata" );
sec->Misc.VirtualSize = dir->Size;
sec->VirtualAddress = (BYTE *)imp - addr;
sec->SizeOfRawData = dir->Size;
sec->PointerToRawData = (BYTE *)imp - addr;
sec->Characteristics = (IMAGE_SCN_CNT_INITIALIZED_DATA |
IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ |
IMAGE_SCN_MEM_WRITE);
sec++;
/* Build the imports */ /* Build the imports */
for (i = 0; i < descr->nb_imports; i++) for (i = 0; i < descr->nb_imports; i++)
{ {
@ -250,138 +257,55 @@ static HMODULE BUILTIN32_DoLoadImage( const BUILTIN32_DESCRIPTOR *descr )
} }
} }
/* Build the export directory */
dir = &nt->OptionalHeader.DataDirectory[IMAGE_FILE_EXPORT_DIRECTORY];
dir->VirtualAddress = (BYTE *)exp - addr;
dir->Size = sizeof(*exp)
+ descr->nb_funcs * sizeof(LPVOID)
+ descr->nb_names * sizeof(LPSTR)
+ descr->fwd_size;
/* Build the exports section */
strcpy( sec->Name, ".edata" );
sec->Misc.VirtualSize = dir->Size;
sec->VirtualAddress = (BYTE *)exp - addr;
sec->SizeOfRawData = dir->Size;
sec->PointerToRawData = (BYTE *)exp - addr;
sec->Characteristics = (IMAGE_SCN_CNT_INITIALIZED_DATA |
IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ |
IMAGE_SCN_MEM_WRITE);
/* Build Wine's .so link section. Those sections are used by the wine debugger to /* Build Wine's .so link section. Those sections are used by the wine debugger to
* link a builtin PE header with the corresponding ELF module (from either a * link a builtin PE header with the corresponding ELF module (from either a
* shared library, or the main executable - wine emulator or any winelib program * shared library, or the main executable - wine emulator or any winelib program
*/ */
if (xcnsize) if (xcnsize)
{ {
sec++;
strcpy( sec->Name, ".xcnlnk" ); strcpy( sec->Name, ".xcnlnk" );
sec->Misc.VirtualSize = xcnsize; sec->Misc.VirtualSize = xcnsize;
sec->VirtualAddress = (BYTE *)xcnlnk - addr; sec->VirtualAddress = (BYTE *)xcnlnk - addr;
sec->SizeOfRawData = sec->Misc.VirtualSize; sec->SizeOfRawData = sec->Misc.VirtualSize;
sec->PointerToRawData = (BYTE *)xcnlnk - addr; sec->PointerToRawData = (BYTE *)xcnlnk - addr;
sec->Characteristics = (IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ); sec->Characteristics = (IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ);
sec++;
*(const char**)xcnlnk = argv0; *(const char**)xcnlnk = argv0;
} }
/* Build the resource directory */ /* Build the resource directory */
if (rsrc) if (descr->rsrc)
{ {
BUILTIN32_RESOURCE *rsrc = descr->rsrc;
IMAGE_RESOURCE_DATA_ENTRY *rdep; IMAGE_RESOURCE_DATA_ENTRY *rdep;
/*
* The resource directory has to be copied because it contains
* RVAs. These would be invalid if the dll is instantiated twice.
*/
memcpy(rtab, rsrc->restab, rsrc->restabsize);
dir = &nt->OptionalHeader.DataDirectory[IMAGE_FILE_RESOURCE_DIRECTORY]; dir = &nt->OptionalHeader.DataDirectory[IMAGE_FILE_RESOURCE_DIRECTORY];
dir->VirtualAddress = (BYTE *)rtab - addr; dir->VirtualAddress = (BYTE *)rsrc->restab - addr;
dir->Size = rsrc->restabsize; dir->Size = rsrc->restabsize;
rdep = (IMAGE_RESOURCE_DATA_ENTRY *)((DWORD)rtab + (DWORD)rsrc->entries - (DWORD)rsrc->restab); rdep = rsrc->entries;
for(i = 0; i < rsrc->nresources; i++) for (i = 0; i < rsrc->nresources; i++) rdep[i].OffsetToData += dir->VirtualAddress;
{
rdep[i].OffsetToData += (DWORD)rsrc->restab - (DWORD)addr;
}
} }
/* Build the exports section data */ /* Build the export directory */
exp->Name = ((BYTE *)descr->name) - addr; /*??*/ if (exports)
exp->Base = descr->base;
exp->NumberOfFunctions = descr->nb_funcs;
exp->NumberOfNames = descr->nb_names;
exp->AddressOfFunctions = (LPDWORD *)((BYTE *)funcs - addr);
exp->AddressOfNames = (LPDWORD *)((BYTE *)names - addr);
exp->AddressOfNameOrdinals = (LPWORD *)((BYTE *)descr->ordinals - addr);
/* Build the funcs table */
for (i = 0; i < descr->nb_funcs; i++, funcs++, debug++)
{ {
BYTE args = descr->args[i]; dir = &nt->OptionalHeader.DataDirectory[IMAGE_FILE_EXPORT_DIRECTORY];
int j; dir->VirtualAddress = (BYTE *)exports - addr;
dir->Size = descr->exports_size;
if (!descr->functions[i]) continue; fixup_rva_ptrs( (void *)exports->AddressOfFunctions, addr, exports->NumberOfFunctions );
fixup_rva_ptrs( (void *)exports->AddressOfNames, addr, exports->NumberOfNames );
fixup_rva_ptrs( &exports->Name, addr, 1 );
fixup_rva_ptrs( &exports->AddressOfFunctions, addr, 1 );
fixup_rva_ptrs( &exports->AddressOfNames, addr, 1 );
fixup_rva_ptrs( &exports->AddressOfNameOrdinals, addr, 1 );
if (args == 0xfd) /* forward func */ /* Setup relay debugging entry points */
{ if (WARN_ON(relay) || TRACE_ON(relay)) RELAY_SetupDLL( addr );
strcpy( pfwd, (LPSTR)descr->functions[i] );
*funcs = (LPVOID)((BYTE *)pfwd - addr);
pfwd += strlen(pfwd) + 1;
}
else *funcs = (LPVOID)((BYTE *)descr->functions[i] - addr);
#ifdef __i386__
if (!(WARN_ON(relay) || TRACE_ON(relay))) continue;
for (j=0;j<descr->nb_names;j++)
if (descr->ordinals[j] == i)
break;
if (j<descr->nb_names) {
if (descr->names[j]) {
char buffer[200];
sprintf(buffer,"%s.%d: %s",descr->name,i,descr->names[j]);
if (!RELAY_ShowDebugmsgRelay(buffer))
continue;
}
}
switch(args)
{
case 0xfd: /* forward */
case 0xff: /* stub or extern */
break;
default: /* normal function (stdcall or cdecl or register) */
if (TRACE_ON(relay)) {
debug->call = 0xe8; /* lcall relative */
if (args & 0x40) /* register func */
debug->callfrom32 = (DWORD)RELAY_CallFrom32Regs -
(DWORD)&debug->ret;
else
debug->callfrom32 = (DWORD)RELAY_CallFrom32 -
(DWORD)&debug->ret;
} else {
debug->call = 0xe9; /* ljmp relative */
debug->callfrom32 = (DWORD)descr->functions[i] -
(DWORD)&debug->ret;
}
debug->ret = (args & 0x80) ? 0xc3 : 0xc2; /*ret/ret $n*/
debug->args = (args & 0x3f) * sizeof(int);
*funcs = (LPVOID)((BYTE *)debug - addr);
break;
}
#endif /* __i386__ */
} }
/* Build the names table */
for (i = 0; i < exp->NumberOfNames; i++, names++)
if (descr->names[i])
*names = (LPSTR)((BYTE *)descr->names[i] - addr);
return (HMODULE)addr; return (HMODULE)addr;
} }
@ -429,7 +353,7 @@ WINE_MODREF *BUILTIN32_LoadLibraryExA(LPCSTR path, DWORD flags)
{ {
if (!(dll_modules[i] = BUILTIN32_DoLoadImage( builtin_dlls[i] ))) return NULL; if (!(dll_modules[i] = BUILTIN32_DoLoadImage( builtin_dlls[i] ))) return NULL;
} }
else BUILTIN32_WarnSecondInstance( builtin_dlls[i]->name ); else BUILTIN32_WarnSecondInstance( builtin_dlls[i]->filename );
/* Create 16-bit dummy module */ /* Create 16-bit dummy module */
if ((hModule16 = MODULE_CreateDummyModule( dllname, dll_modules[i] )) < 32) if ((hModule16 = MODULE_CreateDummyModule( dllname, dll_modules[i] )) < 32)
@ -507,92 +431,6 @@ void BUILTIN32_UnloadLibrary(WINE_MODREF *wm)
/* FIXME: do something here */ /* FIXME: do something here */
} }
/***********************************************************************
* BUILTIN32_GetEntryPoint
*
* Return the name of the DLL entry point corresponding
* to a relay entry point address. This is used only by relay debugging.
*
* This function _must_ return the real entry point to call
* after the debug info is printed.
*/
ENTRYPOINT32 BUILTIN32_GetEntryPoint( char *buffer, void *relay,
unsigned int *typemask )
{
const BUILTIN32_DESCRIPTOR *descr = NULL;
int ordinal = 0, i;
/* First find the module */
for (i = 0; i < nb_dlls; i++)
if (dll_modules[i])
{
IMAGE_SECTION_HEADER *sec = PE_SECTIONS(dll_modules[i]);
DEBUG_ENTRY_POINT *debug =
(DEBUG_ENTRY_POINT *)((DWORD)dll_modules[i] + sec[0].VirtualAddress);
DEBUG_ENTRY_POINT *func = (DEBUG_ENTRY_POINT *)relay;
descr = builtin_dlls[i];
if (debug <= func && func < debug + descr->nb_funcs)
{
ordinal = func - debug;
break;
}
}
if (!descr) return NULL;
/* Now find the function */
for (i = 0; i < descr->nb_names; i++)
if (descr->ordinals[i] == ordinal) break;
sprintf( buffer, "%s.%d: %s", descr->name, ordinal + descr->base,
(i < descr->nb_names) ? descr->names[i] : "@" );
*typemask = descr->argtypes[ordinal];
return descr->functions[ordinal];
}
/***********************************************************************
* BUILTIN32_SwitchRelayDebug
*
* FIXME: enhance to do it module relative.
*/
void BUILTIN32_SwitchRelayDebug(BOOL onoff)
{
const BUILTIN32_DESCRIPTOR *descr;
IMAGE_SECTION_HEADER *sec;
DEBUG_ENTRY_POINT *debug;
int i, j;
#ifdef __i386__
if (!(TRACE_ON(relay) || WARN_ON(relay)))
return;
for (j = 0; j < nb_dlls; j++)
{
if (!dll_modules[j]) continue;
sec = PE_SECTIONS(dll_modules[j]);
debug = (DEBUG_ENTRY_POINT *)((DWORD)dll_modules[j] + sec[1].VirtualAddress);
descr = builtin_dlls[j];
for (i = 0; i < descr->nb_funcs; i++,debug++) {
if (!descr->functions[i]) continue;
if ((descr->args[i]==0xff) || (descr->args[i]==0xfe))
continue;
if (onoff) {
debug->call = 0xe8; /* lcall relative */
debug->callfrom32 = (DWORD)RELAY_CallFrom32 -
(DWORD)&debug->ret;
} else {
debug->call = 0xe9; /* ljmp relative */
debug->callfrom32 = (DWORD)descr->functions[i] -
(DWORD)&debug->ret;
}
}
}
#endif /* __i386__ */
return;
}
/*********************************************************************** /***********************************************************************
* BUILTIN32_RegisterDLL * BUILTIN32_RegisterDLL
* *
@ -610,19 +448,11 @@ void BUILTIN32_RegisterDLL( const BUILTIN32_DESCRIPTOR *descr )
* This function is called for unimplemented 32-bit entry points (declared * This function is called for unimplemented 32-bit entry points (declared
* as 'stub' in the spec file). * as 'stub' in the spec file).
*/ */
void BUILTIN32_Unimplemented( const BUILTIN32_DESCRIPTOR *descr, int ordinal ) void BUILTIN32_Unimplemented( const char *dllname, const char *funcname )
{ {
const char *func_name = "???";
int i;
__RESTORE_ES; /* Just in case */ __RESTORE_ES; /* Just in case */
for (i = 0; i < descr->nb_names; i++) MESSAGE( "No handler for Win32 routine %s.%s", dllname, funcname );
if (descr->ordinals[i] + descr->base == ordinal) break;
if (i < descr->nb_names) func_name = descr->names[i];
MESSAGE( "No handler for Win32 routine %s.%d: %s",
descr->name, ordinal, func_name );
#ifdef __GNUC__ #ifdef __GNUC__
MESSAGE( " (called from %p)", __builtin_return_address(1) ); MESSAGE( " (called from %p)", __builtin_return_address(1) );
#endif #endif

164
relay32/relay386.c
View File

@ -7,12 +7,15 @@
#include <assert.h> #include <assert.h>
#include <string.h> #include <string.h>
#include <stdio.h>
#include "winnt.h" #include "winnt.h"
#include "builtin32.h" #include "builtin32.h"
#include "selectors.h" #include "selectors.h"
#include "stackframe.h" #include "stackframe.h"
#include "syslevel.h" #include "syslevel.h"
#include "main.h" #include "main.h"
#include "module.h"
#include "process.h"
#include "debugtools.h" #include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(relay); DEFAULT_DEBUG_CHANNEL(relay);
@ -62,6 +65,77 @@ int RELAY_ShowDebugmsgRelay(const char *func) {
#ifdef __i386__ #ifdef __i386__
typedef struct
{
BYTE call; /* 0xe8 call callfrom32 (relative) */
DWORD callfrom32 WINE_PACKED; /* RELAY_CallFrom32 relative addr */
BYTE ret; /* 0xc2 ret $n or 0xc3 ret */
WORD args; /* nb of args to remove from the stack */
FARPROC orig; /* original entry point */
DWORD argtypes; /* argument types */
} DEBUG_ENTRY_POINT;
/***********************************************************************
* find_exported_name
*
* Find the name of an exported function.
*/
static const char *find_exported_name( const char *module,
IMAGE_EXPORT_DIRECTORY *exp, int ordinal )
{
int i;
const char *ret = NULL;
WORD *ordptr = (WORD *)(module + exp->AddressOfNameOrdinals);
for (i = 0; i < exp->NumberOfNames; i++, ordptr++)
if (*ordptr + exp->Base == ordinal) break;
if (i < exp->NumberOfNames)
ret = module + ((DWORD*)(module + exp->AddressOfNames))[i];
return ret;
}
/***********************************************************************
* get_entry_point
*
* Get the name of the DLL entry point corresponding to a relay address.
*/
static void get_entry_point( char *buffer, DEBUG_ENTRY_POINT *relay )
{
IMAGE_DATA_DIRECTORY *dir;
IMAGE_EXPORT_DIRECTORY *exp = NULL;
DEBUG_ENTRY_POINT *debug;
char *base = NULL;
const char *name;
int ordinal = 0;
WINE_MODREF *wm;
/* First find the module */
for (wm = PROCESS_Current()->modref_list; wm; wm = wm->next)
{
if (wm->type != MODULE32_PE) continue;
if (!(wm->flags & WINE_MODREF_INTERNAL)) continue;
base = (char *)wm->module;
dir = &PE_HEADER(base)->OptionalHeader.DataDirectory[IMAGE_FILE_EXPORT_DIRECTORY];
if (!dir->Size) continue;
exp = (IMAGE_EXPORT_DIRECTORY *)(base + dir->VirtualAddress);
debug = (DEBUG_ENTRY_POINT *)((char *)exp + dir->Size);
if (debug <= relay && relay < debug + exp->NumberOfFunctions)
{
ordinal = relay - debug;
break;
}
}
/* Now find the function */
name = find_exported_name( base, exp, ordinal + exp->Base );
sprintf( buffer, "%s.%ld: %s", base + exp->Name, ordinal + exp->Base, name ? name : "@" );
}
/*********************************************************************** /***********************************************************************
* RELAY_PrintArgs * RELAY_PrintArgs
*/ */
@ -94,29 +168,28 @@ static inline void RELAY_PrintArgs( int *args, int nb_args, unsigned int typemas
* (esp+4) ret_addr * (esp+4) ret_addr
* (esp) return addr to relay code * (esp) return addr to relay code
*/ */
int RELAY_CallFrom32( int ret_addr, ... ) static int RELAY_CallFrom32( int ret_addr, ... )
{ {
int ret; int ret;
char buffer[80]; char buffer[80];
unsigned int typemask;
FARPROC func;
int *args = &ret_addr + 1; int *args = &ret_addr + 1;
/* Relay addr is the return address for this function */ /* Relay addr is the return address for this function */
BYTE *relay_addr = (BYTE *)__builtin_return_address(0); BYTE *relay_addr = (BYTE *)__builtin_return_address(0);
WORD nb_args = *(WORD *)(relay_addr + 1) / sizeof(int); DEBUG_ENTRY_POINT *relay = (DEBUG_ENTRY_POINT *)(relay_addr - 5);
WORD nb_args = relay->args / sizeof(int);
get_entry_point( buffer, relay );
assert(TRACE_ON(relay));
func = (FARPROC)BUILTIN32_GetEntryPoint( buffer, relay_addr - 5, &typemask );
DPRINTF( "Call %s(", buffer ); DPRINTF( "Call %s(", buffer );
RELAY_PrintArgs( args, nb_args, typemask ); RELAY_PrintArgs( args, nb_args, relay->argtypes );
DPRINTF( ") ret=%08x fs=%04x\n", ret_addr, __get_fs() ); DPRINTF( ") ret=%08x fs=%04x\n", ret_addr, __get_fs() );
SYSLEVEL_CheckNotLevel( 2 ); SYSLEVEL_CheckNotLevel( 2 );
if (*relay_addr == 0xc3) /* cdecl */ if (relay->ret == 0xc3) /* cdecl */
{ {
LRESULT (*cfunc)() = (LRESULT(*)())func; LRESULT (*cfunc)() = (LRESULT(*)())relay->orig;
switch(nb_args) switch(nb_args)
{ {
case 0: ret = cfunc(); break; case 0: ret = cfunc(); break;
@ -159,6 +232,7 @@ int RELAY_CallFrom32( int ret_addr, ... )
} }
else /* stdcall */ else /* stdcall */
{ {
FARPROC func = relay->orig;
switch(nb_args) switch(nb_args)
{ {
case 0: ret = func(); break; case 0: ret = func(); break;
@ -225,14 +299,14 @@ void WINAPI RELAY_DoCallFrom32Regs( CONTEXT86 *context );
DEFINE_REGS_ENTRYPOINT_0( RELAY_CallFrom32Regs, RELAY_DoCallFrom32Regs ) DEFINE_REGS_ENTRYPOINT_0( RELAY_CallFrom32Regs, RELAY_DoCallFrom32Regs )
void WINAPI RELAY_DoCallFrom32Regs( CONTEXT86 *context ) void WINAPI RELAY_DoCallFrom32Regs( CONTEXT86 *context )
{ {
unsigned int typemask;
char buffer[80]; char buffer[80];
int* args; int* args;
FARPROC func; FARPROC func;
BYTE *entry_point; BYTE *entry_point;
BYTE *relay_addr = *((BYTE **)ESP_reg(context) - 1); BYTE *relay_addr = *((BYTE **)ESP_reg(context) - 1);
WORD nb_args = *(WORD *)(relay_addr + 1) / sizeof(int); DEBUG_ENTRY_POINT *relay = (DEBUG_ENTRY_POINT *)(relay_addr - 5);
WORD nb_args = (relay->args & ~0x8000) / sizeof(int);
/* remove extra stuff from the stack */ /* remove extra stuff from the stack */
EIP_reg(context) = stack32_pop(context); EIP_reg(context) = stack32_pop(context);
@ -241,12 +315,14 @@ void WINAPI RELAY_DoCallFrom32Regs( CONTEXT86 *context )
assert(TRACE_ON(relay)); assert(TRACE_ON(relay));
entry_point = (BYTE *)BUILTIN32_GetEntryPoint( buffer, relay_addr - 5, &typemask ); entry_point = (BYTE *)relay->orig;
assert( *entry_point == 0xe8 /* lcall */ ); assert( *entry_point == 0xe8 /* lcall */ );
func = *(FARPROC *)(entry_point + 5); func = *(FARPROC *)(entry_point + 5);
get_entry_point( buffer, relay );
DPRINTF( "Call %s(", buffer ); DPRINTF( "Call %s(", buffer );
RELAY_PrintArgs( args, nb_args, typemask ); RELAY_PrintArgs( args, nb_args, relay->argtypes );
DPRINTF( ") ret=%08lx fs=%04lx\n", EIP_reg(context), FS_reg(context) ); DPRINTF( ") ret=%08lx fs=%04lx\n", EIP_reg(context), FS_reg(context) );
DPRINTF(" eax=%08lx ebx=%08lx ecx=%08lx edx=%08lx esi=%08lx edi=%08lx\n", DPRINTF(" eax=%08lx ebx=%08lx ecx=%08lx edx=%08lx esi=%08lx edi=%08lx\n",
@ -302,5 +378,65 @@ void WINAPI RELAY_DoCallFrom32Regs( CONTEXT86 *context )
SYSLEVEL_CheckNotLevel( 2 ); SYSLEVEL_CheckNotLevel( 2 );
} }
#endif /* __i386__ */
/***********************************************************************
* RELAY_SetupDLL
*
* Setup relay debugging for a built-in dll.
*/
void RELAY_SetupDLL( const char *module )
{
IMAGE_DATA_DIRECTORY *dir;
IMAGE_EXPORT_DIRECTORY *exports;
DEBUG_ENTRY_POINT *debug;
DWORD *funcs;
int i;
const char *name, *dllname;
dir = &PE_HEADER(module)->OptionalHeader.DataDirectory[IMAGE_FILE_EXPORT_DIRECTORY];
if (!dir->Size) return;
exports = (IMAGE_EXPORT_DIRECTORY *)(module + dir->VirtualAddress);
debug = (DEBUG_ENTRY_POINT *)((char *)exports + dir->Size);
funcs = (DWORD *)(module + exports->AddressOfFunctions);
dllname = module + exports->Name;
for (i = 0; i < exports->NumberOfFunctions; i++, funcs++, debug++)
{
int on = 1;
if (!debug->call) continue; /* not a normal function */
if ((name = find_exported_name( module, exports, i + exports->Base )))
{
char buffer[200];
sprintf( buffer, "%s.%d: %s", dllname, i, name );
on = RELAY_ShowDebugmsgRelay(buffer);
}
if (on)
{
debug->call = 0xe8; /* call relative */
if (debug->args & 0x8000) /* register func */
debug->callfrom32 = (char *)RELAY_CallFrom32Regs - (char *)&debug->ret;
else
debug->callfrom32 = (char *)RELAY_CallFrom32 - (char *)&debug->ret;
}
else
{
debug->call = 0xe9; /* jmp relative */
debug->callfrom32 = (char *)debug->orig - (char *)&debug->ret;
}
debug->orig = (FARPROC)(module + (DWORD)*funcs);
*funcs = (char *)debug - module;
}
}
#else /* __i386__ */
void RELAY_SetupDLL( const char *module )
{
}
#endif /* __i386__ */

349
tools/build.c
View File

@ -698,7 +698,6 @@ static void ParseTopLevel(void)
if (strcmp(token, "name") == 0) if (strcmp(token, "name") == 0)
{ {
strcpy(DLLName, GetToken()); strcpy(DLLName, GetToken());
strupper(DLLName);
} }
else if (strcmp(token, "file") == 0) else if (strcmp(token, "file") == 0)
{ {
@ -766,9 +765,9 @@ static void ParseTopLevel(void)
if (!DLLFileName[0]) if (!DLLFileName[0])
{ {
if (SpecMode == SPEC_MODE_DLL) if (SpecMode == SPEC_MODE_DLL)
sprintf( DLLFileName, "%s.DLL", DLLName ); sprintf( DLLFileName, "%s.dll", DLLName );
else else
sprintf( DLLFileName, "%s.EXE", DLLName ); sprintf( DLLFileName, "%s.exe", DLLName );
} }
} }
@ -1025,6 +1024,200 @@ static int BuildModule16( FILE *outfile, int max_code_offset,
} }
/*******************************************************************
* output_exports
*
* Output the export table for a Win32 module.
*/
static void output_exports( FILE *outfile, int nr_exports, int nr_names, int fwd_size )
{
int i, fwd_pos = 0;
if (!nr_exports) return;
fprintf( outfile, "typedef void (*func_ptr)();\n" );
fprintf( outfile, "static struct {\n" );
fprintf( outfile, " struct {\n" );
fprintf( outfile, " unsigned int Characteristics;\n" );
fprintf( outfile, " unsigned int TimeDateStamp;\n" );
fprintf( outfile, " unsigned short MajorVersion;\n" );
fprintf( outfile, " unsigned short MinorVersion;\n" );
fprintf( outfile, " const char *Name;\n" );
fprintf( outfile, " unsigned int Base;\n" );
fprintf( outfile, " unsigned int NumberOfFunctions;\n" );
fprintf( outfile, " unsigned int NumberOfNames;\n" );
fprintf( outfile, " func_ptr *AddressOfFunctions;\n" );
fprintf( outfile, " const char **AddressOfNames;\n" );
fprintf( outfile, " unsigned short *AddressOfNameOrdinals;\n" );
fprintf( outfile, " func_ptr functions[%d];\n", nr_exports );
if (nb_names)
{
fprintf( outfile, " const char *names[%d];\n", nb_names );
fprintf( outfile, " unsigned short ordinals[%d];\n", nb_names );
if (nb_names % 2) fprintf( outfile, " unsigned short pad1;\n" );
}
if (fwd_size)
{
fprintf( outfile, " char forwards[%d];\n", (fwd_size + 3) & ~3 );
}
fprintf( outfile, " } exp;\n" );
#ifdef __i386__
fprintf( outfile, " struct {\n" );
fprintf( outfile, " unsigned char jmp;\n" );
fprintf( outfile, " unsigned char addr[4];\n" );
fprintf( outfile, " unsigned char ret;\n" );
fprintf( outfile, " unsigned short args;\n" );
fprintf( outfile, " func_ptr orig;\n" );
fprintf( outfile, " unsigned int argtypes;\n" );
fprintf( outfile, " } relay[%d];\n", nr_exports );
#endif /* __i386__ */
fprintf( outfile, "} exports = {\n {\n" );
fprintf( outfile, " 0,\n" ); /* Characteristics */
fprintf( outfile, " 0,\n" ); /* TimeDateStamp */
fprintf( outfile, " 0,\n" ); /* MajorVersion */
fprintf( outfile, " 0,\n" ); /* MinorVersion */
fprintf( outfile, " dllname,\n" ); /* Name */
fprintf( outfile, " %d,\n", Base ); /* Base */
fprintf( outfile, " %d,\n", nr_exports ); /* NumberOfFunctions */
fprintf( outfile, " %d,\n", nb_names ); /* NumberOfNames */
fprintf( outfile, " exports.exp.functions,\n" ); /* AddressOfFunctions */
if (nb_names)
{
fprintf( outfile, " exports.exp.names,\n" ); /* AddressOfNames */
fprintf( outfile, " exports.exp.ordinals,\n" ); /* AddressOfNameOrdinals */
}
else
{
fprintf( outfile, " 0,\n" ); /* AddressOfNames */
fprintf( outfile, " 0,\n" ); /* AddressOfNameOrdinals */
}
/* output the function addresses */
fprintf( outfile, " {\n " );
for (i = Base; i <= Limit; i++)
{
ORDDEF *odp = Ordinals[i];
if (!odp) fprintf( outfile, "0" );
else switch(odp->type)
{
case TYPE_EXTERN:
fprintf( outfile, "%s", odp->u.ext.link_name );
break;
case TYPE_STDCALL:
case TYPE_VARARGS:
case TYPE_CDECL:
fprintf( outfile, "%s", odp->u.func.link_name);
break;
case TYPE_STUB:
fprintf( outfile, "__stub_%d", i );
break;
case TYPE_REGISTER:
fprintf( outfile, "__regs_%d", i );
break;
case TYPE_FORWARD:
fprintf( outfile, "(func_ptr)&exports.exp.forwards[%d] /* %s */",
fwd_pos, odp->u.fwd.link_name );
fwd_pos += strlen(odp->u.fwd.link_name) + 1;
break;
default:
assert(0);
}
if (i < Limit) fprintf( outfile, ",\n " );
else fprintf( outfile, "\n },\n" );
}
if (nb_names)
{
/* output the function names */
fprintf( outfile, " {\n" );
for (i = 0; i < nb_names; i++)
{
if (i) fprintf( outfile, ",\n" );
fprintf( outfile, " \"%s\"", Names[i]->name );
}
fprintf( outfile, "\n },\n" );
/* output the function ordinals */
fprintf( outfile, " {\n " );
for (i = 0; i < nb_names; i++)
{
fprintf( outfile, "%4d", Names[i]->ordinal - Base );
if (i < nb_names-1)
{
fputc( ',', outfile );
if ((i % 8) == 7) fprintf( outfile, "\n " );
}
}
fprintf( outfile, "\n },\n" );
if (nb_names % 2) fprintf( outfile, " 0,\n" );
}
/* output forwards */
if (fwd_size)
{
for (i = Base; i <= Limit; i++)
{
ORDDEF *odp = Ordinals[i];
if (odp && odp->type == TYPE_FORWARD)
fprintf( outfile, " \"%s\\0\"\n", odp->u.fwd.link_name );
}
}
/* output relays */
#ifdef __i386__
fprintf( outfile, " },\n {\n" );
for (i = Base; i <= Limit; i++)
{
ORDDEF *odp = Ordinals[i];
if (odp && ((odp->type == TYPE_STDCALL) ||
(odp->type == TYPE_CDECL) ||
(odp->type == TYPE_REGISTER)))
{
unsigned int j, mask = 0;
for (j = 0; odp->u.func.arg_types[j]; j++)
{
if (odp->u.func.arg_types[j] == 't') mask |= 1<< (j*2);
if (odp->u.func.arg_types[j] == 'W') mask |= 2<< (j*2);
}
switch(odp->type)
{
case TYPE_STDCALL:
fprintf( outfile, " { 0xe9, { 0,0,0,0 }, 0xc2, 0x%04x, %s, 0x%08x }",
strlen(odp->u.func.arg_types) * sizeof(int),
odp->u.func.link_name, mask );
break;
case TYPE_CDECL:
fprintf( outfile, " { 0xe9, { 0,0,0,0 }, 0xc3, 0x%04x, %s, 0x%08x }",
strlen(odp->u.func.arg_types) * sizeof(int),
odp->u.func.link_name, mask );
break;
case TYPE_REGISTER:
fprintf( outfile, " { 0xe9, { 0,0,0,0 }, 0xc3, 0x%04x, __regs_%d, 0x%08x }",
0x8000 | (strlen(odp->u.func.arg_types) * sizeof(int)), i, mask );
break;
default:
assert(0);
}
}
else fprintf( outfile, " { 0, }" );
if (i < Limit) fprintf( outfile, ",\n" );
}
#endif /* __i386__ */
fprintf( outfile, " }\n};\n" );
}
/******************************************************************* /*******************************************************************
* BuildSpec32File * BuildSpec32File
* *
@ -1043,7 +1236,15 @@ static int BuildSpec32File( FILE *outfile )
fprintf( outfile, "/* File generated automatically from %s; do not edit! */\n\n", fprintf( outfile, "/* File generated automatically from %s; do not edit! */\n\n",
input_file_name ); input_file_name );
fprintf( outfile, "#include \"builtin32.h\"\n\n" ); fprintf( outfile, "#include \"builtin32.h\"\n\n" );
fprintf( outfile, "static const BUILTIN32_DESCRIPTOR descriptor;\n" );
/* Reserve some space for the PE header */
fprintf( outfile, "extern char pe_header[];\n" );
fprintf( outfile, "asm(\".section .text\\n\\t\"\n" );
fprintf( outfile, " \".align 4096\\n\"\n" );
fprintf( outfile, " \"pe_header:\\t.fill 4096,1,0\\n\\t\");\n" );
fprintf( outfile, "static const char dllname[] = \"%s\";\n", DLLName );
/* Output the DLL functions prototypes */ /* Output the DLL functions prototypes */
@ -1067,8 +1268,15 @@ static int BuildSpec32File( FILE *outfile )
have_regs = TRUE; have_regs = TRUE;
break; break;
case TYPE_STUB: case TYPE_STUB:
fprintf( outfile, "static void __stub_%d() { BUILTIN32_Unimplemented(&descriptor,%d); }\n", if (odp->name[0])
odp->ordinal, odp->ordinal ); fprintf( outfile,
"static void __stub_%d() { BUILTIN32_Unimplemented(dllname,\"%s\"); }\n",
odp->ordinal, odp->name );
else
fprintf( outfile,
"static void __stub_%d() { BUILTIN32_Unimplemented(dllname,\"%d\"); }\n",
odp->ordinal, odp->ordinal );
break; break;
default: default:
fprintf(stderr,"build: function type %d not available for Win32\n", fprintf(stderr,"build: function type %d not available for Win32\n",
@ -1103,117 +1311,9 @@ static int BuildSpec32File( FILE *outfile )
fprintf( outfile, "#endif /* !defined(__GNUC__) */\n" ); fprintf( outfile, "#endif /* !defined(__GNUC__) */\n" );
} }
if (nb_names) /* Output the exports and relay entry points */
{
/* Output the DLL names table */
fprintf( outfile, "static const char * const FuncNames[%d] =\n{\n", nb_names ); output_exports( outfile, nr_exports, nb_names, fwd_size );
for (i = 0; i < nb_names; i++)
{
if (i) fprintf( outfile, ",\n" );
fprintf( outfile, " \"%s\"", Names[i]->name );
}
fprintf( outfile, "\n};\n\n" );
/* Output the DLL ordinals table */
fprintf( outfile, "static const unsigned short FuncOrdinals[%d] =\n{\n", nb_names );
for (i = 0; i < nb_names; i++)
{
if (i) fprintf( outfile, ",\n" );
fprintf( outfile, " %d", Names[i]->ordinal - Base );
}
fprintf( outfile, "\n};\n\n" );
}
if (nr_exports)
{
/* Output the DLL functions table */
fprintf( outfile, "\nstatic const ENTRYPOINT32 Functions[%d] =\n{\n",
nr_exports );
for (i = Base; i <= Limit; i++)
{
ORDDEF *odp = Ordinals[i];
if (!odp) fprintf( outfile, " 0" );
else switch(odp->type)
{
case TYPE_EXTERN:
fprintf( outfile, " %s", odp->u.ext.link_name );
break;
case TYPE_STDCALL:
case TYPE_VARARGS:
case TYPE_CDECL:
fprintf( outfile, " %s", odp->u.func.link_name);
break;
case TYPE_STUB:
fprintf( outfile, " __stub_%d", i );
break;
case TYPE_REGISTER:
fprintf( outfile, " __regs_%d", i );
break;
case TYPE_FORWARD:
fprintf( outfile, " (ENTRYPOINT32)\"%s\"", odp->u.fwd.link_name );
break;
default:
return -1;
}
if (i < Limit) fprintf( outfile, ",\n" );
}
fprintf( outfile, "\n};\n\n" );
/* Output the DLL argument types */
fprintf( outfile, "static const unsigned int ArgTypes[%d] =\n{\n",
nr_exports );
for (i = Base; i <= Limit; i++)
{
ORDDEF *odp = Ordinals[i];
unsigned int j, mask = 0;
if (odp &&
((odp->type == TYPE_STDCALL) || (odp->type == TYPE_CDECL) ||
(odp->type == TYPE_REGISTER)))
for (j = 0; odp->u.func.arg_types[j]; j++)
{
if (odp->u.func.arg_types[j] == 't') mask |= 1<< (j*2);
if (odp->u.func.arg_types[j] == 'W') mask |= 2<< (j*2);
}
fprintf( outfile, " %d", mask );
if (i < Limit) fprintf( outfile, ",\n" );
}
fprintf( outfile, "\n};\n\n" );
/* Output the DLL functions arguments */
fprintf( outfile, "static const unsigned char FuncArgs[%d] =\n{\n",
nr_exports );
for (i = Base; i <= Limit; i++)
{
unsigned char args = 0xff;
ORDDEF *odp = Ordinals[i];
if (odp) switch(odp->type)
{
case TYPE_STDCALL:
args = (unsigned char)strlen(odp->u.func.arg_types);
break;
case TYPE_CDECL:
args = 0x80 | (unsigned char)strlen(odp->u.func.arg_types);
break;
case TYPE_REGISTER:
args = 0x40 | (unsigned char)strlen(odp->u.func.arg_types);
break;
case TYPE_FORWARD:
args = 0xfd;
break;
default:
args = 0xff;
break;
}
fprintf( outfile, " 0x%02x", args );
if (i < Limit) fprintf( outfile, ",\n" );
}
fprintf( outfile, "\n};\n\n" );
}
/* Output the DLL imports */ /* Output the DLL imports */
@ -1284,21 +1384,14 @@ static int BuildSpec32File( FILE *outfile )
/* Output the DLL descriptor */ /* Output the DLL descriptor */
if (rsrc_name[0]) fprintf( outfile, "extern const char %s[];\n\n", rsrc_name ); if (rsrc_name[0]) fprintf( outfile, "extern char %s[];\n\n", rsrc_name );
fprintf( outfile, "static const BUILTIN32_DESCRIPTOR descriptor =\n{\n" ); fprintf( outfile, "static const BUILTIN32_DESCRIPTOR descriptor =\n{\n" );
fprintf( outfile, " \"%s\",\n", DLLName );
fprintf( outfile, " \"%s\",\n", DLLFileName ); fprintf( outfile, " \"%s\",\n", DLLFileName );
fprintf( outfile, " %d,\n", nr_exports? Base : 0 );
fprintf( outfile, " %d,\n", nr_exports );
fprintf( outfile, " %d,\n", nb_names );
fprintf( outfile, " %d,\n", nb_imports ); fprintf( outfile, " %d,\n", nb_imports );
fprintf( outfile, " %d,\n", (fwd_size + 3) & ~3 ); fprintf( outfile, " pe_header,\n" );
fprintf( outfile, " %s,\n", nr_exports ? "Functions" : "0" ); fprintf( outfile, " %s,\n", nr_exports ? "&exports" : "0" );
fprintf( outfile, " %s,\n", nb_names ? "FuncNames" : "0" ); fprintf( outfile, " %s,\n", nr_exports ? "sizeof(exports.exp)" : "0" );
fprintf( outfile, " %s,\n", nb_names ? "FuncOrdinals" : "0" );
fprintf( outfile, " %s,\n", nr_exports ? "FuncArgs" : "0" );
fprintf( outfile, " %s,\n", nr_exports ? "ArgTypes" : "0" );
fprintf( outfile, " %s,\n", nb_imports ? "Imports" : "0" ); fprintf( outfile, " %s,\n", nb_imports ? "Imports" : "0" );
fprintf( outfile, " %s,\n", init_func ? init_func : "0" ); fprintf( outfile, " %s,\n", init_func ? init_func : "0" );
fprintf( outfile, " %d,\n", SpecMode == SPEC_MODE_DLL ? IMAGE_FILE_DLL : 0 ); fprintf( outfile, " %d,\n", SpecMode == SPEC_MODE_DLL ? IMAGE_FILE_DLL : 0 );
@ -1369,7 +1462,7 @@ static int BuildSpec16File( FILE *outfile )
data = (unsigned char *)xmalloc( 0x10000 ); data = (unsigned char *)xmalloc( 0x10000 );
memset( data, 0, 16 ); memset( data, 0, 16 );
data_offset = 16; data_offset = 16;
strupper( DLLName );
/* Build sorted list of all argument types, without duplicates */ /* Build sorted list of all argument types, without duplicates */