Home | History | Annotate | Download | only in interp 
      1 /*
      2  * Copyright (C) 2009 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 /*
     17  * Jit control
     18  */
     19 #ifndef _DALVIK_INTERP_JIT
     20 #define _DALVIK_INTERP_JIT
     21 
     22 #include "InterpDefs.h"
     23 #include "mterp/common/jit-config.h"
     24 
     25 #define JIT_MAX_TRACE_LEN 100
     26 
     27 #if defined (WITH_SELF_VERIFICATION)
     28 
     29 #define REG_SPACE 256                /* default size of shadow space */
     30 #define HEAP_SPACE JIT_MAX_TRACE_LEN /* default size of heap space */
     31 
     32 typedef struct ShadowHeap {
     33     int addr;
     34     int data;
     35 } ShadowHeap;
     36 
     37 typedef struct InstructionTrace {
     38     int addr;
     39     DecodedInstruction decInsn;
     40 } InstructionTrace;
     41 
     42 typedef struct ShadowSpace {
     43     const u2* startPC;          /* starting pc of jitted region */
     44     const void* fp;             /* starting fp of jitted region */
     45     void* glue;                 /* starting glue of jitted region */
     46     SelfVerificationState jitExitState;  /* exit point for JIT'ed code */
     47     SelfVerificationState selfVerificationState;  /* current SV running state */
     48     const u2* endPC;            /* ending pc of jitted region */
     49     void* shadowFP;       /* pointer to fp in shadow space */
     50     InterpState interpState;    /* copy of interpState */
     51     int* registerSpace;         /* copy of register state */
     52     int registerSpaceSize;      /* current size of register space */
     53     ShadowHeap heapSpace[HEAP_SPACE]; /* copy of heap space */
     54     ShadowHeap* heapSpaceTail;        /* tail pointer to heapSpace */
     55     const void* endShadowFP;    /* ending fp in shadow space */
     56     InstructionTrace trace[JIT_MAX_TRACE_LEN]; /* opcode trace for debugging */
     57     int traceLength;            /* counter for current trace length */
     58     const Method* method;       /* starting method of jitted region */
     59 } ShadowSpace;
     60 
     61 /*
     62  * Self verification functions.
     63  */
     64 void* dvmSelfVerificationShadowSpaceAlloc(Thread* self);
     65 void dvmSelfVerificationShadowSpaceFree(Thread* self);
     66 void* dvmSelfVerificationSaveState(const u2* pc, const void* fp,
     67                                    InterpState* interpState,
     68                                    int targetTrace);
     69 void* dvmSelfVerificationRestoreState(const u2* pc, const void* fp,
     70                                       SelfVerificationState exitPoint);
     71 #endif
     72 
     73 /*
     74  * JitTable hash function.
     75  */
     76 
     77 static inline u4 dvmJitHashMask( const u2* p, u4 mask ) {
     78     return ((((u4)p>>12)^(u4)p)>>1) & (mask);
     79 }
     80 
     81 static inline u4 dvmJitHash( const u2* p ) {
     82     return dvmJitHashMask( p, gDvmJit.jitTableMask );
     83 }
     84 
     85 /*
     86  * Entries in the JIT's address lookup hash table.
     87  * Fields which may be updated by multiple threads packed into a
     88  * single 32-bit word to allow use of atomic update.
     89  */
     90 
     91 typedef struct JitEntryInfo {
     92     unsigned int           traceConstruction:1;   /* build underway? */
     93     unsigned int           isMethodEntry:1;
     94     unsigned int           inlineCandidate:1;
     95     unsigned int           profileEnabled:1;
     96     JitInstructionSetType  instructionSet:4;
     97     unsigned int           unused:8;
     98     u2                     chain;                 /* Index of next in chain */
     99 } JitEntryInfo;
    100 
    101 typedef union JitEntryInfoUnion {
    102     JitEntryInfo info;
    103     volatile int infoWord;
    104 } JitEntryInfoUnion;
    105 
    106 typedef struct JitEntry {
    107     JitEntryInfoUnion   u;
    108     const u2*           dPC;            /* Dalvik code address */
    109     void*               codeAddress;    /* Code address of native translation */
    110 } JitEntry;
    111 
    112 int dvmCheckJit(const u2* pc, Thread* self, InterpState* interpState,
    113                 const ClassObject *callsiteClass, const Method* curMethod);
    114 void* dvmJitGetCodeAddr(const u2* dPC);
    115 bool dvmJitCheckTraceRequest(Thread* self, InterpState* interpState);
    116 void dvmJitStopTranslationRequests(void);
    117 void dvmJitStats(void);
    118 bool dvmJitResizeJitTable(unsigned int size);
    119 void dvmJitResetTable(void);
    120 struct JitEntry *dvmFindJitEntry(const u2* pc);
    121 s8 dvmJitd2l(double d);
    122 s8 dvmJitf2l(float f);
    123 void dvmJitSetCodeAddr(const u2* dPC, void *nPC, JitInstructionSetType set);
    124 void dvmJitAbortTraceSelect(InterpState* interpState);
    125 
    126 #endif /*_DALVIK_INTERP_JIT*/
    127