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