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_ 985