/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* Dalvik interpreter definitions. These are internal to the interpreter.
*
* This includes defines, types, function declarations, and inline functions
* that are common to all interpreter implementations.
*
* Functions and globals declared here are defined in Interp.c.
*/
#ifndef DALVIK_INTERP_STATE_H_
#define DALVIK_INTERP_STATE_H_
/*
* For x86 JIT. In the lowered code sequences for bytecodes, at most 10
* temporary variables may be live at the same time. Therefore, at most
* 10 temporary variables can be spilled at the same time.
*/
#define MAX_SPILL_JIT_IA 10
/*
* Execution mode, e.g. interpreter vs. JIT.
*/
enum ExecutionMode {
kExecutionModeUnknown = 0,
kExecutionModeInterpPortable,
kExecutionModeInterpFast,
#if defined(WITH_JIT)
kExecutionModeJit,
#endif
#if defined(WITH_JIT) /* IA only */
kExecutionModeNcgO0,
kExecutionModeNcgO1,
#endif
};
/*
* Execution sub modes, e.g. debugging, profiling, etc.
* Treated as bit flags for fast access. These values are used directly
* by assembly code in the mterp interpeter and may also be used by
* code generated by the JIT. Take care when changing.
*/
enum ExecutionSubModes {
kSubModeNormal = 0x0000, /* No active subMode */
kSubModeMethodTrace = 0x0001,
kSubModeEmulatorTrace = 0x0002,
kSubModeInstCounting = 0x0004,
kSubModeDebuggerActive = 0x0008,
kSubModeSuspendPending = 0x0010,
kSubModeCallbackPending = 0x0020,
kSubModeCountedStep = 0x0040,
kSubModeCheckAlways = 0x0080,
kSubModeJitTraceBuild = 0x4000,
kSubModeJitSV = 0x8000,
kSubModeDebugProfile = (kSubModeMethodTrace |
kSubModeEmulatorTrace |
kSubModeInstCounting |
kSubModeDebuggerActive)
};
/*
* Interpreter break flags. When set, causes the interpreter to
* break from normal execution and invoke the associated callback
* handler.
*/
enum InterpBreakFlags {
kInterpNoBreak = 0x00, /* Don't check */
kInterpSingleStep = 0x01, /* Check between each inst */
kInterpSafePoint = 0x02, /* Check at safe points */
};
/*
* Mapping between subModes and required check intervals. Note: in
* the future we might want to make this mapping target-dependent.
*/
#define SINGLESTEP_BREAK_MASK ( kSubModeInstCounting | \
kSubModeDebuggerActive | \
kSubModeCountedStep | \
kSubModeCheckAlways | \
kSubModeJitSV | \
kSubModeJitTraceBuild )
#define SAFEPOINT_BREAK_MASK ( kSubModeSuspendPending | \
kSubModeCallbackPending )
typedef bool (*SafePointCallback)(struct Thread* thread, void* arg);
/*
* Identify which break and submode flags should be local
* to an interpreter activation.
*/
#define LOCAL_SUBMODE (kSubModeJitTraceBuild)
struct InterpSaveState {
const u2* pc; // Dalvik PC
u4* curFrame; // Dalvik frame pointer
const Method *method; // Method being executed
DvmDex* methodClassDex;
JValue retval;
void* bailPtr;
#if defined(WITH_TRACKREF_CHECKS)
int debugTrackedRefStart;
#else
int unused; // Keep struct size constant
#endif
struct InterpSaveState* prev; // To follow nested activations
} __attribute__ ((__packed__));
#ifdef WITH_JIT
/*
* NOTE: Only entry points dispatched via [self + #offset] are put
* in this struct, and there are six of them:
* 1) dvmJitToInterpNormal: find if there is a corresponding compilation for
* the new dalvik PC. If so, chain the originating compilation with the
* target then jump to it. If the destination trace doesn't exist, update
* the profile count for that Dalvik PC.
* 2) dvmJitToInterpNoChain: similar to dvmJitToInterpNormal but chaining is
* not performed.
* 3) dvmJitToInterpPunt: use the fast interpreter to execute the next
* instruction(s) and stay there as long as it is appropriate to return
* to the compiled land. This is used when the jit'ed code is about to
* throw an exception.
* 4) dvmJitToInterpSingleStep: use the portable interpreter to execute the
* next instruction only and return to pre-specified location in the
* compiled code to resume execution. This is mainly used as debugging
* feature to bypass problematic opcode implementations without
* disturbing the trace formation.
* 5) dvmJitToTraceSelect: Similar to dvmJitToInterpNormal except for the
* profiling operation. If the new Dalvik PC is dominated by an already
* translated trace, directly request a new translation if the destinaion
* trace doesn't exist.
* 6) dvmJitToBackwardBranch: special case for SELF_VERIFICATION when the
* destination Dalvik PC is included by the trace itself.
*/
struct JitToInterpEntries {
void (*dvmJitToInterpNormal)(void);
void (*dvmJitToInterpNoChain)(void);
void (*dvmJitToInterpPunt)(void);
void (*dvmJitToInterpSingleStep)(void);
void (*dvmJitToInterpTraceSelect)(void);
#if defined(WITH_SELF_VERIFICATION)
void (*dvmJitToInterpBackwardBranch)(void);
#else
void (*unused)(void); // Keep structure size constant
#endif
};
/* States of the interpreter when serving a JIT-related request */
enum JitState {
/* Entering states in the debug interpreter */
kJitNot = 0, // Non-JIT related reasons */
kJitTSelectRequest = 1, // Request a trace (subject to filtering)
kJitTSelectRequestHot = 2, // Request a hot trace (bypass the filter)
kJitSelfVerification = 3, // Self Verification Mode
/* Operational states in the debug interpreter */
kJitTSelect = 4, // Actively selecting a trace
kJitTSelectEnd = 5, // Done with the trace - wrap it up
kJitDone = 6, // No further JIT actions for interpBreak
};
#if defined(WITH_SELF_VERIFICATION)
enum SelfVerificationState {
kSVSIdle = 0, // Idle
kSVSStart = 1, // Shadow space set up, running compiled code
kSVSPunt = 2, // Exiting compiled code by punting
kSVSSingleStep = 3, // Exiting compiled code by single stepping
kSVSNoProfile = 4, // Exiting compiled code and don't collect profiles
kSVSTraceSelect = 5, // Exiting compiled code and compile the next pc
kSVSNormal = 6, // Exiting compiled code normally
kSVSNoChain = 7, // Exiting compiled code by no chain
kSVSBackwardBranch = 8, // Exiting compiled code with backward branch trace
kSVSDebugInterp = 9, // Normal state restored, running debug interpreter
};
#endif
/* Number of entries in the 2nd level JIT profiler filter cache */
#define JIT_TRACE_THRESH_FILTER_SIZE 32
/* Number of low dalvik pc address bits to include in 2nd level filter key */
#define JIT_TRACE_THRESH_FILTER_PC_BITS 4
#define MAX_JIT_RUN_LEN 64
enum JitHint {
kJitHintNone = 0,
kJitHintTaken = 1, // Last inst in run was taken branch
kJitHintNotTaken = 2, // Last inst in run was not taken branch
kJitHintNoBias = 3, // Last inst in run was unbiased branch
};
/*
* Element of a Jit trace description. If the isCode bit is set, it describes
* a contiguous sequence of Dalvik byte codes.
*/
struct JitCodeDesc {
unsigned numInsts:8; // Number of Byte codes in run
unsigned runEnd:1; // Run ends with last byte code
JitHint hint:7; // Hint to apply to final code of run
u2 startOffset; // Starting offset for trace run
};
/*
* A complete list of trace runs passed to the compiler looks like the
* following:
* frag1
* frag2
* frag3
* meta1
* :
* metan
* frag4
*
* frags 1-4 have the "isCode" field set and describe the location/length of
* real code traces, while metas 1-n are misc information.
* The meaning of the meta content is loosely defined. It is usually the code
* fragment right before the first meta field (frag3 in this case) to
* understand and parse them. Frag4 could be a dummy one with 0 "numInsts" but
* the "runEnd" field set.
*
* For example, if a trace run contains a method inlining target, the class
* descriptor/loader of "this" and the currently resolved method pointer are
* three instances of meta information stored there.
*/
struct JitTraceRun {
union {
JitCodeDesc frag;
void* meta;
} info;
u4 isCode:1;
u4 unused:31;
};
#if defined(ARCH_IA32)
/*
* JIT code genarator optimization level
*/
enum JitOptLevel {
kJitOptLevelO0 = 0,
kJitOptLevelO1 = 1,
};
#endif // #if defined(ARCH_IA32)
#endif
#endif // DALVIK_INTERP_STATE_H_