解释器入口 Interp.c

1. void dvmInterpret(Thread* self, const Method* method, JValue* pResult)
2. {
3.     InterpState interpState;
4.     //glue结构体实例   glue就是存放信息的一个结构体  类似于ecb
5.     bool change;
6. #if defined(WITH_JIT)
7. //解释器是否使用jit    编译热路径使用的  纯汇编编写 提高速度使用
8.     /* Target-specific save/restore */
9. //保存信息 以便回复  有一种调用函数的感觉  最后还会有返回值
10. //那么解释器是否以一个方法作为最小单位澹(或者是一小段代码)
11.     extern void dvmJitCalleeSave(double *saveArea);
12.     extern void dvmJitCalleeRestore(double *saveArea);
13.     /* Interpreter entry points from compiled code */
14.     extern void dvmJitToInterpNormal();
15.     extern void dvmJitToInterpNoChain();
16.     extern void dvmJitToInterpPunt();
17.     extern void dvmJitToInterpSingleStep();
18.     extern void dvmJitToInterpTraceSelectNoChain();
19.     extern void dvmJitToInterpTraceSelect();
20.     extern void dvmJitToPatchPredictedChain();
21.     //使用jit  需要的方法
22. #if defined(WITH_SELF_VERIFICATION)
23.     extern void dvmJitToInterpBackwardBranch();
24. //关于验证的
25. #endif
27.     /*
28.      * Reserve a static entity here to quickly setup runtime contents as
29.      * gcc will issue block copy instructions.
30.      */
31.     static struct JitToInterpEntries jitToInterpEntries = {
32.         dvmJitToInterpNormal,
33.         dvmJitToInterpNoChain,
34.         dvmJitToInterpPunt,
35.         dvmJitToInterpSingleStep,
36.         dvmJitToInterpTraceSelectNoChain,
37.         dvmJitToInterpTraceSelect,
38.         dvmJitToPatchPredictedChain,
39. #if defined(WITH_SELF_VERIFICATION)
40.         dvmJitToInterpBackwardBranch,
41. #endif
42.     };
44.     /*
45.      * If the previous VM left the code cache through single-stepping the
46.      * inJitCodeCache flag will be set when the VM is re-entered (for example,
47.      * in self-verification mode we single-step NEW_INSTANCE which may re-enter
48.      * the VM through findClassFromLoaderNoInit). Because of that, we cannot
49.      * assert that self->inJitCodeCache is NULL here.
50.      */
51. #endif
54. #if defined(WITH_TRACKREF_CHECKS)
55.     interpState.debugTrackedRefStart =
56.         dvmReferenceTableEntries(&self->internalLocalRefTable);
57. #endif
58.     interpState.debugIsMethodEntry = true;
59. //假设是dbg模式
60. #if defined(WITH_JIT)
61.     dvmJitCalleeSave(interpState.calleeSave);
62. //调用外部方法
63.     /* Initialize the state to kJitNot */
64.     interpState.jitState = kJitNot;
65. //jit状态就是指是否使用jit
66.     /* Setup the Jit-to-interpreter entry points */
67.     interpState.jitToInterpEntries = jitToInterpEntries;
68. //jit的入口信息
69.     /*
70.      * Initialize the threshold filter [don't bother to zero out the
71.      * actual table.  We're looking for matches, and an occasional
72.      * false positive is acceptible.
73.      */
74.     interpState.lastThreshFilter = 0;
76.     interpState.icRechainCount = PREDICTED_CHAIN_COUNTER_RECHAIN;
77. #endif
79.     /*
80.      * Initialize working state.
81.      *
82.      * No need to initialize "retval".
83.      //返回值不需要初始化
84.      */
85. //对glue结构里面的变量赋值
86.     interpState.method = method;
87.     interpState.fp = (u4*) self->curFrame;
88.     interpState.pc = method->insns;
89.     interpState.entryPoint = kInterpEntryInstr;
90. //glue结构下的模式参数更改
91.     if (dvmDebuggerOrProfilerActive())
92.         interpState.nextMode = INTERP_DBG;
93.     else
94.         interpState.nextMode = INTERP_STD;
95. //是不是本地方法
96.     assert(!dvmIsNativeMethod(method));  
98.     /*
99.      * Make sure the class is ready to go.  Shouldn't be possible to get
100.      * here otherwise.
101.      */
102.     if (method->clazz->status < CLASS_INITIALIZING ||
103.         method->clazz->status == CLASS_ERROR)
104.     {
105.         LOGE("ERROR: tried to execute code in unprepared class '%s' (%d)\n",
106.             method->clazz->descriptor, method->clazz->status);
107.         dvmDumpThread(self, false);
108.         dvmAbort();
109.     }
111.     typedef bool (*Interpreter)(Thread*, InterpState*);
112.     //入口参数是线持刚胩与glue结构体指针
113.     Interpreter stdInterp;
114.     //这里是定义的一个解释器实例?
115.     if (gDvm.executionMode == kExecutionModeInterpFast)
116.         stdInterp = dvmMterpStd;
117.     //如果是快速行得 就是汇编行得
118. #if defined(WITH_JIT)
119.     else if (gDvm.executionMode == kExecutionModeJit)
120. /* If profiling overhead can be kept low enough, we can use a profiling
121.  * mterp fast for both Jit and "fast" modes.  If overhead is too high,
122.  * create a specialized profiling interpreter.
123.  */
124.         stdInterp = dvmMterpStd;
125.     //汇编实现
126. #endif
127.     else
128.         stdInterp = dvmInterpretStd;
129. //c语言实现
130.     change = true;
131.     while (change) {
132.         switch (interpState.nextMode) {
133.         case INTERP_STD:
134.             LOGVV("threadid=%d: interp STD\n", self->threadId);
135.             change = (*stdInterp)(self, &interpState);    这里就进入解释器执行了  传入参数就是解释器类型  所属线程   所使用的glue结构体
     
136.             break;
137.         case INTERP_DBG:
138.             LOGVV("threadid=%d: interp DBG\n", self->threadId);
139.             change = dvmInterpretDbg(self, &interpState);    这里也是
     
140.             break;
141.         default:
142.             dvmAbort();
143.         }
144.     }
146.     *pResult = interpState.retval;
147.     //返回值
148. #if defined(WITH_JIT)
149.     dvmJitCalleeRestore(interpState.calleeSave);
150. //如果使用了jit  就采用这种回复方式
151. #endif
152. }

主要做了三点

1.glue结构体中变量的赋值

2.选择解释器的类型

3.判断是否是本地方法  采取不同的解释路径

1. typedef struct InterpState {
2.     const u2*   pc;                       //程序计数器
3.     u4*         fp;                     //帧指针
4.     JValue      retval;                      //返回值
5.     const Method* method;                  //将要执行的方法
6.     DvmDex*         methodClassDex;        //dex文件生成的结构
7.     Thread*         self;                              //所属线程
8.     void*           bailPtr;                          //出错以后跳转的目标
9.     const u1*       interpStackEnd;                     //为加速复制到这里
10.     volatile int*   pSelfSuspendCount;            //为加速复制到这里
11.     InterpEntry entryPoint;                     //下一步该做什么
12.     int         nextMode;                  //INTERP_STD还是INTERP_DBG
13. } InterpState;

这是glue结构体  存储一定的信息  解释器在解释执行时会查看或者更改  像是存放即时信息的地方

还有一个问题   是谁调用了解释器的入口呢  ？

    线程与解释的关系可以通过下面的代码得到：

VMThread_createà

dvmCreateInterpThreadà

interpThreadStartà

dvmCallMethodà

dvmCallMethod*à

dvmInterpret

       由此可以看出，每个线程都最终调用了解释器代码。因此可以说线程与解释器是一一对应的关系。

所以线程与解释器有很大的关系   根据程序创建进程 创建主线程 程序代码调入内存 类加载器加载  调用解释器入口  开始解释执行