dalvik/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_H_
  20 #define DALVIK_INTERP_JIT_H_
  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 struct ShadowHeap {
  33     int addr;
  34     int data;
  35 };
  36
  37 struct InstructionTrace {
  38     int addr;
  39     DecodedInstruction decInsn;
  40 };
  41
  42 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 };
  61
  62 /*
  63  * Self verification functions.
  64  */
  65 extern "C" {
  66 void* dvmSelfVerificationShadowSpaceAlloc(Thread* self);
  67 void dvmSelfVerificationShadowSpaceFree(Thread* self);
  68 void* dvmSelfVerificationSaveState(const u2* pc, u4* fp,
  69                                    Thread* self,
  70                                    int targetTrace);
  71 void* dvmSelfVerificationRestoreState(const u2* pc, u4* fp,
  72                                       SelfVerificationState exitPoint,
  73                                       Thread *self);
  74 void dvmCheckSelfVerification(const u2* pc, Thread* self);
  75 }
  76 #endif
  77
  78 /*
  79  * Offsets for metadata in the trace run array from the trace that ends with
  80  * invoke instructions.
  81  */
  82 #define JIT_TRACE_CLASS_DESC    1
  83 #define JIT_TRACE_CLASS_LOADER  2
  84 #define JIT_TRACE_CUR_METHOD    3
  85
  86 /*
  87  * JitTable hash function.
  88  */
  89
  90 static inline u4 dvmJitHashMask( const u2* p, u4 mask ) {
  91     return ((((u4)p>>12)^(u4)p)>>1) & (mask);
  92 }
  93
  94 static inline u4 dvmJitHash( const u2* p ) {
  95     return dvmJitHashMask( p, gDvmJit.jitTableMask );
  96 }
  97
  98 /*
  99  * The width of the chain field in JitEntryInfo sets the upper
 100  * bound on the number of translations.  Be careful if changing
 101  * the size of JitEntry struct - the Dalvik PC to JitEntry
 102  * hash functions have built-in knowledge of the size.
 103  */
 104 #define JIT_ENTRY_CHAIN_WIDTH 2
 105 #define JIT_MAX_ENTRIES (1 << (JIT_ENTRY_CHAIN_WIDTH * 8))
 106
 107 /*
 108  * The trace profiling counters are allocated in blocks and individual
 109  * counters must not move so long as any referencing trace exists.
 110  */
 111 #define JIT_PROF_BLOCK_ENTRIES 1024
 112 #define JIT_PROF_BLOCK_BUCKETS (JIT_MAX_ENTRIES / JIT_PROF_BLOCK_ENTRIES)
 113
 114 typedef s4 JitTraceCounter_t;
 115
 116 struct JitTraceProfCounters {
 117     unsigned int           next;
 118     JitTraceCounter_t      *buckets[JIT_PROF_BLOCK_BUCKETS];
 119 };
 120
 121 /*
 122  * Entries in the JIT's address lookup hash table.
 123  * Fields which may be updated by multiple threads packed into a
 124  * single 32-bit word to allow use of atomic update.
 125  */
 126
 127 struct JitEntryInfo {
 128     unsigned int           isMethodEntry:1;
 129     unsigned int           inlineCandidate:1;
 130     unsigned int           profileEnabled:1;
 131     JitInstructionSetType  instructionSet:3;
 132     unsigned int           profileOffset:5;
 133     unsigned int           unused:5;
 134     u2                     chain;                 /* Index of next in chain */
 135 };
 136
 137 union JitEntryInfoUnion {
 138     JitEntryInfo info;
 139     volatile int infoWord;
 140 };
 141
 142 struct JitEntry {
 143     JitEntryInfoUnion   u;
 144     const u2*           dPC;            /* Dalvik code address */
 145     void*               codeAddress;    /* Code address of native translation */
 146 };
 147
 148 extern "C" {
 149 void dvmCheckJit(const u2* pc, Thread* self);
 150 void* dvmJitGetTraceAddr(const u2* dPC);
 151 void* dvmJitGetMethodAddr(const u2* dPC);
 152 void* dvmJitGetTraceAddrThread(const u2* dPC, Thread* self);
 153 void* dvmJitGetMethodAddrThread(const u2* dPC, Thread* self);
 154 void dvmJitCheckTraceRequest(Thread* self);
 155 void dvmJitStopTranslationRequests(void);
 156 #if defined(WITH_JIT_TUNING)
 157 void dvmBumpNoChain(int from);
 158 void dvmBumpNormal(void);
 159 void dvmBumpPunt(int from);
 160 #endif
 161 void dvmJitStats(void);
 162 bool dvmJitResizeJitTable(unsigned int size);
 163 void dvmJitResetTable(void);
 164 JitEntry *dvmJitFindEntry(const u2* pc, bool isMethodEntry);
 165 s8 dvmJitd2l(double d);
 166 s8 dvmJitf2l(float f);
 167 void dvmJitSetCodeAddr(const u2* dPC, void *nPC, JitInstructionSetType set,
 168                        bool isMethodEntry, int profilePrefixSize);
 169 void dvmJitEndTraceSelect(Thread* self, const u2* dPC);
 170 JitTraceCounter_t *dvmJitNextTraceCounter(void);
 171 void dvmJitTraceProfilingOff(void);
 172 void dvmJitTraceProfilingOn(void);
 173 void dvmJitChangeProfileMode(TraceProfilingModes newState);
 174 void dvmJitDumpTraceDesc(JitTraceDescription *trace);
 175 void dvmJitUpdateThreadStateSingle(Thread* threead);
 176 void dvmJitUpdateThreadStateAll(void);
 177 void dvmJitResumeTranslation(Thread* self, const u2* pc, const u4* fp);
 178 }
 179
 180 #endif  // DALVIK_INTERP_JIT_H_