inspectorJ -- JavaTM Profiler

sf project site browse source checkout source

src/inspectorj/agent/commandset/bytecodecmdset.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 "bytecodecmdset.h"
#include "virtualmachinecmdset.h"
namespace inspectorj {
namespace agent {
namespace commandset {

using namespace inspectorj::jdwp;

const QString BytecodeCmdSet::failureMsg = "Bytecode generation failed:\n";
BytecodeCmdSet::BytecodeCmdSet(JavaVM *vm, JNIEnv *env, jvmtiEnv *jvmti): ReferenceTypeCmdSet(vm, env, jvmti)
{
    
}

BytecodeCmdSet::~BytecodeCmdSet()
{
}


void BytecodeCmdSet::process(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    int jdwpCmd = static_cast<int>(cmd->getCmd());
    switch (jdwpCmd) {

        case BC_TYPE_CMD_DISASSEMBLE : disassembleBytecodes(cmd, cbk); break;

        default : sendNotImplementedReply(cmd, cbk); break;
    }    
}

void addColumnSpacing(int prvHdrLen, int hdrSpace, int prvDataLen, QString &tableStr)
{
    int desiredSpace = prvHdrLen + hdrSpace;
    if (prvDataLen < desiredSpace) {
        for (int i = prvDataLen; i < desiredSpace; i++) {
            tableStr.append(" ");
        }
    } else {
        tableStr.append(" ");
    }
}

void BytecodeCmdSet::disassembleBytecodes(JDWPCommand* cmd, boost::function< void (JDWPReply*) > cbk)
{
    QString bytecodeStr;
    QString tab = "    ";
    QString tab2(tab);
    tab2.append(tab);
    QString errStr(failureMsg);
    JDWPReply *reply = getJDWPReply(cmd);
    qint64 refid;
    QString args;
    *cmd >> refid;
    *cmd >> args;
    jvmtiError error;
    
    if (JDWPCommandSet::getClassMap().contains(refid)) {
        
        // obtain the class
        jclass klass = JDWPCommandSet::getClassMap().value(refid);
        
        // get the source file name        
        error = getSourceFileName(klass, bytecodeStr);        
        if (error != JVMTI_ERROR_NONE) {
            *reply << bytecodeStr;
            cbk(reply);
            return;
        }
        
        // get modifiers
        QString modStr;
        error = getClassModifierString(klass, modStr);
        if (error != JVMTI_ERROR_NONE) {
            errStr.append("Error getting class modifiers.");
            *reply << errStr;
            cbk(reply);
            return;
        }    
        bytecodeStr.append(modStr).append(" ");
            
        // get reference type
        QString refType;
        error = getReferenceTypeString(klass, refType);
        if (error != JVMTI_ERROR_NONE) {
            errStr.append("Error getting class reference type.");
            *reply << errStr;
            cbk(reply);
            return;
        }
        bytecodeStr.append(refType).append(" ");
        
        // get class signature
        QString classSig;
        error = getClassSignatureString(klass, classSig);
        if (error != JVMTI_ERROR_NONE) {
            errStr.append("Error getting class signature.");
            *reply << errStr;
            cbk(reply);
            return;
        }
        classSig = inspectorj::toolset::ToolSetUtils::normalizeClassSignature(classSig);
        bytecodeStr.append(classSig).append(" ");  
         
        // get super class
        QString signature = "";
        jclass superClass = env->GetSuperclass(klass);
        if (superClass) {
            error = getClassSignatureString(superClass, signature);        
            if (error != JVMTI_ERROR_NONE) {
                errStr.append("Error getting SuperClass signature.");
                *reply << errStr;
                cbk(reply);
                return;
            }   
        }
        if (!signature.isEmpty()) {
            signature = inspectorj::toolset::ToolSetUtils::normalizeClassSignature(signature);
            bytecodeStr.append("extends ").append(signature).append(" ");  
        }  
                       
        // get implemented interfaces
        jint infCnt;
        jclass *interfaces;
        error = jvmti->GetImplementedInterfaces(klass, &infCnt, &interfaces);

        if (infCnt > 0) {
            if (refType == "interface") {
                bytecodeStr.append("extends ");
            } else {
                bytecodeStr.append("implements ");
            }
            for (int i = 0; i < infCnt; i++) {
                error = getClassSignatureString(interfaces[i], signature);
                if (error != JVMTI_ERROR_NONE) {
                    errStr.append("Error getting interface signature.");
                    *reply << errStr;
                    cbk(reply);
                    return;
                }
                signature =  inspectorj::toolset::ToolSetUtils::normalizeClassSignature(signature);
                bytecodeStr.append(signature); 
                if (i < infCnt - 1) {
                    bytecodeStr.append(", ");
                }                                   
            }
            jvmti->Deallocate((unsigned char*)interfaces);
        }
        
        bytecodeStr.append(" {\n\n");
                       
        // get fields
        if (args.indexOf("f") >= 0) {
            jint fieldCnt = 0;
            jfieldID *fieldIds;
            error = jvmti->GetClassFields(klass, &fieldCnt, &fieldIds);
            if (error != JVMTI_ERROR_NONE) {
                errStr.append("Error getting class fields.");
                *reply << errStr;
                cbk(reply);
                return;
            }
            if (fieldCnt > 0) {
                bytecodeStr.append(tab).append("// fields\n");
            }            
            for (int i = 0; i < fieldCnt; i++) {
                QString fieldModStr;
                QString fieldSig;
                QString fieldName;
                error = getFieldModifierString(klass, fieldIds[i], fieldModStr);
                error = getFieldString(klass, fieldIds[i], fieldSig, fieldName);
                bytecodeStr.append(tab);
                if (!fieldModStr.isEmpty()) {
                    bytecodeStr.append(fieldModStr).append(" ");
                }
                fieldSig = inspectorj::toolset::ToolSetUtils::normalizeClassSignature(fieldSig);
                bytecodeStr.append(fieldSig).append(" ").append(fieldName).append(";\n"); 
            }
            error = jvmti->Deallocate((unsigned char*)fieldIds);
            if (fieldCnt > 0) {
                bytecodeStr.append("\n");
            }
        }
        
        // get method signatures
        jint methodCnt;
        jmethodID *methodIds;
        error = jvmti->GetClassMethods(klass, &methodCnt, &methodIds);
        if (error != JVMTI_ERROR_NONE) {
            errStr.append("Error getting class methods.");
            *reply << errStr;
            cbk(reply);
            return;
        }
        if (methodCnt > 0) {
            bytecodeStr.append(tab).append("// methods\n");
        }            
        for (int i = 0; i < methodCnt; i++) {
            QString methodModStr;
            QString jniSig;
            QString methodSig;
            QString methodName;
            error = getMethodModifierString(methodIds[i], methodModStr);
            error = getMethodSignatureString(methodIds[i], jniSig, methodName);
            bytecodeStr.append(tab);
            if (!methodModStr.isEmpty()) {
                bytecodeStr.append(methodModStr).append(" ");
            }
            methodSig = jniSig;
            inspectorj::toolset::ToolSetUtils::normalizeMethodSignature(
                    methodSig, methodName, classSig);
            bytecodeStr.append(methodSig).append(";\n");
            if (args.indexOf("i") >= 0) {
                bytecodeStr.append(tab).append(tab).append("Signature: ");
                bytecodeStr.append(jniSig).append("\n");
            }
            // print line number table and local variable table
            if (args.indexOf("l") >= 0) {
                
                bytecodeStr.append(tab2).append("LineNumberTable:\n");
                jint entryCnt;
                jvmtiLineNumberEntry *table;
                QString lineNumStr;
                QString startLoc;
                error = jvmti->GetLineNumberTable(methodIds[i], &entryCnt, &table);
                for (int j = 0; j < entryCnt; j++) {
                    bytecodeStr.append(tab2).append(" line ");
                    bytecodeStr.append(lineNumStr.setNum((jint)table[j].line_number));
                    bytecodeStr.append(": ");
                    bytecodeStr.append(startLoc.setNum((jlong)table[j].start_location));
                    bytecodeStr.append("\n");
                }                
                if (!error) jvmti->Deallocate((unsigned char*)table);
                bytecodeStr.append("\n");      
                
                entryCnt = 0;
                QString num;
                jvmtiLocalVariableEntry *lvTable;
                error = jvmti->GetLocalVariableTable(methodIds[i], &entryCnt, &lvTable);
                if (entryCnt > 0) { 
                    QString lvtStart = "Start";
                    QString lvtLength = "Length";
                    QString lvtSlot = "Slot";
                    QString lvtName = "Name";
                    QString lvtSig = "Signature";      
                    bytecodeStr.append(tab2).append("LocalVariableTable:\n");
                    bytecodeStr.append(tab2).append(" ").append(lvtStart);
                    bytecodeStr.append(tab).append(lvtLength);
                    bytecodeStr.append(tab).append(lvtSlot);
                    bytecodeStr.append(tab).append(lvtName);
                    bytecodeStr.append(tab2).append(lvtSig).append("\n");
                    for (int k = 0; k < entryCnt; k++) {
                        bytecodeStr.append(tab2).append(" ");                       
                        bytecodeStr.append(num.setNum((qint64)(lvTable[k].start_location)));
                        addColumnSpacing(lvtStart.length(), tab.length(), num.length(), bytecodeStr);
                        
                        bytecodeStr.append(num.setNum((jint)(lvTable[k].length)));
                        addColumnSpacing(lvtLength.length(), tab.length(), num.length(), bytecodeStr);
                        
                        bytecodeStr.append(num.setNum((jint)(lvTable[k].slot)));
                        addColumnSpacing(lvtSlot.length(), tab.length(), num.length(), bytecodeStr);
                        
                        QString lvt_name(lvTable[k].name);
                        bytecodeStr.append(lvt_name);
                        addColumnSpacing(lvtName.length(), tab2.length(), lvt_name.length(), bytecodeStr);
                        
                        bytecodeStr.append(lvTable[k].signature).append("\n");
                        
                        jvmti->Deallocate((unsigned char*)lvTable[k].name);
                        jvmti->Deallocate((unsigned char*)lvTable[k].signature);
                        jvmti->Deallocate((unsigned char*)lvTable[k].generic_signature);
                    }
                    bytecodeStr.append("\n");
                }
                if (!error) jvmti->Deallocate((unsigned char*)lvTable);    
            }
        }
        error = jvmti->Deallocate((unsigned char*)methodIds);
        
        
        // close the class/interface brace
        bytecodeStr.append("}");
        // store the bytecode str in the packet's payload
        *reply << bytecodeStr;
    } else {
        // no class found with the provided ReferenceTypeId
        reply->setErrorCode((short)JVMTI_ERROR_INVALID_CLASS);
    }
    cbk(reply);
}

jvmtiError BytecodeCmdSet::getSourceFileName(jclass &klass, QString &bytecodeStr)
{
        char* srcFileStr;        
        jvmtiError error = jvmti->GetSourceFileName(klass, &srcFileStr);        
        check_jvmti_error(jvmti, error, "Bytecode Disassembly => Error getting source file.\n");
        
        if (error == JVMTI_ERROR_NONE)
        {
            bytecodeStr.append("Compiled from: \"").append(srcFileStr).append("\"\n");
            jvmti->Deallocate((unsigned char*)srcFileStr);
        } 
        else if (error == JVMTI_ERROR_ABSENT_INFORMATION) {
            bytecodeStr.append("*-- Class information does not include a source file name. --*");
        }
        else if (error == JVMTI_ERROR_INVALID_CLASS) {
            bytecodeStr.append("Bytecode generation failed:\n*-- The class or reference ID is invalid. --*");
        }
        
        return error;
}




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

---