jni/staticjvmtiagent/agent.cc

/*
 * Copyright (C) 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <cstdlib>
#include <sstream>
#include <cstring>
#include <cassert>
#include <cstdarg>
#include <algorithm>

#include <jni.h>

#include "jvmti.h"

#include <slicer/dex_ir.h>
#include <slicer/code_ir.h>
#include <slicer/dex_ir_builder.h>
#include <slicer/dex_utf8.h>
#include <slicer/writer.h>
#include <slicer/reader.h>
#include <slicer/instrumentation.h>

using namespace dex;
using namespace lir;

namespace com_android_dx_mockito_inline {
    static jvmtiEnv* localJvmtiEnv;

    static jobject sTransformer;

    // Converts a class name to a type descriptor
    // (ex. "java.lang.String" to "Ljava/lang/String;")
    static std::string
    ClassNameToDescriptor(const char* class_name) {
        std::stringstream ss;
        ss << "L";
        for (auto p = class_name; *p != '\0'; ++p) {
            ss << (*p == '.' ? '/' : *p);
        }
        ss << ";";
        return ss.str();
    }

    // Takes the full dex file for class 'classBeingRedefined'
    // - isolates the dex code for the class out of the dex file
    // - calls sTransformer.runTransformers on the isolated dex code
    // - send the transformed code back to the runtime
    static void
    Transform(jvmtiEnv* jvmti_env,
              JNIEnv* env,
              jclass classBeingRedefined,
              jobject loader,
              const char* name,
              jobject protectionDomain,
              jint classDataLen,
              const unsigned char* classData,
              jint* newClassDataLen,
              unsigned char** newClassData) {
        if (sTransformer != nullptr) {
            // Even reading the classData array is expensive as the data is only generated when the
            // memory is touched. Hence call JvmtiAgent#shouldTransform to check if we need to transform
            // the class.
            jclass cls = env->GetObjectClass(sTransformer);
            jmethodID shouldTransformMethod = env->GetMethodID(cls, "shouldTransform",
                                                               "(Ljava/lang/Class;)Z");

            jboolean shouldTransform = env->CallBooleanMethod(sTransformer, shouldTransformMethod,
                                                              classBeingRedefined);
            if (!shouldTransform) {
                return;
            }

            // Isolate byte code of class class. This is needed as Android usually gives us more
            // than the class we need.
            Reader reader(classData, classDataLen);

            u4 index = reader.FindClassIndex(ClassNameToDescriptor(name).c_str());
            reader.CreateClassIr(index);
            std::shared_ptr<ir::DexFile> ir = reader.GetIr();

            struct Allocator : public Writer::Allocator {
                virtual void* Allocate(size_t size) {return ::malloc(size);}
                virtual void Free(void* ptr) {::free(ptr);}
            };

            Allocator allocator;
            Writer writer(ir);
            size_t isolatedClassLen = 0;
            std::shared_ptr<jbyte> isolatedClass((jbyte*)writer.CreateImage(&allocator,
                                                                            &isolatedClassLen));

            // Create jbyteArray with isolated byte code of class
            jbyteArray isolatedClassArr = env->NewByteArray(isolatedClassLen);
            env->SetByteArrayRegion(isolatedClassArr, 0, isolatedClassLen,
                                    isolatedClass.get());

            jstring nameStr = env->NewStringUTF(name);

            // Call JvmtiAgent#runTransformers
            jmethodID runTransformersMethod = env->GetMethodID(cls, "runTransformers",
                                                               "(Ljava/lang/ClassLoader;"
                                                               "Ljava/lang/String;"
                                                               "Ljava/lang/Class;"
                                                               "Ljava/security/ProtectionDomain;"
                                                               "[B)[B");

            jbyteArray transformedArr = (jbyteArray) env->CallObjectMethod(sTransformer,
                                                                           runTransformersMethod,
                                                                           loader, nameStr,
                                                                           classBeingRedefined,
                                                                           protectionDomain,
                                                                           isolatedClassArr);

            // Set transformed byte code
            if (!env->ExceptionOccurred() && transformedArr != nullptr) {
                *newClassDataLen = env->GetArrayLength(transformedArr);

                jbyte* transformed = env->GetByteArrayElements(transformedArr, 0);

                jvmti_env->Allocate(*newClassDataLen, newClassData);
                std::memcpy(*newClassData, transformed, *newClassDataLen);

                env->ReleaseByteArrayElements(transformedArr, transformed, 0);
            }
        }
    }

    // Add a label before instructionAfter
    static void
    addLabel(CodeIr& c,
             lir::Instruction* instructionAfter,
             Label* returnTrueLabel) {
        c.instructions.InsertBefore(instructionAfter, returnTrueLabel);
    }

    // Add a byte code before instructionAfter
    static void
    addInstr(CodeIr& c,
             lir::Instruction* instructionAfter,
             Opcode opcode,
             const std::list<Operand*>& operands) {
        auto instruction = c.Alloc<Bytecode>();

        instruction->opcode = opcode;

        for (auto it = operands.begin(); it != operands.end(); it++) {
            instruction->operands.push_back(*it);
        }

        c.instructions.InsertBefore(instructionAfter, instruction);
    }

    // Add a method call byte code before instructionAfter
    static void
    addCall(ir::Builder& b,
            CodeIr& c,
            lir::Instruction* instructionAfter,
            Opcode opcode,
            ir::Type* type,
            const char* methodName,
            ir::Type* returnType,
            const std::vector<ir::Type*>& types,
            const std::list<int>& regs) {
        auto proto = b.GetProto(returnType, b.GetTypeList(types));
        auto method = b.GetMethodDecl(b.GetAsciiString(methodName), proto, type);

        VRegList* param_regs = c.Alloc<VRegList>();
        for (auto it = regs.begin(); it != regs.end(); it++) {
            param_regs->registers.push_back(*it);
        }

        addInstr(c, instructionAfter, opcode, {param_regs, c.Alloc<Method>(method,
                                                                           method->orig_index)});
    }

    typedef struct {
        ir::Type* boxedType;
        ir::Type* scalarType;
        std::string unboxMethod;
    } BoxingInfo;

    // Get boxing / unboxing info for a type
    static BoxingInfo
    getBoxingInfo(ir::Builder &b,
                  char typeCode) {
        BoxingInfo boxingInfo;

        if (typeCode != 'L' && typeCode !=  '[') {
            std::stringstream tmp;
            tmp << typeCode;
            boxingInfo.scalarType = b.GetType(tmp.str().c_str());
        }

        switch (typeCode) {
            case 'B':
                boxingInfo.boxedType = b.GetType("Ljava/lang/Byte;");
                boxingInfo.unboxMethod = "byteValue";
                break;
            case 'S':
                boxingInfo.boxedType = b.GetType("Ljava/lang/Short;");
                boxingInfo.unboxMethod = "shortValue";
                break;
            case 'I':
                boxingInfo.boxedType = b.GetType("Ljava/lang/Integer;");
                boxingInfo.unboxMethod = "intValue";
                break;
            case 'C':
                boxingInfo.boxedType = b.GetType("Ljava/lang/Character;");
                boxingInfo.unboxMethod = "charValue";
                break;
            case 'F':
                boxingInfo.boxedType = b.GetType("Ljava/lang/Float;");
                boxingInfo.unboxMethod = "floatValue";
                break;
            case 'Z':
                boxingInfo.boxedType = b.GetType("Ljava/lang/Boolean;");
                boxingInfo.unboxMethod = "booleanValue";
                break;
            case 'J':
                boxingInfo.boxedType = b.GetType("Ljava/lang/Long;");
                boxingInfo.unboxMethod = "longValue";
                break;
            case 'D':
                boxingInfo.boxedType = b.GetType("Ljava/lang/Double;");
                boxingInfo.unboxMethod = "doubleValue";
                break;
            default:
                // real object
                break;
        }

        return boxingInfo;
    }

    static size_t
    getNumParams(ir::EncodedMethod *method) {
        if (method->decl->prototype->param_types == nullptr) {
            return 0;
        }

        return method->decl->prototype->param_types->types.size();
    }

    static bool
    canBeTransformed(ir::EncodedMethod *method) {
        std::string type = method->decl->parent->Decl();
        ir::String* methodName = method->decl->name;

        return ((method->access_flags & kAccStatic) != 0)
               && !(((method->access_flags & (kAccPrivate | kAccBridge | kAccNative)) != 0)
                    || (Utf8Cmp(methodName->c_str(), "<clinit>") == 0)
                    || (strncmp(type.c_str(), "java.", 5) == 0
                        && (method->access_flags & (kAccPrivate | kAccPublic | kAccProtected))
                           == 0));
    }

    // Transforms the classes to add the mockito hooks
    // - equals and hashcode are handled in a special way
    extern "C" JNIEXPORT jbyteArray JNICALL
    Java_com_android_dx_mockito_inline_StaticClassTransformer_nativeRedefine(JNIEnv* env,
                                                                           jobject generator,
                                                                           jstring idStr,
                                                                           jbyteArray originalArr) {
        unsigned char* original = (unsigned char*)env->GetByteArrayElements(originalArr, 0);

        Reader reader(original, env->GetArrayLength(originalArr));
        reader.CreateClassIr(0);
        std::shared_ptr<ir::DexFile> dex_ir = reader.GetIr();
        ir::Builder b(dex_ir);

        ir::Type* objectT = b.GetType("Ljava/lang/Object;");
        ir::Type* objectArrayT = b.GetType("[Ljava/lang/Object;");
        ir::Type* stringT = b.GetType("Ljava/lang/String;");
        ir::Type* methodT = b.GetType("Ljava/lang/reflect/Method;");
        ir::Type* callableT = b.GetType("Ljava/util/concurrent/Callable;");
        ir::Type* dispatcherT = b.GetType("Lcom/android/dx/mockito/inline/MockMethodDispatcher;");

        // Add id to dex file
        const char* idNative = env->GetStringUTFChars(idStr, 0);
        ir::String* id = b.GetAsciiString(idNative);
        env->ReleaseStringUTFChars(idStr, idNative);

        for (auto& method : dex_ir->encoded_methods) {
            if (!canBeTransformed(method.get())) {
                continue;
            }
            /*
            static long method_original(int param1, long param2, String param3) {
                foo();
                return bar();
            }

            static long method_transformed(int param1, long param2, String param3) {
                // MockMethodDispatcher dispatcher = MockMethodDispatcher.get(idStr, this);
                const-string v0, "65463hg34t"
                const v1, 0
                invoke-static {v0, v1}, MockMethodDispatcher.get(String, Object):MockMethodDispatcher
                move-result-object v0

                // if (dispatcher == null) {
                //    goto original_method;
                // }
                if-eqz v0, original_method

                // Method origin = dispatcher.getOrigin(this, methodDesc);
                const-string v1 "fully.qualified.ClassName#original_method(int, long, String)"
                const v2, 0
                invoke-virtual {v0, v2, v1}, MockMethodDispatcher.getOrigin(Object, String):Method
                move-result-object v1

                // if (origin == null) {
                //     goto original_method;
                // }
                if-eqz v1, original_method

                // Create an array with Objects of all parameters.

                //     Object[] arguments = new Object[3]
                const v3, 3
                new-array v2, v3, Object[]

                //     Integer param1Integer = Integer.valueOf(param1)
                move-from16 v3, ARG1     # this is necessary as invoke-static cannot deal with high
                                         # registers and ARG1 might be high
                invoke-static {v3}, Integer.valueOf(int):Integer
                move-result-object v3

                //     arguments[0] = param1Integer
                const v4, 0
                aput-object v3, v2, v4

                //     Long param2Long = Long.valueOf(param2)
                move-widefrom16 v3:v4, ARG2.1:ARG2.2 # this is necessary as invoke-static cannot
                                                     # deal with high registers and ARG2 might be
                                                     # high
                invoke-static {v3, v4}, Long.valueOf(long):Long
                move-result-object v3

                //     arguments[1] = param2Long
                const v4, 1
                aput-object v3, v2, v4

                //     arguments[2] = param3
                const v4, 2
                move-objectfrom16 v3, ARG3     # this is necessary as aput-object cannot deal with
                                               # high registers and ARG3 might be high
                aput-object v3, v2, v4

                // Callable<?> mocked = dispatcher.handle(methodDesc --as this parameter--,
                //                                        origin, arguments);
                const-string v3 "fully.qualified.ClassName#original_method(int, long, String)"
                invoke-virtual {v0,v3,v1,v2}, MockMethodDispatcher.handle(Object, Method,
                                                                          Object[]):Callable
                move-result-object v0

                //  if (mocked != null) {
                if-eqz v0, original_method

                //      Object ret = mocked.call();
                invoke-interface {v0}, Callable.call():Object
                move-result-object v0

                //      Long retLong = (Long)ret
                check-cast v0, Long

                //      long retlong = retLong.longValue();
                invoke-virtual {v0}, Long.longValue():long
                move-result-wide v0:v1

                //      return retlong;
                return-wide v0:v1

                //  }

            original_method:
                // Move all method arguments down so that they match what the original code expects.
                // Let's assume three arguments, one int, one long, one String and the and used to
                // use 4 registers
                move16 v5, v6             # ARG1
                move-wide16 v6:v7, v7:v8  # ARG2 (overlapping moves are allowed)
                move-object16 v8, v9      # ARG3

                // foo();
                // return bar();
                unmodified original byte code
            }
            */

            CodeIr c(method.get(), dex_ir);

            // Make sure there are at least 5 local registers to use
            int originalNumRegisters = method->code->registers - method->code->ins_count;
            int numAdditionalRegs = std::max(0, 5 - originalNumRegisters);
            int firstArg = originalNumRegisters + numAdditionalRegs;

            if (numAdditionalRegs > 0) {
                c.ir_method->code->registers += numAdditionalRegs;
            }

            lir::Instruction* fi = *(c.instructions.begin());

            // Add methodDesc to dex file
            std::stringstream ss;
            ss << method->decl->parent->Decl() << "#" << method->decl->name->c_str() << "(" ;
            bool first = true;
            if (method->decl->prototype->param_types != nullptr) {
                for (const auto& type : method->decl->prototype->param_types->types) {
                    if (first) {
                        first = false;
                    } else {
                        ss << ",";
                    }

                    ss << type->Decl().c_str();
                }
            }
            ss << ")";
            std::string methodDescStr = ss.str();
            ir::String* methodDesc = b.GetAsciiString(methodDescStr.c_str());

            size_t numParams = getNumParams(method.get());

            Label* originalMethodLabel = c.Alloc<Label>(0);
            CodeLocation* originalMethod = c.Alloc<CodeLocation>(originalMethodLabel);
            VReg* v0 = c.Alloc<VReg>(0);
            VReg* v1 = c.Alloc<VReg>(1);
            VReg* v2 = c.Alloc<VReg>(2);
            VReg* v3 = c.Alloc<VReg>(3);
            VReg* v4 = c.Alloc<VReg>(4);

            addInstr(c, fi, OP_CONST_STRING, {v0, c.Alloc<String>(id, id->orig_index)});
            addInstr(c, fi, OP_CONST, {v1, c.Alloc<Const32>(0)});
            addCall(b, c, fi, OP_INVOKE_STATIC, dispatcherT, "get", dispatcherT, {stringT, objectT},
                    {0, 1});
            addInstr(c, fi, OP_MOVE_RESULT_OBJECT, {v0});
            addInstr(c, fi, OP_IF_EQZ, {v0, originalMethod});
            addInstr(c, fi, OP_CONST_STRING,
                     {v1, c.Alloc<String>(methodDesc, methodDesc->orig_index)});
            addInstr(c, fi, OP_CONST, {v2, c.Alloc<Const32>(0)});
            addCall(b, c, fi, OP_INVOKE_VIRTUAL, dispatcherT, "getOrigin", methodT,
                    {objectT, stringT}, {0, 2, 1});
            addInstr(c, fi, OP_MOVE_RESULT_OBJECT, {v1});
            addInstr(c, fi, OP_IF_EQZ, {v1, originalMethod});
            addInstr(c, fi, OP_CONST, {v3, c.Alloc<Const32>(numParams)});
            addInstr(c, fi, OP_NEW_ARRAY, {v2, v3, c.Alloc<Type>(objectArrayT,
                                                                 objectArrayT->orig_index)});

            if (numParams > 0) {
                int argReg = firstArg;

                for (int argNum = 0; argNum < numParams; argNum++) {
                    const auto& type = method->decl->prototype->param_types->types[argNum];
                    BoxingInfo boxingInfo = getBoxingInfo(b, type->descriptor->c_str()[0]);

                    switch (type->GetCategory()) {
                        case ir::Type::Category::Scalar:
                            addInstr(c, fi, OP_MOVE_FROM16, {v3, c.Alloc<VReg>(argReg)});
                            addCall(b, c, fi, OP_INVOKE_STATIC, boxingInfo.boxedType, "valueOf",
                                    boxingInfo.boxedType, {type}, {3});
                            addInstr(c, fi, OP_MOVE_RESULT_OBJECT, {v3});

                            argReg++;
                            break;
                        case ir::Type::Category::WideScalar: {
                            VRegPair* v3v4 = c.Alloc<VRegPair>(3);
                            VRegPair* argRegPair = c.Alloc<VRegPair>(argReg);

                            addInstr(c, fi, OP_MOVE_WIDE_FROM16, {v3v4, argRegPair});
                            addCall(b, c, fi, OP_INVOKE_STATIC, boxingInfo.boxedType, "valueOf",
                                    boxingInfo.boxedType, {type}, {3, 4});
                            addInstr(c, fi, OP_MOVE_RESULT_OBJECT, {v3});

                            argReg += 2;
                            break;
                        }
                        case ir::Type::Category::Reference:
                            addInstr(c, fi, OP_MOVE_OBJECT_FROM16, {v3, c.Alloc<VReg>(argReg)});

                            argReg++;
                            break;
                        case ir::Type::Category::Void:
                            assert(false);
                    }

                    addInstr(c, fi, OP_CONST, {v4, c.Alloc<Const32>(argNum)});
                    addInstr(c, fi, OP_APUT_OBJECT, {v3, v2, v4});
                }
            }

            // NASTY Hack: Push in method name as "mock"
            addInstr(c, fi, OP_CONST_STRING,
                     {v3, c.Alloc<String>(methodDesc, methodDesc->orig_index)});
            addCall(b, c, fi, OP_INVOKE_VIRTUAL, dispatcherT, "handle", callableT,
                    {objectT, methodT, objectArrayT}, {0, 3, 1, 2});
            addInstr(c, fi, OP_MOVE_RESULT_OBJECT, {v0});
            addInstr(c, fi, OP_IF_EQZ, {v0, originalMethod});
            addCall(b, c, fi, OP_INVOKE_INTERFACE, callableT, "call", objectT, {}, {0});
            addInstr(c, fi, OP_MOVE_RESULT_OBJECT, {v0});

            ir::Type *returnType = method->decl->prototype->return_type;
            BoxingInfo boxingInfo = getBoxingInfo(b, returnType->descriptor->c_str()[0]);

            switch (returnType->GetCategory()) {
                case ir::Type::Category::Scalar:
                    addInstr(c, fi, OP_CHECK_CAST, {v0,
                                                    c.Alloc<Type>(boxingInfo.boxedType, boxingInfo.boxedType->orig_index)});
                    addCall(b, c, fi, OP_INVOKE_VIRTUAL, boxingInfo.boxedType,
                            boxingInfo.unboxMethod.c_str(), returnType, {}, {0});
                    addInstr(c, fi, OP_MOVE_RESULT, {v0});
                    addInstr(c, fi, OP_RETURN, {v0});
                    break;
                case ir::Type::Category::WideScalar: {
                    VRegPair* v0v1 = c.Alloc<VRegPair>(0);

                    addInstr(c, fi, OP_CHECK_CAST, {v0,
                                                    c.Alloc<Type>(boxingInfo.boxedType, boxingInfo.boxedType->orig_index)});
                    addCall(b, c, fi, OP_INVOKE_VIRTUAL, boxingInfo.boxedType,
                            boxingInfo.unboxMethod.c_str(), returnType, {}, {0});
                    addInstr(c, fi, OP_MOVE_RESULT_WIDE, {v0v1});
                    addInstr(c, fi, OP_RETURN_WIDE, {v0v1});
                    break;
                }
                case ir::Type::Category::Reference:
                    addInstr(c, fi, OP_CHECK_CAST, {v0, c.Alloc<Type>(returnType,
                                                                      returnType->orig_index)});
                    addInstr(c, fi, OP_RETURN_OBJECT, {v0});
                    break;
                case ir::Type::Category::Void:
                    addInstr(c, fi, OP_RETURN_VOID, {});
                    break;
            }

            addLabel(c, fi, originalMethodLabel);

            if (numParams > 0) {
                int argReg = firstArg;

                for (int argNum = 0; argNum < numParams; argNum++) {
                    const auto& type = method->decl->prototype->param_types->types[argNum];
                    int origReg = argReg - numAdditionalRegs;
                    switch (type->GetCategory()) {
                        case ir::Type::Category::Scalar:
                            addInstr(c, fi, OP_MOVE_16, {c.Alloc<VReg>(origReg),
                                                         c.Alloc<VReg>(argReg)});
                            argReg++;
                            break;
                        case ir::Type::Category::WideScalar:
                            addInstr(c, fi, OP_MOVE_WIDE_16,{c.Alloc<VRegPair>(origReg),
                                                             c.Alloc<VRegPair>(argReg)});
                            argReg +=2;
                            break;
                        case ir::Type::Category::Reference:
                            addInstr(c, fi, OP_MOVE_OBJECT_16, {c.Alloc<VReg>(origReg),
                                                                c.Alloc<VReg>(argReg)});
                            argReg++;
                            break;
                    }
                }
            }

            c.Assemble();
        }

        struct Allocator : public Writer::Allocator {
            virtual void* Allocate(size_t size) {return ::malloc(size);}
            virtual void Free(void* ptr) {::free(ptr);}
        };

        Allocator allocator;
        Writer writer(dex_ir);
        size_t transformedLen = 0;
        std::shared_ptr<jbyte> transformed((jbyte*)writer.CreateImage(&allocator, &transformedLen));

        jbyteArray transformedArr = env->NewByteArray(transformedLen);
        env->SetByteArrayRegion(transformedArr, 0, transformedLen, transformed.get());

        return transformedArr;
    }

    // Initializes the agent
    extern "C" jint Agent_OnAttach(JavaVM* vm,
                                   char* options,
                                   void* reserved) {
        jint jvmError = vm->GetEnv(reinterpret_cast<void**>(&localJvmtiEnv), JVMTI_VERSION_1_2);
        if (jvmError != JNI_OK) {
            return jvmError;
        }

        jvmtiCapabilities caps;
        memset(&caps, 0, sizeof(caps));
        caps.can_retransform_classes = 1;

        jvmtiError error = localJvmtiEnv->AddCapabilities(&caps);
        if (error != JVMTI_ERROR_NONE) {
            return error;
        }

        jvmtiEventCallbacks cb;
        memset(&cb, 0, sizeof(cb));
        cb.ClassFileLoadHook = Transform;

        error = localJvmtiEnv->SetEventCallbacks(&cb, sizeof(cb));
        if (error != JVMTI_ERROR_NONE) {
            return error;
        }

        error = localJvmtiEnv->SetEventNotificationMode(JVMTI_ENABLE,
                                                        JVMTI_EVENT_CLASS_FILE_LOAD_HOOK, nullptr);
        if (error != JVMTI_ERROR_NONE) {
            return error;
        }

        return JVMTI_ERROR_NONE;
    }

    // Throw runtime exception
    static void throwRuntimeExpection(JNIEnv* env, const char* fmt, ...) {
        char msgBuf[512];

        va_list args;
        va_start (args, fmt);
        vsnprintf(msgBuf, sizeof(msgBuf), fmt, args);
        va_end (args);

        jclass exceptionClass = env->FindClass("java/lang/RuntimeException");
        env->ThrowNew(exceptionClass, msgBuf);
    }

    // Register transformer hook
    extern "C" JNIEXPORT void JNICALL
    Java_com_android_dx_mockito_inline_StaticJvmtiAgent_nativeRegisterTransformerHook(JNIEnv* env,
                                                                                     jobject thiz) {
        sTransformer = env->NewGlobalRef(thiz);
    }

    // Unregister transformer hook
    extern "C" JNIEXPORT void JNICALL
    Java_com_android_dx_mockito_inline_StaticJvmtiAgent_nativeUnregisterTransformerHook(JNIEnv* env,
                                                                                     jobject thiz) {
        env->DeleteGlobalRef(sTransformer);
        sTransformer = nullptr;
    }

    // Triggers retransformation of classes via this file's Transform method
    extern "C" JNIEXPORT void JNICALL
    Java_com_android_dx_mockito_inline_StaticJvmtiAgent_nativeRetransformClasses(JNIEnv* env,
                                                                             jobject thiz,
                                                                             jobjectArray classes) {
        jsize numTransformedClasses = env->GetArrayLength(classes);
        jclass *transformedClasses = (jclass*) malloc(numTransformedClasses * sizeof(jclass));
        for (int i = 0; i < numTransformedClasses; i++) {
            transformedClasses[i] = (jclass) env->NewGlobalRef(env->GetObjectArrayElement(classes, i));
        }

        jvmtiError error = localJvmtiEnv->RetransformClasses(numTransformedClasses,
                                                             transformedClasses);

        for (int i = 0; i < numTransformedClasses; i++) {
            env->DeleteGlobalRef(transformedClasses[i]);
        }
        free(transformedClasses);

        if (error != JVMTI_ERROR_NONE) {
            throwRuntimeExpection(env, "Could not retransform classes: %d", error);
        }
    }

    static jvmtiFrameInfo* frameToInspect;
    static std::string calledClass;

    // Takes the full dex file for class 'classBeingRedefined'
    // - isolates the dex code for the class out of the dex file
    // - calls sTransformer.runTransformers on the isolated dex code
    // - send the transformed code back to the runtime
    static void
    InspectClass(jvmtiEnv* jvmtiEnv,
                 JNIEnv* env,
                 jclass classBeingRedefined,
                 jobject loader,
                 const char* name,
                 jobject protectionDomain,
                 jint classDataLen,
                 const unsigned char* classData,
                 jint* newClassDataLen,
                 unsigned char** newClassData) {
        calledClass = "none";

        Reader reader(classData, classDataLen);

        char *calledMethodName;
        char *calledMethodSignature;
        jvmtiError error = jvmtiEnv->GetMethodName(frameToInspect->method, &calledMethodName,
                                                   &calledMethodSignature, nullptr);
        if (error != JVMTI_ERROR_NONE) {
            return;
        }

        u4 index = reader.FindClassIndex(ClassNameToDescriptor(name).c_str());
        reader.CreateClassIr(index);
        std::shared_ptr<ir::DexFile> class_ir = reader.GetIr();

        for (auto& method : class_ir->encoded_methods) {
            if (Utf8Cmp(method->decl->name->c_str(), calledMethodName) == 0
                && Utf8Cmp(method->decl->prototype->Signature().c_str(), calledMethodSignature) == 0) {
                CodeIr method_ir(method.get(), class_ir);

                for (auto instruction : method_ir.instructions) {
                    Bytecode* bytecode = dynamic_cast<Bytecode*>(instruction);
                    if (bytecode != nullptr && bytecode->offset == frameToInspect->location) {
                        Method *method = bytecode->CastOperand<Method>(1);
                        calledClass = method->ir_method->parent->Decl().c_str();

                        goto exit;
                    }
                }
            }
        }

        exit:
        free(calledMethodName);
        free(calledMethodSignature);
    }

#define GOTO_ON_ERROR(label) \
    if (error != JVMTI_ERROR_NONE) { \
        goto label; \
    }

// stack frame of the caller if method was called directly
#define DIRECT_CALL_STACK_FRAME (6)

// stack frame of the caller if method was called as 'real method'
#define REALMETHOD_CALL_STACK_FRAME (23)

    extern "C" JNIEXPORT jstring JNICALL
    Java_com_android_dx_mockito_inline_StaticMockMethodAdvice_nativeGetCalledClassName(JNIEnv* env,
                                                                            jclass klass,
                                                                            jthread currentThread) {

        JavaVM *vm;
        jint jvmError = env->GetJavaVM(&vm);
        if (jvmError != JNI_OK) {
            return nullptr;
        }

        jvmtiEnv *jvmtiEnv;
        jvmError = vm->GetEnv(reinterpret_cast<void**>(&jvmtiEnv), JVMTI_VERSION_1_2);
        if (jvmError != JNI_OK) {
            return nullptr;
        }

        jvmtiCapabilities caps;
        memset(&caps, 0, sizeof(caps));
        caps.can_retransform_classes = 1;

        jvmtiError error = jvmtiEnv->AddCapabilities(&caps);
        GOTO_ON_ERROR(unregister_env_and_exit);

        jvmtiEventCallbacks cb;
        memset(&cb, 0, sizeof(cb));
        cb.ClassFileLoadHook = InspectClass;

        jvmtiFrameInfo frameInfo[REALMETHOD_CALL_STACK_FRAME + 1];
        jint numFrames;
        error = jvmtiEnv->GetStackTrace(nullptr, 0, REALMETHOD_CALL_STACK_FRAME + 1, frameInfo,
                                        &numFrames);
        GOTO_ON_ERROR(unregister_env_and_exit);

        // Method might be called directly or as 'real method' (see
        // StaticMockMethodAdvice.SuperMethodCall#invoke). Hence the real caller might be in stack
        // frame DIRECT_CALL_STACK_FRAME for a direct call or REALMETHOD_CALL_STACK_FRAME for a
        // call through the 'real method' mechanism.
        int callingFrameNum;
        if (numFrames < REALMETHOD_CALL_STACK_FRAME) {
            callingFrameNum = DIRECT_CALL_STACK_FRAME;
        } else {
            char *directCallMethodName;

            jvmtiEnv->GetMethodName(frameInfo[DIRECT_CALL_STACK_FRAME].method,
                                    &directCallMethodName, nullptr, nullptr);
            if (strcmp(directCallMethodName, "invoke") == 0) {
                callingFrameNum = REALMETHOD_CALL_STACK_FRAME;
            } else {
                callingFrameNum = DIRECT_CALL_STACK_FRAME;
            }
        }

        jclass callingClass;
        error = jvmtiEnv->GetMethodDeclaringClass(frameInfo[callingFrameNum].method, &callingClass);
        GOTO_ON_ERROR(unregister_env_and_exit);

        error = jvmtiEnv->SetEventCallbacks(&cb, sizeof(cb));
        GOTO_ON_ERROR(unregister_env_and_exit);

        error = jvmtiEnv->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_CLASS_FILE_LOAD_HOOK,
                                                   currentThread);
        GOTO_ON_ERROR(unset_cb_and_exit);

        frameToInspect = &frameInfo[callingFrameNum];
        error = jvmtiEnv->RetransformClasses(1, &callingClass);
        GOTO_ON_ERROR(disable_hook_and_exit);

        disable_hook_and_exit:
        jvmtiEnv->SetEventNotificationMode(JVMTI_DISABLE, JVMTI_EVENT_CLASS_FILE_LOAD_HOOK,
                                           currentThread);

        unset_cb_and_exit:
        memset(&cb, 0, sizeof(cb));
        jvmtiEnv->SetEventCallbacks(&cb, sizeof(cb));

        unregister_env_and_exit:
        jvmtiEnv->DisposeEnvironment();

        if (error != JVMTI_ERROR_NONE) {
            return nullptr;
        }

        return env->NewStringUTF(calledClass.c_str());
    }

}  // namespace com_android_dx_mockito_inline