From 428fabe8c9db723e882fc5a5c744f44f891e6ea7 Mon Sep 17 00:00:00 2001 From: jowenn Date: Wed, 27 Apr 2005 13:17:07 +0000 Subject: [PATCH] general: less warnings in stacktrace.c x86_64: fix for clinit within native stub --- src/vm/jit/codegen.inc | 7 ++-- src/vm/jit/stacktrace.c | 65 +++++++++++++++++++++++-------------- src/vm/jit/stacktrace.h | 4 +-- src/vm/jit/x86_64/codegen.c | 44 ++++++++++++++++++++----- src/vm/jit/x86_64/patcher.c | 3 +- 5 files changed, 84 insertions(+), 39 deletions(-) diff --git a/src/vm/jit/codegen.inc b/src/vm/jit/codegen.inc index c7865842d..586095bb0 100644 --- a/src/vm/jit/codegen.inc +++ b/src/vm/jit/codegen.inc @@ -47,7 +47,7 @@ memory. All functions writing values into the data area return the offset relative the begin of the code area (start of procedure). - $Id: codegen.inc 2358 2005-04-22 22:01:51Z jowenn $ + $Id: codegen.inc 2402 2005-04-27 13:17:07Z jowenn $ */ @@ -1048,20 +1048,21 @@ static void codegen_resolve_native(methodinfo *m,void **insertionPoint,void *jmp MFREE(nativeName,char,nativeLen); i++; nativeLen++; - nativeNameEscape[nativeLen]=0; + nativeNameEscape[nativeLen-1]=0; nativeName=nativeNameEscape; } if (nativeName[i]=='/') nativeName[i]='_'; i++; } -/* printf("nativename: %s\n",nativeName); */ + /*printf("\nnativename: %s\n",nativeName);*/ /*try to find the symbal fo the function */ sym=dlsym(lib,nativeName); if (sym) { ok=1; /* it worked, everything fine */ /*log_text("resolved");*/ + /*printf("strlen %d, nativeLen %d\n",strlen(nativeName),nativeLen);*/ MFREE(nativeName,char,nativeLen); } else { /* we didn't find the symbol yet, try to resolve an overlaoded function (having the types in it's name*/ size_t overloadedNativeLen=nativeLen+codegen_overloadPartLen(m->descriptor); diff --git a/src/vm/jit/stacktrace.c b/src/vm/jit/stacktrace.c index ea9334d76..a940c161f 100644 --- a/src/vm/jit/stacktrace.c +++ b/src/vm/jit/stacktrace.c @@ -26,7 +26,7 @@ Authors: Joseph Wenninger - $Id: stacktrace.c 2358 2005-04-22 22:01:51Z jowenn $ + $Id: stacktrace.c 2402 2005-04-27 13:17:07Z jowenn $ */ @@ -44,9 +44,9 @@ #include "vm/class.h" #include "vm/tables.h" #include "vm/jit/codegen.inc.h" +#include "vm/loader.h" - -#undef JWDEBUG +#define JWDEBUG /*JoWenn: simplify collectors (trace doesn't contain internal methods)*/ @@ -64,7 +64,7 @@ typedef struct lineNumberTableEntry { /* The special value of -1 means that a inlined function starts, a value of -2 means that an inlined function ends*/ LineNumber lineNr; - void *pc; + u1 *pc; } lineNumberTableEntry; typedef struct lineNumberTableEntryInlineBegin { @@ -105,7 +105,7 @@ static void addEntry(stackTraceBuffer* buffer,methodinfo*method ,LineNumber line } static int fillInStackTrace_methodRecursive(stackTraceBuffer *buffer,methodinfo - *method,lineNumberTableEntry *startEntry, lineNumberTableEntry **entry, size_t *entriesAhead,void *adress) { + *method,lineNumberTableEntry *startEntry, lineNumberTableEntry **entry, size_t *entriesAhead,u1 *adress) { size_t ahead=*entriesAhead; lineNumberTableEntry *ent=*entry; @@ -149,7 +149,7 @@ static int fillInStackTrace_methodRecursive(stackTraceBuffer *buffer,methodinfo } -static void fillInStackTrace_method(stackTraceBuffer *buffer,methodinfo *method,char *dataSeg, void* adress) { +static void fillInStackTrace_method(stackTraceBuffer *buffer,methodinfo *method,u1 *dataSeg, u1* adress) { size_t lineNumberTableSize=(*((size_t*)(dataSeg+LineNumberTableSize))); @@ -164,7 +164,7 @@ static void fillInStackTrace_method(stackTraceBuffer *buffer,methodinfo *method, lineNumberTableEntry *startEntry; /* printf("dataSeg: %p\n",dataSeg);*/ - calc=dataSeg+LineNumberTableStart; + calc=(void**)(dataSeg+LineNumberTableStart); /* printf("position of line number table start reference in data segment: %p\n",calc); printf("line number table start as found in table: %p\n",*calc);*/ ent=(lineNumberTableEntry *) (((char*)(*calc) - (sizeof(lineNumberTableEntry)-sizeof(void*)))); @@ -180,6 +180,20 @@ static void fillInStackTrace_method(stackTraceBuffer *buffer,methodinfo *method, } +typedef union { + u1* u1ptr; + functionptr funcptr; + void* voidptr; +} u1ptr_functionptr_union; + +#define cast_funcptr_u1ptr(dest,src) \ + { u1f.funcptr=src;\ + dest=u1f.u1ptr; } + +#define cast_u1ptr_funcptr(dest,src) \ + { u1f.u1ptr=src;\ + dest=u1f.funcptr; } + void cacao_stacktrace_fillInStackTrace(void **target,CacaoStackTraceCollector coll) { @@ -200,10 +214,12 @@ void cacao_stacktrace_fillInStackTrace(void **target,CacaoStackTraceCollector c *target=0; return; } else { - char *dataseg; /*make it byte addressable*/ + u1 *tmp; + u1 *dataseg; /*make it byte addressable*/ methodinfo *currentMethod=0; - void *returnAdress; - char* stackPtr; + /*void*/ functionptr returnAdress; + u1* stackPtr; + u1ptr_functionptr_union u1f; /* utf_display(info->method->class->name); utf_display(info->method->name);*/ @@ -211,7 +227,7 @@ void cacao_stacktrace_fillInStackTrace(void **target,CacaoStackTraceCollector c while ((currentMethod!=0) || (info!=0)) { if (currentMethod==0) { /*some builtin native */ currentMethod=info->method; - returnAdress=info->returnToFromNative; + returnAdress=(functionptr)info->returnToFromNative; /*log_text("native");*/ if (currentMethod) { /*utf_display(currentMethod->class->name); @@ -224,16 +240,16 @@ void cacao_stacktrace_fillInStackTrace(void **target,CacaoStackTraceCollector c else dataseg=codegen_findmethod(returnAdress); #elif defined(__I386__) || defined (__X86_64__) - dataseg=codegen_findmethod(returnAdress); + cast_funcptr_u1ptr(dataseg,codegen_findmethod(returnAdress)); #endif currentMethod=(*((methodinfo**)(dataseg+MethodPointer))); if (info->beginOfJavaStackframe==0) - stackPtr=((char*)info)+sizeof(native_stackframeinfo); + stackPtr=((u1*)info)+sizeof(native_stackframeinfo); else #if defined(__ALPHA__) - stackPtr=(char*)(info->beginOfJavaStackframe); + stackPtr=(u1*)(info->beginOfJavaStackframe); #elif defined(__I386__) || defined (__X86_64__) - stackPtr=(char*)(info->beginOfJavaStackframe)+sizeof(void*); + stackPtr=(u1*)(info->beginOfJavaStackframe)+sizeof(void*); #endif info=info->oldThreadspecificHeadValue; } else { /*method created by jit*/ @@ -249,16 +265,17 @@ void cacao_stacktrace_fillInStackTrace(void **target,CacaoStackTraceCollector c #endif /*utf_display(currentMethod->class->name); utf_display(currentMethod->name);*/ - fillInStackTrace_method(&buffer,currentMethod,dataseg,returnAdress-1); + cast_funcptr_u1ptr(tmp,returnAdress); + fillInStackTrace_method(&buffer,currentMethod,dataseg,tmp-1); frameSize=*((u4*)(dataseg+FrameSize)); #if defined(__ALPHA__) /* cacao saves the return adress as the first element of the stack frame on alphas*/ - dataseg=codegen_findmethod(*((void**)(stackPtr+frameSize-sizeof(void*)))); + cast_funcptr_u1ptr (dataseg,codegen_findmethod(*((void**)(stackPtr+frameSize-sizeof(void*))))); returnAdress=(*((void**)(stackPtr+frameSize-sizeof(void*)))); #elif defined(__I386__) || defined (__x86_64__) /* on i386 the return adress is the first element before the stack frme*/ - returnAdress=(*((void**)(stackPtr+frameSize))); - dataseg=codegen_findmethod(*((void**)(stackPtr+frameSize))); + cast_u1ptr_funcptr(returnAdress,*((u1**)(stackPtr+frameSize))); + cast_funcptr_u1ptr(dataseg,codegen_findmethod(returnAdress)); #endif /* printf ("threadrootmethod %p\n",builtin_asm_get_threadrootmethod()); if (currentMethod==builtin_asm_get_threadrootmethod()) break;*/ @@ -290,7 +307,7 @@ void stackTraceCollector(void **target, stackTraceBuffer *buffer) { dest->needsFree=0; dest->size=dest->full; - dest->start=dest+1; + dest->start=(stacktraceelement*)(dest+1); /* if (buffer->full>0) { @@ -348,7 +365,7 @@ void classContextCollector(void **target, stackTraceBuffer *buffer) { java_objectarray *cacao_createClassContextArray() { java_objectarray *array=0; - cacao_stacktrace_fillInStackTrace(&array,&classContextCollector); + cacao_stacktrace_fillInStackTrace((void**)&array,&classContextCollector); return array; } @@ -368,7 +385,7 @@ void classLoaderCollector(void **target, stackTraceBuffer *buffer) { if (size > 1) { size--; start=&(buffer->start[1]); - if (start == class_java_lang_SecurityManager) { + if (start->method && (start->method->class == class_java_lang_SecurityManager)) { size--; start--; } @@ -400,7 +417,7 @@ void classLoaderCollector(void **target, stackTraceBuffer *buffer) { java_objectheader *cacao_currentClassLoader() { java_objectheader *header=0; - cacao_stacktrace_fillInStackTrace(&header,&classLoaderCollector); + cacao_stacktrace_fillInStackTrace((void**)&header,&classLoaderCollector); return header; } @@ -413,7 +430,7 @@ void callingMethodCollector(void **target, stackTraceBuffer *buffer) { methodinfo *cacao_callingMethod() { methodinfo *method; - cacao_stacktrace_fillInStackTrace(&method,&callingMethodCollector); + cacao_stacktrace_fillInStackTrace((void**)&method,&callingMethodCollector); return method; } diff --git a/src/vm/jit/stacktrace.h b/src/vm/jit/stacktrace.h index dea999750..ba0d5ad16 100644 --- a/src/vm/jit/stacktrace.h +++ b/src/vm/jit/stacktrace.h @@ -28,7 +28,7 @@ Changes: - $Id: stacktrace.h 2360 2005-04-24 13:07:57Z jowenn $ + $Id: stacktrace.h 2402 2005-04-27 13:17:07Z jowenn $ */ @@ -56,7 +56,7 @@ struct native_stackframeinfo { void *savedpv; #endif void *beginOfJavaStackframe; /*only used if != 0*/ /* on i386 and x86_64 this points to the return addres stored directly below the stackframe*/ - void *returnToFromNative; + functionptr returnToFromNative; #if 0 void *returnFromNative; diff --git a/src/vm/jit/x86_64/codegen.c b/src/vm/jit/x86_64/codegen.c index e4586d189..bc6e56df4 100644 --- a/src/vm/jit/x86_64/codegen.c +++ b/src/vm/jit/x86_64/codegen.c @@ -27,7 +27,7 @@ Authors: Andreas Krall Christian Thalinger - $Id: codegen.c 2392 2005-04-26 19:50:42Z twisti $ + $Id: codegen.c 2402 2005-04-27 13:17:07Z jowenn $ */ @@ -4264,6 +4264,7 @@ void removecompilerstub(u1 *stub) /* #endif */ #define NATIVESTUBSIZE 800 /* keep this size high enough! */ +#define NATIVESTUB_DATA_SIZE (7*8) u1 *createnativestub(functionptr f, methodinfo *m) { @@ -4277,6 +4278,9 @@ u1 *createnativestub(functionptr f, methodinfo *m) s4 iargs; /* count of integer arguments */ s4 fargs; /* count of float arguments */ s4 i; /* counter */ + s4 stubsize; + u8 *cs; + bool require_clinit_call; void **callAddrPatchPos=0; u1 *jmpInstrPos=0; @@ -4311,16 +4315,35 @@ u1 *createnativestub(functionptr f, methodinfo *m) IS_INT_LNG_TYPE(*tptr++) ? iargs++ : fargs++; } - s = CNEW(u1, NATIVESTUBSIZE); /* memory to hold the stub */ + stubsize=NATIVESTUBSIZE; + require_clinit_call= ((m->flags & ACC_STATIC) && !m->class->initialized); + if (require_clinit_call) stubsize+=NATIVESTUB_DATA_SIZE; + s = CNEW(u1, stubsize); /* memory to hold the stub */ + + if (require_clinit_call) { + cs = (u8*) (s+NATIVESTUB_DATA_SIZE); + *(cs - 7) = 0; /* extable size,padding */ + *(cs - 6) = 0; /* line number table start */ + *(cs - 5) = 0; /* line number table size */ + *(cs - 4) = 0; /* padding,fltsave */ + *(cs - 3) = 0; /* intsave=0,isleaf=0 */ + *(cs - 2) = 0x0000000000000000; /* frame size=0 (stack misalignment) issync=0 */ +#if 0 + *(cs - 2) = 0x0000000100000000; /* frame size=1 issync=0 */ +#endif + *(cs - 1) = (u8) m; /* method pointer */ + } else { + cs = (u8*) s; + } /* set some required varibles which are normally set by codegen_setup */ - cd->mcodebase = s; - cd->mcodeptr = s; + cd->mcodebase = (u1*)cs; + cd->mcodeptr = (u1*)cs; cd->patchrefs = NULL; /* if function is static, check for initialized */ - if ((m->flags & ACC_STATIC) && !m->class->initialized) { + if (require_clinit_call) { codegen_addpatchref(cd, cd->mcodeptr, PATCHER_clinit, m->class); } @@ -4687,29 +4710,32 @@ u1 *createnativestub(functionptr f, methodinfo *m) x86_64_mov_imm_reg(cd, (ptrint) asm_wrapper_patcher, REG_ITMP3); x86_64_jmp_reg(cd, REG_ITMP3); + + codegen_insertmethod((functionptr) cs, (functionptr) cd->mcodeptr); + printf("codegen_insertmethod (nativestub) %p - %p\n",cs,cd->mcodeptr); } } /* Check if the stub size is big enough to hold the whole stub generated. */ /* If not, this can lead into unpredictable crashes, because of heap */ /* corruption. */ - if ((s4) (cd->mcodeptr - s) > NATIVESTUBSIZE) { + if ((s4) (cd->mcodeptr - s) > stubsize) { throw_cacao_exception_exit(string_java_lang_InternalError, "Native stub size %d is to small for current stub size %d", - NATIVESTUBSIZE, (s4) (cd->mcodeptr - s)); + stubsize, (s4) (cd->mcodeptr - s)); } #if defined(STATISTICS) if (opt_stat) - count_nstub_len += NATIVESTUBSIZE; + count_nstub_len += stubsize; #endif /* release dump area */ dump_release(dumpsize); - return s; + return (u1*) cs; } diff --git a/src/vm/jit/x86_64/patcher.c b/src/vm/jit/x86_64/patcher.c index 87f303362..a85df29ff 100644 --- a/src/vm/jit/x86_64/patcher.c +++ b/src/vm/jit/x86_64/patcher.c @@ -28,7 +28,7 @@ Changes: - $Id: patcher.c 2391 2005-04-26 19:49:15Z twisti $ + $Id: patcher.c 2402 2005-04-27 13:17:07Z jowenn $ */ @@ -904,6 +904,7 @@ bool patcher_clinit(u1 *sp) c = (classinfo *) *((ptrint *) (sp + 0 * 8)); beginJavaStack = (void*) (sp+2*8); + /*printf("beginJavaStack: %p, ra %p\n",beginJavaStack,ra);*/ /* calculate and set the new return address */ ra = ra - 5; -- 2.25.1