blob: 29f7356addc5ff5abadea8c2ff818a62a3147b39 [file] [log] [blame]
* Copyright (C) 2008 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
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* See the License for the specific language governing permissions and
* limitations under the License.
* Variables with library scope.
* Prefer this over scattered static and global variables -- it's easier to
* view the state in a debugger, it makes clean shutdown simpler, we can
* trivially dump the state into a crash log, and it dodges most naming
* collisions that will arise when we are embedded in a larger program.
* If we want multiple VMs per process, this can get stuffed into TLS (or
* accessed through a Thread field). May need to pass it around for some
* of the early initialization functions.
#include <string>
#include <vector>
#include <stdarg.h>
#include <pthread.h>
/* private structures */
struct GcHeap;
struct BreakpointSet;
struct InlineSub;
* One of these for each -ea/-da/-esa/-dsa on the command line.
struct AssertionControl {
char* pkgOrClass; /* package/class string, or NULL for esa/dsa */
int pkgOrClassLen; /* string length, for quick compare */
bool enable; /* enable or disable */
bool isPackage; /* string ended with "..."? */
* Register map generation mode. Only applicable when generateRegisterMaps
* is enabled. (The "disabled" state is not folded into this because
* there are callers like dexopt that want to enable/disable without
* specifying the configuration details.)
* "TypePrecise" is slower and requires additional storage for the register
* maps, but allows type-precise GC. "LivePrecise" is even slower and
* requires additional heap during processing, but allows live-precise GC.
enum RegisterMapMode {
kRegisterMapModeUnknown = 0,
* Profiler clock source.
enum ProfilerClockSource {
* All fields are initialized to zero.
* Storage allocated here must be freed by a subsystem shutdown function.
struct DvmGlobals {
* Some options from the command line or environment.
char* bootClassPathStr;
char* classPathStr;
size_t heapStartingSize;
size_t heapMaximumSize;
size_t heapGrowthLimit;
bool lowMemoryMode;
double heapTargetUtilization;
size_t heapMinFree;
size_t heapMaxFree;
size_t stackSize;
size_t mainThreadStackSize;
bool verboseGc;
bool verboseJni;
bool verboseClass;
bool verboseShutdown;
bool jdwpAllowed; // debugging allowed for this process?
bool jdwpConfigured; // has debugging info been provided?
JdwpTransportType jdwpTransport;
bool jdwpServer;
char* jdwpHost;
int jdwpPort;
bool jdwpSuspend;
ProfilerClockSource profilerClockSource;
* Lock profiling threshold value in milliseconds. Acquires that
* exceed threshold are logged. Acquires within the threshold are
* logged with a probability of $\frac{time}{threshold}$ . If the
* threshold is unset no additional logging occurs.
u4 lockProfThreshold;
int (*vfprintfHook)(FILE*, const char*, va_list);
void (*exitHook)(int);
void (*abortHook)(void);
bool (*isSensitiveThreadHook)(void);
char* jniTrace;
bool reduceSignals;
bool noQuitHandler;
bool verifyDexChecksum;
char* stackTraceFile; // for SIGQUIT-inspired output
bool logStdio;
DexOptimizerMode dexOptMode;
DexClassVerifyMode classVerifyMode;
bool generateRegisterMaps;
RegisterMapMode registerMapMode;
bool monitorVerification;
bool dexOptForSmp;
* GC option flags.
bool preciseGc;
bool preVerify;
bool postVerify;
bool concurrentMarkSweep;
bool verifyCardTable;
bool disableExplicitGc;
int assertionCtrlCount;
AssertionControl* assertionCtrl;
ExecutionMode executionMode;
bool commonInit; /* whether common stubs are generated */
bool constInit; /* whether global constants are initialized */
* VM init management.
bool initializing;
bool optimizing;
* java.lang.System properties set from the command line with -D.
* This is effectively a set, where later entries override earlier
* ones.
std::vector<std::string>* properties;
* Where the VM goes to find system classes.
ClassPathEntry* bootClassPath;
/* used by the DEX optimizer to load classes from an unfinished DEX */
DvmDex* bootClassPathOptExtra;
bool optimizingBootstrapClass;
* Loaded classes, hashed by class name. Each entry is a ClassObject*,
* allocated in GC space.
HashTable* loadedClasses;
* Value for the next class serial number to be assigned. This is
* incremented as we load classes. Failed loads and races may result
* in some numbers being skipped, and the serial number is not
* guaranteed to start at 1, so the current value should not be used
* as a count of loaded classes.
volatile int classSerialNumber;
* Classes with a low classSerialNumber are probably in the zygote, and
* their InitiatingLoaderList is not used, to promote sharing. The list is
* kept here instead.
InitiatingLoaderList* initiatingLoaderList;
* Interned strings.
/* A mutex that guards access to the interned string tables. */
pthread_mutex_t internLock;
/* Hash table of strings interned by the user. */
HashTable* internedStrings;
/* Hash table of strings interned by the class loader. */
HashTable* literalStrings;
* Classes constructed directly by the vm.
/* the class Class */
ClassObject* classJavaLangClass;
/* synthetic classes representing primitive types */
ClassObject* typeVoid;
ClassObject* typeBoolean;
ClassObject* typeByte;
ClassObject* typeShort;
ClassObject* typeChar;
ClassObject* typeInt;
ClassObject* typeLong;
ClassObject* typeFloat;
ClassObject* typeDouble;
/* synthetic classes for arrays of primitives */
ClassObject* classArrayBoolean;
ClassObject* classArrayByte;
ClassObject* classArrayShort;
ClassObject* classArrayChar;
ClassObject* classArrayInt;
ClassObject* classArrayLong;
ClassObject* classArrayFloat;
ClassObject* classArrayDouble;
* Quick lookups for popular classes used internally.
ClassObject* classJavaLangClassArray;
ClassObject* classJavaLangClassLoader;
ClassObject* classJavaLangObject;
ClassObject* classJavaLangObjectArray;
ClassObject* classJavaLangString;
ClassObject* classJavaLangThread;
ClassObject* classJavaLangVMThread;
ClassObject* classJavaLangThreadGroup;
ClassObject* classJavaLangStackTraceElement;
ClassObject* classJavaLangStackTraceElementArray;
ClassObject* classJavaLangAnnotationAnnotationArray;
ClassObject* classJavaLangAnnotationAnnotationArrayArray;
ClassObject* classJavaLangReflectAccessibleObject;
ClassObject* classJavaLangReflectConstructor;
ClassObject* classJavaLangReflectConstructorArray;
ClassObject* classJavaLangReflectField;
ClassObject* classJavaLangReflectFieldArray;
ClassObject* classJavaLangReflectMethod;
ClassObject* classJavaLangReflectMethodArray;
ClassObject* classJavaLangReflectProxy;
ClassObject* classJavaLangSystem;
ClassObject* classJavaNioDirectByteBuffer;
ClassObject* classLibcoreReflectAnnotationFactory;
ClassObject* classLibcoreReflectAnnotationMember;
ClassObject* classLibcoreReflectAnnotationMemberArray;
ClassObject* classOrgApacheHarmonyDalvikDdmcChunk;
ClassObject* classOrgApacheHarmonyDalvikDdmcDdmServer;
ClassObject* classJavaLangRefFinalizerReference;
* classes representing exception types. The names here don't include
* packages, just to keep the use sites a bit less verbose. All are
* in java.lang, except where noted.
ClassObject* exAbstractMethodError;
ClassObject* exArithmeticException;
ClassObject* exArrayIndexOutOfBoundsException;
ClassObject* exArrayStoreException;
ClassObject* exClassCastException;
ClassObject* exClassCircularityError;
ClassObject* exClassFormatError;
ClassObject* exClassNotFoundException;
ClassObject* exError;
ClassObject* exExceptionInInitializerError;
ClassObject* exFileNotFoundException; /* in */
ClassObject* exIOException; /* in */
ClassObject* exIllegalAccessError;
ClassObject* exIllegalAccessException;
ClassObject* exIllegalArgumentException;
ClassObject* exIllegalMonitorStateException;
ClassObject* exIllegalStateException;
ClassObject* exIllegalThreadStateException;
ClassObject* exIncompatibleClassChangeError;
ClassObject* exInstantiationError;
ClassObject* exInstantiationException;
ClassObject* exInternalError;
ClassObject* exInterruptedException;
ClassObject* exLinkageError;
ClassObject* exNegativeArraySizeException;
ClassObject* exNoClassDefFoundError;
ClassObject* exNoSuchFieldError;
ClassObject* exNoSuchFieldException;
ClassObject* exNoSuchMethodError;
ClassObject* exNullPointerException;
ClassObject* exOutOfMemoryError;
ClassObject* exRuntimeException;
ClassObject* exStackOverflowError;
ClassObject* exStaleDexCacheError; /* in dalvik.system */
ClassObject* exStringIndexOutOfBoundsException;
ClassObject* exThrowable;
ClassObject* exTypeNotPresentException;
ClassObject* exUnsatisfiedLinkError;
ClassObject* exUnsupportedOperationException;
ClassObject* exVerifyError;
ClassObject* exVirtualMachineError;
/* method offsets - Object */
int voffJavaLangObject_equals;
int voffJavaLangObject_hashCode;
int voffJavaLangObject_toString;
/* field offsets - String */
int offJavaLangString_value;
int offJavaLangString_count;
int offJavaLangString_offset;
int offJavaLangString_hashCode;
/* field offsets - Thread */
int offJavaLangThread_vmThread;
int offJavaLangThread_group;
int offJavaLangThread_daemon;
int offJavaLangThread_name;
int offJavaLangThread_priority;
int offJavaLangThread_uncaughtHandler;
int offJavaLangThread_contextClassLoader;
/* method offsets - Thread */
int voffJavaLangThread_run;
/* field offsets - ThreadGroup */
int offJavaLangThreadGroup_name;
int offJavaLangThreadGroup_parent;
/* field offsets - VMThread */
int offJavaLangVMThread_thread;
int offJavaLangVMThread_vmData;
/* method offsets - ThreadGroup */
int voffJavaLangThreadGroup_removeThread;
/* field offsets - Throwable */
int offJavaLangThrowable_stackState;
int offJavaLangThrowable_cause;
/* method offsets - ClassLoader */
int voffJavaLangClassLoader_loadClass;
/* direct method pointers - ClassLoader */
Method* methJavaLangClassLoader_getSystemClassLoader;
/* field offsets - java.lang.reflect.* */
int offJavaLangReflectConstructor_slot;
int offJavaLangReflectConstructor_declClass;
int offJavaLangReflectField_slot;
int offJavaLangReflectField_declClass;
int offJavaLangReflectMethod_slot;
int offJavaLangReflectMethod_declClass;
/* field offsets - java.lang.ref.Reference */
int offJavaLangRefReference_referent;
int offJavaLangRefReference_queue;
int offJavaLangRefReference_queueNext;
int offJavaLangRefReference_pendingNext;
/* field offsets - java.lang.ref.FinalizerReference */
int offJavaLangRefFinalizerReference_zombie;
/* method pointers - java.lang.ref.ReferenceQueue */
Method* methJavaLangRefReferenceQueueAdd;
/* method pointers - java.lang.ref.FinalizerReference */
Method* methJavaLangRefFinalizerReferenceAdd;
/* constructor method pointers; no vtable involved, so use Method* */
Method* methJavaLangStackTraceElement_init;
Method* methJavaLangReflectConstructor_init;
Method* methJavaLangReflectField_init;
Method* methJavaLangReflectMethod_init;
Method* methOrgApacheHarmonyLangAnnotationAnnotationMember_init;
/* static method pointers - android.lang.annotation.* */
/* direct method pointers - java.lang.reflect.Proxy */
Method* methJavaLangReflectProxy_constructorPrototype;
/* field offsets - java.lang.reflect.Proxy */
int offJavaLangReflectProxy_h;
/* direct method pointer - java.lang.System.runFinalization */
Method* methJavaLangSystem_runFinalization;
/* field offsets - */
int offJavaIoFileDescriptor_descriptor;
/* direct method pointers - dalvik.system.NativeStart */
Method* methDalvikSystemNativeStart_main;
Method* methDalvikSystemNativeStart_run;
/* assorted direct buffer helpers */
Method* methJavaNioDirectByteBuffer_init;
int offJavaNioBuffer_capacity;
int offJavaNioBuffer_effectiveDirectAddress;
/* direct method pointers - org.apache.harmony.dalvik.ddmc.DdmServer */
Method* methDalvikDdmcServer_dispatch;
Method* methDalvikDdmcServer_broadcast;
/* field offsets - org.apache.harmony.dalvik.ddmc.Chunk */
int offDalvikDdmcChunk_type;
int offDalvikDdmcChunk_data;
int offDalvikDdmcChunk_offset;
int offDalvikDdmcChunk_length;
* Thread list. This always has at least one element in it (main),
* and main is always the first entry.
* The threadListLock is used for several things, including the thread
* start condition variable. Generally speaking, you must hold the
* threadListLock when:
* - adding/removing items from the list
* - waiting on or signaling threadStartCond
* - examining the Thread struct for another thread (this is to avoid
* one thread freeing the Thread struct while another thread is
* perusing it)
Thread* threadList;
pthread_mutex_t threadListLock;
pthread_cond_t threadStartCond;
* The thread code grabs this before suspending all threads. There
* are a few things that can cause a "suspend all":
* (1) the GC is starting;
* (2) the debugger has sent a "suspend all" request;
* (3) a thread has hit a breakpoint or exception that the debugger
* has marked as a "suspend all" event;
* (4) the SignalCatcher caught a signal that requires suspension.
* (5) (if implemented) the JIT needs to perform a heavyweight
* rearrangement of the translation cache or JitTable.
* Because we use "safe point" self-suspension, it is never safe to
* do a blocking "lock" call on this mutex -- if it has been acquired,
* somebody is probably trying to put you to sleep. The leading '_' is
* intended as a reminder that this lock is special.
pthread_mutex_t _threadSuspendLock;
* Guards Thread->suspendCount for all threads, and
* provides the lock for the condition variable that all suspended threads
* sleep on (threadSuspendCountCond).
* This has to be separate from threadListLock because of the way
* threads put themselves to sleep.
pthread_mutex_t threadSuspendCountLock;
* Suspended threads sleep on this. They should sleep on the condition
* variable until their "suspend count" is zero.
* Paired with "threadSuspendCountLock".
pthread_cond_t threadSuspendCountCond;
* Sum of all threads' suspendCount fields. Guarded by
* threadSuspendCountLock.
int sumThreadSuspendCount;
* MUTEX ORDERING: when locking multiple mutexes, always grab them in
* this order to avoid deadlock:
* (1) _threadSuspendLock (use lockThreadSuspend())
* (2) threadListLock (use dvmLockThreadList())
* (3) threadSuspendCountLock (use lockThreadSuspendCount())
* Thread ID bitmap. We want threads to have small integer IDs so
* we can use them in "thin locks".
BitVector* threadIdMap;
* Manage exit conditions. The VM exits when all non-daemon threads
* have exited. If the main thread returns early, we need to sleep
* on a condition variable.
int nonDaemonThreadCount; /* must hold threadListLock to access */
pthread_cond_t vmExitCond;
* The set of DEX files loaded by custom class loaders.
HashTable* userDexFiles;
* JNI global reference table.
IndirectRefTable jniGlobalRefTable;
IndirectRefTable jniWeakGlobalRefTable;
pthread_mutex_t jniGlobalRefLock;
pthread_mutex_t jniWeakGlobalRefLock;
* JNI pinned object table (used for primitive arrays).
ReferenceTable jniPinRefTable;
pthread_mutex_t jniPinRefLock;
* Native shared library table.
HashTable* nativeLibs;
* GC heap lock. Functions like gcMalloc() acquire this before making
* any changes to the heap. It is held throughout garbage collection.
pthread_mutex_t gcHeapLock;
* Condition variable to queue threads waiting to retry an
* allocation. Signaled after a concurrent GC is completed.
pthread_cond_t gcHeapCond;
/* Opaque pointer representing the heap. */
GcHeap* gcHeap;
/* The card table base, modified as needed for marking cards. */
u1* biasedCardTableBase;
* Pre-allocated throwables.
Object* outOfMemoryObj;
Object* internalErrorObj;
Object* noClassDefFoundErrorObj;
/* Monitor list, so we can free them */
/*volatile*/ Monitor* monitorList;
/* Monitor for Thread.sleep() implementation */
Monitor* threadSleepMon;
/* set when we create a second heap inside the zygote */
bool newZygoteHeapAllocated;
* TLS keys.
pthread_key_t pthreadKeySelf; /* Thread*, for dvmThreadSelf */
* Cache results of "A instanceof B".
AtomicCache* instanceofCache;
/* inline substitution table, used during optimization */
InlineSub* inlineSubs;
* Bootstrap class loader linear allocator.
LinearAllocHdr* pBootLoaderAlloc;
* Compute some stats on loaded classes.
int numLoadedClasses;
int numDeclaredMethods;
int numDeclaredInstFields;
int numDeclaredStaticFields;
/* when using a native debugger, set this to suppress watchdog timers */
bool nativeDebuggerActive;
* JDWP debugger support.
* Note: Each thread will normally determine whether the debugger is active
* for it by referring to its subMode flags. "debuggerActive" here should be
* seen as "debugger is making requests of 1 or more threads".
bool debuggerConnected; /* debugger or DDMS is connected */
bool debuggerActive; /* debugger is making requests */
JdwpState* jdwpState;
* Registry of objects known to the debugger.
HashTable* dbgRegistry;
* Debugger breakpoint table.
BreakpointSet* breakpointSet;
* Single-step control struct. We currently only allow one thread to
* be single-stepping at a time, which is all that really makes sense,
* but it's possible we may need to expand this to be per-thread.
StepControl stepControl;
* DDM features embedded in the VM.
bool ddmThreadNotification;
* Zygote (partially-started process) support
bool zygote;
* Used for tracking allocations that we report to DDMS. When the feature
* is enabled (through a DDMS request) the "allocRecords" pointer becomes
* non-NULL.
pthread_mutex_t allocTrackerLock;
AllocRecord* allocRecords;
int allocRecordHead; /* most-recently-added entry */
int allocRecordCount; /* #of valid entries */
int allocRecordMax; /* Number of allocated entries. */
* When a profiler is enabled, this is incremented. Distinct profilers
* include "dmtrace" method tracing, emulator method tracing, and
* possibly instruction counting.
* The purpose of this is to have a single value that shows whether any
* profiling is going on. Individual thread will normally check their
* thread-private subMode flags to take any profiling action.
volatile int activeProfilers;
* State for method-trace profiling.
MethodTraceState methodTrace;
Method* methodTraceGcMethod;
Method* methodTraceClassPrepMethod;
* State for emulator tracing.
void* emulatorTracePage;
int emulatorTraceEnableCount;
* Global state for memory allocation profiling.
AllocProfState allocProf;
* Pointers to the original methods for things that have been inlined.
* This makes it easy for us to output method entry/exit records for
* the method calls we're not actually making. (Used by method
* profiling.)
Method** inlinedMethods;
* Dalvik instruction counts (kNumPackedOpcodes entries).
int* executedInstrCounts;
int instructionCountEnableCount;
* Signal catcher thread (for SIGQUIT).
pthread_t signalCatcherHandle;
bool haltSignalCatcher;
* Stdout/stderr conversion thread.
bool haltStdioConverter;
bool stdioConverterReady;
pthread_t stdioConverterHandle;
pthread_mutex_t stdioConverterLock;
pthread_cond_t stdioConverterCond;
int stdoutPipe[2];
int stderrPipe[2];
* pid of the system_server process. We track it so that when system server
* crashes the Zygote process will be killed and restarted.
pid_t systemServerPid;
int kernelGroupScheduling;
PointerSet* preciseMethods;
/* some RegisterMap statistics, useful during development */
void* registerMapStats;
VerifierStats verifierStats;
/* String pointed here will be deposited on the stack frame of dvmAbort */
const char *lastMessage;
extern struct DvmGlobals gDvm;
#if defined(WITH_JIT)
#define DEFAULT_CODE_CACHE_SIZE 0xffffffff
/* Trace profiling modes. Ordering matters - off states before on states */
enum TraceProfilingModes {
kTraceProfilingDisabled = 0, // Not profiling
kTraceProfilingPeriodicOff = 1, // Periodic profiling, off phase
kTraceProfilingContinuous = 2, // Always profiling
kTraceProfilingPeriodicOn = 3 // Periodic profiling, on phase
* Exiting the compiled code w/o chaining will incur overhead to look up the
* target in the code cache which is extra work only when JIT is enabled. So
* we want to monitor it closely to make sure we don't have performance bugs.
enum NoChainExits {
kInlineCacheMiss = 0,
* JIT-specific global state
struct DvmJitGlobals {
* Guards writes to Dalvik PC (dPC), translated code address (codeAddr) and
* chain fields within the JIT hash table. Note carefully the access
* mechanism.
* Only writes are guarded, and the guarded fields must be updated in a
* specific order using atomic operations. Further, once a field is
* written it cannot be changed without halting all threads.
* The write order is:
* 1) codeAddr
* 2) dPC
* 3) chain [if necessary]
* This mutex also guards both read and write of curJitTableEntries.
pthread_mutex_t tableLock;
/* The JIT hash table. Note that for access speed, copies of this pointer
* are stored in each thread. */
struct JitEntry *pJitEntryTable;
/* Array of compilation trigger threshold counters */
unsigned char *pProfTable;
/* Trace profiling counters */
struct JitTraceProfCounters *pJitTraceProfCounters;
/* Copy of pProfTable used for temporarily disabling the Jit */
unsigned char *pProfTableCopy;
/* Size of JIT hash table in entries. Must be a power of 2 */
unsigned int jitTableSize;
/* Mask used in hash function for JitTable. Should be jitTableSize-1 */
unsigned int jitTableMask;
/* How many entries in the JitEntryTable are in use */
unsigned int jitTableEntriesUsed;
/* Max bytes allocated for the code cache. Rough rule of thumb: 1K per 1M of system RAM */
unsigned int codeCacheSize;
/* Trigger for trace selection */
unsigned short threshold;
/* JIT Compiler Control */
bool haltCompilerThread;
bool blockingMode;
bool methodTraceSupport;
bool genSuspendPoll;
Thread* compilerThread;
pthread_t compilerHandle;
pthread_mutex_t compilerLock;
pthread_mutex_t compilerICPatchLock;
pthread_cond_t compilerQueueActivity;
pthread_cond_t compilerQueueEmpty;
volatile int compilerQueueLength;
int compilerHighWater;
int compilerWorkEnqueueIndex;
int compilerWorkDequeueIndex;
int compilerICPatchIndex;
/* JIT internal stats */
int compilerMaxQueued;
int translationChains;
/* Compiled code cache */
void* codeCache;
* This is used to store the base address of an in-flight compilation whose
* class object pointers have been calculated to populate literal pool.
* Once the compiler thread has changed its status to VM_WAIT, we cannot
* guarantee whether GC has happened before the code address has been
* installed to the JIT table. Because of that, this field can only
* been cleared/overwritten by the compiler thread if it is in the
* THREAD_RUNNING state or in a safe point.
void *inflightBaseAddr;
/* Translation cache version (protected by compilerLock */
int cacheVersion;
/* Bytes used by the code templates */
unsigned int templateSize;
/* Bytes already used in the code cache */
unsigned int codeCacheByteUsed;
/* Number of installed compilations in the cache */
unsigned int numCompilations;
/* Flag to indicate that the code cache is full */
bool codeCacheFull;
/* Page size - 1 */
unsigned int pageSizeMask;
/* Lock to change the protection type of the code cache */
pthread_mutex_t codeCacheProtectionLock;
/* Number of times that the code cache has been reset */
int numCodeCacheReset;
/* Number of times that the code cache reset request has been delayed */
int numCodeCacheResetDelayed;
/* true/false: compile/reject opcodes specified in the -Xjitop list */
bool includeSelectedOp;
/* true/false: compile/reject methods specified in the -Xjitmethod list */
bool includeSelectedMethod;
/* true/false: compile/reject traces with offset specified in the -Xjitoffset list */
bool includeSelectedOffset;
/* Disable JIT for selected opcodes - one bit for each opcode */
char opList[(kNumPackedOpcodes+7)/8];
/* Disable JIT for selected methods */
HashTable *methodTable;
/* Disable JIT for selected classes */
HashTable *classTable;
/* Disable JIT for selected offsets */
unsigned int pcTable[COMPILER_PC_OFFSET_SIZE];
int num_entries_pcTable;
/* Flag to dump all compiled code */
bool printMe;
/* Flag to dump compiled binary code in bytes */
bool printBinary;
/* Per-process debug flag toggled when receiving a SIGUSR2 */
bool receivedSIGUSR2;
/* Trace profiling mode */
TraceProfilingModes profileMode;
/* Periodic trace profiling countdown timer */
int profileCountdown;
/* Vector to disable selected optimizations */
int disableOpt;
/* Table to track the overall and trace statistics of hot methods */
HashTable* methodStatsTable;
/* Filter method compilation blacklist with call-graph information */
bool checkCallGraph;
/* New translation chain has been set up */
volatile bool hasNewChain;
/* Spin when error is detected, volatile so GDB can reset it */
volatile bool selfVerificationSpin;
/* Framework or stand-alone? */
bool runningInAndroidFramework;
/* Framework callback happened? */
bool alreadyEnabledViaFramework;
/* Framework requests to disable the JIT for good */
bool disableJit;
/* Signature breakpoint */
u4 signatureBreakpointSize; // # of words
u4 *signatureBreakpoint; // Signature content
#if defined(WITH_JIT_TUNING)
/* Performance tuning counters */
int addrLookupsFound;
int addrLookupsNotFound;
int noChainExit[kNoChainExitLast];
int normalExit;
int puntExit;
int invokeMonomorphic;
int invokePolymorphic;
int invokeNative;
int invokeMonoGetterInlined;
int invokeMonoSetterInlined;
int invokePolyGetterInlined;
int invokePolySetterInlined;
int returnOp;
int icPatchInit;
int icPatchLockFree;
int icPatchQueued;
int icPatchRejected;
int icPatchDropped;
int codeCachePatches;
int numCompilerThreadBlockGC;
u8 jitTime;
u8 compilerThreadBlockGCStart;
u8 compilerThreadBlockGCTime;
u8 maxCompilerThreadBlockGCTime;
#if defined(ARCH_IA32)
JitOptLevel optLevel;
/* Place arrays at the end to ease the display in gdb sessions */
/* Work order queue for compilations */
CompilerWorkOrder compilerWorkQueue[COMPILER_WORK_QUEUE_SIZE];
/* Work order queue for predicted chain patching */
ICPatchWorkOrder compilerICPatchQueue[COMPILER_IC_PATCH_QUEUE_SIZE];
extern struct DvmJitGlobals gDvmJit;
#if defined(WITH_JIT_TUNING)
extern int gDvmICHitCount;
struct DvmJniGlobals {
bool useCheckJni;
bool warnOnly;
bool forceCopy;
// Provide backwards compatibility for pre-ICS apps on ICS.
bool workAroundAppJniBugs;
// Debugging help for third-party developers. Similar to -Xjnitrace.
bool logThirdPartyJni;
// We only support a single JavaVM per process.
JavaVM* jniVm;
extern struct DvmJniGlobals gDvmJni;