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 1735 2004-12-07 14:33:27Z twisti $
  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/tables.h"
  45 #include "vm/jit/codegen.inc.h"
  46
  47
  48 #undef JWDEBUG
  49
  50 extern classinfo *class_java_lang_Class;
  51 extern classinfo *class_java_lang_SecurityManager;
  52
  53 /* the line number is only u2, but to avoid alignment problems it is made the same size as a native
  54         pointer. In the structures where this is used, values of -1 or -2 have a special meainging, so
  55         if java bytecode is ever extended to support more than 65535 lines/file, this could will have to
  56         be changed.*/
  57
  58 #ifdef _ALPHA_
  59         #define LineNumber u8
  60 #else
  61         #define LineNumber u4
  62 #endif
  63
  64 typedef struct lineNumberTableEntry {
  65 /* The special value of -1 means that a inlined function starts, a value of -2 means that an inlined function ends*/
  66         LineNumber lineNr;
  67         void *pc;
  68 } lineNumberTableEntry;
  69
  70 typedef struct lineNumberTableEntryInlineBegin {
  71 /*this should have the same layout and size as the lineNumberTableEntry*/
  72         LineNumber lineNrOuter;
  73         methodinfo *method;
  74 } lineNumberTableEntryInlineBegin;
  75
  76
  77 typedef void(*CacaoStackTraceCollector)(void **,stackTraceBuffer*);
  78
  79 #define BLOCK_INITIALSIZE 40
  80 #define BLOCK_SIZEINCREMENT 40
  81
  82 static void addEntry(stackTraceBuffer* buffer,methodinfo*method ,LineNumber line) {
  83         if (buffer->size>buffer->full) {
  84                 stacktraceelement *tmp=&(buffer->start[buffer->full]);
  85                 tmp->method=method;
  86                 tmp->linenumber=line;
  87                 buffer->full = buffer->full + 1;
  88 #ifdef JWDEBUG
  89                 log_text("addEntry (stacktrace):");
  90                 if (method) utf_display(method->name); else printf("Native");
  91                 if (method) {printf("\n");utf_display(method->class->name);}
  92                 printf("\nLine:%ld\n",line);
  93 #endif
  94         } else {
  95                 stacktraceelement *newBuffer=(stacktraceelement*)
  96                         malloc((buffer->size+BLOCK_SIZEINCREMENT)*sizeof(stacktraceelement));
  97                 if (newBuffer==0) panic("OOM during stacktrace creation");
  98                 memcpy(newBuffer,buffer->start,buffer->size*sizeof(stacktraceelement));
  99                 if (buffer->needsFree) free(buffer->start);
 100                 buffer->start=newBuffer;
 101                 buffer->size=buffer->size+BLOCK_SIZEINCREMENT;
 102                 buffer->needsFree=1;
 103                 addEntry(buffer,method,line);
 104         }
 105 }
 106
 107 static int fillInStackTrace_methodRecursive(stackTraceBuffer *buffer,methodinfo
 108                 *method,lineNumberTableEntry *startEntry, lineNumberTableEntry **entry, size_t *entriesAhead,void *adress) {
 109
 110         size_t ahead=*entriesAhead;
 111         lineNumberTableEntry *ent=*entry;
 112         lineNumberTableEntryInlineBegin *ilStart;
 113
 114         for (;ahead>0;ahead--,ent++) {
 115                 if (adress>=ent->pc) {
 116                         switch (ent->lineNr) {
 117                                 case -1: /*begin of inlined method */
 118                                         ilStart=(lineNumberTableEntryInlineBegin*)(++ent);
 119                                         ent ++;
 120                                         ahead--; ahead--;
 121                                         if (fillInStackTrace_methodRecursive(buffer,ilStart->method,ent,&ent,&ahead,adress)) {
 122                                                 addEntry(buffer,method,ilStart->lineNrOuter);
 123                                                 return 1;
 124                                         }
 125                                         break;
 126                                 case -2: /*end of inlined method*/
 127                                         *entry=ent;
 128                                         *entriesAhead=ahead;
 129                                         return 0;
 130                                         break;
 131                                 default:
 132                                         if (adress==ent->pc) {
 133                                                 addEntry(buffer,method,ent->lineNr);
 134                                                 return 1;
 135                                         }
 136                                         break;
 137                         }
 138                 } else {
 139                         if (adress>startEntry->pc) {
 140                                 ent--;
 141                                 addEntry(buffer,method,ent->lineNr);
 142                                 return 1;
 143                         } else panic("trace point before method");
 144                 }
 145         }
 146         ent--;
 147         addEntry(buffer,method,ent->lineNr);
 148         return 1;
 149
 150 }
 151
 152 static void fillInStackTrace_method(stackTraceBuffer *buffer,methodinfo *method,char *dataSeg, void* adress) {
 153         size_t lineNumberTableSize=(*((size_t*)(dataSeg+LineNumberTableSize)));
 154
 155
 156         if ( lineNumberTableSize == 0) {
 157                 /*right now this happens only on
 158                 i386,if the native stub causes an exception in a <clinit> invocation (jowenn)*/
 159                 addEntry(buffer,method,0);
 160                 return;
 161         } else {
 162                 lineNumberTableEntry *ent; /*=(lineNumberTableEntry*) ((*((char**)(dataSeg+LineNumberTableStart))) - (sizeof(lineNumberTableEntry)-sizeof(void*)));*/
 163                 void **calc;
 164                 lineNumberTableEntry *startEntry;
 165
 166                 /*              printf("dataSeg: %p\n",dataSeg);*/
 167                 calc=dataSeg+LineNumberTableStart;
 168                 /*              printf("position of line number table start reference in data segment: %p\n",calc);
 169                                 printf("line number table start as found in table: %p\n",*calc);*/
 170                 ent=(lineNumberTableEntry *) (((char*)(*calc) - (sizeof(lineNumberTableEntry)-sizeof(void*))));
 171                 /*              printf("line number table start as calculated: %p\n",ent);*/
 172                 ent-=(lineNumberTableSize-1);
 173                 startEntry=ent;
 174                 /*              printf("line number table real start (bottom end) as calculated(2): %p\n",startEntry);*/
 175
 176                 if (!fillInStackTrace_methodRecursive(buffer,method,startEntry,&ent,&lineNumberTableSize,adress)) {
 177                         panic("Trace point not found in suspected method");
 178                 }
 179         }
 180 }
 181
 182
 183 void  cacao_stacktrace_fillInStackTrace(void **target,CacaoStackTraceCollector coll)
 184 {
 185
 186         stacktraceelement primaryBlock[BLOCK_INITIALSIZE*sizeof(stacktraceelement)];
 187                 /*In most cases this should be enough -> one malloc less. I don't think temporary data should be
 188                 allocated with the GC, only the result*/
 189         stackTraceBuffer buffer;
 190         buffer.needsFree=0;
 191         buffer.start=primaryBlock;
 192         buffer.size=BLOCK_INITIALSIZE*sizeof(stacktraceelement);
 193         buffer.full=0;
 194
 195
 196         {
 197                 struct native_stackframeinfo *info=(*(((void**)(builtin_asm_get_stackframeinfo()))));
 198                 if (!info) {
 199                         log_text("info ==0");
 200                         *target=0;
 201                         return;
 202                 } else {
 203                         char *dataseg; /*make it byte addressable*/
 204                         methodinfo *currentMethod=0;
 205                         void *returnAdress;
 206                         char* stackPtr;
 207
 208 /*                      utf_display(info->method->class->name);
 209                         utf_display(info->method->name);*/
 210
 211                         while ((currentMethod!=0) ||  (info!=0)) {
 212                                 if (currentMethod==0) { /*some builtin native */
 213                                         currentMethod=info->method;
 214                                         returnAdress=info->returnToFromNative;
 215                                         /*log_text("native");*/
 216                                         if (currentMethod) {
 217                                                 /*utf_display(currentMethod->class->name);
 218                                                 utf_display(currentMethod->name);*/
 219                                                 addEntry(&buffer,currentMethod,0);
 220                                         }
 221 #if defined(__ALPHA__)
 222                                         if (info->savedpv!=0)
 223                                                 dataseg=info->savedpv;
 224                                         else
 225                                                 dataseg=codegen_findmethod(returnAdress);
 226 #elif defined(__I386__)
 227                                         dataseg=codegen_findmethod(returnAdress);
 228 #endif
 229                                         currentMethod=(*((methodinfo**)(dataseg+MethodPointer)));
 230                                         if (info->beginOfJavaStackframe==0)
 231                                                 stackPtr=((char*)info)+sizeof(native_stackframeinfo);
 232                                         else
 233 #if defined(__ALPHA__)
 234                                                 stackPtr=(char*)(info->beginOfJavaStackframe);
 235 #elif defined(__I386__)
 236                                                 stackPtr=(char*)(info->beginOfJavaStackframe)+sizeof(void*);
 237 #endif
 238                                         info=info->oldThreadspecificHeadValue;
 239                                 } else { /*method created by jit*/
 240                                         u4 frameSize;
 241                                         /*log_text("JIT");*/
 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                                         /*utf_display(currentMethod->class->name);
 249                                         utf_display(currentMethod->name);*/
 250                                         fillInStackTrace_method(&buffer,currentMethod,dataseg,returnAdress);
 251                                         frameSize=*((u4*)(dataseg+FrameSize));
 252 #if defined(__ALPHA__)
 253                                         /* cacao saves the return adress as the first element of the stack frame on alphas*/
 254                                         dataseg=codegen_findmethod(*((void**)(stackPtr+frameSize-sizeof(void*))));
 255                                         returnAdress=(*((void**)(stackPtr+frameSize-sizeof(void*))));
 256 #elif defined(__I386__)
 257                                         /* on i386 the return adress is the first element before the stack frme*/
 258                                         returnAdress=(*((void**)(stackPtr+frameSize)));
 259                                         dataseg=codegen_findmethod(*((void**)(stackPtr+frameSize)));
 260 #endif
 261 /*                                      printf ("threadrootmethod %p\n",builtin_asm_get_threadrootmethod());
 262                                         if (currentMethod==builtin_asm_get_threadrootmethod()) break;*/
 263                                         currentMethod=(*((methodinfo**)(dataseg+MethodPointer)));
 264 #if defined(__ALPHA__)
 265                                         stackPtr+=frameSize;
 266 #elif defined(__I386__)
 267                                         stackPtr+=frameSize+sizeof(void*);
 268 #endif
 269                                 }
 270                         }
 271
 272                         if (coll) coll(target,&buffer);
 273                         if (buffer.needsFree) free(buffer.start);
 274                         return;
 275                 }
 276                 /*log_text("\n=========================================================");*/
 277         }
 278         *target=0;
 279
 280 }
 281
 282
 283 static
 284 void stackTraceCollector(void **target, stackTraceBuffer *buffer) {
 285         stackTraceBuffer *dest=*target=heap_allocate(sizeof(stackTraceBuffer)+buffer->full*sizeof(stacktraceelement),true,0);
 286         memcpy(*target,buffer,sizeof(stackTraceBuffer));
 287         memcpy(dest+1,buffer->start,buffer->full*sizeof(stacktraceelement));
 288
 289         dest->needsFree=0;
 290         dest->size=dest->full;
 291         dest->start=dest+1;
 292
 293         /*
 294         if (buffer->full>0) {
 295                 printf("SOURCE BUFFER:%s\n",buffer->start[0].method->name->text);
 296                 printf("DEST BUFFER:%s\n",dest->start[0].method->name->text);
 297         } else printf("Buffer is empty\n");
 298         */
 299 }
 300
 301
 302 void  cacao_stacktrace_NormalTrace(void **target) {
 303         cacao_stacktrace_fillInStackTrace(target,&stackTraceCollector);
 304 }
 305
 306
 307
 308 static
 309 void classContextCollector(void **target, stackTraceBuffer *buffer) {
 310         java_objectarray *tmpArray;
 311         int i;
 312         stacktraceelement *current;
 313         stacktraceelement *start;
 314         classinfo *c;
 315         size_t size;
 316         size_t targetSize;
 317
 318         size=buffer->full;
 319         targetSize=0;
 320         for (i=0;i<size;i++)
 321                 if (buffer->start[i].method!=0) targetSize++;
 322         start=buffer->start;
 323         start++;
 324         targetSize--;
 325         if (!class_java_lang_Class)
 326                 class_java_lang_Class = class_new(utf_new_char("java/lang/Class"));
 327
 328         if (!class_java_lang_SecurityManager)
 329                 class_java_lang_SecurityManager =
 330                         class_new(utf_new_char("java/lang/SecurityManager"));
 331
 332         if (targetSize > 0) {
 333                 if ((start->method) && (start->method->class== class_java_lang_SecurityManager)) {
 334                         targetSize--;
 335                         start++;
 336                 }
 337         }
 338
 339         tmpArray =
 340                 builtin_newarray(targetSize, class_array_of(class_java_lang_Class)->vftbl);
 341
 342         for(i = 0, current = start; i < targetSize; i++, current++) {
 343                 if (current->method==0) { i--; continue;}
 344                 /*printf("adding item to class context array:%s\n",current->method->class->name->text);
 345                 printf("method for class: :%s\n",current->method->name->text);*/
 346                 use_class_as_object(current->method->class);
 347                 tmpArray->data[i] = (java_objectheader *) current->method->class;
 348         }
 349
 350         *target=tmpArray;
 351 }
 352
 353
 354
 355 java_objectarray *cacao_createClassContextArray() {
 356         java_objectarray *array=0;
 357         cacao_stacktrace_fillInStackTrace(&array,&classContextCollector);
 358         return array;
 359
 360 }
 361
 362
 363 static
 364 void classLoaderCollector(void **target, stackTraceBuffer *buffer) {
 365         int i;
 366         stacktraceelement *current;
 367         stacktraceelement *start;
 368         methodinfo *m;
 369         classinfo *privilegedAction;
 370         size_t size;
 371
 372         size = buffer->full;
 373
 374
 375         if (!class_java_lang_SecurityManager)
 376                 class_java_lang_SecurityManager =
 377                         class_new(utf_new_char("java/lang/SecurityManager"));
 378
 379         if (size > 1) {
 380                 size--;
 381                 start=&(buffer->start[1]);
 382                 if (start == class_java_lang_SecurityManager) {
 383                         size--;
 384                         start--;
 385                 }
 386         } else {
 387                 start=0;
 388                 size=0;
 389         }
 390         privilegedAction=class_new(utf_new_char("java/security/PrivilegedAction"));
 391
 392         for(i=0, current = start; i < size; i++, current++) {
 393                 m=start->method;
 394                 if (!m) continue;
 395
 396                 if (m->class == privilegedAction) {
 397                         *target=NULL;
 398                         return;
 399                 }
 400
 401                 if (m->class->classloader) {
 402                         *target= (java_lang_ClassLoader *) m->class->classloader;
 403                         return;
 404                 }
 405         }
 406
 407         *target=NULL;
 408 }
 409
 410 java_objectheader *cacao_currentClassLoader() {
 411         java_objectheader *header=0;
 412         cacao_stacktrace_fillInStackTrace(&header,&classLoaderCollector);
 413         return header;
 414 }
 415
 416
 417 /*
 418  * These are local overrides for various environment variables in Emacs.
 419  * Please do not remove this and leave it at the end of the file, where
 420  * Emacs will automagically detect them.
 421  * ---------------------------------------------------------------------
 422  * Local variables:
 423  * mode: c
 424  * indent-tabs-mode: t
 425  * c-basic-offset: 4
 426  * tab-width: 4
 427  * End:
 428  */