dalvik/vm/Globals.h

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