实现原理核心代码详解（davlik部分）

1、c++背景知识介绍

• extern关键字

extern可置于变量或者函数前，以表示变量或者函数的定义在别的文件中，提示编译器遇到此变量或函数时，在其它模块中寻找其定义

//该方法声明在头文件
extern void dalvik_setFieldFlag(JNIEnv* env, jobject field) {}

• __attribute__关键字

GNU C的一大特色就是__attribute__机制,__attribute__可以设置函数属性(Function Attribute)、变量属性(Variable Attribute)和类型属性(Type Attribute),语法格式：__attribute__ ( ( attribute-list ) )

//设置dalvik_setup函数属性为hidden
extern jboolean __attribute__ ((visibility ("hidden"))) dalvik_setup(JNIEnv* env, int apilevel) {}

• dlopen函数

• dlopen（）函数以指定模式打开指定的动态链接库文件，并返回一个句柄给dlsym（）的调用进程。
• RTLD_NOW:需要在dlopen返回前，解析出所有未定义符号，如果解析不出来，在dlopen会返回NULL。
• 句柄和指针的区别：我们调用句柄就是调用句柄所提供的服务，即句柄已经把它能做的操作都设定好了，我们只能在句柄所提供的操作范围内进行操作，但是普通指针的操作却多种多样，不受限制。

//打开libdvm.so文件，并返还句柄给后面dlsym（）使用
void* dvm_hand = dlopen("libdvm.so", RTLD_NOW);

• dlsym函数

根据动态链接库操作句柄与符号，返回符号对应的地址，使用这个函数不但可以获取函数地址，也可以获取变量地址。

//获取函数地址方法
static void* dvm_dlsym(void *hand, const char *name) {
 //根据动态链接库操作句柄与符号，返回符号对应的地址。 
void* ret = dlsym(hand, name); return ret; 
}

• typedef关键字>typedef关键字使用可自行了解，这里解释的是复杂的变量声明。结合下面代码分析说明

typedef int (*dvmComputeMethodArgsSize_func)(void*);
//首先找到变量名dvmComputeMethodArgsSize_func，
//外面有一对圆括号，而且左边是一个*号，说明这它是一个指针；
//然后跳出这个圆括号，先看右边又遇到圆括号，
//说明（*dvmComputeMethodArgsSize_func）是一个函数
//所以dvmComputeMethodArgsSize_func即是函数指针，
//具有void＊类型的形参，返回值类型为int。

当调用了dlsym方法获取函数指针后继给它们做相应的引用。

• 方法调用表各方法可到davlik源码查，
  这里有个比较方便的源码查寻：Android cross;

具体方法代码详见方法源码附录。
大家读源码的时候可能注意到_Z20dvmDecodeIndirectRefP6ThreadP8_jobject类似函数还附加了些特殊符号，这是因为编译时区分不同版本，c＋＋做了命名重载。

2、字节码的文件结构

• 字段访问标识

• class 访问标识

  
  
  class.png

• field访问标识

  
  
  field.png

• method访问标识

  
  
  method.png

• 字段的描述符

character.png

上面的当我们分析andfix时遇到符号查表对应即可。

3、函数核心方法分析
3.1 replaceMethod

extern void __attribute__ ((visibility ("hidden"))) 
dalvik_replaceMethod( JNIEnv* env, jobject src, jobject dest) { 
//src:待修复的函数。 
//dest:修复函数。  
//jni调用反射包下Method类getDeclaringclass方法,获得class对象clazz jobject clazz = env->CallObjectMethod(dest, jClassMethod); 

//将clazz对象转换为dalvik直接引用,返回ClassObject*引用它.
//因为davlik是操作ClassObject的。 
ClassObject* clz = (ClassObject*) dvmDecodeIndirectRef_fnPtr( dvmThreadSelf_fnPtr(), clazz); 

//参见http://osxr.org/android/source/dalvik/vm/oo/Object.h 不过andfix jni目录下copy一份放在dalvik.h 
//标示clz为初始化完毕的ready状态。
 clz->status = CLASS_INITIALIZED; 

//转换java.lang.reflect.Method或java.lang.reflect.Constructor对象为函数地址。 
Method* meth = (Method*) env->FromReflectedMethod(src); 
 
//修复函数地址。 
Method* target = (Method*) env->FromReflectedMethod(dest);  

//打印待修复方法名称 LOGD("dalvikMethod: %s", meth->name); 
//这个变量记录了一些预先计算好的信息，从而不需要在调用的时候再通过方法的参数和返回值实时计算了，方便了JNI的调用，提高了调用的速度。
//如果第一位为1（即0x80000000），则Dalvik虚拟机会忽略后面的所有信息，强制在调用时实时计算； 
meth->jniArgInfo = 0x80000000; 

//方法的访问标识置为native，即将meth的访问标识设为native方式。
 meth->accessFlags |= ACC_NATIVE; 

//获取方法形参个数 
int argsSize = dvmComputeMethodArgsSize_fnPtr(meth);  
if (!dvmIsStaticMethod(meth)) argsSize++;

//非静态方法参数个数加一,引用改方法的对象this也默认当作一个参数，且放到第0位。  
//registersSize：该方法总共用到的寄存器个数，包含入口参数所用到的寄存器，还有方法内部自己所用到的其它本地寄存器； 
//insSize：作为调用该方法时，参数传递而使用到的寄存器个数； 
//outsSize：当该方法要调用其它方法时，用作参数传递而使用的寄存器个数；  
meth->registersSize = meth->insSize = argsSize; 

//如果这个方法不是Native的话，则这里存放了指向方法具体的Dalvik指令的指针（这个变量指向的是实际加载到内存中的Dalvik 
//指令，而不是在Dex文件中的）。如果这个方法是一个Dalvik虚拟机自带的Native函数（Internal Native）的话，则这个变量 
//会是Null。如果这个方法是一个普通的Native函数的话，则这里存放了指向JNI实际函数机器码的首地址； 
meth->insns = (void*) target;

//指向替换src的target方法. 
//如果这个方法是一个Dalvik虚拟机自带的Native函数（Internal Native）的话，则这里存放了指向JNI实际函数机器码的首地址。
//如果这个方法是一个普通的Native函数的话，则这里将指向一个中间的跳转JNI桥（Bridge）代码； 
meth->nativeFunc = dalvik_dispatcher;

}

上面即完成了待修复函数的替换.

实际执行将通过jni桥代码执行。

static void dalvik_dispatcher(const u4* args, jvalue* pResult, const Method* method, void* self) { 
//返回对象类型 
ClassObject* returnType;

//返回值 ArrayObject* argArray;//对象数组，这里表示为参数数组。 
jvalue result;

//打印一下，函数名称和简短的函数名，这里输出待修复方法 
LOGD("dalvik_dispatcher source method: %s %s", method->name,method->shorty);  

//赋值为修复函数 
Method* meth = (Method*) method->insns; 

//访问标识置为
public meth->accessFlags = meth->accessFlags | ACC_PUBLIC; 

//打印修复函数的名称和简短名称 
LOGD("dalvik_dispatcher target method: %s %s", method->name, method->shorty); 

//调用返回值装箱类型函数， 
returnType = dvmGetBoxedReturnType_fnPtr(method);
 
//处理返回值类型装箱异常 
if (returnType == NULL) { 
  assert(dvmCheckException_fnPtr(self));
  goto bail; 
}  
//函数开始调用 
LOGD("dalvik_dispatcher start call->");
if (!dvmIsStaticMethod(meth)) {
//如果不是静态函数 
//获取持有该方法的对象。注意这个object是dalvik中typedef的。 
Object* thisObj = (Object*) args[0]; 

//获取tmp临时ClassObject临时较好对象。 
ClassObject* tmp = thisObj->clazz; 
thisObj->clazz = meth->clazz; 

//将方法参数都封装到array中 
argArray = boxMethodArgs(meth, args + 1); 
if (dvmCheckException_fnPtr(self)) 
  goto bail;  

//执行该方法 
//1、self：线程id 
//2、jInvokeMethod:指向invoke函数,public Object invoke(Object receiver, Object... args) 
//3、创建一个新的Method对象.使用Meth地址来构造出它. 
//4、result返回值的地址 
//5、持有该方法的对象 
//6、函数参数数组 
dvmCallMethod_fnPtr(self, (Method*) jInvokeMethod, dvmCreateReflectMethodObject_fnPtr(meth), &result, thisObj, argArray); 
//恢复引用 
thisObj->clazz = tmp; 
} 
else 
{
 //静态函数 
 argArray = boxMethodArgs(meth, args); 
  if (dvmCheckException_fnPtr(self)) 
    goto bail; 
//不用传递持有该函数的对象，因为函数是静态的
  dvmCallMethod_fnPtr(self, (Method*) jInvokeMethod, dvmCreateReflectMethodObject_fnPtr(meth), &result, NULL, argArray); 
} 
if (dvmCheckException_fnPtr(self)) { 
  Object* excep = dvmGetException_fnPtr(self); 
  jni_env->Throw((jthrowable) excep); goto bail; 
} 
//检测返回类型和返回值。 
if (returnType->primitiveType == PRIM_VOID) {
//返回类型为void 
LOGD("+++ ignoring return to void"); 
} else if (result.l == NULL) {
//返回值为null 
  if (dvmIsPrimitiveClass(returnType)) {
    //检测返回类型是否是原型类型。 
    jni_env->ThrowNew(NPEClazz, "null result when primitive expected"); goto bail; 
  } 
  pResult->l = NULL;
  //非原型类型，即引用类型返回null值。
 } else { 
  //解析拆箱后的类型，该方法无论原型或非原型类型的拆箱。 
   if (!dvmUnboxPrimitive_fnPtr(result.l, returnType, pResult)) { 
    char msg[1024] = { 0 };
   snprintf(msg, sizeof(msg) - 1, "%s!=%s\0", ((Object*) result.l)->clazz->descriptor, returnType->descriptor); 
   jni_env->ThrowNew(CastEClazz, msg); goto bail;
 } 
} 
//出异常时dalvik释放tracked内存 
bail: dvmReleaseTrackedAlloc_fnPtr((Object*) argArray, self);
}

下面是获取参数时的装箱方法，比较简单就不详细的介绍了。

static ArrayObject* boxMethodArgs(const Method* method, const u4* args) { 
const char* desc = &method->shorty[1]; 
// [0] is the return type. 
/* count args */ 
size_t argCount = dexProtoGetParameterCount_fnPtr(&method->prototype); 
/* allocate storage */ 
ArrayObject* argArray = dvmAllocArrayByClass_fnPtr(classJavaLangObjectArray, argCount, ALLOC_DEFAULT);
 if (argArray == NULL) 
return NULL; 
Object** argObjects = (Object**) (void*) argArray->contents; 
/* * Fill in the array. */ 
size_t srcIndex = 0; 
size_t dstIndex = 0; 
while (*desc != '\0')
 { 
char descChar = *(desc++); 
jvalue value; 
switch (descChar) { 
 case 'Z':
 case 'C':
 case 'F':
 case 'B':
 case 'S':
 case 'I':
  value.i = args[srcIndex++]; 
  argObjects[dstIndex] = (Object*) dvmBoxPrimitive_fnPtr(value,   
  dvmFindPrimitiveClass_fnPtr(descChar));
   /* argObjects is tracked, don't need to hold this too */ 
   dvmReleaseTrackedAlloc_fnPtr(argObjects[dstIndex], NULL);   
   dstIndex++;
 break;
 case 'D':
 case 'J':
 value.j = dvmGetArgLong(args, srcIndex);
 srcIndex += 2;
 argObjects[dstIndex] = (Object*) dvmBoxPrimitive_fnPtr(value, dvmFindPrimitiveClass_fnPtr(descChar));
 dvmReleaseTrackedAlloc_fnPtr(argObjects[dstIndex], NULL);
 dstIndex++;
 break;
 case '[':
 case 'L':
 argObjects[dstIndex++] = (Object*) args[srcIndex++];
 LOGD("boxMethodArgs object: index = %d", dstIndex - 1); break; }
 }
 return argArray;
}

上述的核心代码流程分析完毕，相信大家做下分析下都能了解方法替换的实现了。需要学习xpose机制，熟悉dalvik结构，然后吸收成自己的理解创出这个实现方案。