mirror of
git://source.winehq.org/git/wine.git
synced 2024-09-05 19:29:43 +00:00
Modified process creation sequence: call PE_CreateModule in the
context of the new process (in TASK_CallToStart). Changed all PE/Module routines so as to always operate on the current process; adapted all callers.
This commit is contained in:
Ulrich Weigand
Alexandre Julliard
parent
219cfd8387
commit
1d90d69f08
|
|
@ -143,15 +143,15 @@ typedef struct resource_nameinfo_s NE_NAMEINFO;
|
|||
(((OFSTRUCT *)((char*)(pModule) + (pModule)->fileinfo))->szPathName)
|
||||
|
||||
/* module.c */
|
||||
extern FARPROC32 MODULE_GetProcAddress32( struct _PDB32*pdb,HMODULE32 hModule,LPCSTR function,BOOL32 snoop );
|
||||
extern WINE_MODREF *MODULE32_LookupHMODULE( struct _PDB32 *process, HMODULE32 hModule );
|
||||
extern void MODULE_InitializeDLLs( struct _PDB32 *process, HMODULE32 root, DWORD type, LPVOID lpReserved );
|
||||
extern HMODULE32 MODULE_FindModule32( struct _PDB32 *process, LPCSTR path );
|
||||
extern FARPROC32 MODULE_GetProcAddress32( HMODULE32 hModule, LPCSTR function, BOOL32 snoop );
|
||||
extern WINE_MODREF *MODULE32_LookupHMODULE( HMODULE32 hModule );
|
||||
extern void MODULE_InitializeDLLs( HMODULE32 root, DWORD type, LPVOID lpReserved );
|
||||
extern HMODULE32 MODULE_FindModule32( LPCSTR path );
|
||||
extern HMODULE32 MODULE_CreateDummyModule( const OFSTRUCT *ofs, LPCSTR modName );
|
||||
extern FARPROC16 MODULE_GetWndProcEntry16( const char *name );
|
||||
extern FARPROC16 WINAPI WIN32_GetProcAddress16( HMODULE32 hmodule, LPCSTR name );
|
||||
extern SEGPTR WINAPI HasGPHandler( SEGPTR address );
|
||||
HMODULE32 MODULE_LoadLibraryEx32A(LPCSTR libname,struct _PDB32*process,HFILE32 hfile,DWORD flags);
|
||||
HMODULE32 MODULE_LoadLibraryEx32A( LPCSTR libname, HFILE32 hfile, DWORD flags );
|
||||
|
||||
/* loader/ne/module.c */
|
||||
extern NE_MODULE *NE_GetPtr( HMODULE16 hModule );
|
||||
|
|
|
|||
|
|
@ -20,12 +20,9 @@ typedef struct {
|
|||
int tlsindex;
|
||||
} PE_MODREF;
|
||||
|
||||
struct _PDB32;
|
||||
struct _wine_modref;
|
||||
extern int PE_unloadImage(HMODULE32 hModule);
|
||||
extern FARPROC32 PE_FindExportedFunction(
|
||||
struct _PDB32 *process,struct _wine_modref *wm, LPCSTR funcName, BOOL32 snoop
|
||||
);
|
||||
extern FARPROC32 PE_FindExportedFunction(struct _wine_modref *wm, LPCSTR funcName, BOOL32 snoop);
|
||||
extern BOOL32 PE_EnumResourceTypes32A(HMODULE32,ENUMRESTYPEPROC32A,LONG);
|
||||
extern BOOL32 PE_EnumResourceTypes32W(HMODULE32,ENUMRESTYPEPROC32W,LONG);
|
||||
extern BOOL32 PE_EnumResourceNames32A(HMODULE32,LPCSTR,ENUMRESNAMEPROC32A,LONG);
|
||||
|
|
@ -34,8 +31,11 @@ extern BOOL32 PE_EnumResourceLanguages32A(HMODULE32,LPCSTR,LPCSTR,ENUMRESLANGPRO
|
|||
extern BOOL32 PE_EnumResourceLanguages32W(HMODULE32,LPCWSTR,LPCWSTR,ENUMRESLANGPROC32W,LONG);
|
||||
extern HRSRC32 PE_FindResourceEx32W(struct _wine_modref*,LPCWSTR,LPCWSTR,WORD);
|
||||
extern DWORD PE_SizeofResource32(HMODULE32,HRSRC32);
|
||||
extern HMODULE32 PE_LoadLibraryEx32A(LPCSTR,struct _PDB32*,HFILE32,DWORD);
|
||||
extern HMODULE32 PE_LoadLibraryEx32A(LPCSTR,HFILE32,DWORD);
|
||||
extern HGLOBAL32 PE_LoadResource32(struct _wine_modref *wm,HRSRC32);
|
||||
extern HMODULE32 PE_LoadImage( LPCSTR name, OFSTRUCT *ofs, LPCSTR *modName );
|
||||
extern struct _wine_modref *PE_CreateModule( HMODULE32 hModule, OFSTRUCT *ofs,
|
||||
DWORD flags, BOOL32 builtin );
|
||||
extern HINSTANCE16 PE_CreateProcess( LPCSTR name, LPCSTR cmd_line,
|
||||
LPCSTR env, BOOL32 inherit, LPSTARTUPINFO32A startup,
|
||||
LPPROCESS_INFORMATION info );
|
||||
|
|
@ -69,8 +69,8 @@ typedef struct {
|
|||
ELF_STDCALL_STUB *stubs;
|
||||
} ELF_MODREF;
|
||||
|
||||
extern struct _wine_modref *ELF_CreateDummyModule(LPCSTR,LPCSTR,struct _PDB32 *);
|
||||
extern HMODULE32 ELF_LoadLibraryEx32A(LPCSTR,struct _PDB32*,HFILE32,DWORD);
|
||||
extern FARPROC32 ELF_FindExportedFunction(struct _PDB32 *process,struct _wine_modref *wm, LPCSTR funcName);
|
||||
extern struct _wine_modref *ELF_CreateDummyModule(LPCSTR,LPCSTR);
|
||||
extern HMODULE32 ELF_LoadLibraryEx32A(LPCSTR,HFILE32,DWORD);
|
||||
extern FARPROC32 ELF_FindExportedFunction(struct _wine_modref *wm, LPCSTR funcName);
|
||||
|
||||
#endif /* __WINE_PE_IMAGE_H */
|
||||
|
|
|
|||
45
loader/elf.c
45
loader/elf.c
|
|
@ -25,8 +25,7 @@
|
|||
#include "module.h"
|
||||
#include "debug.h"
|
||||
|
||||
WINE_MODREF *
|
||||
ELF_CreateDummyModule( LPCSTR libname, LPCSTR modname, PDB32 *process )
|
||||
WINE_MODREF *ELF_CreateDummyModule( LPCSTR libname, LPCSTR modname )
|
||||
{
|
||||
PIMAGE_DOS_HEADER dh;
|
||||
PIMAGE_NT_HEADERS nth;
|
||||
|
|
@ -34,17 +33,20 @@ ELF_CreateDummyModule( LPCSTR libname, LPCSTR modname, PDB32 *process )
|
|||
WINE_MODREF *wm;
|
||||
HMODULE32 hmod;
|
||||
|
||||
wm=(WINE_MODREF*)HeapAlloc(process->heap,HEAP_ZERO_MEMORY,sizeof(*wm));
|
||||
wm=(WINE_MODREF*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wm) );
|
||||
wm->type = MODULE32_ELF;
|
||||
|
||||
/* FIXME: hmm, order? */
|
||||
wm->next = process->modref_list;
|
||||
process->modref_list = wm;
|
||||
wm->next = PROCESS_Current()->modref_list;
|
||||
PROCESS_Current()->modref_list = wm;
|
||||
|
||||
wm->modname = HEAP_strdupA(process->heap,0,modname);
|
||||
wm->longname = HEAP_strdupA(process->heap,0,libname);
|
||||
wm->modname = HEAP_strdupA( GetProcessHeap(), 0, modname );
|
||||
wm->longname = HEAP_strdupA( GetProcessHeap(), 0, libname );
|
||||
|
||||
hmod = (HMODULE32)HeapAlloc(process->heap,HEAP_ZERO_MEMORY,sizeof(IMAGE_DOS_HEADER)+sizeof(IMAGE_NT_HEADERS)+sizeof(IMAGE_SECTION_HEADER)+100);
|
||||
hmod = (HMODULE32)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
|
||||
sizeof(IMAGE_DOS_HEADER) +
|
||||
sizeof(IMAGE_NT_HEADERS) +
|
||||
sizeof(IMAGE_SECTION_HEADER) + 100 );
|
||||
dh = (PIMAGE_DOS_HEADER)hmod;
|
||||
dh->e_magic = IMAGE_DOS_SIGNATURE;
|
||||
dh->e_lfanew = sizeof(IMAGE_DOS_HEADER);
|
||||
|
|
@ -94,13 +96,14 @@ ELF_CreateDummyModule( LPCSTR libname, LPCSTR modname, PDB32 *process )
|
|||
|
||||
#include <dlfcn.h>
|
||||
|
||||
HMODULE32
|
||||
ELF_LoadLibraryEx32A(LPCSTR libname,PDB32 *process,HANDLE32 hf,DWORD flags) {
|
||||
HMODULE32 ELF_LoadLibraryEx32A( LPCSTR libname, HANDLE32 hf, DWORD flags )
|
||||
{
|
||||
WINE_MODREF *wm;
|
||||
char *modname,*s,*t,*x;
|
||||
LPVOID *dlhandle;
|
||||
|
||||
t = HeapAlloc(process->heap,HEAP_ZERO_MEMORY,strlen(libname)+strlen("lib.so")+1);
|
||||
t = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
|
||||
strlen(libname) + strlen("lib.so") + 1 );
|
||||
*t = '\0';
|
||||
/* copy path to tempvar ... */
|
||||
s=strrchr(libname,'/');
|
||||
|
|
@ -130,19 +133,19 @@ ELF_LoadLibraryEx32A(LPCSTR libname,PDB32 *process,HANDLE32 hf,DWORD flags) {
|
|||
/* ... and open it */
|
||||
dlhandle = dlopen(t,RTLD_NOW);
|
||||
if (!dlhandle) {
|
||||
HeapFree(process->heap,0,t);
|
||||
HeapFree( GetProcessHeap(), 0, t );
|
||||
return 0;
|
||||
}
|
||||
|
||||
wm = ELF_CreateDummyModule( t, modname, process );
|
||||
wm = ELF_CreateDummyModule( t, modname );
|
||||
wm->binfmt.elf.dlhandle = dlhandle;
|
||||
|
||||
SNOOP_RegisterDLL(wm->module,libname,STUBSIZE/sizeof(ELF_STDCALL_STUB));
|
||||
return wm->module;
|
||||
}
|
||||
|
||||
FARPROC32
|
||||
ELF_FindExportedFunction( PDB32 *process,WINE_MODREF *wm, LPCSTR funcName) {
|
||||
FARPROC32 ELF_FindExportedFunction( WINE_MODREF *wm, LPCSTR funcName)
|
||||
{
|
||||
LPVOID fun;
|
||||
int i,nrofargs = 0;
|
||||
ELF_STDCALL_STUB *stub;
|
||||
|
|
@ -163,14 +166,14 @@ ELF_FindExportedFunction( PDB32 *process,WINE_MODREF *wm, LPCSTR funcName) {
|
|||
* with nrofargs bytes that are popped at the end
|
||||
*/
|
||||
if (strchr(funcName,'@')) {
|
||||
LPSTR t,fn = HEAP_strdupA(process->heap,0,funcName);
|
||||
LPSTR t,fn = HEAP_strdupA( GetProcessHeap(), 0, funcName );
|
||||
|
||||
t = strchr(fn,'@');
|
||||
*t = '\0';
|
||||
nrofargs = 0;
|
||||
sscanf(t+1,"%d",&nrofargs);
|
||||
fun = dlsym(wm->binfmt.elf.dlhandle,fn);
|
||||
HeapFree(process->heap,0,fn);
|
||||
HeapFree( GetProcessHeap(), 0, fn );
|
||||
}
|
||||
}
|
||||
/* We sometimes have Win32 dlls implemented using stdcall but UNIX
|
||||
|
|
@ -242,12 +245,12 @@ ELF_FindExportedFunction( PDB32 *process,WINE_MODREF *wm, LPCSTR funcName) {
|
|||
}
|
||||
#else
|
||||
|
||||
HMODULE32
|
||||
ELF_LoadLibraryEx32A(LPCSTR libname,PDB32 *process,HANDLE32 hf,DWORD flags) {
|
||||
HMODULE32 ELF_LoadLibraryEx32A( LPCSTR libname, HANDLE32 hf, DWORD flags)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
FARPROC32
|
||||
ELF_FindExportedFunction( PDB32 *process,WINE_MODREF *wm, LPCSTR funcName) {
|
||||
FARPROC32 ELF_FindExportedFunction( WINE_MODREF *wm, LPCSTR funcName)
|
||||
{
|
||||
return (FARPROC32)0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -282,7 +282,7 @@ HINSTANCE32 MAIN_WinelibInit( int *argc, char *argv[] )
|
|||
if (!MAIN_KernelInit(0, 0, NULL)) return 0;
|
||||
|
||||
/* Create and switch to initial task */
|
||||
if (!(wm = ELF_CreateDummyModule( argv[0], argv[0], PROCESS_Current() )))
|
||||
if (!(wm = ELF_CreateDummyModule( argv[0], argv[0] )))
|
||||
return 0;
|
||||
PROCESS_Current()->exe_modref = wm;
|
||||
|
||||
|
|
|
|||
106
loader/module.c
106
loader/module.c
|
|
@ -36,17 +36,18 @@ extern BOOL32 THREAD_InitDone;
|
|||
* MODULE32_LookupHMODULE
|
||||
* looks for the referenced HMODULE in the current process
|
||||
*/
|
||||
WINE_MODREF*
|
||||
MODULE32_LookupHMODULE(PDB32 *process,HMODULE32 hmod) {
|
||||
WINE_MODREF *MODULE32_LookupHMODULE( HMODULE32 hmod )
|
||||
{
|
||||
WINE_MODREF *wm;
|
||||
|
||||
if (!hmod)
|
||||
return process->exe_modref;
|
||||
return PROCESS_Current()->exe_modref;
|
||||
|
||||
if (!HIWORD(hmod)) {
|
||||
ERR(module,"tried to lookup 0x%04x in win32 module handler!\n",hmod);
|
||||
return NULL;
|
||||
}
|
||||
for (wm = process->modref_list;wm;wm=wm->next)
|
||||
for ( wm = PROCESS_Current()->modref_list; wm; wm=wm->next )
|
||||
if (wm->module == hmod)
|
||||
return wm;
|
||||
return NULL;
|
||||
|
|
@ -70,14 +71,14 @@ MODULE32_LookupHMODULE(PDB32 *process,HMODULE32 hmod) {
|
|||
* from itself, but also via LoadLibrary from one of the called initialization
|
||||
* routines.)
|
||||
*/
|
||||
static void MODULE_DoInitializeDLLs( PDB32 *process, WINE_MODREF *wm,
|
||||
static void MODULE_DoInitializeDLLs( WINE_MODREF *wm,
|
||||
DWORD type, LPVOID lpReserved )
|
||||
{
|
||||
int i;
|
||||
|
||||
assert( wm && !wm->initDone );
|
||||
TRACE( module, "(%p,%08x,%ld,%p) - START\n",
|
||||
process, wm->module, type, lpReserved );
|
||||
TRACE( module, "(%08x,%ld,%p) - START\n",
|
||||
wm->module, type, lpReserved );
|
||||
|
||||
/* Tag current MODREF to prevent recursive loop */
|
||||
wm->initDone = TRUE;
|
||||
|
|
@ -85,8 +86,7 @@ static void MODULE_DoInitializeDLLs( PDB32 *process, WINE_MODREF *wm,
|
|||
/* Recursively initialize all child DLLs */
|
||||
for ( i = 0; i < wm->nDeps; i++ )
|
||||
if ( wm->deps[i] && !wm->deps[i]->initDone )
|
||||
MODULE_DoInitializeDLLs( process,
|
||||
wm->deps[i], type, lpReserved );
|
||||
MODULE_DoInitializeDLLs( wm->deps[i], type, lpReserved );
|
||||
|
||||
/* Now we can call the initialization routine */
|
||||
switch ( wm->type )
|
||||
|
|
@ -103,24 +103,23 @@ static void MODULE_DoInitializeDLLs( PDB32 *process, WINE_MODREF *wm,
|
|||
break;
|
||||
}
|
||||
|
||||
TRACE( module, "(%p,%08x,%ld,%p) - END\n",
|
||||
process, wm->module, type, lpReserved );
|
||||
TRACE( module, "(%08x,%ld,%p) - END\n",
|
||||
wm->module, type, lpReserved );
|
||||
}
|
||||
|
||||
void MODULE_InitializeDLLs( PDB32 *process, HMODULE32 root,
|
||||
DWORD type, LPVOID lpReserved )
|
||||
void MODULE_InitializeDLLs( HMODULE32 root, DWORD type, LPVOID lpReserved )
|
||||
{
|
||||
BOOL32 inProgress = FALSE;
|
||||
WINE_MODREF *wm;
|
||||
|
||||
/* Grab the process critical section to protect the recursion flags */
|
||||
/* FIXME: This is probably overkill! */
|
||||
EnterCriticalSection( &process->crit_section );
|
||||
EnterCriticalSection( &PROCESS_Current()->crit_section );
|
||||
|
||||
TRACE( module, "(%p,%08x,%ld,%p) - START\n", process, root, type, lpReserved );
|
||||
TRACE( module, "(%08x,%ld,%p) - START\n", root, type, lpReserved );
|
||||
|
||||
/* First, check whether initialization is currently in progress */
|
||||
for ( wm = process->modref_list; wm; wm = wm->next )
|
||||
for ( wm = PROCESS_Current()->modref_list; wm; wm = wm->next )
|
||||
if ( wm->initDone )
|
||||
{
|
||||
inProgress = TRUE;
|
||||
|
|
@ -136,9 +135,9 @@ void MODULE_InitializeDLLs( PDB32 *process, HMODULE32 root,
|
|||
*/
|
||||
if ( root )
|
||||
{
|
||||
wm = MODULE32_LookupHMODULE( process, root );
|
||||
wm = MODULE32_LookupHMODULE( root );
|
||||
if ( wm && !wm->initDone )
|
||||
MODULE_DoInitializeDLLs( process, wm, type, lpReserved );
|
||||
MODULE_DoInitializeDLLs( wm, type, lpReserved );
|
||||
}
|
||||
else
|
||||
FIXME(module, "Invalid recursion!\n");
|
||||
|
|
@ -149,26 +148,26 @@ void MODULE_InitializeDLLs( PDB32 *process, HMODULE32 root,
|
|||
if ( !root )
|
||||
{
|
||||
/* If called for main EXE, initialize all DLLs */
|
||||
for ( wm = process->modref_list; wm; wm = wm->next )
|
||||
for ( wm = PROCESS_Current()->modref_list; wm; wm = wm->next )
|
||||
if ( !wm->initDone )
|
||||
MODULE_DoInitializeDLLs( process, wm, type, lpReserved );
|
||||
MODULE_DoInitializeDLLs( wm, type, lpReserved );
|
||||
}
|
||||
else
|
||||
{
|
||||
/* If called for a specific DLL, initialize only it and its children */
|
||||
wm = MODULE32_LookupHMODULE( process, root );
|
||||
if (wm) MODULE_DoInitializeDLLs( process, wm, type, lpReserved );
|
||||
wm = MODULE32_LookupHMODULE( root );
|
||||
if (wm) MODULE_DoInitializeDLLs( wm, type, lpReserved );
|
||||
}
|
||||
|
||||
/* We're finished, so we reset all recursion flags */
|
||||
for ( wm = process->modref_list; wm; wm = wm->next )
|
||||
for ( wm = PROCESS_Current()->modref_list; wm; wm = wm->next )
|
||||
wm->initDone = FALSE;
|
||||
}
|
||||
|
||||
TRACE( module, "(%p,%08x,%ld,%p) - END\n", process, root, type, lpReserved );
|
||||
TRACE( module, "(%08x,%ld,%p) - END\n", root, type, lpReserved );
|
||||
|
||||
/* Release critical section */
|
||||
LeaveCriticalSection( &process->crit_section );
|
||||
LeaveCriticalSection( &PROCESS_Current()->crit_section );
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -339,26 +338,23 @@ FARPROC16 MODULE_GetWndProcEntry16( LPCSTR name )
|
|||
* 0 if not
|
||||
*/
|
||||
HMODULE32 MODULE_FindModule32(
|
||||
PDB32* process, /* [in] process in which to find the library */
|
||||
LPCSTR path /* [in] pathname of module/library to be found */
|
||||
) {
|
||||
LPSTR filename;
|
||||
LPSTR dotptr;
|
||||
WINE_MODREF *wm;
|
||||
|
||||
if (!process)
|
||||
return 0;
|
||||
if (!(filename = strrchr( path, '\\' )))
|
||||
filename = HEAP_strdupA(process->heap,0,path);
|
||||
filename = HEAP_strdupA( GetProcessHeap(), 0, path );
|
||||
else
|
||||
filename = HEAP_strdupA(process->heap,0,filename+1);
|
||||
filename = HEAP_strdupA( GetProcessHeap(), 0, filename+1 );
|
||||
dotptr=strrchr(filename,'.');
|
||||
|
||||
for (wm=process->modref_list;wm;wm=wm->next) {
|
||||
for ( wm = PROCESS_Current()->modref_list; wm; wm=wm->next ) {
|
||||
LPSTR xmodname,xdotptr;
|
||||
|
||||
assert (wm->modname);
|
||||
xmodname = HEAP_strdupA(process->heap,0,wm->modname);
|
||||
xmodname = HEAP_strdupA( GetProcessHeap(), 0, wm->modname );
|
||||
xdotptr=strrchr(xmodname,'.');
|
||||
if ( (xdotptr && !dotptr) ||
|
||||
(!xdotptr && dotptr)
|
||||
|
|
@ -367,16 +363,16 @@ HMODULE32 MODULE_FindModule32(
|
|||
if (xdotptr) *xdotptr = '\0';
|
||||
}
|
||||
if (!strcasecmp( filename, xmodname)) {
|
||||
HeapFree(process->heap,0,filename);
|
||||
HeapFree(process->heap,0,xmodname);
|
||||
HeapFree( GetProcessHeap(), 0, filename );
|
||||
HeapFree( GetProcessHeap(), 0, xmodname );
|
||||
return wm->module;
|
||||
}
|
||||
if (dotptr) *dotptr='.';
|
||||
/* FIXME: add paths, shortname */
|
||||
HeapFree(process->heap,0,xmodname);
|
||||
HeapFree( GetProcessHeap(), 0, xmodname );
|
||||
}
|
||||
/* if that fails, try looking for the filename... */
|
||||
for (wm=process->modref_list;wm;wm=wm->next) {
|
||||
for ( wm = PROCESS_Current()->modref_list; wm; wm=wm->next ) {
|
||||
LPSTR xlname,xdotptr;
|
||||
|
||||
assert (wm->longname);
|
||||
|
|
@ -385,7 +381,7 @@ HMODULE32 MODULE_FindModule32(
|
|||
xlname = wm->longname;
|
||||
else
|
||||
xlname++;
|
||||
xlname = HEAP_strdupA(process->heap,0,xlname);
|
||||
xlname = HEAP_strdupA( GetProcessHeap(), 0, xlname );
|
||||
xdotptr=strrchr(xlname,'.');
|
||||
if ( (xdotptr && !dotptr) ||
|
||||
(!xdotptr && dotptr)
|
||||
|
|
@ -394,15 +390,15 @@ HMODULE32 MODULE_FindModule32(
|
|||
if (xdotptr) *xdotptr = '\0';
|
||||
}
|
||||
if (!strcasecmp( filename, xlname)) {
|
||||
HeapFree(process->heap,0,filename);
|
||||
HeapFree(process->heap,0,xlname);
|
||||
HeapFree( GetProcessHeap(), 0, filename );
|
||||
HeapFree( GetProcessHeap(), 0, xlname );
|
||||
return wm->module;
|
||||
}
|
||||
if (dotptr) *dotptr='.';
|
||||
/* FIXME: add paths, shortname */
|
||||
HeapFree(process->heap,0,xlname);
|
||||
HeapFree( GetProcessHeap(), 0, xlname );
|
||||
}
|
||||
HeapFree(process->heap,0,filename);
|
||||
HeapFree( GetProcessHeap(), 0, filename );
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -748,7 +744,7 @@ HMODULE32 WINAPI GetModuleHandle32A(LPCSTR module)
|
|||
if (module == NULL)
|
||||
return PROCESS_Current()->exe_modref->module;
|
||||
else
|
||||
return MODULE_FindModule32(PROCESS_Current(),module);
|
||||
return MODULE_FindModule32( module );
|
||||
}
|
||||
|
||||
HMODULE32 WINAPI GetModuleHandle32W(LPCWSTR module)
|
||||
|
|
@ -769,7 +765,7 @@ DWORD WINAPI GetModuleFileName32A(
|
|||
LPSTR lpFileName, /* [out] filenamebuffer */
|
||||
DWORD size /* [in] size of filenamebuffer */
|
||||
) {
|
||||
WINE_MODREF *wm = MODULE32_LookupHMODULE(PROCESS_Current(),hModule);
|
||||
WINE_MODREF *wm = MODULE32_LookupHMODULE( hModule );
|
||||
|
||||
if (!wm) /* can happen on start up or the like */
|
||||
return 0;
|
||||
|
|
@ -815,7 +811,7 @@ HMODULE32 WINAPI LoadLibraryEx32W16( LPCSTR libname, HANDLE16 hf,
|
|||
HMODULE32 WINAPI LoadLibraryEx32A(LPCSTR libname,HFILE32 hfile,DWORD flags)
|
||||
{
|
||||
HMODULE32 hmod;
|
||||
hmod = MODULE_LoadLibraryEx32A(libname,PROCESS_Current(),hfile,flags);
|
||||
hmod = MODULE_LoadLibraryEx32A( libname, hfile, flags );
|
||||
|
||||
/* at least call not the dllmain...*/
|
||||
if ( DONT_RESOLVE_DLL_REFERENCES==flags || LOAD_LIBRARY_AS_DATAFILE==flags )
|
||||
|
|
@ -825,20 +821,19 @@ HMODULE32 WINAPI LoadLibraryEx32A(LPCSTR libname,HFILE32 hfile,DWORD flags)
|
|||
|
||||
/* initialize DLL just loaded */
|
||||
if ( hmod >= 32 )
|
||||
MODULE_InitializeDLLs( PROCESS_Current(), hmod,
|
||||
DLL_PROCESS_ATTACH, (LPVOID)-1 );
|
||||
MODULE_InitializeDLLs( hmod, DLL_PROCESS_ATTACH, (LPVOID)-1 );
|
||||
|
||||
return hmod;
|
||||
}
|
||||
|
||||
HMODULE32 MODULE_LoadLibraryEx32A(LPCSTR libname,PDB32*process,HFILE32 hfile,DWORD flags)
|
||||
HMODULE32 MODULE_LoadLibraryEx32A( LPCSTR libname, HFILE32 hfile, DWORD flags )
|
||||
{
|
||||
HMODULE32 hmod;
|
||||
|
||||
hmod = ELF_LoadLibraryEx32A(libname,process,hfile,flags);
|
||||
hmod = ELF_LoadLibraryEx32A( libname, hfile, flags );
|
||||
if (hmod) return hmod;
|
||||
|
||||
hmod = PE_LoadLibraryEx32A(libname,process,hfile,flags);
|
||||
hmod = PE_LoadLibraryEx32A( libname, hfile, flags );
|
||||
return hmod;
|
||||
}
|
||||
|
||||
|
|
@ -1130,7 +1125,7 @@ FARPROC16 WINAPI GetProcAddress16( HMODULE16 hModule, SEGPTR name )
|
|||
*/
|
||||
FARPROC32 WINAPI GetProcAddress32( HMODULE32 hModule, LPCSTR function )
|
||||
{
|
||||
return MODULE_GetProcAddress32( PROCESS_Current(), hModule, function, TRUE );
|
||||
return MODULE_GetProcAddress32( hModule, function, TRUE );
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
|
|
@ -1138,19 +1133,18 @@ FARPROC32 WINAPI GetProcAddress32( HMODULE32 hModule, LPCSTR function )
|
|||
*/
|
||||
FARPROC32 WINAPI WIN16_GetProcAddress32( HMODULE32 hModule, LPCSTR function )
|
||||
{
|
||||
return MODULE_GetProcAddress32( PROCESS_Current(), hModule, function, FALSE );
|
||||
return MODULE_GetProcAddress32( hModule, function, FALSE );
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
* MODULE_GetProcAddress32 (internal)
|
||||
*/
|
||||
FARPROC32 MODULE_GetProcAddress32(
|
||||
PDB32 *process, /* [in] process context */
|
||||
HMODULE32 hModule, /* [in] current module handle */
|
||||
LPCSTR function, /* [in] function to be looked up */
|
||||
BOOL32 snoop )
|
||||
{
|
||||
WINE_MODREF *wm = MODULE32_LookupHMODULE(process,hModule);
|
||||
WINE_MODREF *wm = MODULE32_LookupHMODULE( hModule );
|
||||
|
||||
if (HIWORD(function))
|
||||
TRACE(win32,"(%08lx,%s)\n",(DWORD)hModule,function);
|
||||
|
|
@ -1161,9 +1155,9 @@ FARPROC32 MODULE_GetProcAddress32(
|
|||
switch (wm->type)
|
||||
{
|
||||
case MODULE32_PE:
|
||||
return PE_FindExportedFunction( process, wm, function, snoop );
|
||||
return PE_FindExportedFunction( wm, function, snoop );
|
||||
case MODULE32_ELF:
|
||||
return ELF_FindExportedFunction( process, wm, function);
|
||||
return ELF_FindExportedFunction( wm, function);
|
||||
default:
|
||||
ERR(module,"wine_modref type %d not handled.\n",wm->type);
|
||||
return (FARPROC32)0;
|
||||
|
|
@ -1181,7 +1175,7 @@ PIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE32 hModule)
|
|||
* but we could get HMODULE16 or the like (think builtin modules)
|
||||
*/
|
||||
|
||||
WINE_MODREF *wm = MODULE32_LookupHMODULE( PROCESS_Current(), hModule );
|
||||
WINE_MODREF *wm = MODULE32_LookupHMODULE( hModule );
|
||||
if (!wm || (wm->type != MODULE32_PE)) return (PIMAGE_NT_HEADERS)0;
|
||||
return PE_HEADER(wm->module);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -31,9 +31,6 @@
|
|||
* and 'blocksize' file-aligned (offsets). Since we have 512/1024/2048 (CDROM)
|
||||
* and other byte blocksizes, we can't do this. However, this could be less
|
||||
* difficult to support... (See mm/filemap.c).
|
||||
* - All those function map things into a new addresspace. From the wrong
|
||||
* process and the wrong thread. So calling other API functions will mess
|
||||
* things up badly sometimes.
|
||||
*/
|
||||
|
||||
#include <errno.h>
|
||||
|
|
@ -119,7 +116,6 @@ void dump_exports( HMODULE32 hModule )
|
|||
* - use ordinal-pe_export->Base as offset into the functionlist
|
||||
*/
|
||||
FARPROC32 PE_FindExportedFunction(
|
||||
PDB32 *process, /* [in] process context */
|
||||
WINE_MODREF *wm, /* [in] WINE modreference */
|
||||
LPCSTR funcName, /* [in] function name */
|
||||
BOOL32 snoop )
|
||||
|
|
@ -207,14 +203,14 @@ FARPROC32 PE_FindExportedFunction(
|
|||
assert(end-forward<256);
|
||||
strncpy(module, forward, (end - forward));
|
||||
module[end-forward] = 0;
|
||||
hMod = MODULE_FindModule32(process,module);
|
||||
hMod = MODULE_FindModule32( module );
|
||||
assert(hMod);
|
||||
return MODULE_GetProcAddress32( process, hMod, end + 1, snoop );
|
||||
return MODULE_GetProcAddress32( hMod, end + 1, snoop );
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
DWORD fixup_imports (PDB32 *process,WINE_MODREF *wm)
|
||||
DWORD fixup_imports( WINE_MODREF *wm )
|
||||
{
|
||||
IMAGE_IMPORT_DESCRIPTOR *pe_imp;
|
||||
WINE_MODREF *xwm;
|
||||
|
|
@ -252,7 +248,7 @@ DWORD fixup_imports (PDB32 *process,WINE_MODREF *wm)
|
|||
|
||||
/* Allocate module dependency list */
|
||||
wm->nDeps = i;
|
||||
wm->deps = HeapAlloc(process->heap, 0, i*sizeof(WINE_MODREF *));
|
||||
wm->deps = HeapAlloc( GetProcessHeap(), 0, i*sizeof(WINE_MODREF *) );
|
||||
|
||||
/* load the imported modules. They are automatically
|
||||
* added to the modref list of the process.
|
||||
|
|
@ -268,7 +264,7 @@ DWORD fixup_imports (PDB32 *process,WINE_MODREF *wm)
|
|||
break;
|
||||
|
||||
/* don't use MODULE_Load, Win32 creates new task differently */
|
||||
hImpModule = MODULE_LoadLibraryEx32A( name, process, 0, 0 );
|
||||
hImpModule = MODULE_LoadLibraryEx32A( name, 0, 0 );
|
||||
if (!hImpModule) {
|
||||
char *p,buffer[2000];
|
||||
|
||||
|
|
@ -277,13 +273,13 @@ DWORD fixup_imports (PDB32 *process,WINE_MODREF *wm)
|
|||
if (!(p = strrchr (buffer, '\\')))
|
||||
p = buffer;
|
||||
strcpy (p + 1, name);
|
||||
hImpModule = MODULE_LoadLibraryEx32A( buffer, process, 0, 0 );
|
||||
hImpModule = MODULE_LoadLibraryEx32A( buffer, 0, 0 );
|
||||
}
|
||||
if (!hImpModule) {
|
||||
ERR (module, "Module %s not found\n", name);
|
||||
return 1;
|
||||
}
|
||||
xwm = MODULE32_LookupHMODULE(process, hImpModule);
|
||||
xwm = MODULE32_LookupHMODULE( hImpModule );
|
||||
assert( xwm );
|
||||
wm->deps[i++] = xwm;
|
||||
|
||||
|
|
@ -300,7 +296,7 @@ DWORD fixup_imports (PDB32 *process,WINE_MODREF *wm)
|
|||
|
||||
TRACE(win32, "--- Ordinal %s,%d\n", name, ordinal);
|
||||
thunk_list->u1.Function=MODULE_GetProcAddress32(
|
||||
process, hImpModule, (LPCSTR)ordinal, TRUE
|
||||
hImpModule, (LPCSTR)ordinal, TRUE
|
||||
);
|
||||
if (!thunk_list->u1.Function) {
|
||||
ERR(win32,"No implementation for %s.%d, setting to 0xdeadbeef\n",
|
||||
|
|
@ -311,7 +307,7 @@ DWORD fixup_imports (PDB32 *process,WINE_MODREF *wm)
|
|||
pe_name = (PIMAGE_IMPORT_BY_NAME)RVA(import_list->u1.AddressOfData);
|
||||
TRACE(win32, "--- %s %s.%d\n", pe_name->Name, name, pe_name->Hint);
|
||||
thunk_list->u1.Function=MODULE_GetProcAddress32(
|
||||
process, hImpModule, pe_name->Name, TRUE
|
||||
hImpModule, pe_name->Name, TRUE
|
||||
);
|
||||
if (!thunk_list->u1.Function) {
|
||||
ERR(win32,"No implementation for %s.%d(%s), setting to 0xdeadbeef\n",
|
||||
|
|
@ -332,7 +328,7 @@ DWORD fixup_imports (PDB32 *process,WINE_MODREF *wm)
|
|||
|
||||
TRACE(win32,"--- Ordinal %s.%d\n",name,ordinal);
|
||||
thunk_list->u1.Function=MODULE_GetProcAddress32(
|
||||
process, hImpModule, (LPCSTR) ordinal, TRUE
|
||||
hImpModule, (LPCSTR) ordinal, TRUE
|
||||
);
|
||||
if (!thunk_list->u1.Function) {
|
||||
ERR(win32, "No implementation for %s.%d, setting to 0xdeadbeef\n",
|
||||
|
|
@ -344,7 +340,7 @@ DWORD fixup_imports (PDB32 *process,WINE_MODREF *wm)
|
|||
TRACE(win32,"--- %s %s.%d\n",
|
||||
pe_name->Name,name,pe_name->Hint);
|
||||
thunk_list->u1.Function=MODULE_GetProcAddress32(
|
||||
process, hImpModule, pe_name->Name, TRUE
|
||||
hImpModule, pe_name->Name, TRUE
|
||||
);
|
||||
if (!thunk_list->u1.Function) {
|
||||
ERR(win32, "No implementation for %s.%d, setting to 0xdeadbeef\n",
|
||||
|
|
@ -456,7 +452,7 @@ static void do_relocations( unsigned int load_addr, IMAGE_BASE_RELOCATION *r )
|
|||
* BUT we have to map the whole image anyway, for Win32 programs sometimes
|
||||
* want to access them. (HMODULE32 point to the start of it)
|
||||
*/
|
||||
static HMODULE32 PE_LoadImage( LPCSTR name, OFSTRUCT *ofs, LPCSTR *modName )
|
||||
HMODULE32 PE_LoadImage( LPCSTR name, OFSTRUCT *ofs, LPCSTR *modName )
|
||||
{
|
||||
HMODULE32 hModule;
|
||||
HFILE32 hFile;
|
||||
|
|
@ -658,9 +654,12 @@ error:
|
|||
* Note: hModule must point to a correctly allocated PE image,
|
||||
* with base relocations applied; the 16-bit dummy module
|
||||
* associated to hModule must already exist.
|
||||
*
|
||||
* Note: This routine must always be called in the context of the
|
||||
* process that is to own the module to be created.
|
||||
*/
|
||||
static WINE_MODREF *PE_CreateModule( PDB32 *process, HMODULE32 hModule,
|
||||
OFSTRUCT *ofs, DWORD flags, BOOL32 builtin )
|
||||
WINE_MODREF *PE_CreateModule( HMODULE32 hModule,
|
||||
OFSTRUCT *ofs, DWORD flags, BOOL32 builtin )
|
||||
{
|
||||
DWORD load_addr = (DWORD)hModule; /* for RVA */
|
||||
IMAGE_NT_HEADERS *nt = PE_HEADER(hModule);
|
||||
|
|
@ -728,7 +727,8 @@ static WINE_MODREF *PE_CreateModule( PDB32 *process, HMODULE32 hModule,
|
|||
|
||||
/* Allocate and fill WINE_MODREF */
|
||||
|
||||
wm = (WINE_MODREF *)HeapAlloc( process->heap, HEAP_ZERO_MEMORY, sizeof(*wm) );
|
||||
wm = (WINE_MODREF *)HeapAlloc( GetProcessHeap(),
|
||||
HEAP_ZERO_MEMORY, sizeof(*wm) );
|
||||
wm->module = hModule;
|
||||
|
||||
wm->type = MODULE32_PE;
|
||||
|
|
@ -747,24 +747,24 @@ static WINE_MODREF *PE_CreateModule( PDB32 *process, HMODULE32 hModule,
|
|||
while ((s=strchr(modname,'\\')))
|
||||
modname = s+1;
|
||||
}
|
||||
wm->modname = HEAP_strdupA( process->heap, 0, modname );
|
||||
wm->modname = HEAP_strdupA( GetProcessHeap(), 0, modname );
|
||||
|
||||
result = GetLongPathName32A( ofs->szPathName, NULL, 0 );
|
||||
wm->longname = (char *)HeapAlloc( process->heap, 0, result+1 );
|
||||
wm->longname = (char *)HeapAlloc( GetProcessHeap(), 0, result+1 );
|
||||
GetLongPathName32A( ofs->szPathName, wm->longname, result+1 );
|
||||
|
||||
wm->shortname = HEAP_strdupA( process->heap, 0, ofs->szPathName );
|
||||
wm->shortname = HEAP_strdupA( GetProcessHeap(), 0, ofs->szPathName );
|
||||
|
||||
/* Link MODREF into process list */
|
||||
|
||||
wm->next = process->modref_list;
|
||||
process->modref_list = wm;
|
||||
wm->next = PROCESS_Current()->modref_list;
|
||||
PROCESS_Current()->modref_list = wm;
|
||||
|
||||
if ( !(nt->FileHeader.Characteristics & IMAGE_FILE_DLL) )
|
||||
{
|
||||
if ( process->exe_modref )
|
||||
if ( PROCESS_Current()->exe_modref )
|
||||
FIXME( win32, "overwriting old exe_modref... arrgh\n" );
|
||||
process->exe_modref = wm;
|
||||
PROCESS_Current()->exe_modref = wm;
|
||||
}
|
||||
|
||||
/* Dump Exports */
|
||||
|
|
@ -774,11 +774,11 @@ static WINE_MODREF *PE_CreateModule( PDB32 *process, HMODULE32 hModule,
|
|||
|
||||
/* Fixup Imports */
|
||||
|
||||
if ( pe_import && fixup_imports( process, wm ) )
|
||||
if ( pe_import && fixup_imports( wm ) )
|
||||
{
|
||||
/* remove entry from modref chain */
|
||||
WINE_MODREF **xwm;
|
||||
for ( xwm = &process->modref_list; *xwm; xwm = &(*xwm)->next )
|
||||
for ( xwm = &PROCESS_Current()->modref_list; *xwm; xwm = &(*xwm)->next )
|
||||
if ( *xwm == wm )
|
||||
{
|
||||
*xwm = wm->next;
|
||||
|
|
@ -801,7 +801,7 @@ static WINE_MODREF *PE_CreateModule( PDB32 *process, HMODULE32 hModule,
|
|||
* The PE Library Loader frontend.
|
||||
* FIXME: handle the flags.
|
||||
*/
|
||||
HMODULE32 PE_LoadLibraryEx32A (LPCSTR name, PDB32 *process,
|
||||
HMODULE32 PE_LoadLibraryEx32A (LPCSTR name,
|
||||
HFILE32 hFile, DWORD flags)
|
||||
{
|
||||
LPCSTR modName = NULL;
|
||||
|
|
@ -813,7 +813,7 @@ HMODULE32 PE_LoadLibraryEx32A (LPCSTR name, PDB32 *process,
|
|||
BOOL32 builtin;
|
||||
|
||||
/* Check for already loaded module */
|
||||
if ((hModule32 = MODULE_FindModule32( process, name )))
|
||||
if ((hModule32 = MODULE_FindModule32( name )))
|
||||
return hModule32;
|
||||
|
||||
/* try to load builtin, enabled modules first */
|
||||
|
|
@ -839,7 +839,7 @@ HMODULE32 PE_LoadLibraryEx32A (LPCSTR name, PDB32 *process,
|
|||
pModule->module32 = hModule32;
|
||||
|
||||
/* Create 32-bit MODREF */
|
||||
if ( !(wm = PE_CreateModule( process, hModule32, &ofs, flags, builtin )) )
|
||||
if ( !(wm = PE_CreateModule( hModule32, &ofs, flags, builtin )) )
|
||||
{
|
||||
ERR(win32,"can't load %s\n",ofs.szPathName);
|
||||
FreeLibrary16( hModule16 );
|
||||
|
|
@ -868,8 +868,6 @@ HINSTANCE16 PE_CreateProcess( LPCSTR name, LPCSTR cmd_line,
|
|||
NE_MODULE *pModule;
|
||||
OFSTRUCT ofs;
|
||||
PDB32 *process;
|
||||
TDB *pTask;
|
||||
WINE_MODREF *wm;
|
||||
|
||||
/* Load file */
|
||||
if ((hModule32 = PE_LoadImage( name, &ofs, &modName )) < 32)
|
||||
|
|
@ -890,16 +888,8 @@ HINSTANCE16 PE_CreateProcess( LPCSTR name, LPCSTR cmd_line,
|
|||
process = PROCESS_Create( pModule, cmd_line, env,
|
||||
hInstance, 0, inherit, startup, info );
|
||||
|
||||
/* Create 32-bit MODREF */
|
||||
if ( !(wm = PE_CreateModule( process, hModule32, &ofs, 0, FALSE )) )
|
||||
{
|
||||
/* FIXME: should destroy the task created and free referenced stuff */
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* FIXME: Yuck. Is there no other good place to do that? */
|
||||
pTask = (TDB *)GlobalLock16( process->task );
|
||||
PE_InitTls( pTask->thdb );
|
||||
/* Note: PE_CreateModule and the remaining process initialization will
|
||||
be done in the context of the new process, in TASK_CallToStart */
|
||||
|
||||
return hInstance;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -32,9 +32,8 @@
|
|||
static PE_MODREF*
|
||||
HMODULE32toPE_MODREF(HMODULE32 hmod) {
|
||||
WINE_MODREF *wm;
|
||||
PDB32 *pdb = PROCESS_Current();
|
||||
|
||||
wm = MODULE32_LookupHMODULE( pdb, hmod );
|
||||
wm = MODULE32_LookupHMODULE( hmod );
|
||||
if (!wm || wm->type!=MODULE32_PE)
|
||||
return NULL;
|
||||
return &(wm->binfmt.pe);
|
||||
|
|
|
|||
|
|
@ -176,7 +176,7 @@ HANDLE32 WINAPI FindResourceEx32A( HMODULE32 hModule, LPCSTR type, LPCSTR name,
|
|||
HRSRC32 WINAPI FindResourceEx32W( HMODULE32 hModule, LPCWSTR type,
|
||||
LPCWSTR name, WORD lang )
|
||||
{
|
||||
WINE_MODREF *wm = MODULE32_LookupHMODULE(PROCESS_Current(),hModule);
|
||||
WINE_MODREF *wm = MODULE32_LookupHMODULE( hModule );
|
||||
HRSRC32 hrsrc;
|
||||
|
||||
TRACE(resource, "module=%08x(%s) type=%s name=%s\n",
|
||||
|
|
@ -249,7 +249,7 @@ HGLOBAL32 WINAPI LoadResource32(
|
|||
HINSTANCE32 hModule, /* [in] module handle */
|
||||
HRSRC32 hRsrc ) /* [in] resource handle */
|
||||
{
|
||||
WINE_MODREF *wm = MODULE32_LookupHMODULE(PROCESS_Current(),hModule);
|
||||
WINE_MODREF *wm = MODULE32_LookupHMODULE( hModule );
|
||||
|
||||
TRACE(resource, "module=%04x res=%04x\n",
|
||||
hModule, hRsrc );
|
||||
|
|
@ -372,7 +372,7 @@ DWORD WINAPI SizeofResource16( HMODULE16 hModule, HRSRC16 hRsrc )
|
|||
*/
|
||||
DWORD WINAPI SizeofResource32( HINSTANCE32 hModule, HRSRC32 hRsrc )
|
||||
{
|
||||
WINE_MODREF *wm = MODULE32_LookupHMODULE(PROCESS_Current(),hModule);
|
||||
WINE_MODREF *wm = MODULE32_LookupHMODULE( hModule );
|
||||
|
||||
TRACE(resource, "module=%08x res=%08x\n", hModule, hRsrc );
|
||||
if (!wm) return 0;
|
||||
|
|
|
|||
|
|
@ -242,16 +242,27 @@ static void TASK_CallToStart(void)
|
|||
{
|
||||
/* FIXME: all this is an ugly hack */
|
||||
|
||||
OFSTRUCT *ofs = (OFSTRUCT *)((char*)(pModule) + (pModule)->fileinfo);
|
||||
LPTHREAD_START_ROUTINE entry = (LPTHREAD_START_ROUTINE)
|
||||
RVA_PTR(pModule->module32, OptionalHeader.AddressOfEntryPoint);
|
||||
|
||||
/* Create 32-bit MODREF */
|
||||
if ( !PE_CreateModule( pModule->module32, ofs, 0, FALSE ) )
|
||||
{
|
||||
ERR( task, "Could not initialize process\n" );
|
||||
ExitProcess( 1 );
|
||||
}
|
||||
|
||||
/* Initialize Thread-Local Storage */
|
||||
PE_InitTls( pTask->thdb );
|
||||
|
||||
if (PE_HEADER(pModule->module32)->OptionalHeader.Subsystem==IMAGE_SUBSYSTEM_WINDOWS_CUI)
|
||||
AllocConsole();
|
||||
|
||||
if (pModule->heap_size)
|
||||
LocalInit( pTask->hInstance, 0, pModule->heap_size );
|
||||
|
||||
MODULE_InitializeDLLs( PROCESS_Current(), 0, DLL_PROCESS_ATTACH, (LPVOID)-1 );
|
||||
MODULE_InitializeDLLs( 0, DLL_PROCESS_ATTACH, (LPVOID)-1 );
|
||||
TRACE(relay, "(entryproc=%p)\n", entry );
|
||||
|
||||
#if 1
|
||||
|
|
|
|||
|
|
@ -317,7 +317,7 @@ void THREAD_Start( THDB *thdb )
|
|||
LPTHREAD_START_ROUTINE func = (LPTHREAD_START_ROUTINE)thdb->entry_point;
|
||||
assert( THREAD_Current() == thdb );
|
||||
CLIENT_InitThread();
|
||||
MODULE_InitializeDLLs( thdb->process, 0, DLL_THREAD_ATTACH, NULL );
|
||||
MODULE_InitializeDLLs( 0, DLL_THREAD_ATTACH, NULL );
|
||||
ExitThread( func( thdb->entry_arg ) );
|
||||
}
|
||||
|
||||
|
|
@ -362,7 +362,7 @@ void WINAPI ExitThread(
|
|||
THDB *thdb = THREAD_Current();
|
||||
LONG count;
|
||||
|
||||
MODULE_InitializeDLLs( thdb->process, 0, DLL_THREAD_DETACH, NULL );
|
||||
MODULE_InitializeDLLs( 0, DLL_THREAD_DETACH, NULL );
|
||||
|
||||
SYSTEM_LOCK();
|
||||
thdb->exit_code = code;
|
||||
|
|
|
|||
Loading…
Reference in a new issue