Compiler.h revision dca714364abf3111fc18c1ac49c2760392fb7c9b 
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#include <Thread.h>
18#include <setjmp.h>
19
20#ifndef _DALVIK_VM_COMPILER
21#define _DALVIK_VM_COMPILER
22
23/*
24 * Uncomment the following to enable JIT signature breakpoint
25 * #define SIGNATURE_BREAKPOINT
26 */
27
28#define MAX_JIT_RUN_LEN                 64
29#define COMPILER_WORK_QUEUE_SIZE        100
30#define COMPILER_IC_PATCH_QUEUE_SIZE    64
31
32#define COMPILER_TRACED(X)
33#define COMPILER_TRACEE(X)
34#define COMPILER_TRACE_CHAINING(X)
35
36typedef enum JitInstructionSetType {
37    DALVIK_JIT_NONE = 0,
38    DALVIK_JIT_ARM,
39    DALVIK_JIT_THUMB,
40    DALVIK_JIT_THUMB2,
41    DALVIK_JIT_THUMB2EE,
42    DALVIK_JIT_X86
43} JitInstructionSetType;
44
45/* Description of a compiled trace. */
46typedef struct JitTranslationInfo {
47    void *codeAddress;
48    JitInstructionSetType instructionSet;
49    bool discardResult;         // Used for debugging divergence and IC patching
50    Thread *requestingThread;   // For debugging purpose
51} JitTranslationInfo;
52
53typedef enum WorkOrderKind {
54    kWorkOrderInvalid = 0,      // Should never see by the backend
55    kWorkOrderMethod = 1,       // Work is to compile a whole method
56    kWorkOrderTrace = 2,        // Work is to compile code fragment(s)
57    kWorkOrderTraceDebug = 3,   // Work is to compile/debug code fragment(s)
58} WorkOrderKind;
59
60typedef struct CompilerWorkOrder {
61    const u2* pc;
62    WorkOrderKind kind;
63    void* info;
64    JitTranslationInfo result;
65    jmp_buf *bailPtr;
66} CompilerWorkOrder;
67
68/* Chain cell for predicted method invocation */
69typedef struct PredictedChainingCell {
70    u4 branch;                  /* Branch to chained destination */
71    const ClassObject *clazz;   /* key #1 for prediction */
72    const Method *method;       /* key #2 to lookup native PC from dalvik PC */
73    u4 counter;                 /* counter to patch the chaining cell */
74} PredictedChainingCell;
75
76/* Work order for inline cache patching */
77typedef struct ICPatchWorkOrder {
78    PredictedChainingCell *cellAddr;    /* Address to be patched */
79    PredictedChainingCell cellContent;  /* content of the new cell */
80} ICPatchWorkOrder;
81
82typedef enum JitState {
83    kJitOff = 0,
84    kJitNormal = 1,            // Profiling in mterp or running native
85    kJitTSelectRequest = 2,    // Transition state - start trace selection
86    kJitTSelectRequestHot = 3, // Transition state - start hot trace selection
87    kJitTSelect = 4,           // Actively selecting trace in dbg interp
88    kJitTSelectAbort = 5,      // Something threw during selection - abort
89    kJitTSelectEnd = 6,        // Done with the trace - wrap it up
90    kJitSingleStep = 7,        // Single step interpretation
91    kJitSingleStepEnd = 8,     // Done with single step, return to mterp
92    kJitSelfVerification = 9,  // Self Verification Mode
93} JitState;
94
95#if defined(WITH_SELF_VERIFICATION)
96typedef enum SelfVerificationState {
97    kSVSIdle = 0,           // Idle
98    kSVSStart = 1,          // Shadow space set up, running compiled code
99    kSVSPunt = 2,           // Exiting compiled code by punting
100    kSVSSingleStep = 3,     // Exiting compiled code by single stepping
101    kSVSTraceSelectNoChain = 4,// Exiting compiled code by trace select no chain
102    kSVSTraceSelect = 5,    // Exiting compiled code by trace select
103    kSVSNormal = 6,         // Exiting compiled code normally
104    kSVSNoChain = 7,        // Exiting compiled code by no chain
105    kSVSBackwardBranch = 8, // Exiting compiled code with backward branch trace
106    kSVSDebugInterp = 9,    // Normal state restored, running debug interpreter
107} SelfVerificationState;
108#endif
109
110typedef enum JitHint {
111   kJitHintNone = 0,
112   kJitHintTaken = 1,         // Last inst in run was taken branch
113   kJitHintNotTaken = 2,      // Last inst in run was not taken branch
114   kJitHintNoBias = 3,        // Last inst in run was unbiased branch
115} jitHint;
116
117/*
118 * Element of a Jit trace description.  Describes a contiguous
119 * sequence of Dalvik byte codes, the last of which can be
120 * associated with a hint.
121 * Dalvik byte code
122 */
123typedef struct {
124    u2    startOffset;       // Starting offset for trace run
125    unsigned numInsts:8;     // Number of Byte codes in run
126    unsigned runEnd:1;       // Run ends with last byte code
127    jitHint  hint:7;         // Hint to apply to final code of run
128} JitCodeDesc;
129
130typedef union {
131    JitCodeDesc frag;
132    void*       hint;
133} JitTraceRun;
134
135/*
136 * Trace description as will appear in the translation cache.  Note
137 * flexible array at end, as these will be of variable size.  To
138 * conserve space in the translation cache, total length of JitTraceRun
139 * array must be recomputed via seqential scan if needed.
140 */
141typedef struct {
142    const Method* method;
143    JitTraceRun trace[];
144} JitTraceDescription;
145
146typedef struct CompilerMethodStats {
147    const Method *method;       // Used as hash entry signature
148    int dalvikSize;             // # of bytes for dalvik bytecodes
149    int compiledDalvikSize;     // # of compiled dalvik bytecodes
150    int nativeSize;             // # of bytes for produced native code
151} CompilerMethodStats;
152
153bool dvmCompilerSetupCodeCache(void);
154bool dvmCompilerArchInit(void);
155void dvmCompilerArchDump(void);
156bool dvmCompilerStartup(void);
157void dvmCompilerShutdown(void);
158bool dvmCompilerWorkEnqueue(const u2* pc, WorkOrderKind kind, void* info);
159void *dvmCheckCodeCache(void *method);
160bool dvmCompileMethod(const Method *method, JitTranslationInfo *info);
161bool dvmCompileTrace(JitTraceDescription *trace, int numMaxInsts,
162                     JitTranslationInfo *info, jmp_buf *bailPtr);
163void dvmCompilerDumpStats(void);
164void dvmCompilerDrainQueue(void);
165void dvmJitUnchainAll(void);
166void dvmCompilerSortAndPrintTraceProfiles(void);
167
168struct CompilationUnit;
169struct BasicBlock;
170struct SSARepresentation;
171struct GrowableList;
172struct JitEntry;
173
174void dvmInitializeSSAConversion(struct CompilationUnit *cUnit);
175int dvmConvertSSARegToDalvik(struct CompilationUnit *cUnit, int ssaReg);
176void dvmCompilerLoopOpt(struct CompilationUnit *cUnit);
177void dvmCompilerNonLoopAnalysis(struct CompilationUnit *cUnit);
178void dvmCompilerFindLiveIn(struct CompilationUnit *cUnit,
179                           struct BasicBlock *bb);
180void dvmCompilerDoSSAConversion(struct CompilationUnit *cUnit,
181                                struct BasicBlock *bb);
182void dvmCompilerDoConstantPropagation(struct CompilationUnit *cUnit,
183                                      struct BasicBlock *bb);
184void dvmCompilerFindInductionVariables(struct CompilationUnit *cUnit,
185                                       struct BasicBlock *bb);
186char *dvmCompilerGetDalvikDisassembly(DecodedInstruction *insn);
187char *dvmCompilerGetSSAString(struct CompilationUnit *cUnit,
188                              struct SSARepresentation *ssaRep);
189void dvmCompilerDataFlowAnalysisDispatcher(struct CompilationUnit *cUnit,
190                void (*func)(struct CompilationUnit *, struct BasicBlock *));
191void dvmCompilerStateRefresh(void);
192JitTraceDescription *dvmCopyTraceDescriptor(const u2 *pc,
193                                            const struct JitEntry *desc);
194#endif /* _DALVIK_VM_COMPILER */
195