src/native/vm/gnu/gnu_classpath_jdwp_VMMethod.c

   1 /* src/native/vm/VMMethod.c - jdwp->jvmti interface
   2
   3 Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel,
   4 C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
   5 E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
   6 J. Wenninger, 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., 51 Franklin Street, Fifth Floor, Boston, MA
  23 02110-1301, USA.
  24
  25 Contact: cacao@cacaojvm.org
  26
  27 Authors: Samuel Vinson
  28          Martin Platter
  29
  30
  31 Changes:
  32
  33
  34 $Id: VMMethod.c $
  35
  36 */
  37
  38 #include "native/jni.h"
  39 #include "native/include/gnu_classpath_jdwp_VMMethod.h"
  40 #include "native/jvmti/jvmti.h"
  41 #include "native/jvmti/VMjdwp.h"
  42
  43
  44 void printjvmtierror(char *desc, jvmtiError err) {
  45     char* errdesc;
  46
  47         if (err == JVMTI_ERROR_NONE) return;
  48         (*jvmtienv)->GetErrorName(jvmtienv,err, &errdesc);
  49         fprintf(stderr,"%s: jvmti error %s\n",desc, errdesc);
  50         fflush(stderr);
  51         (*jvmtienv)->Deallocate(jvmtienv,(unsigned char*)errdesc);
  52 }
  53
  54
  55
  56 /*
  57  * Class:     gnu/classpath/jdwp/VMMethod
  58  * Method:    getName
  59  * Signature: ()Ljava/lang/String;
  60  */
  61 JNIEXPORT struct java_lang_String* JNICALL Java_gnu_classpath_jdwp_VMMethod_getName(JNIEnv *env, struct gnu_classpath_jdwp_VMMethod* this)
  62 {
  63     jvmtiError err;
  64     char *name;
  65     jstring stringname;
  66
  67     if (JVMTI_ERROR_NONE != (err= (*jvmtienv)->
  68                              GetMethodName(jvmtienv,
  69                                                                                    (jmethodID)(long)this->_methodId,
  70                                            &name,NULL, NULL))) {
  71                 printjvmtierror("VMMethod.getName GetMethodName",err);
  72         return NULL;
  73     }
  74
  75     stringname = (*env)->NewStringUTF(env,name);
  76     (*jvmtienv)->Deallocate(jvmtienv,(unsigned char*)name);
  77
  78     return stringname;
  79 }
  80
  81
  82 /*
  83  * Class:     gnu/classpath/jdwp/VMMethod
  84  * Method:    getSignature
  85  * Signature: ()Ljava/lang/String;
  86  */
  87 JNIEXPORT struct java_lang_String* JNICALL Java_gnu_classpath_jdwp_VMMethod_getSignature(JNIEnv *env, struct gnu_classpath_jdwp_VMMethod* this)
  88 {
  89     jvmtiError err;
  90     char *signature;
  91     jstring stringsignature;
  92
  93     if (JVMTI_ERROR_NONE != (err= (*jvmtienv)->
  94                              GetMethodName(jvmtienv,
  95                                                                                    (jmethodID)(long)this->_methodId,
  96                                            NULL, &signature, NULL))) {
  97                 printjvmtierror("VMMethod.getSignature GetMethodName",err);
  98         return NULL;
  99     }
 100
 101     stringsignature = (*env)->NewStringUTF(env,signature);
 102     (*jvmtienv)->Deallocate(jvmtienv,(unsigned char*)signature);
 103
 104     return stringsignature;
 105 }
 106
 107
 108 /*
 109  * Class:     gnu/classpath/jdwp/VMMethod
 110  * Method:    getModifiers
 111  * Signature: ()I
 112  */
 113 JNIEXPORT s4 JNICALL Java_gnu_classpath_jdwp_VMMethod_getModifiers(JNIEnv *env, struct gnu_classpath_jdwp_VMMethod* this)
 114 {
 115     jvmtiError err;
 116     jint modifiers;
 117
 118     if (JVMTI_ERROR_NONE!=(err= (*jvmtienv)->
 119                                                    GetMethodModifiers(jvmtienv,
 120                                                                                           (jmethodID)(long)this->_methodId,
 121                                                                                           &modifiers))) {
 122                 printjvmtierror("VMMethod.getModifiers GetMethodModifiers",err);
 123         return 0;
 124     }
 125
 126     return modifiers;
 127 }
 128
 129
 130 /*
 131  * Class:     gnu/classpath/jdwp/VMMethod
 132  * Method:    getLineTable
 133  * Signature: ()Lgnu/classpath/jdwp/util/LineTable;
 134  */
 135 JNIEXPORT struct gnu_classpath_jdwp_util_LineTable* JNICALL Java_gnu_classpath_jdwp_VMMethod_getLineTable(JNIEnv *env, struct gnu_classpath_jdwp_VMMethod* this)
 136 {
 137     jclass cl;
 138     jmethodID m;
 139     jobject ol;
 140     jlongArray jlineCI;
 141     jintArray jlineNum;
 142     jint count = 0, i;
 143     int *lineNum;
 144     long *lineCI;
 145     jvmtiLineNumberEntry *lne;
 146     jlocation start,end;
 147
 148     jvmtiError err;
 149
 150     if (JVMTI_ERROR_NONE!=(err= (*jvmtienv)->
 151                                                    GetLineNumberTable(jvmtienv,
 152                                                                                           (jmethodID)(long)this->_methodId,
 153                                                                                           &count, &lne))) {
 154                 printjvmtierror("VMMethod.getlinetable GetLineNumberTable",err);
 155         return NULL;
 156     }
 157
 158     cl = (*env)->FindClass(env,"gnu.classpath.jdwp.util.LineTable");
 159     if (!cl) return NULL;
 160
 161     m = (*env)->GetMethodID(env, cl, "<init>", "(JJ[I[J)V");
 162     if (!m) return NULL;
 163
 164     jlineNum = (*env)->NewIntArray(env, count);
 165     if (!jlineNum) return NULL;
 166     jlineCI = (*env)->NewLongArray(env, count);
 167     if (!jlineCI) return NULL;
 168     lineNum = (*env)->GetIntArrayElements(env, jlineNum, NULL);
 169     lineCI = (*env)->GetLongArrayElements(env, jlineCI, NULL);
 170     for (i = 0; i < count; ++i) {
 171         lineNum[i] = lne[i].line_number;
 172         lineCI[i] = lne[i].start_location;
 173     }
 174     (*env)->ReleaseLongArrayElements(env, jlineCI, lineCI, 0);
 175     (*env)->ReleaseIntArrayElements(env, jlineNum, lineNum, 0);
 176     (*jvmtienv)->Deallocate(jvmtienv, lne);
 177
 178     if (JVMTI_ERROR_NONE!=(err= (*jvmtienv)->
 179                                                    GetMethodLocation(jvmtienv,
 180                                                                                          (jmethodID)(long)this->_methodId,
 181                                                                                          &start, &end))) {
 182                 printjvmtierror("VMMethod.getlinetable GetMethodLocation",err);
 183         return NULL;
 184     }
 185
 186     ol = (*env)->NewObject(env, cl, m, start,
 187                            end, jlineNum, jlineCI);
 188
 189     return (struct gnu_classpath_jdwp_util_LineTable*)ol;
 190
 191 }
 192
 193 static bool fillVariableTable(JNIEnv *env, jvmtiLocalVariableEntry* entries,
 194                                                           int count, jlongArray *jlineCI,
 195                                                           jobjectArray *names, jobjectArray *sigs,
 196                                                           jintArray *jlengths, jintArray *jslot) {
 197         jint *lengths, *slot,i;
 198         jclass cl;
 199         jlong *lineCI;
 200
 201         *jlineCI = (*env)->NewLongArray(env, count);
 202         if (!*jlineCI) return false;
 203
 204         cl=(*env)->FindClass(env,"java/lang/String");
 205         if (!cl) return false;
 206
 207         *names = (*env)->NewObjectArray(env, count, cl, NULL);
 208         if (names) return false;
 209         sigs = (*env)->NewObjectArray(env, count, cl, NULL);
 210         if (sigs) return false;
 211
 212         jlengths = (*env)->NewIntArray(env, count);
 213         if (!lengths) return false;
 214
 215         jslot = (*env)->NewIntArray(env, count);
 216         if (!slot) return false;
 217
 218         lineCI = (*env)->GetLongArrayElements(env, *jlineCI, NULL);
 219         lengths = (*env)->GetIntArrayElements(env, *jlengths, NULL);
 220         slot = (*env)->GetIntArrayElements(env, jslot, NULL);
 221
 222         for (i=0; i<count; i++) {
 223                 (*env)->
 224                         SetObjectArrayElement(env, *names, i,
 225                                                                   (*env)->NewStringUTF(env,entries[i].name));
 226                 (*env)->
 227                         SetObjectArrayElement(env, *sigs, i, (*env)->NewStringUTF(
 228                                                                           env,entries[i].signature));
 229                 lineCI[i]=entries[i].start_location;
 230                 lengths[i]=entries[i].length;
 231                 slot[i]=entries[i].slot;
 232         }
 233     (*env)->ReleaseLongArrayElements(env, jlineCI, lineCI, 0);
 234     (*env)->ReleaseIntArrayElements(env, jlengths, lengths, 0);
 235     (*env)->ReleaseIntArrayElements(env, jslot, slot, 0);
 236         return true;
 237 }
 238
 239
 240 /*
 241  * Class:     gnu/classpath/jdwp/VMMethod
 242  * Method:    getVariableTable
 243  * Signature: ()Lgnu/classpath/jdwp/util/VariableTable;
 244  */
 245 JNIEXPORT struct gnu_classpath_jdwp_util_VariableTable* JNICALL Java_gnu_classpath_jdwp_VMMethod_getVariableTable(JNIEnv *env, struct gnu_classpath_jdwp_VMMethod* this)
 246 {
 247         jvmtiLocalVariableEntry* localvarentries;
 248         jint entry_count, argCnt, slots;
 249         jclass cl;
 250         jmethodID m, vmmethodid;
 251     jobject o;
 252         jobjectArray names, sigs;
 253     jvmtiError err;
 254     jlongArray jlineCI;
 255         jintArray jlengths, jslot;
 256
 257         vmmethodid = (jmethodID)(long)this->_methodId;
 258
 259         err= (*jvmtienv)->GetLocalVariableTable(jvmtienv,
 260                                                                                         vmmethodid,
 261                                                                                         &entry_count,
 262                                                                                         &localvarentries);
 263     if (JVMTI_ERROR_NONE != err) {
 264                 if (err == JVMTI_ERROR_ABSENT_INFORMATION) {
 265                         /* no local variable table available for this method.
 266                            return an empty local variable table */
 267                         argCnt = slots = 0;
 268                         names = sigs = jlineCI = jlengths = jslot = NULL;
 269                 } else {
 270                         printjvmtierror("VMMethod.getVariableTable GetLocalVariableTable",err);
 271                         return NULL;
 272                 }
 273         } else {
 274                 if (JVMTI_ERROR_NONE != (err=
 275                                                                  (*jvmtienv)->GetArgumentsSize(jvmtienv,
 276                                                                                                                            vmmethodid,
 277                                                                                                                            &argCnt))) {
 278                         printjvmtierror("VMMethod.getVariableTable GetArgumentsSize",err);
 279                         return NULL;
 280                 }
 281
 282                 if (JVMTI_ERROR_NONE != (err= (*jvmtienv)->GetMaxLocals(jvmtienv,
 283                                                                                                                                 vmmethodid,
 284                                                                                                                                 &slots))) {
 285                         printjvmtierror("VMMethod.getVariableTable GetMaxLocals",err);
 286                         return NULL;
 287                 }
 288
 289                 slots = slots - argCnt;
 290                 if (!fillVariableTable(env, localvarentries, entry_count, &jlineCI,
 291                                                            &names, &sigs, &jlengths, &jslot))
 292                         return NULL;
 293                 (*jvmtienv)->
 294                         Deallocate(jvmtienv, (unsigned char*)localvarentries->signature);
 295                 (*jvmtienv)->
 296                         Deallocate(jvmtienv, (unsigned char*)localvarentries->name);
 297                 if (localvarentries->generic_signature != NULL)
 298                         (*jvmtienv)-> Deallocate(jvmtienv, (unsigned char*)
 299                                                                          localvarentries->generic_signature);
 300
 301
 302                 (*jvmtienv)->Deallocate(jvmtienv,(unsigned char*)localvarentries);
 303         }
 304
 305     cl = (*env)->FindClass(env,"gnu.classpath.jdwp.util.VariableTable");
 306     if (!cl) return NULL;
 307
 308     m = (*env)->
 309                 GetMethodID(env, cl,"<init>",
 310                                         "(II[J[Ljava/lang/String;[Ljava/lang/String;[I[I)V");
 311     if (!m) return NULL;
 312
 313     o = (*env)->NewObject(env, cl, m, argCnt, slots, jlineCI,
 314                                                   names, sigs, jlengths, jslot);
 315
 316     return (struct gnu_classpath_jdwp_util_VariableTable*) o;
 317 }
 318
 319 /*
 320  * These are local overrides for various environment variables in Emacs.
 321  * Please do not remove this and leave it at the end of the file, where
 322  * Emacs will automagically detect them.
 323  * ---------------------------------------------------------------------
 324  * Local variables:
 325  * mode: c
 326  * indent-tabs-mode: t
 327  * c-basic-offset: 4
 328  * tab-width: 4
 329  * End:
 330  */