2 * Copyright (C) 2008 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 * Variables with library scope.
20 * Prefer this over scattered static and global variables -- it's easier to
21 * view the state in a debugger, it makes clean shutdown simpler, we can
22 * trivially dump the state into a crash log, and it dodges most naming
23 * collisions that will arise when we are embedded in a larger program.
25 * If we want multiple VMs per process, this can get stuffed into TLS (or
26 * accessed through a Thread field). May need to pass it around for some
27 * of the early initialization functions.
29 #ifndef _DALVIK_GLOBALS
30 #define _DALVIK_GLOBALS
35 #define MAX_BREAKPOINTS 20 /* used for a debugger optimization */
37 /* private structures */
38 typedef struct GcHeap GcHeap;
39 typedef struct BreakpointSet BreakpointSet;
40 typedef struct InlineSub InlineSub;
43 * One of these for each -ea/-da/-esa/-dsa on the command line.
45 typedef struct AssertionControl {
46 char* pkgOrClass; /* package/class string, or NULL for esa/dsa */
47 int pkgOrClassLen; /* string length, for quick compare */
48 bool enable; /* enable or disable */
49 bool isPackage; /* string ended with "..."? */
53 * Execution mode, e.g. interpreter vs. JIT.
55 typedef enum ExecutionMode {
56 kExecutionModeUnknown = 0,
57 kExecutionModeInterpPortable,
58 kExecutionModeInterpFast,
65 * All fields are initialized to zero.
67 * Storage allocated here must be freed by a subsystem shutdown function or
68 * from within freeGlobals().
72 * Some options from the command line or environment.
74 char* bootClassPathStr;
77 unsigned int heapSizeStart;
78 unsigned int heapSizeMax;
79 unsigned int stackSize;
86 bool jdwpAllowed; // debugging allowed for this process?
87 bool jdwpConfigured; // has debugging info been provided?
95 * Lock profiling threshold value in milliseconds. Acquires that
96 * exceed threshold are logged. Acquires within the threshold are
97 * logged with a probability of $\frac{time}{threshold}$ . If the
98 * threshold is unset no additional logging occurs.
100 u4 lockProfThreshold;
102 int (*vfprintfHook)(FILE*, const char*, va_list);
103 void (*exitHook)(int);
104 void (*abortHook)(void);
106 int jniGrefLimit; // 0 means no limit
110 bool verifyDexChecksum;
111 char* stackTraceFile; // for SIGQUIT-inspired output
115 DexOptimizerMode dexOptMode;
116 DexClassVerifyMode classVerifyMode;
124 bool generateRegisterMaps;
125 bool concurrentMarkSweep;
126 bool verifyCardTable;
128 int assertionCtrlCount;
129 AssertionControl* assertionCtrl;
131 ExecutionMode executionMode;
134 * VM init management.
137 int initExceptionCount;
141 * java.lang.System properties set from the command line.
148 * Where the VM goes to find system classes.
150 ClassPathEntry* bootClassPath;
151 /* used by the DEX optimizer to load classes from an unfinished DEX */
152 DvmDex* bootClassPathOptExtra;
153 bool optimizingBootstrapClass;
156 * Loaded classes, hashed by class name. Each entry is a ClassObject*,
157 * allocated in GC space.
159 HashTable* loadedClasses;
162 * Value for the next class serial number to be assigned. This is
163 * incremented as we load classes. Failed loads and races may result
164 * in some numbers being skipped, and the serial number is not
165 * guaranteed to start at 1, so the current value should not be used
166 * as a count of loaded classes.
168 volatile int classSerialNumber;
171 * Classes with a low classSerialNumber are probably in the zygote, and
172 * their InitiatingLoaderList is not used, to promote sharing. The list is
175 InitiatingLoaderList* initiatingLoaderList;
181 /* A mutex that guards access to the interned string tables. */
182 pthread_mutex_t internLock;
184 /* Hash table of strings interned by the user. */
185 HashTable* internedStrings;
187 /* Hash table of strings interned by the class loader. */
188 HashTable* literalStrings;
191 * Quick lookups for popular classes used internally.
193 ClassObject* classJavaLangClass;
194 ClassObject* classJavaLangClassArray;
195 ClassObject* classJavaLangError;
196 ClassObject* classJavaLangObject;
197 ClassObject* classJavaLangObjectArray;
198 ClassObject* classJavaLangRuntimeException;
199 ClassObject* classJavaLangString;
200 ClassObject* classJavaLangThread;
201 ClassObject* classJavaLangVMThread;
202 ClassObject* classJavaLangThreadGroup;
203 ClassObject* classJavaLangThrowable;
204 ClassObject* classJavaLangStackOverflowError;
205 ClassObject* classJavaLangStackTraceElement;
206 ClassObject* classJavaLangStackTraceElementArray;
207 ClassObject* classJavaLangAnnotationAnnotationArray;
208 ClassObject* classJavaLangAnnotationAnnotationArrayArray;
209 ClassObject* classJavaLangReflectAccessibleObject;
210 ClassObject* classJavaLangReflectConstructor;
211 ClassObject* classJavaLangReflectConstructorArray;
212 ClassObject* classJavaLangReflectField;
213 ClassObject* classJavaLangReflectFieldArray;
214 ClassObject* classJavaLangReflectMethod;
215 ClassObject* classJavaLangReflectMethodArray;
216 ClassObject* classJavaLangReflectProxy;
217 ClassObject* classJavaLangExceptionInInitializerError;
218 ClassObject* classJavaLangRefPhantomReference;
219 ClassObject* classJavaLangRefReference;
220 ClassObject* classJavaNioReadWriteDirectByteBuffer;
221 ClassObject* classJavaSecurityAccessController;
222 ClassObject* classOrgApacheHarmonyLangAnnotationAnnotationFactory;
223 ClassObject* classOrgApacheHarmonyLangAnnotationAnnotationMember;
224 ClassObject* classOrgApacheHarmonyLangAnnotationAnnotationMemberArray;
225 ClassObject* classOrgApacheHarmonyNioInternalDirectBuffer;
226 jclass jclassOrgApacheHarmonyNioInternalDirectBuffer;
228 /* synthetic classes for arrays of primitives */
229 ClassObject* classArrayBoolean;
230 ClassObject* classArrayChar;
231 ClassObject* classArrayFloat;
232 ClassObject* classArrayDouble;
233 ClassObject* classArrayByte;
234 ClassObject* classArrayShort;
235 ClassObject* classArrayInt;
236 ClassObject* classArrayLong;
238 /* method offsets - Object */
239 int voffJavaLangObject_equals;
240 int voffJavaLangObject_hashCode;
241 int voffJavaLangObject_toString;
242 int voffJavaLangObject_finalize;
244 /* field offsets - Class */
245 int offJavaLangClass_pd;
247 /* field offsets - String */
248 int javaLangStringReady; /* 0=not init, 1=ready, -1=initing */
249 int offJavaLangString_value;
250 int offJavaLangString_count;
251 int offJavaLangString_offset;
252 int offJavaLangString_hashCode;
254 /* field offsets - Thread */
255 int offJavaLangThread_vmThread;
256 int offJavaLangThread_group;
257 int offJavaLangThread_daemon;
258 int offJavaLangThread_name;
259 int offJavaLangThread_priority;
261 /* method offsets - Thread */
262 int voffJavaLangThread_run;
264 /* field offsets - VMThread */
265 int offJavaLangVMThread_thread;
266 int offJavaLangVMThread_vmData;
268 /* method offsets - ThreadGroup */
269 int voffJavaLangThreadGroup_removeThread;
271 /* field offsets - Throwable */
272 int offJavaLangThrowable_stackState;
273 int offJavaLangThrowable_message;
274 int offJavaLangThrowable_cause;
276 /* field offsets - java.lang.reflect.* */
277 int offJavaLangReflectAccessibleObject_flag;
278 int offJavaLangReflectConstructor_slot;
279 int offJavaLangReflectConstructor_declClass;
280 int offJavaLangReflectField_slot;
281 int offJavaLangReflectField_declClass;
282 int offJavaLangReflectMethod_slot;
283 int offJavaLangReflectMethod_declClass;
285 /* field offsets - java.lang.ref.Reference */
286 int offJavaLangRefReference_referent;
287 int offJavaLangRefReference_queue;
288 int offJavaLangRefReference_queueNext;
289 int offJavaLangRefReference_pendingNext;
291 /* method pointers - java.lang.ref.Reference */
292 Method* methJavaLangRefReference_enqueueInternal;
294 /* field offsets - java.nio.Buffer and java.nio.DirectByteBufferImpl */
295 //int offJavaNioBuffer_capacity;
296 //int offJavaNioDirectByteBufferImpl_pointer;
298 /* method pointers - java.security.AccessController */
299 volatile bool javaSecurityAccessControllerReady;
300 Method* methJavaSecurityAccessController_doPrivileged[4];
302 /* constructor method pointers; no vtable involved, so use Method* */
303 Method* methJavaLangStackTraceElement_init;
304 Method* methJavaLangExceptionInInitializerError_init;
305 Method* methJavaLangRefPhantomReference_init;
306 Method* methJavaLangReflectConstructor_init;
307 Method* methJavaLangReflectField_init;
308 Method* methJavaLangReflectMethod_init;
309 Method* methOrgApacheHarmonyLangAnnotationAnnotationMember_init;
311 /* static method pointers - android.lang.annotation.* */
313 methOrgApacheHarmonyLangAnnotationAnnotationFactory_createAnnotation;
315 /* direct method pointers - java.lang.reflect.Proxy */
316 Method* methJavaLangReflectProxy_constructorPrototype;
318 /* field offsets - java.lang.reflect.Proxy */
319 int offJavaLangReflectProxy_h;
321 /* fake native entry point method */
322 Method* methFakeNativeEntry;
324 /* assorted direct buffer helpers */
325 Method* methJavaNioReadWriteDirectByteBuffer_init;
326 Method* methOrgApacheHarmonyLuniPlatformPlatformAddress_on;
327 Method* methOrgApacheHarmonyNioInternalDirectBuffer_getEffectiveAddress;
328 int offJavaNioBuffer_capacity;
329 int offJavaNioBuffer_effectiveDirectAddress;
330 int offOrgApacheHarmonyLuniPlatformPlatformAddress_osaddr;
331 int voffOrgApacheHarmonyLuniPlatformPlatformAddress_toLong;
334 * VM-synthesized primitive classes, for arrays.
336 ClassObject* volatile primitiveClass[PRIM_MAX];
339 * Thread list. This always has at least one element in it (main),
340 * and main is always the first entry.
342 * The threadListLock is used for several things, including the thread
343 * start condition variable. Generally speaking, you must hold the
344 * threadListLock when:
345 * - adding/removing items from the list
346 * - waiting on or signaling threadStartCond
347 * - examining the Thread struct for another thread (this is to avoid
348 * one thread freeing the Thread struct while another thread is
352 pthread_mutex_t threadListLock;
354 pthread_cond_t threadStartCond;
357 * The thread code grabs this before suspending all threads. There
358 * are a few things that can cause a "suspend all":
359 * (1) the GC is starting;
360 * (2) the debugger has sent a "suspend all" request;
361 * (3) a thread has hit a breakpoint or exception that the debugger
362 * has marked as a "suspend all" event;
363 * (4) the SignalCatcher caught a signal that requires suspension.
364 * (5) (if implemented) the JIT needs to perform a heavyweight
365 * rearrangement of the translation cache or JitTable.
367 * Because we use "safe point" self-suspension, it is never safe to
368 * do a blocking "lock" call on this mutex -- if it has been acquired,
369 * somebody is probably trying to put you to sleep. The leading '_' is
370 * intended as a reminder that this lock is special.
372 pthread_mutex_t _threadSuspendLock;
375 * Guards Thread->suspendCount for all threads, and provides the lock
376 * for the condition variable that all suspended threads sleep on
377 * (threadSuspendCountCond).
379 * This has to be separate from threadListLock because of the way
380 * threads put themselves to sleep.
382 pthread_mutex_t threadSuspendCountLock;
385 * Suspended threads sleep on this. They should sleep on the condition
386 * variable until their "suspend count" is zero.
388 * Paired with "threadSuspendCountLock".
390 pthread_cond_t threadSuspendCountCond;
393 * Sum of all threads' suspendCount fields. The JIT needs to know if any
394 * thread is suspended. Guarded by threadSuspendCountLock.
396 int sumThreadSuspendCount;
399 * MUTEX ORDERING: when locking multiple mutexes, always grab them in
400 * this order to avoid deadlock:
402 * (1) _threadSuspendLock (use lockThreadSuspend())
403 * (2) threadListLock (use dvmLockThreadList())
404 * (3) threadSuspendCountLock (use lockThreadSuspendCount())
409 * Thread ID bitmap. We want threads to have small integer IDs so
410 * we can use them in "thin locks".
412 BitVector* threadIdMap;
415 * Manage exit conditions. The VM exits when all non-daemon threads
416 * have exited. If the main thread returns early, we need to sleep
417 * on a condition variable.
419 int nonDaemonThreadCount; /* must hold threadListLock to access */
420 //pthread_mutex_t vmExitLock;
421 pthread_cond_t vmExitCond;
424 * The set of DEX files loaded by custom class loaders.
426 HashTable* userDexFiles;
429 * JNI global reference table.
431 #ifdef USE_INDIRECT_REF
432 IndirectRefTable jniGlobalRefTable;
434 ReferenceTable jniGlobalRefTable;
436 pthread_mutex_t jniGlobalRefLock;
437 int jniGlobalRefHiMark;
438 int jniGlobalRefLoMark;
441 * JNI pinned object table (used for primitive arrays).
443 ReferenceTable jniPinRefTable;
444 pthread_mutex_t jniPinRefLock;
447 * Native shared library table.
449 HashTable* nativeLibs;
452 * GC heap lock. Functions like gcMalloc() acquire this before making
453 * any changes to the heap. It is held throughout garbage collection.
455 pthread_mutex_t gcHeapLock;
458 * Condition variable to queue threads waiting to retry an
459 * allocation. Signaled after a concurrent GC is completed.
461 pthread_cond_t gcHeapCond;
463 /* Opaque pointer representing the heap. */
466 /* The card table base, modified as needed for marking cards. */
467 u1* biasedCardTableBase;
470 * Pre-allocated throwables.
472 Object* outOfMemoryObj;
473 Object* internalErrorObj;
474 Object* noClassDefFoundErrorObj;
476 /* Monitor list, so we can free them */
477 /*volatile*/ Monitor* monitorList;
479 /* Monitor for Thread.sleep() implementation */
480 Monitor* threadSleepMon;
482 /* set when we create a second heap inside the zygote */
483 bool newZygoteHeapAllocated;
488 pthread_key_t pthreadKeySelf; /* Thread*, for dvmThreadSelf */
491 * JNI allows you to have multiple VMs, but we limit ourselves to 1,
492 * so "vmList" is really just a pointer to the one and only VM.
497 * Cache results of "A instanceof B".
499 AtomicCache* instanceofCache;
501 /* instruction width table, used for optimization and verification */
502 InstructionWidth* instrWidth;
503 /* instruction flags table, used for verification */
504 InstructionFlags* instrFlags;
505 /* instruction format table, used for verification */
506 InstructionFormat* instrFormat;
508 /* inline substitution table, used during optimization */
509 InlineSub* inlineSubs;
512 * Bootstrap class loader linear allocator.
514 LinearAllocHdr* pBootLoaderAlloc;
518 * Heap worker thread.
520 bool heapWorkerInitialized;
521 bool heapWorkerReady;
523 pthread_t heapWorkerHandle;
524 pthread_mutex_t heapWorkerLock;
525 pthread_cond_t heapWorkerCond;
526 pthread_cond_t heapWorkerIdleCond;
527 pthread_mutex_t heapWorkerListLock;
530 * Compute some stats on loaded classes.
532 int numLoadedClasses;
533 int numDeclaredMethods;
534 int numDeclaredInstFields;
535 int numDeclaredStaticFields;
537 /* when using a native debugger, set this to suppress watchdog timers */
538 bool nativeDebuggerActive;
541 * JDWP debugger support.
543 * Note "debuggerActive" is accessed from mterp, so its storage size and
544 * meaning must not be changed without updating the assembly sources.
546 bool debuggerConnected; /* debugger or DDMS is connected */
547 u1 debuggerActive; /* debugger is making requests */
548 JdwpState* jdwpState;
551 * Registry of objects known to the debugger.
553 HashTable* dbgRegistry;
556 * Debugger breakpoint table.
558 BreakpointSet* breakpointSet;
561 * Single-step control struct. We currently only allow one thread to
562 * be single-stepping at a time, which is all that really makes sense,
563 * but it's possible we may need to expand this to be per-thread.
565 StepControl stepControl;
568 * DDM features embedded in the VM.
570 bool ddmThreadNotification;
573 * Zygote (partially-started process) support
578 * Used for tracking allocations that we report to DDMS. When the feature
579 * is enabled (through a DDMS request) the "allocRecords" pointer becomes
582 pthread_mutex_t allocTrackerLock;
583 AllocRecord* allocRecords;
584 int allocRecordHead; /* most-recently-added entry */
585 int allocRecordCount; /* #of valid entries */
587 #ifdef WITH_ALLOC_LIMITS
588 /* set on first use of an alloc limit, never cleared */
589 bool checkAllocLimits;
590 /* allocation limit, for setGlobalAllocationLimit() regression testing */
594 #ifdef WITH_DEADLOCK_PREDICTION
595 /* global lock on history tree accesses */
596 pthread_mutex_t deadlockHistoryLock;
598 enum { kDPOff=0, kDPWarn, kDPErr, kDPAbort } deadlockPredictMode;
603 * When a profiler is enabled, this is incremented. Distinct profilers
604 * include "dmtrace" method tracing, emulator method tracing, and
605 * possibly instruction counting.
607 * The purpose of this is to have a single value that the interpreter
608 * can check to see if any profiling activity is enabled.
610 volatile int activeProfilers;
613 * State for method-trace profiling.
615 MethodTraceState methodTrace;
618 * State for emulator tracing.
620 void* emulatorTracePage;
621 int emulatorTraceEnableCount;
624 * Global state for memory allocation profiling.
626 AllocProfState allocProf;
629 * Pointers to the original methods for things that have been inlined.
630 * This makes it easy for us to output method entry/exit records for
631 * the method calls we're not actually making.
633 Method** inlinedMethods;
636 * Dalvik instruction counts (256 entries).
638 int* executedInstrCounts;
639 bool instructionCountEnableCount;
643 * Signal catcher thread (for SIGQUIT).
645 pthread_t signalCatcherHandle;
646 bool haltSignalCatcher;
649 * Stdout/stderr conversion thread.
651 bool haltStdioConverter;
652 bool stdioConverterReady;
653 pthread_t stdioConverterHandle;
654 pthread_mutex_t stdioConverterLock;
655 pthread_cond_t stdioConverterCond;
658 * pid of the system_server process. We track it so that when system server
659 * crashes the Zygote process will be killed and restarted.
661 pid_t systemServerPid;
663 int kernelGroupScheduling;
665 //#define COUNT_PRECISE_METHODS
666 #ifdef COUNT_PRECISE_METHODS
667 PointerSet* preciseMethods;
670 /* some RegisterMap statistics, useful during development */
671 void* registerMapStats;
674 extern struct DvmGlobals gDvm;
676 #if defined(WITH_JIT)
679 * Exiting the compiled code w/o chaining will incur overhead to look up the
680 * target in the code cache which is extra work only when JIT is enabled. So
681 * we want to monitor it closely to make sure we don't have performance bugs.
683 typedef enum NoChainExits {
684 kInlineCacheMiss = 0,
685 kCallsiteInterpreted,
692 * JIT-specific global state
694 struct DvmJitGlobals {
696 * Guards writes to Dalvik PC (dPC), translated code address (codeAddr) and
697 * chain fields within the JIT hash table. Note carefully the access
699 * Only writes are guarded, and the guarded fields must be updated in a
700 * specific order using atomic operations. Further, once a field is
701 * written it cannot be changed without halting all threads.
703 * The write order is:
706 * 3) chain [if necessary]
708 * This mutex also guards both read and write of curJitTableEntries.
710 pthread_mutex_t tableLock;
712 /* The JIT hash table. Note that for access speed, copies of this pointer
713 * are stored in each thread. */
714 struct JitEntry *pJitEntryTable;
716 /* Array of profile threshold counters */
717 unsigned char *pProfTable;
719 /* Copy of pProfTable used for temporarily disabling the Jit */
720 unsigned char *pProfTableCopy;
722 /* Size of JIT hash table in entries. Must be a power of 2 */
723 unsigned int jitTableSize;
725 /* Mask used in hash function for JitTable. Should be jitTableSize-1 */
726 unsigned int jitTableMask;
728 /* How many entries in the JitEntryTable are in use */
729 unsigned int jitTableEntriesUsed;
731 /* Bytes allocated for the code cache */
732 unsigned int codeCacheSize;
734 /* Trigger for trace selection */
735 unsigned short threshold;
737 /* JIT Compiler Control */
738 bool haltCompilerThread;
740 pthread_t compilerHandle;
741 pthread_mutex_t compilerLock;
742 pthread_mutex_t compilerICPatchLock;
743 pthread_cond_t compilerQueueActivity;
744 pthread_cond_t compilerQueueEmpty;
745 volatile int compilerQueueLength;
746 int compilerHighWater;
747 int compilerWorkEnqueueIndex;
748 int compilerWorkDequeueIndex;
749 int compilerICPatchIndex;
751 /* JIT internal stats */
752 int compilerMaxQueued;
753 int translationChains;
755 /* Compiled code cache */
758 /* Bytes used by the code templates */
759 unsigned int templateSize;
761 /* Bytes already used in the code cache */
762 unsigned int codeCacheByteUsed;
764 /* Number of installed compilations in the cache */
765 unsigned int numCompilations;
767 /* Flag to indicate that the code cache is full */
771 unsigned int pageSizeMask;
773 /* Lock to change the protection type of the code cache */
774 pthread_mutex_t codeCacheProtectionLock;
776 /* Number of times that the code cache has been reset */
777 int numCodeCacheReset;
779 /* Number of times that the code cache reset request has been delayed */
780 int numCodeCacheResetDelayed;
782 /* true/false: compile/reject opcodes specified in the -Xjitop list */
783 bool includeSelectedOp;
785 /* true/false: compile/reject methods specified in the -Xjitmethod list */
786 bool includeSelectedMethod;
788 /* Disable JIT for selected opcodes - one bit for each opcode */
791 /* Disable JIT for selected methods */
792 HashTable *methodTable;
794 /* Flag to dump all compiled code */
797 /* Flag to count trace execution */
800 /* Vector to disable selected optimizations */
803 /* Table to track the overall and trace statistics of hot methods */
804 HashTable* methodStatsTable;
806 /* Filter method compilation blacklist with call-graph information */
809 /* New translation chain has been set up */
810 volatile bool hasNewChain;
812 #if defined(WITH_SELF_VERIFICATION)
813 /* Spin when error is detected, volatile so GDB can reset it */
814 volatile bool selfVerificationSpin;
817 /* Framework or stand-alone? */
818 bool runningInAndroidFramework;
820 /* Framework callback happened? */
821 bool alreadyEnabledViaFramework;
823 /* Framework requests to disable the JIT for good */
826 #if defined(SIGNATURE_BREAKPOINT)
827 /* Signature breakpoint */
828 u4 signatureBreakpointSize; // # of words
829 u4 *signatureBreakpoint; // Signature content
832 #if defined(WITH_JIT_TUNING)
833 /* Performance tuning counters */
834 int addrLookupsFound;
835 int addrLookupsNotFound;
836 int noChainExit[kNoChainExitLast];
839 int invokeMonomorphic;
840 int invokePolymorphic;
842 int invokeMonoGetterInlined;
843 int invokeMonoSetterInlined;
844 int invokePolyGetterInlined;
845 int invokePolySetterInlined;
853 int codeCachePatches;
856 /* Place arrays at the end to ease the display in gdb sessions */
858 /* Work order queue for compilations */
859 CompilerWorkOrder compilerWorkQueue[COMPILER_WORK_QUEUE_SIZE];
861 /* Work order queue for predicted chain patching */
862 ICPatchWorkOrder compilerICPatchQueue[COMPILER_IC_PATCH_QUEUE_SIZE];
865 extern struct DvmJitGlobals gDvmJit;
867 #if defined(WITH_JIT_TUNING)
868 extern int gDvmICHitCount;
873 #endif /*_DALVIK_GLOBALS*/