Ticket #514: win32_darwin.diff

File win32_darwin.diff, 6.7 KB (added by stephane.lapie@…, 13 years ago)

loader/win32.c patch, allows to clear DllMain? loading, and execution up to a certain point... Not perfect at all.

  • win32.c

    old new  
    1919
    2020#include "config.h"
    2121
     22
     23/*
     24 * Modified by DarkSoul (darksoul@darkbsd.org)
     25 *
     26 * Added prefixes and suffixes to every non-WINAPI
     27 * function. This is for use with ia32/Darwin, in
     28 * order to ensure a clean %esp register.
     29 */
     30
     31#ifdef CONFIG_DARWIN
     32# define STACK_CLEANER_PREFIX   __asm__(        "pushl  %ebp            \n\t" \
     33                                                "movl   %esp, %ebp      \n\t" \
     34                                                "andl   $-16, %esp      \n\t" \
     35                                                "subl   $16, %esp       \n\t" )
     36# define STACK_CLEANER_SUFFIX   __asm__(        "leave                  \n\t" )
     37#else
     38/* No need for stack cleaner unless for Darwin, is there ? */
     39# define STACK_CLEANER_PREFIX
     40# define STACK_CLEANER_SUFFIX
     41#endif
     42
    2243#ifdef MPLAYER
    2344#ifdef USE_QTX_CODECS
    2445#define QTX
     
    193214#endif
    194215int LOADER_DEBUG=1; // active only if compiled with -DDETAILED_OUT
    195216//#define DETAILED_OUT
    196 static inline void dbgprintf(char* fmt, ...)
     217static void dbgprintf(char* fmt, ...)
    197218{
     219#ifndef CONFIG_DARWIN
    198220#ifdef DETAILED_OUT
    199221    if(LOADER_DEBUG)
    200222    {
     223STACK_CLEANER_PREFIX;
    201224        FILE* f;
    202225        va_list va;
    203226        va_start(va, fmt);
     
    211234            fclose(f);
    212235        }
    213236        va_end(va);
     237STACK_CLEANER_SUFFIX;
    214238    }
    215239#endif
    216240#ifdef MPLAYER
     
    223247//      mp_dbg(MSGT_WIN32, MSGL_DBG3, fmt, va);
    224248        va_end(va);
    225249    }
     250STACK_CLEANER_PREFIX;
    226251  fflush(stdout);
     252STACK_CLEANER_SUFFIX;
     253#endif
    227254#endif
    228255}
    229256
     
    465492}
    466493#endif
    467494
     495#ifndef MEMORY_DEBUG
    468496static inline void* my_mreq(int size, int to_zero)
    469497{
    470498    return mreq_private(size, to_zero, AREATYPE_CLIENT);
    471499}
     500#endif
    472501
    473502static int my_size(void* memory)
    474503{
     
    31703199#define SECS_1601_TO_1970  ((369 * 365 + 89) * 86400ULL)
    31713200static void WINAPI expGetSystemTimeAsFileTime(FILETIME* systime)
    31723201{
     3202    STACK_CLEANER_PREFIX;
    31733203    struct tm *local_tm;
    31743204    struct timeval tv;
    31753205    unsigned long long secs;
    31763206
     3207#ifndef CONFIG_DARWIN
     3208    // This calls fflush(), which is not really liked on Darwin() in a DLL-code context
     3209    // which maims %esp register.
    31773210    dbgprintf("GetSystemTime(0x%x)\n", systime);
     3211#endif /* !CONFIG_DARWIN */
    31783212    gettimeofday(&tv, NULL);
    31793213    secs = (tv.tv_sec + SECS_1601_TO_1970) * 10000000;
    31803214    secs += tv.tv_usec * 10;
    31813215    systime->dwLowDateTime = secs & 0xffffffff;
    31823216    systime->dwHighDateTime = (secs >> 32);
     3217    STACK_CLEANER_SUFFIX;
    31833218}
    31843219
    31853220static int WINAPI expGetEnvironmentVariableA(const char* name, char* field, int size)
     
    38863921 */
    38873922static void* expmalloc(int size)
    38883923{
     3924    STACK_CLEANER_PREFIX;
    38893925    //printf("malloc");
    38903926    //    return malloc(size);
    38913927    void* result=my_mreq(size,0);
    38923928    dbgprintf("malloc(0x%x) => 0x%x\n", size,result);
    38933929    if(result==0)
    3894         printf("WARNING: malloc() failed\n");
     3930        printf("WARNING: malloc(%d) failed\n", size);
     3931    STACK_CLEANER_SUFFIX;
    38953932    return result;
    38963933}
    38973934static void expfree(void* mem)
    38983935{
     3936    STACK_CLEANER_PREFIX;
    38993937    //    return free(mem);
    39003938    dbgprintf("free(%p)\n", mem);
    39013939    my_release(mem);
     3940    STACK_CLEANER_SUFFIX;
    39023941}
    39033942/* needed by atrac3.acm */
    39043943static void *expcalloc(int num, int size)
    39053944{
     3945    STACK_CLEANER_PREFIX;
    39063946    void* result=my_mreq(num*size,1);
    39073947    dbgprintf("calloc(%d,%d) => %p\n", num,size,result);
    39083948    if(result==0)
    39093949        printf("WARNING: calloc() failed\n");
     3950    STACK_CLEANER_SUFFIX;
    39103951    return result;
    39113952}
    39123953static void* expnew(int size)
    39133954{
     3955    STACK_CLEANER_PREFIX;
    39143956    //    printf("NEW:: Call from address %08x\n STACK DUMP:\n", *(-1+(int*)&size));
    39153957    //    printf("%08x %08x %08x %08x\n",
    39163958    //    size, *(1+(int*)&size),
     
    39223964    dbgprintf("new(%d) => %p\n", size, result);
    39233965    if (result==0)
    39243966        printf("WARNING: new() failed\n");
     3967    STACK_CLEANER_SUFFIX;
    39253968    return result;
    39263969
    39273970}
    39283971static int expdelete(void* memory)
    39293972{
     3973    STACK_CLEANER_PREFIX;
    39303974    dbgprintf("delete(%p)\n", memory);
    39313975    my_release(memory);
     3976    STACK_CLEANER_SUFFIX;
    39323977    return 0;
    39333978}
    39343979
     
    40184063#if 0
    40194064static int exp_initterm(int v1, int v2)
    40204065{
     4066    STACK_CLEANER_PREFIX;
    40214067    dbgprintf("_initterm(0x%x, 0x%x) => 0\n", v1, v2);
    40224068    return 0;
     4069    STACK_CLEANER_SUFFIX;
    40234070}
    40244071#else
    40254072/* merged from wine - 2002.04.21 */
    40264073typedef void (*_INITTERMFUNC)();
    40274074static int exp_initterm(_INITTERMFUNC *start, _INITTERMFUNC *end)
    40284075{
    4029     dbgprintf("_initterm(0x%x, 0x%x) %p\n", start, end, *start);
     4076    //dbgprintf("_initterm(0x%x, 0x%x) %p\n", start, end, *start);
    40304077    while (start < end)
    40314078    {
    40324079        if (*start)
     
    40374084            void* p = *start;
    40384085            __asm__ __volatile__
    40394086                (
     4087                 "pushl  %ebp           \n\t"
     4088                 "movl   %esp, %ebp     \n\t"
     4089                 "andl   $-16, %esp     \n\t"
     4090                 "subl   $16, %esp      \n\t" );
     4091            __asm__ __volatile__
     4092                (
    40404093                 "pushl %%ebx           \n\t"
    40414094                 "pushl %%ecx           \n\t"
    40424095                 "pushl %%edx           \n\t"
     
    40484101                 "popl  %%edx           \n\t"
    40494102                 "popl  %%ecx           \n\t"
    40504103                 "popl  %%ebx           \n\t"
     4104                 "leave                 \n\t"
    40514105                 :
    40524106                 : "a"(p)
    40534107                 : "memory"
     
    40684122
    40694123static int expwsprintfA(char* string, const char* format, ...)
    40704124{
     4125    STACK_CLEANER_PREFIX;
    40714126    va_list va;
    40724127    int result;
    40734128    va_start(va, format);
    40744129    result = vsprintf(string, format, va);
    40754130    dbgprintf("wsprintfA(0x%x, '%s', ...) => %d\n", string, format, result);
    40764131    va_end(va);
     4132    STACK_CLEANER_SUFFIX;
    40774133    return result;
    40784134}
    40794135
    40804136static int expsprintf(char* str, const char* format, ...)
    40814137{
     4138    STACK_CLEANER_PREFIX;
    40824139    va_list args;
    40834140    int r;
    40844141    dbgprintf("sprintf(0x%x, %s)\n", str, format);
    40854142    va_start(args, format);
    40864143    r = vsprintf(str, format, args);
    40874144    va_end(args);
     4145    STACK_CLEANER_SUFFIX;
    40884146    return r;
    40894147}
    40904148static int expsscanf(const char* str, const char* format, ...)
    40914149{
     4150    STACK_CLEANER_PREFIX;
    40924151    va_list args;
    40934152    int r;
    40944153    dbgprintf("sscanf(%s, %s)\n", str, format);
    40954154    va_start(args, format);
    40964155    r = vsscanf(str, format, args);
    40974156    va_end(args);
     4157    STACK_CLEANER_SUFFIX;
    40984158    return r;
    40994159}
    41004160static void* expfopen(const char* path, const char* mode)
     
    41054165}
    41064166static int expfprintf(void* stream, const char* format, ...)
    41074167{
     4168    STACK_CLEANER_PREFIX;
    41084169    va_list args;
    41094170    int r = 0;
    41104171    dbgprintf("fprintf(%p, %s, ...)\n", stream, format);
     
    41134174    r = vfprintf((FILE*) stream, format, args);
    41144175    va_end(args);
    41154176#endif
     4177    STACK_CLEANER_SUFFIX;
    41164178    return r;
    41174179}
    41184180
    41194181static int expprintf(const char* format, ...)
    41204182{
     4183    STACK_CLEANER_PREFIX;
    41214184    va_list args;
    41224185    int r;
    41234186    dbgprintf("printf(%s, ...)\n", format);
    41244187    va_start(args, format);
    41254188    r = vprintf(format, args);
    41264189    va_end(args);
     4190    STACK_CLEANER_SUFFIX;
    41274191    return r;
    41284192}
    41294193
    41304194static char* expgetenv(const char* varname)
    41314195{
     4196    STACK_CLEANER_PREFIX;
    41324197    char* v = getenv(varname);
    41334198    dbgprintf("getenv(%s) => %s\n", varname, v);
     4199    STACK_CLEANER_SUFFIX;
    41344200    return v;
    41354201}
    41364202