inspectorJ -- JavaTM Profiler

sf project site browse source checkout source

src/inspectorj/agent/commandset/referencetypecmdset.cpp

Go to the documentation of this file.

/***************************************************************************
 *   inspectorJ - java profiler                                            *
 *   Copyright (C) 2007 by James May
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "referencetypecmdset.h"
#include "virtualmachinecmdset.h"
namespace inspectorj {
namespace agent {
namespace commandset {

using namespace inspectorj::jdwp;

ReferenceTypeCmdSet::ReferenceTypeCmdSet(JavaVM *vm, JNIEnv *env, jvmtiEnv *jvmti)
{
    this->vm = vm;
    this->env = env;
    this->jvmti = jvmti;
}

ReferenceTypeCmdSet::~ReferenceTypeCmdSet()
{
}


void ReferenceTypeCmdSet::process(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    int jdwpCmd = static_cast<int>(cmd->getCmd());
    switch (jdwpCmd) {
        case REF_TYPE_CMD_FIELDS : getFields(cmd, cbk); break;
        case REF_TYPE_CMD_METHODS : getMethods(cmd, cbk); break;
        default : sendNotImplementedReply(cmd, cbk); break;
    }    
}

void ReferenceTypeCmdSet::getFields(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    JDWPReply *reply = getJDWPReply(cmd);
    qint64 refid;
    *cmd >> refid;
    jint fieldCnt;
    jfieldID *fieldIds;
    jvmtiError error;
    if (JDWPCommandSet::getClassMap().contains(refid)) {
        jclass klass = JDWPCommandSet::getClassMap().value(refid);
        error = jvmti->GetClassFields(klass, &fieldCnt, &fieldIds);
        if (error) {
            reply->setErrorCode((short) error);
            cbk(reply);
            return;
        }
        *reply << fieldCnt;
        for (int i = 0; i < fieldCnt; i++) {
            char *fieldName;
            char *fieldSignature;
            char *generic;
            error = jvmti->GetFieldName(
                klass,
                fieldIds[i],
                &fieldName,
                &fieldSignature,
                &generic);
            if (error) {
                reply->setErrorCode((short) error);
                cbk(reply);
                return;
            }
            
            jint id = (int) fieldIds[i];
            *reply << id;
            QString name(fieldName);
            QString signature(fieldSignature);
            *reply << name;
            *reply << signature;
            error = jvmti->Deallocate((unsigned char*)fieldName);
            error = jvmti->Deallocate((unsigned char*)fieldSignature);
            error = jvmti->Deallocate((unsigned char*)generic);
            
            jint modBits;
            error = jvmti->GetFieldModifiers(
                klass,
                fieldIds[i],
                &modBits);
            *reply << modBits;
        }      
        error = jvmti->Deallocate((unsigned char*)fieldIds);
    } else {
        // no class found with the provided ReferenceTypeId
        reply->setErrorCode((short)JVMTI_ERROR_INVALID_CLASS);
    }
    cbk(reply);
}

void ReferenceTypeCmdSet::getMethods(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    JDWPReply *reply = getJDWPReply(cmd);
    qint64 refid;
    *cmd >> refid;
    jint methodCnt;
    jmethodID *methodIds;
    jvmtiError error;

    if (JDWPCommandSet::getClassMap().contains(refid)) {

        jclass klass = JDWPCommandSet::getClassMap().value(refid);
        error = jvmti->GetClassMethods(klass, &methodCnt, &methodIds);
        if (error) {
            reply->setErrorCode((short) error);
            cbk(reply);
            return;
        }
        *reply << methodCnt;
        for (int i = 0; i < methodCnt; i++) {
            char *methodName;
            char *methodSignature;
            char *generic;

            error = jvmti->GetMethodName(
                methodIds[i],
                &methodName,
                &methodSignature,
                &generic);
            if (error) {
                reply->setErrorCode((short) error);
                cbk(reply);
                return;
            }
            
            jint id = (int) methodIds[i];
            *reply << id;
            QString name(methodName);
            QString signature(methodSignature);
            *reply << name;
            *reply << signature;
            error = jvmti->Deallocate((unsigned char*)methodName);
            error = jvmti->Deallocate((unsigned char*)methodSignature);
            error = jvmti->Deallocate((unsigned char*)generic);
            
            jint modBits;
            error = jvmti->GetMethodModifiers(
                methodIds[i],
                &modBits);
            *reply << modBits;
        }      
        error = jvmti->Deallocate((unsigned char*)methodIds);
    } else {
        // no class found with the provided ReferenceTypeId
        reply->setErrorCode((short)JVMTI_ERROR_INVALID_CLASS);
    }
    cbk(reply);
}

jvmtiError ReferenceTypeCmdSet::getFieldModifierString(jclass &klass, jfieldID &fieldId, QString &modifierStr)
{
    // get the method modifiers
    jvmtiError error;
    jint modBits;
    
    error = jvmti->GetFieldModifiers(klass, fieldId, &modBits);
    if (error != JVMTI_ERROR_NONE) {
        return error;
    } 
    
    if ((modBits & JVM_ACC_PUBLIC) == JVM_ACC_PUBLIC) { 
        modifierStr.append("public ");
    }
    if ((modBits & JVM_ACC_PRIVATE) == JVM_ACC_PRIVATE) { 
        modifierStr.append("private ");
    }   
    if ((modBits & JVM_ACC_PROTECTED) == JVM_ACC_PROTECTED) { 
        modifierStr.append("protected ");
    }    
    if ((modBits & JVM_ACC_STATIC) == JVM_ACC_STATIC) { 
        modifierStr.append("static ");
    }              
    if ((modBits & JVM_ACC_FINAL) == JVM_ACC_FINAL) {
        modifierStr.append("final ");
    }
    if ((modBits & JVM_ACC_VOLATILE) == JVM_ACC_VOLATILE) {
        modifierStr.append("volatile ");
    }   
    if ((modBits & JVM_ACC_TRANSIENT) == JVM_ACC_TRANSIENT) {
        modifierStr.append("transient ");
    }       
    
    modifierStr = modifierStr.trimmed();
    return error;
}

jvmtiError ReferenceTypeCmdSet::getMethodModifierString(jmethodID &methodId, QString &modifierStr)
{
    // get the method modifiers
    jvmtiError error;
    jint modBits;
    error = jvmti->GetMethodModifiers(methodId, &modBits);
    if (error != JVMTI_ERROR_NONE) {
        return error;
    } 
    
    if ((modBits & JVM_ACC_PUBLIC) == JVM_ACC_PUBLIC) { 
        modifierStr.append("public ");
    }
    if ((modBits & JVM_ACC_PRIVATE) == JVM_ACC_PRIVATE) { 
        modifierStr.append("private ");
    }   
    if ((modBits & JVM_ACC_PROTECTED) == JVM_ACC_PROTECTED) { 
        modifierStr.append("protected ");
    }    
    if ((modBits & JVM_ACC_STATIC) == JVM_ACC_STATIC) { 
        modifierStr.append("static ");
    }              
    if ((modBits & JVM_ACC_FINAL) == JVM_ACC_FINAL) {
        modifierStr.append("final ");
    }
    if ((modBits & JVM_ACC_SYNCHRONIZED) == JVM_ACC_SYNCHRONIZED) {
        modifierStr.append("synchronized ");
    }
    if ((modBits & JVM_ACC_NATIVE) == JVM_ACC_NATIVE) {
        modifierStr.append("native ");
    }    
    
    modifierStr = modifierStr.trimmed();
    return error;
}

jvmtiError ReferenceTypeCmdSet::getClassModifierString(jclass &klass, QString &modifierStr)
{
    // get the class modifiers
    jint modBits;
    jvmtiError error = jvmti->GetClassModifiers(klass, &modBits);
    if (error != JVMTI_ERROR_NONE) {
        return error;
    } 
    
    if ((modBits & JVM_ACC_PUBLIC) == JVM_ACC_PUBLIC) { 
        modifierStr.append("public ");
    }
    if ((modBits & JVM_ACC_PRIVATE) == JVM_ACC_PRIVATE) { 
        modifierStr.append("private ");
    }   
    if ((modBits & JVM_ACC_PROTECTED) == JVM_ACC_PROTECTED) { 
        modifierStr.append("protected ");
    }    
    if ((modBits & JVM_ACC_STATIC) == JVM_ACC_STATIC) { 
        modifierStr.append("static ");
    }              
    if ((modBits & JVM_ACC_FINAL) == JVM_ACC_FINAL) {
        modifierStr.append("final ");
    }
    if ((modBits & JVM_ACC_ABSTRACT) == JVM_ACC_ABSTRACT) {
        modifierStr.append("abstract ");
    }      
    
    modifierStr = modifierStr.trimmed();
    return error;
}

jvmtiError ReferenceTypeCmdSet::getReferenceTypeString(jclass &klass, QString &refType)
{
    // Get the reference type
    jvmtiError error;
    jboolean type = 0;    
    error = jvmti->IsInterface(klass, &type);
    
    if (type) {
        refType = "interface";
    } else {
        error = jvmti->IsArrayClass(klass, &type);
        if (type) { 
            refType = "array";
        } else {
            refType = "class";
        }  
    }
    return error;
}

jvmtiError ReferenceTypeCmdSet::getFieldString(jclass &klass, jfieldID &field, QString &fieldSig, QString &name)
{
    // Get the jni signature of the class
    jvmtiError error;
    char *fieldName;
    char *fieldSignature;
    char *generic;
    error = jvmti->GetFieldName(
        klass,
        field,
        &fieldName,
        &fieldSignature,
        &generic);
    if (error) {
        return error;
    }

    fieldSig = fieldSignature;
    name = fieldName;

    error = jvmti->Deallocate((unsigned char*)fieldName);
    error = jvmti->Deallocate((unsigned char*)fieldSignature);
    error = jvmti->Deallocate((unsigned char*)generic);

    return error; 
}

jvmtiError ReferenceTypeCmdSet::getClassSignatureString(jclass &klass, QString &signature)
{
    // Get the jni signature of the class
    jvmtiError error;
    char* jniSignature;
    char* genericSignature; 
    
    error = jvmti->GetClassSignature(klass, &jniSignature, &genericSignature);
    check_jvmti_error(jvmti, error, "Error getting class signature\n");
    signature = jniSignature;
    error = jvmti->Deallocate((unsigned char*)jniSignature);
    error = jvmti->Deallocate((unsigned char*)genericSignature);  
    return error; 
}

jvmtiError ReferenceTypeCmdSet::getMethodSignatureString(jmethodID &methodId, QString &signature, QString &name)
{
    // Get the jni signature of the class
    jvmtiError error;
        
    char *methodName;
    char *methodSignature;
    char *generic;

    error = jvmti->GetMethodName(
        methodId,
        &methodName,
        &methodSignature,
        &generic);
    if (error) {
        return error;
    }

    name = methodName;
    signature = methodSignature;

    error = jvmti->Deallocate((unsigned char*)methodName);
    error = jvmti->Deallocate((unsigned char*)methodSignature);
    error = jvmti->Deallocate((unsigned char*)generic);
    
    return error;
}

} // end namespace commandset
} // end namespace agent
} // end namespace inspectorj

---