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 selfVerificationState;  /* self verification state */
     47     const u2* endPC;            /* ending pc of jitted region */
     48     void* shadowFP;       /* pointer to fp in shadow space */
     49     InterpState interpState;    /* copy of interpState */
     50     int* registerSpace;         /* copy of register state */
     51     int registerSpaceSize;      /* current size of register space */
     52     ShadowHeap heapSpace[HEAP_SPACE]; /* copy of heap space */
     53     ShadowHeap* heapSpaceTail;        /* tail pointer to heapSpace */
     54     const void* endShadowFP;    /* ending fp in shadow space */
     55     InstructionTrace trace[JIT_MAX_TRACE_LEN]; /* opcode trace for debugging */
     56     int traceLength;            /* counter for current trace length */
     57     const Method* method;       /* starting method of jitted region */
     58 } ShadowSpace;
     59 
     60 /*
     61  * Self verification functions.
     62  */
     63 void* dvmSelfVerificationShadowSpaceAlloc(Thread* self);
     64 void dvmSelfVerificationShadowSpaceFree(Thread* self);
     65 void* dvmSelfVerificationSaveState(const u2* pc, const void* fp,
     66                                    InterpState* interpState,
     67                                    int targetTrace);
     68 void* dvmSelfVerificationRestoreState(const u2* pc, const void* fp,
     69                                       SelfVerificationState exitPoint);
     70 #endif
     71 
     72 /*
     73  * JitTable hash function.
     74  */
     75 
     76 static inline u4 dvmJitHashMask( const u2* p, u4 mask ) {
     77     return ((((u4)p>>12)^(u4)p)>>1) & (mask);
     78 }
     79 
     80 static inline u4 dvmJitHash( const u2* p ) {
     81     return dvmJitHashMask( p, gDvmJit.jitTableMask );
     82 }
     83 
     84 /*
     85  * Entries in the JIT's address lookup hash table.
     86  * Fields which may be updated by multiple threads packed into a
     87  * single 32-bit word to allow use of atomic update.
     88  */
     89 
     90 typedef struct JitEntryInfo {
     91     unsigned int           traceConstruction:1;   /* build underway? */
     92     unsigned int           isMethodEntry:1;
     93     unsigned int           inlineCandidate:1;
     94     unsigned int           profileEnabled:1;
     95     JitInstructionSetType  instructionSet:4;
     96     unsigned int           unused:8;
     97     u2                     chain;                 /* Index of next in chain */
     98 } JitEntryInfo;
     99 
    100 typedef union JitEntryInfoUnion {
    101     JitEntryInfo info;
    102     volatile int infoWord;
    103 } JitEntryInfoUnion;
    104 
    105 typedef struct JitEntry {
    106     JitEntryInfoUnion   u;
    107     const u2*           dPC;            /* Dalvik code address */
    108     void*               codeAddress;    /* Code address of native translation */
    109 } JitEntry;
    110 
    111 int dvmCheckJit(const u2* pc, Thread* self, InterpState* interpState);
    112 void* dvmJitGetCodeAddr(const u2* dPC);
    113 bool dvmJitCheckTraceRequest(Thread* self, InterpState* interpState);
    114 void dvmJitStopTranslationRequests(void);
    115 void dvmJitStats(void);
    116 bool dvmJitResizeJitTable(unsigned int size);
    117 void dvmJitResetTable(void);
    118 struct JitEntry *dvmFindJitEntry(const u2* pc);
    119 s8 dvmJitd2l(double d);
    120 s8 dvmJitf2l(float f);
    121 void dvmJitSetCodeAddr(const u2* dPC, void *nPC, JitInstructionSetType set);
    122 void dvmJitAbortTraceSelect(InterpState* interpState);
    123 
    124 #endif /*_DALVIK_INTERP_JIT*/
    125