Globals.h revision 7222596c216393e5386b260a0b19082cf4a0d0ec 
1/*
2 * Copyright (C) 2008 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/*
18 * Variables with library scope.
19 *
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.
24 *
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.
28 */
29#ifndef DALVIK_GLOBALS_H_
30#define DALVIK_GLOBALS_H_
31
32#include <string>
33#include <vector>
34
35#include <stdarg.h>
36#include <pthread.h>
37
38/* private structures */
39struct GcHeap;
40struct BreakpointSet;
41struct InlineSub;
42
43/*
44 * One of these for each -ea/-da/-esa/-dsa on the command line.
45 */
46struct AssertionControl {
47    char*   pkgOrClass;         /* package/class string, or NULL for esa/dsa */
48    int     pkgOrClassLen;      /* string length, for quick compare */
49    bool    enable;             /* enable or disable */
50    bool    isPackage;          /* string ended with "..."? */
51};
52
53/*
54 * Register map generation mode.  Only applicable when generateRegisterMaps
55 * is enabled.  (The "disabled" state is not folded into this because
56 * there are callers like dexopt that want to enable/disable without
57 * specifying the configuration details.)
58 *
59 * "TypePrecise" is slower and requires additional storage for the register
60 * maps, but allows type-precise GC.  "LivePrecise" is even slower and
61 * requires additional heap during processing, but allows live-precise GC.
62 */
63enum RegisterMapMode {
64    kRegisterMapModeUnknown = 0,
65    kRegisterMapModeTypePrecise,
66    kRegisterMapModeLivePrecise
67};
68
69/*
70 * Profiler clock source.
71 */
72enum ProfilerClockSource {
73    kProfilerClockSourceThreadCpu,
74    kProfilerClockSourceWall,
75    kProfilerClockSourceDual,
76};
77
78/*
79 * All fields are initialized to zero.
80 *
81 * Storage allocated here must be freed by a subsystem shutdown function.
82 */
83struct DvmGlobals {
84    /*
85     * Some options from the command line or environment.
86     */
87    char*       bootClassPathStr;
88    char*       classPathStr;
89
90    size_t      heapStartingSize;
91    size_t      heapMaximumSize;
92    size_t      heapGrowthLimit;
93    size_t      stackSize;
94    size_t      mainThreadStackSize;
95
96    bool        verboseGc;
97    bool        verboseJni;
98    bool        verboseClass;
99    bool        verboseShutdown;
100
101    bool        jdwpAllowed;        // debugging allowed for this process?
102    bool        jdwpConfigured;     // has debugging info been provided?
103    JdwpTransportType jdwpTransport;
104    bool        jdwpServer;
105    char*       jdwpHost;
106    int         jdwpPort;
107    bool        jdwpSuspend;
108
109    ProfilerClockSource profilerClockSource;
110
111    /*
112     * Lock profiling threshold value in milliseconds.  Acquires that
113     * exceed threshold are logged.  Acquires within the threshold are
114     * logged with a probability of $\frac{time}{threshold}$ .  If the
115     * threshold is unset no additional logging occurs.
116     */
117    u4          lockProfThreshold;
118
119    int         (*vfprintfHook)(FILE*, const char*, va_list);
120    void        (*exitHook)(int);
121    void        (*abortHook)(void);
122    bool        (*isSensitiveThreadHook)(void);
123
124    int         jniGrefLimit;       // 0 means no limit
125    char*       jniTrace;
126    bool        reduceSignals;
127    bool        noQuitHandler;
128    bool        verifyDexChecksum;
129    char*       stackTraceFile;     // for SIGQUIT-inspired output
130
131    bool        logStdio;
132
133    DexOptimizerMode    dexOptMode;
134    DexClassVerifyMode  classVerifyMode;
135
136    bool        generateRegisterMaps;
137    RegisterMapMode     registerMapMode;
138
139    bool        monitorVerification;
140
141    bool        dexOptForSmp;
142
143    /*
144     * GC option flags.
145     */
146    bool        preciseGc;
147    bool        preVerify;
148    bool        postVerify;
149    bool        concurrentMarkSweep;
150    bool        verifyCardTable;
151    bool        disableExplicitGc;
152
153    int         assertionCtrlCount;
154    AssertionControl*   assertionCtrl;
155
156    ExecutionMode   executionMode;
157
158    /*
159     * VM init management.
160     */
161    bool        initializing;
162    bool        optimizing;
163
164    /*
165     * java.lang.System properties set from the command line with -D.
166     * This is effectively a set, where later entries override earlier
167     * ones.
168     */
169    std::vector<std::string>* properties;
170
171    /*
172     * Where the VM goes to find system classes.
173     */
174    ClassPathEntry* bootClassPath;
175    /* used by the DEX optimizer to load classes from an unfinished DEX */
176    DvmDex*     bootClassPathOptExtra;
177    bool        optimizingBootstrapClass;
178
179    /*
180     * Loaded classes, hashed by class name.  Each entry is a ClassObject*,
181     * allocated in GC space.
182     */
183    HashTable*  loadedClasses;
184
185    /*
186     * Value for the next class serial number to be assigned.  This is
187     * incremented as we load classes.  Failed loads and races may result
188     * in some numbers being skipped, and the serial number is not
189     * guaranteed to start at 1, so the current value should not be used
190     * as a count of loaded classes.
191     */
192    volatile int classSerialNumber;
193
194    /*
195     * Classes with a low classSerialNumber are probably in the zygote, and
196     * their InitiatingLoaderList is not used, to promote sharing. The list is
197     * kept here instead.
198     */
199    InitiatingLoaderList* initiatingLoaderList;
200
201    /*
202     * Interned strings.
203     */
204
205    /* A mutex that guards access to the interned string tables. */
206    pthread_mutex_t internLock;
207
208    /* Hash table of strings interned by the user. */
209    HashTable*  internedStrings;
210
211    /* Hash table of strings interned by the class loader. */
212    HashTable*  literalStrings;
213
214    /*
215     * Classes constructed directly by the vm.
216     */
217
218    /* the class Class */
219    ClassObject* classJavaLangClass;
220
221    /* synthetic classes representing primitive types */
222    ClassObject* typeVoid;
223    ClassObject* typeBoolean;
224    ClassObject* typeByte;
225    ClassObject* typeShort;
226    ClassObject* typeChar;
227    ClassObject* typeInt;
228    ClassObject* typeLong;
229    ClassObject* typeFloat;
230    ClassObject* typeDouble;
231
232    /* synthetic classes for arrays of primitives */
233    ClassObject* classArrayBoolean;
234    ClassObject* classArrayByte;
235    ClassObject* classArrayShort;
236    ClassObject* classArrayChar;
237    ClassObject* classArrayInt;
238    ClassObject* classArrayLong;
239    ClassObject* classArrayFloat;
240    ClassObject* classArrayDouble;
241
242    /*
243     * Quick lookups for popular classes used internally.
244     */
245    ClassObject* classJavaLangClassArray;
246    ClassObject* classJavaLangClassLoader;
247    ClassObject* classJavaLangObject;
248    ClassObject* classJavaLangObjectArray;
249    ClassObject* classJavaLangString;
250    ClassObject* classJavaLangThread;
251    ClassObject* classJavaLangVMThread;
252    ClassObject* classJavaLangThreadGroup;
253    ClassObject* classJavaLangStackTraceElement;
254    ClassObject* classJavaLangStackTraceElementArray;
255    ClassObject* classJavaLangAnnotationAnnotationArray;
256    ClassObject* classJavaLangAnnotationAnnotationArrayArray;
257    ClassObject* classJavaLangReflectAccessibleObject;
258    ClassObject* classJavaLangReflectConstructor;
259    ClassObject* classJavaLangReflectConstructorArray;
260    ClassObject* classJavaLangReflectField;
261    ClassObject* classJavaLangReflectFieldArray;
262    ClassObject* classJavaLangReflectMethod;
263    ClassObject* classJavaLangReflectMethodArray;
264    ClassObject* classJavaLangReflectProxy;
265    ClassObject* classJavaNioReadWriteDirectByteBuffer;
266    ClassObject* classOrgApacheHarmonyLangAnnotationAnnotationFactory;
267    ClassObject* classOrgApacheHarmonyLangAnnotationAnnotationMember;
268    ClassObject* classOrgApacheHarmonyLangAnnotationAnnotationMemberArray;
269    ClassObject* classOrgApacheHarmonyDalvikDdmcChunk;
270    ClassObject* classOrgApacheHarmonyDalvikDdmcDdmServer;
271    ClassObject* classJavaLangRefFinalizerReference;
272
273    /*
274     * classes representing exception types. The names here don't include
275     * packages, just to keep the use sites a bit less verbose. All are
276     * in java.lang, except where noted.
277     */
278    ClassObject* exAbstractMethodError;
279    ClassObject* exArithmeticException;
280    ClassObject* exArrayIndexOutOfBoundsException;
281    ClassObject* exArrayStoreException;
282    ClassObject* exClassCastException;
283    ClassObject* exClassCircularityError;
284    ClassObject* exClassFormatError;
285    ClassObject* exClassNotFoundException;
286    ClassObject* exError;
287    ClassObject* exExceptionInInitializerError;
288    ClassObject* exFileNotFoundException; /* in java.io */
289    ClassObject* exIOException;           /* in java.io */
290    ClassObject* exIllegalAccessError;
291    ClassObject* exIllegalAccessException;
292    ClassObject* exIllegalArgumentException;
293    ClassObject* exIllegalMonitorStateException;
294    ClassObject* exIllegalStateException;
295    ClassObject* exIllegalThreadStateException;
296    ClassObject* exIncompatibleClassChangeError;
297    ClassObject* exInstantiationError;
298    ClassObject* exInstantiationException;
299    ClassObject* exInternalError;
300    ClassObject* exInterruptedException;
301    ClassObject* exLinkageError;
302    ClassObject* exNegativeArraySizeException;
303    ClassObject* exNoClassDefFoundError;
304    ClassObject* exNoSuchFieldError;
305    ClassObject* exNoSuchFieldException;
306    ClassObject* exNoSuchMethodError;
307    ClassObject* exNullPointerException;
308    ClassObject* exOutOfMemoryError;
309    ClassObject* exRuntimeException;
310    ClassObject* exStackOverflowError;
311    ClassObject* exStaleDexCacheError;    /* in dalvik.system */
312    ClassObject* exStringIndexOutOfBoundsException;
313    ClassObject* exThrowable;
314    ClassObject* exTypeNotPresentException;
315    ClassObject* exUnsatisfiedLinkError;
316    ClassObject* exUnsupportedOperationException;
317    ClassObject* exVerifyError;
318    ClassObject* exVirtualMachineError;
319
320    /* method offsets - Object */
321    int         voffJavaLangObject_equals;
322    int         voffJavaLangObject_hashCode;
323    int         voffJavaLangObject_toString;
324
325    /* field offsets - String */
326    int         offJavaLangString_value;
327    int         offJavaLangString_count;
328    int         offJavaLangString_offset;
329    int         offJavaLangString_hashCode;
330
331    /* field offsets - Thread */
332    int         offJavaLangThread_vmThread;
333    int         offJavaLangThread_group;
334    int         offJavaLangThread_daemon;
335    int         offJavaLangThread_name;
336    int         offJavaLangThread_priority;
337    int         offJavaLangThread_uncaughtHandler;
338    int         offJavaLangThread_contextClassLoader;
339
340    /* method offsets - Thread */
341    int         voffJavaLangThread_run;
342
343    /* field offsets - ThreadGroup */
344    int         offJavaLangThreadGroup_name;
345    int         offJavaLangThreadGroup_parent;
346
347    /* field offsets - VMThread */
348    int         offJavaLangVMThread_thread;
349    int         offJavaLangVMThread_vmData;
350
351    /* method offsets - ThreadGroup */
352    int         voffJavaLangThreadGroup_removeThread;
353
354    /* field offsets - Throwable */
355    int         offJavaLangThrowable_stackState;
356    int         offJavaLangThrowable_cause;
357
358    /* method offsets - ClassLoader */
359    int         voffJavaLangClassLoader_loadClass;
360
361    /* direct method pointers - ClassLoader */
362    Method*     methJavaLangClassLoader_getSystemClassLoader;
363
364    /* field offsets - java.lang.reflect.* */
365    int         offJavaLangReflectConstructor_slot;
366    int         offJavaLangReflectConstructor_declClass;
367    int         offJavaLangReflectField_slot;
368    int         offJavaLangReflectField_declClass;
369    int         offJavaLangReflectMethod_slot;
370    int         offJavaLangReflectMethod_declClass;
371
372    /* field offsets - java.lang.ref.Reference */
373    int         offJavaLangRefReference_referent;
374    int         offJavaLangRefReference_queue;
375    int         offJavaLangRefReference_queueNext;
376    int         offJavaLangRefReference_pendingNext;
377
378    /* field offsets - java.lang.ref.FinalizerReference */
379    int offJavaLangRefFinalizerReference_zombie;
380
381    /* method pointers - java.lang.ref.ReferenceQueue */
382    Method* methJavaLangRefReferenceQueueAdd;
383
384    /* method pointers - java.lang.ref.FinalizerReference */
385    Method* methJavaLangRefFinalizerReferenceAdd;
386
387    /* constructor method pointers; no vtable involved, so use Method* */
388    Method*     methJavaLangStackTraceElement_init;
389    Method*     methJavaLangReflectConstructor_init;
390    Method*     methJavaLangReflectField_init;
391    Method*     methJavaLangReflectMethod_init;
392    Method*     methOrgApacheHarmonyLangAnnotationAnnotationMember_init;
393
394    /* static method pointers - android.lang.annotation.* */
395    Method*
396        methOrgApacheHarmonyLangAnnotationAnnotationFactory_createAnnotation;
397
398    /* direct method pointers - java.lang.reflect.Proxy */
399    Method*     methJavaLangReflectProxy_constructorPrototype;
400
401    /* field offsets - java.lang.reflect.Proxy */
402    int         offJavaLangReflectProxy_h;
403
404    /* field offsets - java.io.FileDescriptor */
405    int         offJavaIoFileDescriptor_descriptor;
406
407    /* direct method pointers - dalvik.system.NativeStart */
408    Method*     methDalvikSystemNativeStart_main;
409    Method*     methDalvikSystemNativeStart_run;
410
411    /* assorted direct buffer helpers */
412    Method*     methJavaNioReadWriteDirectByteBuffer_init;
413    int         offJavaNioBuffer_capacity;
414    int         offJavaNioBuffer_effectiveDirectAddress;
415
416    /* direct method pointers - org.apache.harmony.dalvik.ddmc.DdmServer */
417    Method*     methDalvikDdmcServer_dispatch;
418    Method*     methDalvikDdmcServer_broadcast;
419
420    /* field offsets - org.apache.harmony.dalvik.ddmc.Chunk */
421    int         offDalvikDdmcChunk_type;
422    int         offDalvikDdmcChunk_data;
423    int         offDalvikDdmcChunk_offset;
424    int         offDalvikDdmcChunk_length;
425
426    /*
427     * Thread list.  This always has at least one element in it (main),
428     * and main is always the first entry.
429     *
430     * The threadListLock is used for several things, including the thread
431     * start condition variable.  Generally speaking, you must hold the
432     * threadListLock when:
433     *  - adding/removing items from the list
434     *  - waiting on or signaling threadStartCond
435     *  - examining the Thread struct for another thread (this is to avoid
436     *    one thread freeing the Thread struct while another thread is
437     *    perusing it)
438     */
439    Thread*     threadList;
440    pthread_mutex_t threadListLock;
441
442    pthread_cond_t threadStartCond;
443
444    /*
445     * The thread code grabs this before suspending all threads.  There
446     * are a few things that can cause a "suspend all":
447     *  (1) the GC is starting;
448     *  (2) the debugger has sent a "suspend all" request;
449     *  (3) a thread has hit a breakpoint or exception that the debugger
450     *      has marked as a "suspend all" event;
451     *  (4) the SignalCatcher caught a signal that requires suspension.
452     *  (5) (if implemented) the JIT needs to perform a heavyweight
453     *      rearrangement of the translation cache or JitTable.
454     *
455     * Because we use "safe point" self-suspension, it is never safe to
456     * do a blocking "lock" call on this mutex -- if it has been acquired,
457     * somebody is probably trying to put you to sleep.  The leading '_' is
458     * intended as a reminder that this lock is special.
459     */
460    pthread_mutex_t _threadSuspendLock;
461
462    /*
463     * Guards Thread->suspendCount for all threads, and
464     * provides the lock for the condition variable that all suspended threads
465     * sleep on (threadSuspendCountCond).
466     *
467     * This has to be separate from threadListLock because of the way
468     * threads put themselves to sleep.
469     */
470    pthread_mutex_t threadSuspendCountLock;
471
472    /*
473     * Suspended threads sleep on this.  They should sleep on the condition
474     * variable until their "suspend count" is zero.
475     *
476     * Paired with "threadSuspendCountLock".
477     */
478    pthread_cond_t  threadSuspendCountCond;
479
480    /*
481     * Sum of all threads' suspendCount fields. Guarded by
482     * threadSuspendCountLock.
483     */
484    int  sumThreadSuspendCount;
485
486    /*
487     * MUTEX ORDERING: when locking multiple mutexes, always grab them in
488     * this order to avoid deadlock:
489     *
490     *  (1) _threadSuspendLock      (use lockThreadSuspend())
491     *  (2) threadListLock          (use dvmLockThreadList())
492     *  (3) threadSuspendCountLock  (use lockThreadSuspendCount())
493     */
494
495
496    /*
497     * Thread ID bitmap.  We want threads to have small integer IDs so
498     * we can use them in "thin locks".
499     */
500    BitVector*  threadIdMap;
501
502    /*
503     * Manage exit conditions.  The VM exits when all non-daemon threads
504     * have exited.  If the main thread returns early, we need to sleep
505     * on a condition variable.
506     */
507    int         nonDaemonThreadCount;   /* must hold threadListLock to access */
508    pthread_cond_t  vmExitCond;
509
510    /*
511     * The set of DEX files loaded by custom class loaders.
512     */
513    HashTable*  userDexFiles;
514
515    /*
516     * JNI global reference table.
517     */
518    IndirectRefTable jniGlobalRefTable;
519    IndirectRefTable jniWeakGlobalRefTable;
520    pthread_mutex_t jniGlobalRefLock;
521    pthread_mutex_t jniWeakGlobalRefLock;
522    int         jniGlobalRefHiMark;
523    int         jniGlobalRefLoMark;
524
525    /*
526     * JNI pinned object table (used for primitive arrays).
527     */
528    ReferenceTable  jniPinRefTable;
529    pthread_mutex_t jniPinRefLock;
530
531    /*
532     * Native shared library table.
533     */
534    HashTable*  nativeLibs;
535
536    /*
537     * GC heap lock.  Functions like gcMalloc() acquire this before making
538     * any changes to the heap.  It is held throughout garbage collection.
539     */
540    pthread_mutex_t gcHeapLock;
541
542    /*
543     * Condition variable to queue threads waiting to retry an
544     * allocation.  Signaled after a concurrent GC is completed.
545     */
546    pthread_cond_t gcHeapCond;
547
548    /* Opaque pointer representing the heap. */
549    GcHeap*     gcHeap;
550
551    /* The card table base, modified as needed for marking cards. */
552    u1*         biasedCardTableBase;
553
554    /*
555     * Pre-allocated throwables.
556     */
557    Object*     outOfMemoryObj;
558    Object*     internalErrorObj;
559    Object*     noClassDefFoundErrorObj;
560
561    /* Monitor list, so we can free them */
562    /*volatile*/ Monitor* monitorList;
563
564    /* Monitor for Thread.sleep() implementation */
565    Monitor*    threadSleepMon;
566
567    /* set when we create a second heap inside the zygote */
568    bool        newZygoteHeapAllocated;
569
570    /*
571     * TLS keys.
572     */
573    pthread_key_t pthreadKeySelf;       /* Thread*, for dvmThreadSelf */
574
575    /*
576     * Cache results of "A instanceof B".
577     */
578    AtomicCache* instanceofCache;
579
580    /* inline substitution table, used during optimization */
581    InlineSub*          inlineSubs;
582
583    /*
584     * Bootstrap class loader linear allocator.
585     */
586    LinearAllocHdr* pBootLoaderAlloc;
587
588    /*
589     * Compute some stats on loaded classes.
590     */
591    int         numLoadedClasses;
592    int         numDeclaredMethods;
593    int         numDeclaredInstFields;
594    int         numDeclaredStaticFields;
595
596    /* when using a native debugger, set this to suppress watchdog timers */
597    bool        nativeDebuggerActive;
598
599    /*
600     * JDWP debugger support.
601     *
602     * Note: Each thread will normally determine whether the debugger is active
603     * for it by referring to its subMode flags.  "debuggerActive" here should be
604     * seen as "debugger is making requests of 1 or more threads".
605     */
606    bool        debuggerConnected;      /* debugger or DDMS is connected */
607    bool        debuggerActive;         /* debugger is making requests */
608    JdwpState*  jdwpState;
609
610    /*
611     * Registry of objects known to the debugger.
612     */
613    HashTable*  dbgRegistry;
614
615    /*
616     * Debugger breakpoint table.
617     */
618    BreakpointSet*  breakpointSet;
619
620    /*
621     * Single-step control struct.  We currently only allow one thread to
622     * be single-stepping at a time, which is all that really makes sense,
623     * but it's possible we may need to expand this to be per-thread.
624     */
625    StepControl stepControl;
626
627    /*
628     * DDM features embedded in the VM.
629     */
630    bool        ddmThreadNotification;
631
632    /*
633     * Zygote (partially-started process) support
634     */
635    bool        zygote;
636
637    /*
638     * Used for tracking allocations that we report to DDMS.  When the feature
639     * is enabled (through a DDMS request) the "allocRecords" pointer becomes
640     * non-NULL.
641     */
642    pthread_mutex_t allocTrackerLock;
643    AllocRecord*    allocRecords;
644    int             allocRecordHead;        /* most-recently-added entry */
645    int             allocRecordCount;       /* #of valid entries */
646
647    /*
648     * When a profiler is enabled, this is incremented.  Distinct profilers
649     * include "dmtrace" method tracing, emulator method tracing, and
650     * possibly instruction counting.
651     *
652     * The purpose of this is to have a single value that shows whether any
653     * profiling is going on.  Individual thread will normally check their
654     * thread-private subMode flags to take any profiling action.
655     */
656    volatile int activeProfilers;
657
658    /*
659     * State for method-trace profiling.
660     */
661    MethodTraceState methodTrace;
662    Method*     methodTraceGcMethod;
663    Method*     methodTraceClassPrepMethod;
664
665    /*
666     * State for emulator tracing.
667     */
668    void*       emulatorTracePage;
669    int         emulatorTraceEnableCount;
670
671    /*
672     * Global state for memory allocation profiling.
673     */
674    AllocProfState allocProf;
675
676    /*
677     * Pointers to the original methods for things that have been inlined.
678     * This makes it easy for us to output method entry/exit records for
679     * the method calls we're not actually making.  (Used by method
680     * profiling.)
681     */
682    Method**    inlinedMethods;
683
684    /*
685     * Dalvik instruction counts (kNumPackedOpcodes entries).
686     */
687    int*        executedInstrCounts;
688    int         instructionCountEnableCount;
689
690    /*
691     * Signal catcher thread (for SIGQUIT).
692     */
693    pthread_t   signalCatcherHandle;
694    bool        haltSignalCatcher;
695
696    /*
697     * Stdout/stderr conversion thread.
698     */
699    bool            haltStdioConverter;
700    bool            stdioConverterReady;
701    pthread_t       stdioConverterHandle;
702    pthread_mutex_t stdioConverterLock;
703    pthread_cond_t  stdioConverterCond;
704    int             stdoutPipe[2];
705    int             stderrPipe[2];
706
707    /*
708     * pid of the system_server process. We track it so that when system server
709     * crashes the Zygote process will be killed and restarted.
710     */
711    pid_t systemServerPid;
712
713    int kernelGroupScheduling;
714
715//#define COUNT_PRECISE_METHODS
716#ifdef COUNT_PRECISE_METHODS
717    PointerSet* preciseMethods;
718#endif
719
720    /* some RegisterMap statistics, useful during development */
721    void*       registerMapStats;
722
723#ifdef VERIFIER_STATS
724    VerifierStats verifierStats;
725#endif
726
727    /* String pointed here will be deposited on the stack frame of dvmAbort */
728    const char *lastMessage;
729};
730
731extern struct DvmGlobals gDvm;
732
733#if defined(WITH_JIT)
734
735/* Trace profiling modes.  Ordering matters - off states before on states */
736enum TraceProfilingModes {
737    kTraceProfilingDisabled = 0,      // Not profiling
738    kTraceProfilingPeriodicOff = 1,   // Periodic profiling, off phase
739    kTraceProfilingContinuous = 2,    // Always profiling
740    kTraceProfilingPeriodicOn = 3     // Periodic profiling, on phase
741};
742
743/*
744 * Exiting the compiled code w/o chaining will incur overhead to look up the
745 * target in the code cache which is extra work only when JIT is enabled. So
746 * we want to monitor it closely to make sure we don't have performance bugs.
747 */
748enum NoChainExits {
749    kInlineCacheMiss = 0,
750    kCallsiteInterpreted,
751    kSwitchOverflow,
752    kHeavyweightMonitor,
753    kNoChainExitLast,
754};
755
756/*
757 * JIT-specific global state
758 */
759struct DvmJitGlobals {
760    /*
761     * Guards writes to Dalvik PC (dPC), translated code address (codeAddr) and
762     * chain fields within the JIT hash table.  Note carefully the access
763     * mechanism.
764     * Only writes are guarded, and the guarded fields must be updated in a
765     * specific order using atomic operations.  Further, once a field is
766     * written it cannot be changed without halting all threads.
767     *
768     * The write order is:
769     *    1) codeAddr
770     *    2) dPC
771     *    3) chain [if necessary]
772     *
773     * This mutex also guards both read and write of curJitTableEntries.
774     */
775    pthread_mutex_t tableLock;
776
777    /* The JIT hash table.  Note that for access speed, copies of this pointer
778     * are stored in each thread. */
779    struct JitEntry *pJitEntryTable;
780
781    /* Array of compilation trigger threshold counters */
782    unsigned char *pProfTable;
783
784    /* Trace profiling counters */
785    struct JitTraceProfCounters *pJitTraceProfCounters;
786
787    /* Copy of pProfTable used for temporarily disabling the Jit */
788    unsigned char *pProfTableCopy;
789
790    /* Size of JIT hash table in entries.  Must be a power of 2 */
791    unsigned int jitTableSize;
792
793    /* Mask used in hash function for JitTable.  Should be jitTableSize-1 */
794    unsigned int jitTableMask;
795
796    /* How many entries in the JitEntryTable are in use */
797    unsigned int jitTableEntriesUsed;
798
799    /* Bytes allocated for the code cache */
800    unsigned int codeCacheSize;
801
802    /* Trigger for trace selection */
803    unsigned short threshold;
804
805    /* JIT Compiler Control */
806    bool               haltCompilerThread;
807    bool               blockingMode;
808    bool               methodTraceSupport;
809    bool               genSuspendPoll;
810    Thread*            compilerThread;
811    pthread_t          compilerHandle;
812    pthread_mutex_t    compilerLock;
813    pthread_mutex_t    compilerICPatchLock;
814    pthread_cond_t     compilerQueueActivity;
815    pthread_cond_t     compilerQueueEmpty;
816    volatile int       compilerQueueLength;
817    int                compilerHighWater;
818    int                compilerWorkEnqueueIndex;
819    int                compilerWorkDequeueIndex;
820    int                compilerICPatchIndex;
821
822    /* JIT internal stats */
823    int                compilerMaxQueued;
824    int                translationChains;
825
826    /* Compiled code cache */
827    void* codeCache;
828
829    /*
830     * This is used to store the base address of an in-flight compilation whose
831     * class object pointers have been calculated to populate literal pool.
832     * Once the compiler thread has changed its status to VM_WAIT, we cannot
833     * guarantee whether GC has happened before the code address has been
834     * installed to the JIT table. Because of that, this field can only
835     * been cleared/overwritten by the compiler thread if it is in the
836     * THREAD_RUNNING state or in a safe point.
837     */
838    void *inflightBaseAddr;
839
840    /* Translation cache version (protected by compilerLock */
841    int cacheVersion;
842
843    /* Bytes used by the code templates */
844    unsigned int templateSize;
845
846    /* Bytes already used in the code cache */
847    unsigned int codeCacheByteUsed;
848
849    /* Number of installed compilations in the cache */
850    unsigned int numCompilations;
851
852    /* Flag to indicate that the code cache is full */
853    bool codeCacheFull;
854
855    /* Page size  - 1 */
856    unsigned int pageSizeMask;
857
858    /* Lock to change the protection type of the code cache */
859    pthread_mutex_t    codeCacheProtectionLock;
860
861    /* Number of times that the code cache has been reset */
862    int numCodeCacheReset;
863
864    /* Number of times that the code cache reset request has been delayed */
865    int numCodeCacheResetDelayed;
866
867    /* true/false: compile/reject opcodes specified in the -Xjitop list */
868    bool includeSelectedOp;
869
870    /* true/false: compile/reject methods specified in the -Xjitmethod list */
871    bool includeSelectedMethod;
872
873    /* Disable JIT for selected opcodes - one bit for each opcode */
874    char opList[(kNumPackedOpcodes+7)/8];
875
876    /* Disable JIT for selected methods */
877    HashTable *methodTable;
878
879    /* Flag to dump all compiled code */
880    bool printMe;
881
882    /* Per-process debug flag toggled when receiving a SIGUSR2 */
883    bool receivedSIGUSR2;
884
885    /* Trace profiling mode */
886    TraceProfilingModes profileMode;
887
888    /* Periodic trace profiling countdown timer */
889    int profileCountdown;
890
891    /* Vector to disable selected optimizations */
892    int disableOpt;
893
894    /* Table to track the overall and trace statistics of hot methods */
895    HashTable*  methodStatsTable;
896
897    /* Filter method compilation blacklist with call-graph information */
898    bool checkCallGraph;
899
900    /* New translation chain has been set up */
901    volatile bool hasNewChain;
902
903#if defined(WITH_SELF_VERIFICATION)
904    /* Spin when error is detected, volatile so GDB can reset it */
905    volatile bool selfVerificationSpin;
906#endif
907
908    /* Framework or stand-alone? */
909    bool runningInAndroidFramework;
910
911    /* Framework callback happened? */
912    bool alreadyEnabledViaFramework;
913
914    /* Framework requests to disable the JIT for good */
915    bool disableJit;
916
917#if defined(SIGNATURE_BREAKPOINT)
918    /* Signature breakpoint */
919    u4 signatureBreakpointSize;         // # of words
920    u4 *signatureBreakpoint;            // Signature content
921#endif
922
923#if defined(WITH_JIT_TUNING)
924    /* Performance tuning counters */
925    int                addrLookupsFound;
926    int                addrLookupsNotFound;
927    int                noChainExit[kNoChainExitLast];
928    int                normalExit;
929    int                puntExit;
930    int                invokeMonomorphic;
931    int                invokePolymorphic;
932    int                invokeNative;
933    int                invokeMonoGetterInlined;
934    int                invokeMonoSetterInlined;
935    int                invokePolyGetterInlined;
936    int                invokePolySetterInlined;
937    int                returnOp;
938    int                icPatchInit;
939    int                icPatchLockFree;
940    int                icPatchQueued;
941    int                icPatchRejected;
942    int                icPatchDropped;
943    int                codeCachePatches;
944    int                numCompilerThreadBlockGC;
945    u8                 jitTime;
946    u8                 compilerThreadBlockGCStart;
947    u8                 compilerThreadBlockGCTime;
948    u8                 maxCompilerThreadBlockGCTime;
949#endif
950
951    /* Place arrays at the end to ease the display in gdb sessions */
952
953    /* Work order queue for compilations */
954    CompilerWorkOrder compilerWorkQueue[COMPILER_WORK_QUEUE_SIZE];
955
956    /* Work order queue for predicted chain patching */
957    ICPatchWorkOrder compilerICPatchQueue[COMPILER_IC_PATCH_QUEUE_SIZE];
958};
959
960extern struct DvmJitGlobals gDvmJit;
961
962#if defined(WITH_JIT_TUNING)
963extern int gDvmICHitCount;
964#endif
965
966#endif
967
968struct DvmJniGlobals {
969    bool useCheckJni;
970    bool warnOnly;
971    bool forceCopy;
972
973    // Provide backwards compatibility for pre-ICS apps on ICS.
974    bool workAroundAppJniBugs;
975
976    // Debugging help for third-party developers. Similar to -Xjnitrace.
977    bool logThirdPartyJni;
978
979    // We only support a single JavaVM per process.
980    JavaVM*     jniVm;
981};
982
983extern struct DvmJniGlobals gDvmJni;
984
985#endif  // DALVIK_GLOBALS_H_
986