src/vm/jit/stacktrace.c

   1 /* vm/jit/stacktrace.c
   2
   3    Copyright (C) 1996-2005 R. Grafl, A. Krall, C. Kruegel, C. Oates,
   4    R. Obermaisser, M. Platter, M. Probst, S. Ring, E. Steiner,
   5    C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich, J. Wenninger,
   6    Institut f. Computersprachen - TU Wien
   7
   8    This file is part of CACAO.
   9
  10    This program is free software; you can redistribute it and/or
  11    modify it under the terms of the GNU General Public License as
  12    published by the Free Software Foundation; either version 2, or (at
  13    your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful, but
  16    WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18    General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  23    02111-1307, USA.
  24
  25    Contact: cacao@complang.tuwien.ac.at
  26
  27    Authors: Joseph Wenninger
  28
  29    $Id: stacktrace.c 2193 2005-04-02 19:33:43Z edwin $
  30
  31 */
  32
  33
  34 #include <stdlib.h>
  35 #include <string.h>
  36
  37 #include "asmoffsets.h"
  38 #include "mm/boehm.h"
  39 #include "native/native.h"
  40 #include "vm/global.h"                   /* required here for native includes */
  41 #include "native/include/java_lang_ClassLoader.h"
  42 #include "toolbox/logging.h"
  43 #include "vm/builtin.h"
  44 #include "vm/class.h"
  45 #include "vm/tables.h"
  46 #include "vm/jit/codegen.inc.h"
  47
  48
  49 #undef JWDEBUG
  50 /*JoWenn: simplify collectors (trace doesn't contain internal methods)*/
  51
  52 /* the line number is only u2, but to avoid alignment problems it is made the same size as a native
  53         pointer. In the structures where this is used, values of -1 or -2 have a special meainging, so
  54         if java bytecode is ever extended to support more than 65535 lines/file, this could will have to
  55         be changed.*/
  56
  57 #ifdef _ALPHA_
  58         #define LineNumber u8
  59 #else
  60         #define LineNumber u4
  61 #endif
  62
  63 typedef struct lineNumberTableEntry {
  64 /* The special value of -1 means that a inlined function starts, a value of -2 means that an inlined function ends*/
  65         LineNumber lineNr;
  66         void *pc;
  67 } lineNumberTableEntry;
  68
  69 typedef struct lineNumberTableEntryInlineBegin {
  70 /*this should have the same layout and size as the lineNumberTableEntry*/
  71         LineNumber lineNrOuter;
  72         methodinfo *method;
  73 } lineNumberTableEntryInlineBegin;
  74
  75
  76 typedef void(*CacaoStackTraceCollector)(void **,stackTraceBuffer*);
  77
  78 #define BLOCK_INITIALSIZE 40
  79 #define BLOCK_SIZEINCREMENT 40
  80
  81 static void addEntry(stackTraceBuffer* buffer,methodinfo*method ,LineNumber line) {
  82         if (buffer->size>buffer->full) {
  83                 stacktraceelement *tmp=&(buffer->start[buffer->full]);
  84                 tmp->method=method;
  85                 tmp->linenumber=line;
  86                 buffer->full = buffer->full + 1;
  87 #ifdef JWDEBUG
  88                 log_text("addEntry (stacktrace):");
  89                 if (method) utf_display(method->name); else printf("Native");
  90                 if (method) {printf("\n");utf_display(method->class->name);}
  91                 printf("\nLine:%ld\n",line);
  92 #endif
  93         } else {
  94                 stacktraceelement *newBuffer=(stacktraceelement*)
  95                         malloc((buffer->size+BLOCK_SIZEINCREMENT)*sizeof(stacktraceelement));
  96                 if (newBuffer==0) panic("OOM during stacktrace creation");
  97                 memcpy(newBuffer,buffer->start,buffer->size*sizeof(stacktraceelement));
  98                 if (buffer->needsFree) free(buffer->start);
  99                 buffer->start=newBuffer;
 100                 buffer->size=buffer->size+BLOCK_SIZEINCREMENT;
 101                 buffer->needsFree=1;
 102                 addEntry(buffer,method,line);
 103         }
 104 }
 105
 106 static int fillInStackTrace_methodRecursive(stackTraceBuffer *buffer,methodinfo
 107                 *method,lineNumberTableEntry *startEntry, lineNumberTableEntry **entry, size_t *entriesAhead,void *adress) {
 108
 109         size_t ahead=*entriesAhead;
 110         lineNumberTableEntry *ent=*entry;
 111         lineNumberTableEntryInlineBegin *ilStart;
 112
 113         for (;ahead>0;ahead--,ent++) {
 114                 if (adress>=ent->pc) {
 115                         switch (ent->lineNr) {
 116                                 case -1: /*begin of inlined method */
 117                                         ilStart=(lineNumberTableEntryInlineBegin*)(++ent);
 118                                         ent ++;
 119                                         ahead--; ahead--;
 120                                         if (fillInStackTrace_methodRecursive(buffer,ilStart->method,ent,&ent,&ahead,adress)) {
 121                                                 addEntry(buffer,method,ilStart->lineNrOuter);
 122                                                 return 1;
 123                                         }
 124                                         break;
 125                                 case -2: /*end of inlined method*/
 126                                         *entry=ent;
 127                                         *entriesAhead=ahead;
 128                                         return 0;
 129                                         break;
 130                                 default:
 131                                         if (adress==ent->pc) {
 132                                                 addEntry(buffer,method,ent->lineNr);
 133                                                 return 1;
 134                                         }
 135                                         break;
 136                         }
 137                 } else {
 138                         if (adress>startEntry->pc) {
 139                                 ent--;
 140                                 addEntry(buffer,method,ent->lineNr);
 141                                 return 1;
 142                         } else panic("trace point before method");
 143                 }
 144         }
 145         ent--;
 146         addEntry(buffer,method,ent->lineNr);
 147         return 1;
 148
 149 }
 150
 151 static void fillInStackTrace_method(stackTraceBuffer *buffer,methodinfo *method,char *dataSeg, void* adress) {
 152         size_t lineNumberTableSize=(*((size_t*)(dataSeg+LineNumberTableSize)));
 153
 154
 155         if ( lineNumberTableSize == 0) {
 156                 /*right now this happens only on
 157                 i386,if the native stub causes an exception in a <clinit> invocation (jowenn)*/
 158                 addEntry(buffer,method,0);
 159                 return;
 160         } else {
 161                 lineNumberTableEntry *ent; /*=(lineNumberTableEntry*) ((*((char**)(dataSeg+LineNumberTableStart))) - (sizeof(lineNumberTableEntry)-sizeof(void*)));*/
 162                 void **calc;
 163                 lineNumberTableEntry *startEntry;
 164
 165                 /*              printf("dataSeg: %p\n",dataSeg);*/
 166                 calc=dataSeg+LineNumberTableStart;
 167                 /*              printf("position of line number table start reference in data segment: %p\n",calc);
 168                                 printf("line number table start as found in table: %p\n",*calc);*/
 169                 ent=(lineNumberTableEntry *) (((char*)(*calc) - (sizeof(lineNumberTableEntry)-sizeof(void*))));
 170                 /*              printf("line number table start as calculated: %p\n",ent);*/
 171                 ent-=(lineNumberTableSize-1);
 172                 startEntry=ent;
 173                 /*              printf("line number table real start (bottom end) as calculated(2): %p\n",startEntry);*/
 174
 175                 if (!fillInStackTrace_methodRecursive(buffer,method,startEntry,&ent,&lineNumberTableSize,adress)) {
 176                         panic("Trace point not found in suspected method");
 177                 }
 178         }
 179 }
 180
 181
 182 void  cacao_stacktrace_fillInStackTrace(void **target,CacaoStackTraceCollector coll)
 183 {
 184
 185         stacktraceelement primaryBlock[BLOCK_INITIALSIZE*sizeof(stacktraceelement)];
 186                 /*In most cases this should be enough -> one malloc less. I don't think temporary data should be
 187                 allocated with the GC, only the result*/
 188         stackTraceBuffer buffer;
 189         buffer.needsFree=0;
 190         buffer.start=primaryBlock;
 191         buffer.size=BLOCK_INITIALSIZE*sizeof(stacktraceelement);
 192         buffer.full=0;
 193
 194
 195         {
 196                 struct native_stackframeinfo *info=(*(((void**)(builtin_asm_get_stackframeinfo()))));
 197                 if (!info) {
 198                         log_text("info ==0");
 199                         *target=0;
 200                         return;
 201                 } else {
 202                         char *dataseg; /*make it byte addressable*/
 203                         methodinfo *currentMethod=0;
 204                         void *returnAdress;
 205                         char* stackPtr;
 206
 207 /*                      utf_display(info->method->class->name);
 208                         utf_display(info->method->name);*/
 209
 210                         while ((currentMethod!=0) ||  (info!=0)) {
 211                                 if (currentMethod==0) { /*some builtin native */
 212                                         currentMethod=info->method;
 213                                         returnAdress=info->returnToFromNative;
 214                                         /*log_text("native");*/
 215                                         if (currentMethod) {
 216                                                 /*utf_display(currentMethod->class->name);
 217                                                 utf_display(currentMethod->name);*/
 218                                                 addEntry(&buffer,currentMethod,0);
 219                                         }
 220 #if defined(__ALPHA__)
 221                                         if (info->savedpv!=0)
 222                                                 dataseg=info->savedpv;
 223                                         else
 224                                                 dataseg=codegen_findmethod(returnAdress);
 225 #elif defined(__I386__)
 226                                         dataseg=codegen_findmethod(returnAdress);
 227 #endif
 228                                         currentMethod=(*((methodinfo**)(dataseg+MethodPointer)));
 229                                         if (info->beginOfJavaStackframe==0)
 230                                                 stackPtr=((char*)info)+sizeof(native_stackframeinfo);
 231                                         else
 232 #if defined(__ALPHA__)
 233                                                 stackPtr=(char*)(info->beginOfJavaStackframe);
 234 #elif defined(__I386__)
 235                                                 stackPtr=(char*)(info->beginOfJavaStackframe)+sizeof(void*);
 236 #endif
 237                                         info=info->oldThreadspecificHeadValue;
 238                                 } else { /*method created by jit*/
 239                                         u4 frameSize;
 240                                         /*log_text("JIT");*/
 241 #if defined (__ALPHA__)
 242                                         if (currentMethod->isleafmethod) {
 243 #ifdef JWDEBUG
 244                                                 printf("class.method:%s.%s\n",currentMethod->class->name->text,currentMethod->name->text);
 245 #endif
 246                                                 panic("How could that happen ??? A leaf method in the middle of a stacktrace ??");
 247                                         }
 248 #endif
 249                                         /*utf_display(currentMethod->class->name);
 250                                         utf_display(currentMethod->name);*/
 251                                         fillInStackTrace_method(&buffer,currentMethod,dataseg,returnAdress);
 252                                         frameSize=*((u4*)(dataseg+FrameSize));
 253 #if defined(__ALPHA__)
 254                                         /* cacao saves the return adress as the first element of the stack frame on alphas*/
 255                                         dataseg=codegen_findmethod(*((void**)(stackPtr+frameSize-sizeof(void*))));
 256                                         returnAdress=(*((void**)(stackPtr+frameSize-sizeof(void*))));
 257 #elif defined(__I386__)
 258                                         /* on i386 the return adress is the first element before the stack frme*/
 259                                         returnAdress=(*((void**)(stackPtr+frameSize)));
 260                                         dataseg=codegen_findmethod(*((void**)(stackPtr+frameSize)));
 261 #endif
 262 /*                                      printf ("threadrootmethod %p\n",builtin_asm_get_threadrootmethod());
 263                                         if (currentMethod==builtin_asm_get_threadrootmethod()) break;*/
 264                                         currentMethod=(*((methodinfo**)(dataseg+MethodPointer)));
 265 #if defined(__ALPHA__)
 266                                         stackPtr+=frameSize;
 267 #elif defined(__I386__)
 268                                         stackPtr+=frameSize+sizeof(void*);
 269 #endif
 270                                 }
 271                         }
 272
 273                         if (coll) coll(target,&buffer);
 274                         if (buffer.needsFree) free(buffer.start);
 275                         return;
 276                 }
 277                 /*log_text("\n=========================================================");*/
 278         }
 279         *target=0;
 280
 281 }
 282
 283
 284 static
 285 void stackTraceCollector(void **target, stackTraceBuffer *buffer) {
 286         stackTraceBuffer *dest=*target=heap_allocate(sizeof(stackTraceBuffer)+buffer->full*sizeof(stacktraceelement),true,0);
 287         memcpy(*target,buffer,sizeof(stackTraceBuffer));
 288         memcpy(dest+1,buffer->start,buffer->full*sizeof(stacktraceelement));
 289
 290         dest->needsFree=0;
 291         dest->size=dest->full;
 292         dest->start=dest+1;
 293
 294         /*
 295         if (buffer->full>0) {
 296                 printf("SOURCE BUFFER:%s\n",buffer->start[0].method->name->text);
 297                 printf("DEST BUFFER:%s\n",dest->start[0].method->name->text);
 298         } else printf("Buffer is empty\n");
 299         */
 300 }
 301
 302
 303 void  cacao_stacktrace_NormalTrace(void **target) {
 304         cacao_stacktrace_fillInStackTrace(target,&stackTraceCollector);
 305 }
 306
 307
 308
 309 static
 310 void classContextCollector(void **target, stackTraceBuffer *buffer) {
 311         java_objectarray *tmpArray;
 312         int i;
 313         stacktraceelement *current;
 314         stacktraceelement *start;
 315         classinfo *c;
 316         size_t size;
 317         size_t targetSize;
 318
 319         size=buffer->full;
 320         targetSize=0;
 321         for (i=0;i<size;i++)
 322                 if (buffer->start[i].method!=0) targetSize++;
 323         start=buffer->start;
 324         start++;
 325         targetSize--;
 326
 327         if (targetSize > 0) {
 328                 if ((start->method) && (start->method->class== class_java_lang_SecurityManager)) {
 329                         targetSize--;
 330                         start++;
 331                 }
 332         }
 333
 334         tmpArray =
 335                 builtin_newarray(targetSize, class_array_of(class_java_lang_Class)->vftbl);
 336
 337         for(i = 0, current = start; i < targetSize; i++, current++) {
 338                 if (current->method==0) { i--; continue;}
 339                 /*printf("adding item to class context array:%s\n",current->method->class->name->text);
 340                 printf("method for class: :%s\n",current->method->name->text);*/
 341                 use_class_as_object(current->method->class);
 342                 tmpArray->data[i] = (java_objectheader *) current->method->class;
 343         }
 344
 345         *target=tmpArray;
 346 }
 347
 348
 349
 350 java_objectarray *cacao_createClassContextArray() {
 351         java_objectarray *array=0;
 352         cacao_stacktrace_fillInStackTrace(&array,&classContextCollector);
 353         return array;
 354
 355 }
 356
 357
 358 static
 359 void classLoaderCollector(void **target, stackTraceBuffer *buffer) {
 360         int i;
 361         stacktraceelement *current;
 362         stacktraceelement *start;
 363         methodinfo *m;
 364         classinfo *privilegedAction;
 365         size_t size;
 366
 367         size = buffer->full;
 368
 369         if (size > 1) {
 370                 size--;
 371                 start=&(buffer->start[1]);
 372                 if (start == class_java_lang_SecurityManager) {
 373                         size--;
 374                         start--;
 375                 }
 376         } else {
 377                 start=0;
 378                 size=0;
 379         }
 380
 381                 if (!load_class_bootstrap(utf_new_char("java/security/PrivilegedAction"),&privilegedAction))
 382                         /* XXX handle exception */;
 383
 384         for(i=0, current = start; i < size; i++, current++) {
 385                 m=start->method;
 386                 if (!m) continue;
 387
 388                 if (m->class == privilegedAction) {
 389                         *target=NULL;
 390                         return;
 391                 }
 392
 393                 if (m->class->classloader) {
 394                         *target= (java_lang_ClassLoader *) m->class->classloader;
 395                         return;
 396                 }
 397         }
 398
 399         *target=NULL;
 400 }
 401
 402 java_objectheader *cacao_currentClassLoader() {
 403         java_objectheader *header=0;
 404         cacao_stacktrace_fillInStackTrace(&header,&classLoaderCollector);
 405         return header;
 406 }
 407
 408
 409 static
 410 void callingMethodCollector(void **target, stackTraceBuffer *buffer) {
 411         if (buffer->full >2) (*target)=buffer->start[2].method;
 412         else (*target=0);
 413 }
 414
 415 methodinfo *cacao_callingMethod() {
 416         methodinfo *method;
 417         cacao_stacktrace_fillInStackTrace(&method,&callingMethodCollector);
 418         return method;
 419 }
 420
 421 /*
 422  * These are local overrides for various environment variables in Emacs.
 423  * Please do not remove this and leave it at the end of the file, where
 424  * Emacs will automagically detect them.
 425  * ---------------------------------------------------------------------
 426  * Local variables:
 427  * mode: c
 428  * indent-tabs-mode: t
 429  * c-basic-offset: 4
 430  * tab-width: 4
 431  * End:
 432  */