代码改变世界

解释器入口 Interp.c

2012-04-10 20:51  至上  阅读(756)  评论(0)  编辑  收藏  举报
  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

 

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

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