vm/interp/Jit.h

   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     u4* fp;                     /* starting fp of jitted region */
  45     const Method *method;
  46     DvmDex* methodClassDex;
  47     JValue retval;
  48     const u1* interpStackEnd;
  49     SelfVerificationState jitExitState;  /* exit point for JIT'ed code */
  50     SelfVerificationState selfVerificationState;  /* current SV running state */
  51     const u2* endPC;            /* ending pc of jitted region */
  52     void* shadowFP;       /* pointer to fp in shadow space */
  53     int* registerSpace;         /* copy of register state */
  54     int registerSpaceSize;      /* current size of register space */
  55     ShadowHeap heapSpace[HEAP_SPACE]; /* copy of heap space */
  56     ShadowHeap* heapSpaceTail;        /* tail pointer to heapSpace */
  57     const void* endShadowFP;    /* ending fp in shadow space */
  58     InstructionTrace trace[JIT_MAX_TRACE_LEN]; /* opcode trace for debugging */
  59     int traceLength;            /* counter for current trace length */
  60 } ShadowSpace;
  61
  62 /*
  63  * Self verification functions.
  64  */
  65 void* dvmSelfVerificationShadowSpaceAlloc(Thread* self);
  66 void dvmSelfVerificationShadowSpaceFree(Thread* self);
  67 void* dvmSelfVerificationSaveState(const u2* pc, u4* fp,
  68                                    Thread* self,
  69                                    int targetTrace);
  70 void* dvmSelfVerificationRestoreState(const u2* pc, u4* fp,
  71                                       SelfVerificationState exitPoint,
  72                                       Thread *self);
  73 void dvmCheckSelfVerification(const u2* pc, Thread* self);
  74 #endif
  75
  76 /*
  77  * Offsets for metadata in the trace run array from the trace that ends with
  78  * invoke instructions.
  79  */
  80 #define JIT_TRACE_CLASS_DESC    1
  81 #define JIT_TRACE_CLASS_LOADER  2
  82 #define JIT_TRACE_CUR_METHOD    3
  83
  84 /*
  85  * JitTable hash function.
  86  */
  87
  88 static inline u4 dvmJitHashMask( const u2* p, u4 mask ) {
  89     return ((((u4)p>>12)^(u4)p)>>1) & (mask);
  90 }
  91
  92 static inline u4 dvmJitHash( const u2* p ) {
  93     return dvmJitHashMask( p, gDvmJit.jitTableMask );
  94 }
  95
  96 /*
  97  * The width of the chain field in JitEntryInfo sets the upper
  98  * bound on the number of translations.  Be careful if changing
  99  * the size of JitEntry struct - the Dalvik PC to JitEntry
 100  * hash functions have built-in knowledge of the size.
 101  */
 102 #define JIT_ENTRY_CHAIN_WIDTH 2
 103 #define JIT_MAX_ENTRIES (1 << (JIT_ENTRY_CHAIN_WIDTH * 8))
 104
 105 /*
 106  * The trace profiling counters are allocated in blocks and individual
 107  * counters must not move so long as any referencing trace exists.
 108  */
 109 #define JIT_PROF_BLOCK_ENTRIES 1024
 110 #define JIT_PROF_BLOCK_BUCKETS (JIT_MAX_ENTRIES / JIT_PROF_BLOCK_ENTRIES)
 111
 112 typedef s4 JitTraceCounter_t;
 113
 114 typedef struct JitTraceProfCounters {
 115     unsigned int           next;
 116     JitTraceCounter_t      *buckets[JIT_PROF_BLOCK_BUCKETS];
 117 } JitTraceProfCounters;
 118
 119 /*
 120  * Entries in the JIT's address lookup hash table.
 121  * Fields which may be updated by multiple threads packed into a
 122  * single 32-bit word to allow use of atomic update.
 123  */
 124
 125 typedef struct JitEntryInfo {
 126     unsigned int           isMethodEntry:1;
 127     unsigned int           inlineCandidate:1;
 128     unsigned int           profileEnabled:1;
 129     JitInstructionSetType  instructionSet:3;
 130     unsigned int           profileOffset:5;
 131     unsigned int           unused:5;
 132     u2                     chain;                 /* Index of next in chain */
 133 } JitEntryInfo;
 134
 135 typedef union JitEntryInfoUnion {
 136     JitEntryInfo info;
 137     volatile int infoWord;
 138 } JitEntryInfoUnion;
 139
 140 typedef struct JitEntry {
 141     JitEntryInfoUnion   u;
 142     const u2*           dPC;            /* Dalvik code address */
 143     void*               codeAddress;    /* Code address of native translation */
 144 } JitEntry;
 145
 146 void dvmCheckJit(const u2* pc, Thread* self);
 147 void* dvmJitGetTraceAddr(const u2* dPC);
 148 void* dvmJitGetMethodAddr(const u2* dPC);
 149 void dvmJitCheckTraceRequest(Thread* self);
 150 void dvmJitStopTranslationRequests(void);
 151 void dvmJitStats(void);
 152 bool dvmJitResizeJitTable(unsigned int size);
 153 void dvmJitResetTable(void);
 154 struct JitEntry *dvmJitFindEntry(const u2* pc, bool isMethodEntry);
 155 s8 dvmJitd2l(double d);
 156 s8 dvmJitf2l(float f);
 157 void dvmJitSetCodeAddr(const u2* dPC, void *nPC, JitInstructionSetType set,
 158                        bool isMethodEntry, int profilePrefixSize);
 159 void dvmJitEndTraceSelect(Thread* self, const u2* dPC);
 160 JitTraceCounter_t *dvmJitNextTraceCounter(void);
 161 void dvmJitTraceProfilingOff(void);
 162 void dvmJitTraceProfilingOn(void);
 163 void dvmJitChangeProfileMode(TraceProfilingModes newState);
 164 void dvmJitDumpTraceDesc(JitTraceDescription *trace);
 165 void dvmJitUpdateThreadStateSingle(Thread* threead);
 166 void dvmJitUpdateThreadStateAll(void);
 167 void dvmJitResumeTranslation(Thread* self, const u2* pc, const u4* fp);
 168
 169 #endif /*_DALVIK_INTERP_JIT*/