mirror of
https://github.com/reactos/wine.git
synced 2024-11-26 21:20:25 +00:00
573 lines
18 KiB
C
573 lines
18 KiB
C
/*
|
|
* Win32 builtin functions
|
|
*
|
|
* Copyright 1997 Alexandre Julliard
|
|
*/
|
|
|
|
#include <assert.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <ctype.h>
|
|
#include "windef.h"
|
|
#include "wingdi.h"
|
|
#include "winuser.h"
|
|
#include "builtin32.h"
|
|
#include "peexe.h"
|
|
#include "neexe.h"
|
|
#include "heap.h"
|
|
#include "main.h"
|
|
#include "snoop.h"
|
|
#include "winerror.h"
|
|
#include "debugtools.h"
|
|
|
|
DEFAULT_DEBUG_CHANNEL(module);
|
|
DECLARE_DEBUG_CHANNEL(relay);
|
|
|
|
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 */
|
|
} DEBUG_ENTRY_POINT;
|
|
|
|
typedef struct
|
|
{
|
|
const BYTE *restab;
|
|
const DWORD nresources;
|
|
const DWORD restabsize;
|
|
const IMAGE_RESOURCE_DATA_ENTRY *entries;
|
|
} BUILTIN32_RESOURCE;
|
|
|
|
#define MAX_DLLS 60
|
|
|
|
static const BUILTIN32_DESCRIPTOR *builtin_dlls[MAX_DLLS];
|
|
static HMODULE dll_modules[MAX_DLLS];
|
|
static int nb_dlls;
|
|
|
|
extern void RELAY_CallFrom32();
|
|
extern void RELAY_CallFrom32Regs();
|
|
|
|
|
|
/***********************************************************************
|
|
* BUILTIN32_WarnSecondInstance
|
|
*
|
|
* Emit a warning when we are creating a second instance for a DLL
|
|
* that is known to not support this.
|
|
*/
|
|
static void BUILTIN32_WarnSecondInstance( const char *name )
|
|
{
|
|
static const char * const warning_list[] =
|
|
{ "comctl32", "comdlg32", "crtdll", "imagehlp", "msacm32", "shell32", NULL };
|
|
|
|
const char * const *ptr = warning_list;
|
|
|
|
while (*ptr)
|
|
{
|
|
if (!strcasecmp( *ptr, name ))
|
|
{
|
|
ERR( "Attempt to instantiate built-in dll '%s' twice "
|
|
"in the same address space. Expect trouble!\n", name );
|
|
return;
|
|
}
|
|
ptr++;
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* BUILTIN32_DoLoadImage
|
|
*
|
|
* Load a built-in Win32 module. Helper function for BUILTIN32_LoadImage.
|
|
*/
|
|
static HMODULE BUILTIN32_DoLoadImage( const BUILTIN32_DESCRIPTOR *descr )
|
|
{
|
|
|
|
IMAGE_DATA_DIRECTORY *dir;
|
|
IMAGE_DOS_HEADER *dos;
|
|
IMAGE_NT_HEADERS *nt;
|
|
IMAGE_SECTION_HEADER *sec;
|
|
IMAGE_EXPORT_DIRECTORY *exp;
|
|
IMAGE_IMPORT_DESCRIPTOR *imp;
|
|
LPVOID *funcs;
|
|
LPSTR *names;
|
|
LPSTR pfwd;
|
|
DEBUG_ENTRY_POINT *debug;
|
|
INT i, size, nb_sections;
|
|
BYTE *addr;
|
|
|
|
/* Allocate the module */
|
|
|
|
nb_sections = 2; /* exports + code */
|
|
if (descr->nb_imports) nb_sections++;
|
|
size = (sizeof(IMAGE_DOS_HEADER)
|
|
+ sizeof(IMAGE_NT_HEADERS)
|
|
+ nb_sections * sizeof(IMAGE_SECTION_HEADER)
|
|
+ (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);
|
|
#ifdef __i386__
|
|
if (WARN_ON(relay) || TRACE_ON(relay))
|
|
size += descr->nb_funcs * sizeof(DEBUG_ENTRY_POINT);
|
|
#endif
|
|
addr = VirtualAlloc( NULL, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE );
|
|
if (!addr) return 0;
|
|
dos = (IMAGE_DOS_HEADER *)addr;
|
|
nt = (IMAGE_NT_HEADERS *)(dos + 1);
|
|
sec = (IMAGE_SECTION_HEADER *)(nt + 1);
|
|
imp = (IMAGE_IMPORT_DESCRIPTOR *)(sec + nb_sections);
|
|
exp = (IMAGE_EXPORT_DIRECTORY *)(imp + descr->nb_imports + 1);
|
|
funcs = (LPVOID *)(exp + 1);
|
|
names = (LPSTR *)(funcs + descr->nb_funcs);
|
|
pfwd = (LPSTR)(names + descr->nb_names);
|
|
debug = (DEBUG_ENTRY_POINT *)(pfwd + descr->fwd_size);
|
|
|
|
/* Build the DOS and NT headers */
|
|
|
|
dos->e_magic = IMAGE_DOS_SIGNATURE;
|
|
dos->e_lfanew = sizeof(*dos);
|
|
|
|
nt->Signature = IMAGE_NT_SIGNATURE;
|
|
nt->FileHeader.Machine = IMAGE_FILE_MACHINE_I386;
|
|
nt->FileHeader.NumberOfSections = nb_sections;
|
|
nt->FileHeader.SizeOfOptionalHeader = sizeof(nt->OptionalHeader);
|
|
nt->FileHeader.Characteristics = descr->characteristics;
|
|
|
|
nt->OptionalHeader.Magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
|
|
nt->OptionalHeader.SizeOfCode = 0x1000;
|
|
nt->OptionalHeader.SizeOfInitializedData = 0;
|
|
nt->OptionalHeader.SizeOfUninitializedData = 0;
|
|
nt->OptionalHeader.ImageBase = (DWORD)addr;
|
|
nt->OptionalHeader.SectionAlignment = 0x1000;
|
|
nt->OptionalHeader.FileAlignment = 0x1000;
|
|
nt->OptionalHeader.MajorOperatingSystemVersion = 1;
|
|
nt->OptionalHeader.MinorOperatingSystemVersion = 0;
|
|
nt->OptionalHeader.MajorSubsystemVersion = 4;
|
|
nt->OptionalHeader.MinorSubsystemVersion = 0;
|
|
nt->OptionalHeader.SizeOfImage = size;
|
|
nt->OptionalHeader.SizeOfHeaders = (BYTE *)exp - addr;
|
|
nt->OptionalHeader.NumberOfRvaAndSizes = IMAGE_NUMBEROF_DIRECTORY_ENTRIES;
|
|
if (descr->dllentrypoint)
|
|
nt->OptionalHeader.AddressOfEntryPoint = (DWORD)descr->dllentrypoint - (DWORD)addr;
|
|
|
|
/* Build the code section */
|
|
|
|
strcpy( sec->Name, ".code" );
|
|
sec->SizeOfRawData = 0;
|
|
#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->VirtualAddress = (BYTE *)debug - addr;
|
|
sec->PointerToRawData = (BYTE *)debug - addr;
|
|
sec->Characteristics = (IMAGE_SCN_CNT_INITIALIZED_DATA |
|
|
IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ);
|
|
sec++;
|
|
|
|
/* Build the import directory */
|
|
|
|
if (descr->nb_imports)
|
|
{
|
|
dir = &nt->OptionalHeader.DataDirectory[IMAGE_FILE_IMPORT_DIRECTORY];
|
|
dir->VirtualAddress = (BYTE *)imp - addr;
|
|
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 */
|
|
for (i = 0; i < descr->nb_imports; i++)
|
|
{
|
|
imp[i].u.Characteristics = 0;
|
|
imp[i].ForwarderChain = -1;
|
|
imp[i].Name = (BYTE *)descr->imports[i] - addr;
|
|
/* hack: make first thunk point to some zero value */
|
|
imp[i].FirstThunk = (PIMAGE_THUNK_DATA)((BYTE *)&imp[i].u.Characteristics - addr);
|
|
}
|
|
}
|
|
|
|
/* 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);
|
|
sec++;
|
|
|
|
/* Build the resource directory */
|
|
if(descr->rsrc)
|
|
{
|
|
const BUILTIN32_RESOURCE *rsrc = descr->rsrc;
|
|
int i;
|
|
void *rtab;
|
|
IMAGE_RESOURCE_DATA_ENTRY *rdep;
|
|
|
|
rtab = HeapAlloc(GetProcessHeap(), 0, rsrc->restabsize);
|
|
if(!rtab)
|
|
{
|
|
ERR("Failed to get memory for resource directory\n");
|
|
VirtualFree(addr, size, MEM_RELEASE);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* 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->VirtualAddress = (DWORD)rtab - (DWORD)addr;
|
|
dir->Size = rsrc->restabsize;
|
|
rdep = (IMAGE_RESOURCE_DATA_ENTRY *)((DWORD)rtab + (DWORD)rsrc->entries - (DWORD)rsrc->restab);
|
|
for(i = 0; i < rsrc->nresources; i++)
|
|
{
|
|
rdep[i].OffsetToData += (DWORD)rsrc->restab - (DWORD)addr;
|
|
}
|
|
}
|
|
|
|
/* Build the exports section data */
|
|
|
|
exp->Name = ((BYTE *)descr->name) - addr; /*??*/
|
|
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];
|
|
int j;
|
|
|
|
if (!descr->functions[i]) continue;
|
|
|
|
if (args == 0xfd) /* forward func */
|
|
{
|
|
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;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* BUILTIN32_LoadLibraryExA
|
|
*
|
|
* Partly copied from the original PE_ version.
|
|
*
|
|
*/
|
|
WINE_MODREF *BUILTIN32_LoadLibraryExA(LPCSTR path, DWORD flags, DWORD *err)
|
|
{
|
|
HMODULE16 hModule16;
|
|
NE_MODULE *pModule;
|
|
WINE_MODREF *wm;
|
|
char dllname[MAX_PATH], *p;
|
|
int i;
|
|
|
|
/* Fix the name in case we have a full path and extension */
|
|
if ((p = strrchr( path, '\\' ))) path = p + 1;
|
|
lstrcpynA( dllname, path, sizeof(dllname) );
|
|
|
|
p = strrchr( dllname, '.' );
|
|
if (!p) strcat( dllname, ".dll" );
|
|
|
|
/* Search built-in descriptor */
|
|
for (i = 0; i < nb_dlls; i++)
|
|
if (!lstrcmpiA( builtin_dlls[i]->filename, dllname )) break;
|
|
|
|
if (i == nb_dlls)
|
|
{
|
|
*err = ERROR_FILE_NOT_FOUND;
|
|
return NULL;
|
|
}
|
|
|
|
/* Load built-in module */
|
|
if (!dll_modules[i])
|
|
{
|
|
if (!(dll_modules[i] = BUILTIN32_DoLoadImage( builtin_dlls[i] )))
|
|
{
|
|
*err = ERROR_FILE_NOT_FOUND;
|
|
return NULL;
|
|
}
|
|
}
|
|
else BUILTIN32_WarnSecondInstance( builtin_dlls[i]->name );
|
|
|
|
/* Create 16-bit dummy module */
|
|
if ((hModule16 = MODULE_CreateDummyModule( dllname, 0 )) < 32)
|
|
{
|
|
*err = (DWORD)hModule16;
|
|
return NULL; /* FIXME: Should unload the builtin module */
|
|
}
|
|
|
|
pModule = (NE_MODULE *)GlobalLock16( hModule16 );
|
|
pModule->flags = NE_FFLAGS_LIBMODULE | NE_FFLAGS_SINGLEDATA | NE_FFLAGS_WIN32 | NE_FFLAGS_BUILTIN;
|
|
pModule->module32 = dll_modules[i];
|
|
|
|
/* Create 32-bit MODREF */
|
|
if ( !(wm = PE_CreateModule( pModule->module32, dllname, flags, TRUE )) )
|
|
{
|
|
ERR( "can't load %s\n", path );
|
|
FreeLibrary16( hModule16 ); /* FIXME: Should unload the builtin module */
|
|
*err = ERROR_OUTOFMEMORY;
|
|
return NULL;
|
|
}
|
|
|
|
if (wm->binfmt.pe.pe_export)
|
|
SNOOP_RegisterDLL(wm->module,wm->modname,wm->binfmt.pe.pe_export->NumberOfFunctions);
|
|
|
|
*err = 0;
|
|
return wm;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* BUILTIN32_LoadExeModule
|
|
*/
|
|
HMODULE16 BUILTIN32_LoadExeModule( void )
|
|
{
|
|
HMODULE16 hModule16;
|
|
NE_MODULE *pModule;
|
|
int i, exe = -1;
|
|
|
|
/* Search built-in EXE descriptor */
|
|
for ( i = 0; i < nb_dlls; i++ )
|
|
if ( !(builtin_dlls[i]->characteristics & IMAGE_FILE_DLL) )
|
|
{
|
|
if ( exe != -1 )
|
|
{
|
|
MESSAGE( "More than one built-in EXE module loaded!\n" );
|
|
break;
|
|
}
|
|
|
|
exe = i;
|
|
}
|
|
|
|
if ( exe == -1 )
|
|
{
|
|
MESSAGE( "No built-in EXE module loaded! Did you create a .spec file?\n" );
|
|
return 0;
|
|
}
|
|
|
|
/* Load built-in module */
|
|
if ( !dll_modules[exe] )
|
|
if ( !(dll_modules[exe] = BUILTIN32_DoLoadImage( builtin_dlls[exe] )) )
|
|
return 0;
|
|
|
|
/* Create 16-bit dummy module */
|
|
hModule16 = MODULE_CreateDummyModule( builtin_dlls[exe]->filename, 0 );
|
|
if ( hModule16 < 32 ) return 0;
|
|
pModule = (NE_MODULE *)GlobalLock16( hModule16 );
|
|
pModule->flags = NE_FFLAGS_SINGLEDATA | NE_FFLAGS_WIN32 | NE_FFLAGS_BUILTIN;
|
|
pModule->module32 = dll_modules[exe];
|
|
|
|
return hModule16;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* BUILTIN32_UnloadLibrary
|
|
*
|
|
* Unload the built-in library and free the modref.
|
|
*/
|
|
void BUILTIN32_UnloadLibrary(WINE_MODREF *wm)
|
|
{
|
|
/* 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
|
|
*
|
|
* Register a built-in DLL descriptor.
|
|
*/
|
|
void BUILTIN32_RegisterDLL( const BUILTIN32_DESCRIPTOR *descr )
|
|
{
|
|
assert( nb_dlls < MAX_DLLS );
|
|
builtin_dlls[nb_dlls++] = descr;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* BUILTIN32_Unimplemented
|
|
*
|
|
* This function is called for unimplemented 32-bit entry points (declared
|
|
* as 'stub' in the spec file).
|
|
*/
|
|
void BUILTIN32_Unimplemented( const BUILTIN32_DESCRIPTOR *descr, int ordinal )
|
|
{
|
|
const char *func_name = "???";
|
|
int i;
|
|
|
|
__RESTORE_ES; /* Just in case */
|
|
|
|
for (i = 0; i < descr->nb_names; i++)
|
|
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__
|
|
MESSAGE( " (called from %p)", __builtin_return_address(1) );
|
|
#endif
|
|
MESSAGE( "\n" );
|
|
ExitProcess(1);
|
|
}
|