Class.cpp revision ed94ff793680873d2c942641ccda9ea81c95b5ad
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 * Class loading, including bootstrap class loader, linking, and 19 * initialization. 20 */ 21 22#define LOG_CLASS_LOADING 0 23 24#include "Dalvik.h" 25#include "libdex/DexClass.h" 26#include "analysis/Optimize.h" 27 28#include <stdlib.h> 29#include <stddef.h> 30#include <sys/stat.h> 31 32#if LOG_CLASS_LOADING 33#include <unistd.h> 34#include <pthread.h> 35#include <cutils/process_name.h> 36#include <sys/types.h> 37#endif 38 39/* 40Notes on Linking and Verification 41 42The basic way to retrieve a class is to load it, make sure its superclass 43and interfaces are available, prepare its fields, and return it. This gets 44a little more complicated when multiple threads can be trying to retrieve 45the class simultaneously, requiring that we use the class object's monitor 46to keep things orderly. 47 48The linking (preparing, resolving) of a class can cause us to recursively 49load superclasses and interfaces. Barring circular references (e.g. two 50classes that are superclasses of each other), this will complete without 51the loader attempting to access the partially-linked class. 52 53With verification, the situation is different. If we try to verify 54every class as we load it, we quickly run into trouble. Even the lowly 55java.lang.Object requires CloneNotSupportedException; follow the list 56of referenced classes and you can head down quite a trail. The trail 57eventually leads back to Object, which is officially not fully-formed yet. 58 59The VM spec (specifically, v2 5.4.1) notes that classes pulled in during 60verification do not need to be prepared or verified. This means that we 61are allowed to have loaded but unverified classes. It further notes that 62the class must be verified before it is initialized, which allows us to 63defer verification for all classes until class init. You can't execute 64code or access fields in an uninitialized class, so this is safe. 65 66It also allows a more peaceful coexistence between verified and 67unverifiable code. If class A refers to B, and B has a method that 68refers to a bogus class C, should we allow class A to be verified? 69If A only exercises parts of B that don't use class C, then there is 70nothing wrong with running code in A. We can fully verify both A and B, 71and allow execution to continue until B causes initialization of C. The 72VerifyError is thrown close to the point of use. 73 74This gets a little weird with java.lang.Class, which is the only class 75that can be instantiated before it is initialized. We have to force 76initialization right after the class is created, because by definition we 77have instances of it on the heap, and somebody might get a class object and 78start making virtual calls on it. We can end up going recursive during 79verification of java.lang.Class, but we avoid that by checking to see if 80verification is already in progress before we try to initialize it. 81*/ 82 83/* 84Notes on class loaders and interaction with optimization / verification 85 86In what follows, "pre-verification" and "optimization" are the steps 87performed by the dexopt command, which attempts to verify and optimize 88classes as part of unpacking jar files and storing the DEX data in the 89dalvik-cache directory. These steps are performed by loading the DEX 90files directly, without any assistance from ClassLoader instances. 91 92When we pre-verify and optimize a class in a DEX file, we make some 93assumptions about where the class loader will go to look for classes. 94If we can't guarantee those assumptions, e.g. because a class ("AppClass") 95references something not defined in the bootstrap jars or the AppClass jar, 96we can't pre-verify or optimize the class. 97 98The VM doesn't define the behavior of user-defined class loaders. 99For example, suppose application class AppClass, loaded by UserLoader, 100has a method that creates a java.lang.String. The first time 101AppClass.stringyMethod tries to do something with java.lang.String, it 102asks UserLoader to find it. UserLoader is expected to defer to its parent 103loader, but isn't required to. UserLoader might provide a replacement 104for String. 105 106We can run into trouble if we pre-verify AppClass with the assumption that 107java.lang.String will come from core.jar, and don't verify this assumption 108at runtime. There are two places that an alternate implementation of 109java.lang.String can come from: the AppClass jar, or from some other jar 110that UserLoader knows about. (Someday UserLoader will be able to generate 111some bytecode and call DefineClass, but not yet.) 112 113To handle the first situation, the pre-verifier will explicitly check for 114conflicts between the class being optimized/verified and the bootstrap 115classes. If an app jar contains a class that has the same package and 116class name as a class in a bootstrap jar, the verification resolver refuses 117to find either, which will block pre-verification and optimization on 118classes that reference ambiguity. The VM will postpone verification of 119the app class until first load. 120 121For the second situation, we need to ensure that all references from a 122pre-verified class are satisified by the class' jar or earlier bootstrap 123jars. In concrete terms: when resolving a reference to NewClass, 124which was caused by a reference in class AppClass, we check to see if 125AppClass was pre-verified. If so, we require that NewClass comes out 126of either the AppClass jar or one of the jars in the bootstrap path. 127(We may not control the class loaders, but we do manage the DEX files. 128We can verify that it's either (loader==null && dexFile==a_boot_dex) 129or (loader==UserLoader && dexFile==AppClass.dexFile). Classes from 130DefineClass can't be pre-verified, so this doesn't apply.) 131 132This should ensure that you can't "fake out" the pre-verifier by creating 133a user-defined class loader that replaces system classes. It should 134also ensure that you can write such a loader and have it work in the 135expected fashion; all you lose is some performance due to "just-in-time 136verification" and the lack of DEX optimizations. 137 138There is a "back door" of sorts in the class resolution check, due to 139the fact that the "class ref" entries are shared between the bytecode 140and meta-data references (e.g. annotations and exception handler lists). 141The class references in annotations have no bearing on class verification, 142so when a class does an annotation query that causes a class reference 143index to be resolved, we don't want to fail just because the calling 144class was pre-verified and the resolved class is in some random DEX file. 145The successful resolution adds the class to the "resolved classes" table, 146so when optimized bytecode references it we don't repeat the resolve-time 147check. We can avoid this by not updating the "resolved classes" table 148when the class reference doesn't come out of something that has been 149checked by the verifier, but that has a nonzero performance impact. 150Since the ultimate goal of this test is to catch an unusual situation 151(user-defined class loaders redefining core classes), the added caution 152may not be worth the performance hit. 153*/ 154 155/* 156 * Class serial numbers start at this value. We use a nonzero initial 157 * value so they stand out in binary dumps (e.g. hprof output). 158 */ 159#define INITIAL_CLASS_SERIAL_NUMBER 0x50000000 160 161/* 162 * Constant used to size an auxillary class object data structure. 163 * For optimum memory use this should be equal to or slightly larger than 164 * the number of classes loaded when the zygote finishes initializing. 165 */ 166#define ZYGOTE_CLASS_CUTOFF 2304 167 168#define CLASS_SFIELD_SLOTS 1 169 170static ClassPathEntry* processClassPath(const char* pathStr, bool isBootstrap); 171static void freeCpeArray(ClassPathEntry* cpe); 172 173static ClassObject* findClassFromLoaderNoInit( 174 const char* descriptor, Object* loader); 175static ClassObject* findClassNoInit(const char* descriptor, Object* loader,\ 176 DvmDex* pDvmDex); 177static ClassObject* loadClassFromDex(DvmDex* pDvmDex, 178 const DexClassDef* pClassDef, Object* loader); 179static void loadMethodFromDex(ClassObject* clazz, const DexMethod* pDexMethod,\ 180 Method* meth); 181static int computeJniArgInfo(const DexProto* proto); 182static void loadSFieldFromDex(ClassObject* clazz, 183 const DexField* pDexSField, StaticField* sfield); 184static void loadIFieldFromDex(ClassObject* clazz, 185 const DexField* pDexIField, InstField* field); 186static bool precacheReferenceOffsets(ClassObject* clazz); 187static void computeRefOffsets(ClassObject* clazz); 188static void freeMethodInnards(Method* meth); 189static bool createVtable(ClassObject* clazz); 190static bool createIftable(ClassObject* clazz); 191static bool insertMethodStubs(ClassObject* clazz); 192static bool computeFieldOffsets(ClassObject* clazz); 193static void throwEarlierClassFailure(ClassObject* clazz); 194 195#if LOG_CLASS_LOADING 196/* 197 * Logs information about a class loading with given timestamp. 198 * 199 * TODO: In the case where we fail in dvmLinkClass() and log the class as closing (type='<'), 200 * it would probably be better to use a new type code to indicate the failure. This change would 201 * require a matching change in the parser and analysis code in frameworks/base/tools/preload. 202 */ 203static void logClassLoadWithTime(char type, ClassObject* clazz, u8 time) { 204 pid_t ppid = getppid(); 205 pid_t pid = getpid(); 206 unsigned int tid = (unsigned int) pthread_self(); 207 208 ALOG(LOG_INFO, "PRELOAD", "%c%d:%d:%d:%s:%d:%s:%lld", type, ppid, pid, tid, 209 get_process_name(), (int) clazz->classLoader, clazz->descriptor, 210 time); 211} 212 213/* 214 * Logs information about a class loading. 215 */ 216static void logClassLoad(char type, ClassObject* clazz) { 217 logClassLoadWithTime(type, clazz, dvmGetThreadCpuTimeNsec()); 218} 219#endif 220 221/* 222 * Some LinearAlloc unit tests. 223 */ 224static void linearAllocTests() 225{ 226 char* fiddle; 227 int test = 1; 228 229 switch (test) { 230 case 0: 231 fiddle = (char*)dvmLinearAlloc(NULL, 3200-28); 232 dvmLinearReadOnly(NULL, (char*)fiddle); 233 break; 234 case 1: 235 fiddle = (char*)dvmLinearAlloc(NULL, 3200-24); 236 dvmLinearReadOnly(NULL, (char*)fiddle); 237 break; 238 case 2: 239 fiddle = (char*)dvmLinearAlloc(NULL, 3200-20); 240 dvmLinearReadOnly(NULL, (char*)fiddle); 241 break; 242 case 3: 243 fiddle = (char*)dvmLinearAlloc(NULL, 3200-16); 244 dvmLinearReadOnly(NULL, (char*)fiddle); 245 break; 246 case 4: 247 fiddle = (char*)dvmLinearAlloc(NULL, 3200-12); 248 dvmLinearReadOnly(NULL, (char*)fiddle); 249 break; 250 } 251 fiddle = (char*)dvmLinearAlloc(NULL, 896); 252 dvmLinearReadOnly(NULL, (char*)fiddle); 253 fiddle = (char*)dvmLinearAlloc(NULL, 20); // watch addr of this alloc 254 dvmLinearReadOnly(NULL, (char*)fiddle); 255 256 fiddle = (char*)dvmLinearAlloc(NULL, 1); 257 fiddle[0] = 'q'; 258 dvmLinearReadOnly(NULL, fiddle); 259 fiddle = (char*)dvmLinearAlloc(NULL, 4096); 260 fiddle[0] = 'x'; 261 fiddle[4095] = 'y'; 262 dvmLinearReadOnly(NULL, fiddle); 263 dvmLinearFree(NULL, fiddle); 264 fiddle = (char*)dvmLinearAlloc(NULL, 0); 265 dvmLinearReadOnly(NULL, fiddle); 266 fiddle = (char*)dvmLinearRealloc(NULL, fiddle, 12); 267 fiddle[11] = 'z'; 268 dvmLinearReadOnly(NULL, (char*)fiddle); 269 fiddle = (char*)dvmLinearRealloc(NULL, fiddle, 5); 270 dvmLinearReadOnly(NULL, fiddle); 271 fiddle = (char*)dvmLinearAlloc(NULL, 17001); 272 fiddle[0] = 'x'; 273 fiddle[17000] = 'y'; 274 dvmLinearReadOnly(NULL, (char*)fiddle); 275 276 char* str = (char*)dvmLinearStrdup(NULL, "This is a test!"); 277 ALOGI("GOT: '%s'", str); 278 279 /* try to check the bounds; allocator may round allocation size up */ 280 fiddle = (char*)dvmLinearAlloc(NULL, 12); 281 ALOGI("Should be 1: %d", dvmLinearAllocContains(fiddle, 12)); 282 ALOGI("Should be 0: %d", dvmLinearAllocContains(fiddle, 13)); 283 ALOGI("Should be 0: %d", dvmLinearAllocContains(fiddle - 128*1024, 1)); 284 285 dvmLinearAllocDump(NULL); 286 dvmLinearFree(NULL, (char*)str); 287} 288 289static size_t classObjectSize(size_t sfieldCount) 290{ 291 size_t offset = OFFSETOF_MEMBER(ClassObject, sfields); 292 return offset + sizeof(StaticField) * sfieldCount; 293} 294 295size_t dvmClassObjectSize(const ClassObject *clazz) 296{ 297 assert(clazz != NULL); 298 return classObjectSize(clazz->sfieldCount); 299} 300 301/* (documented in header) */ 302ClassObject* dvmFindPrimitiveClass(char type) 303{ 304 PrimitiveType primitiveType = dexGetPrimitiveTypeFromDescriptorChar(type); 305 306 switch (primitiveType) { 307 case PRIM_VOID: return gDvm.typeVoid; 308 case PRIM_BOOLEAN: return gDvm.typeBoolean; 309 case PRIM_BYTE: return gDvm.typeByte; 310 case PRIM_SHORT: return gDvm.typeShort; 311 case PRIM_CHAR: return gDvm.typeChar; 312 case PRIM_INT: return gDvm.typeInt; 313 case PRIM_LONG: return gDvm.typeLong; 314 case PRIM_FLOAT: return gDvm.typeFloat; 315 case PRIM_DOUBLE: return gDvm.typeDouble; 316 default: { 317 ALOGW("Unknown primitive type '%c'", type); 318 return NULL; 319 } 320 } 321} 322 323/* 324 * Synthesize a primitive class. 325 * 326 * Just creates the class and returns it (does not add it to the class list). 327 */ 328static bool createPrimitiveType(PrimitiveType primitiveType, ClassObject** pClass) 329{ 330 /* 331 * Fill out a few fields in the ClassObject. 332 * 333 * Note that primitive classes do not sub-class the class Object. 334 * This matters for "instanceof" checks. Also, we assume that the 335 * primitive class does not override finalize(). 336 */ 337 338 const char* descriptor = dexGetPrimitiveTypeDescriptor(primitiveType); 339 assert(descriptor != NULL); 340 341 ClassObject* newClass = (ClassObject*) dvmMalloc(sizeof(*newClass), ALLOC_NON_MOVING); 342 if (newClass == NULL) { 343 return false; 344 } 345 346 DVM_OBJECT_INIT(newClass, gDvm.classJavaLangClass); 347 dvmSetClassSerialNumber(newClass); 348 SET_CLASS_FLAG(newClass, ACC_PUBLIC | ACC_FINAL | ACC_ABSTRACT); 349 newClass->primitiveType = primitiveType; 350 newClass->descriptorAlloc = NULL; 351 newClass->descriptor = descriptor; 352 newClass->super = NULL; 353 newClass->status = CLASS_INITIALIZED; 354 355 /* don't need to set newClass->objectSize */ 356 357 LOGVV("Constructed class for primitive type '%s'", newClass->descriptor); 358 359 *pClass = newClass; 360 dvmReleaseTrackedAlloc((Object*) newClass, NULL); 361 362 return true; 363} 364 365/* 366 * Create the initial class instances. These consist of the class 367 * Class and all of the classes representing primitive types. 368 */ 369static bool createInitialClasses() { 370 /* 371 * Initialize the class Class. This has to be done specially, particularly 372 * because it is an instance of itself. 373 */ 374 ClassObject* clazz = (ClassObject*) 375 dvmMalloc(classObjectSize(CLASS_SFIELD_SLOTS), ALLOC_NON_MOVING); 376 if (clazz == NULL) { 377 return false; 378 } 379 DVM_OBJECT_INIT(clazz, clazz); 380 SET_CLASS_FLAG(clazz, ACC_PUBLIC | ACC_FINAL | CLASS_ISCLASS); 381 clazz->descriptor = "Ljava/lang/Class;"; 382 gDvm.classJavaLangClass = clazz; 383 LOGVV("Constructed the class Class."); 384 385 /* 386 * Initialize the classes representing primitive types. These are 387 * instances of the class Class, but other than that they're fairly 388 * different from regular classes. 389 */ 390 bool ok = true; 391 ok &= createPrimitiveType(PRIM_VOID, &gDvm.typeVoid); 392 ok &= createPrimitiveType(PRIM_BOOLEAN, &gDvm.typeBoolean); 393 ok &= createPrimitiveType(PRIM_BYTE, &gDvm.typeByte); 394 ok &= createPrimitiveType(PRIM_SHORT, &gDvm.typeShort); 395 ok &= createPrimitiveType(PRIM_CHAR, &gDvm.typeChar); 396 ok &= createPrimitiveType(PRIM_INT, &gDvm.typeInt); 397 ok &= createPrimitiveType(PRIM_LONG, &gDvm.typeLong); 398 ok &= createPrimitiveType(PRIM_FLOAT, &gDvm.typeFloat); 399 ok &= createPrimitiveType(PRIM_DOUBLE, &gDvm.typeDouble); 400 401 return ok; 402} 403 404/* 405 * Initialize the bootstrap class loader. 406 * 407 * Call this after the bootclasspath string has been finalized. 408 */ 409bool dvmClassStartup() 410{ 411 /* make this a requirement -- don't currently support dirs in path */ 412 if (strcmp(gDvm.bootClassPathStr, ".") == 0) { 413 ALOGE("ERROR: must specify non-'.' bootclasspath"); 414 return false; 415 } 416 417 gDvm.loadedClasses = 418 dvmHashTableCreate(256, (HashFreeFunc) dvmFreeClassInnards); 419 420 gDvm.pBootLoaderAlloc = dvmLinearAllocCreate(NULL); 421 if (gDvm.pBootLoaderAlloc == NULL) 422 return false; 423 424 if (false) { 425 linearAllocTests(); 426 exit(0); 427 } 428 429 /* 430 * Class serial number. We start with a high value to make it distinct 431 * in binary dumps (e.g. hprof). 432 */ 433 gDvm.classSerialNumber = INITIAL_CLASS_SERIAL_NUMBER; 434 435 /* 436 * Set up the table we'll use for tracking initiating loaders for 437 * early classes. 438 * If it's NULL, we just fall back to the InitiatingLoaderList in the 439 * ClassObject, so it's not fatal to fail this allocation. 440 */ 441 gDvm.initiatingLoaderList = (InitiatingLoaderList*) 442 calloc(ZYGOTE_CLASS_CUTOFF, sizeof(InitiatingLoaderList)); 443 444 /* 445 * Create the initial classes. These are the first objects constructed 446 * within the nascent VM. 447 */ 448 if (!createInitialClasses()) { 449 return false; 450 } 451 452 /* 453 * Process the bootstrap class path. This means opening the specified 454 * DEX or Jar files and possibly running them through the optimizer. 455 */ 456 assert(gDvm.bootClassPath == NULL); 457 processClassPath(gDvm.bootClassPathStr, true); 458 459 if (gDvm.bootClassPath == NULL) 460 return false; 461 462 return true; 463} 464 465/* 466 * Clean up. 467 */ 468void dvmClassShutdown() 469{ 470 /* discard all system-loaded classes */ 471 dvmHashTableFree(gDvm.loadedClasses); 472 gDvm.loadedClasses = NULL; 473 474 /* discard primitive classes created for arrays */ 475 dvmFreeClassInnards(gDvm.typeVoid); 476 dvmFreeClassInnards(gDvm.typeBoolean); 477 dvmFreeClassInnards(gDvm.typeByte); 478 dvmFreeClassInnards(gDvm.typeShort); 479 dvmFreeClassInnards(gDvm.typeChar); 480 dvmFreeClassInnards(gDvm.typeInt); 481 dvmFreeClassInnards(gDvm.typeLong); 482 dvmFreeClassInnards(gDvm.typeFloat); 483 dvmFreeClassInnards(gDvm.typeDouble); 484 485 /* this closes DEX files, JAR files, etc. */ 486 freeCpeArray(gDvm.bootClassPath); 487 gDvm.bootClassPath = NULL; 488 489 dvmLinearAllocDestroy(NULL); 490 491 free(gDvm.initiatingLoaderList); 492} 493 494 495/* 496 * =========================================================================== 497 * Bootstrap class loader 498 * =========================================================================== 499 */ 500 501/* 502 * Dump the contents of a ClassPathEntry array. 503 */ 504static void dumpClassPath(const ClassPathEntry* cpe) 505{ 506 int idx = 0; 507 508 while (cpe->kind != kCpeLastEntry) { 509 const char* kindStr; 510 511 switch (cpe->kind) { 512 case kCpeJar: kindStr = "jar"; break; 513 case kCpeDex: kindStr = "dex"; break; 514 default: kindStr = "???"; break; 515 } 516 517 ALOGI(" %2d: type=%s %s %p", idx, kindStr, cpe->fileName, cpe->ptr); 518 if (CALC_CACHE_STATS && cpe->kind == kCpeJar) { 519 JarFile* pJarFile = (JarFile*) cpe->ptr; 520 DvmDex* pDvmDex = dvmGetJarFileDex(pJarFile); 521 dvmDumpAtomicCacheStats(pDvmDex->pInterfaceCache); 522 } 523 524 cpe++; 525 idx++; 526 } 527} 528 529/* 530 * Dump the contents of the bootstrap class path. 531 */ 532void dvmDumpBootClassPath() 533{ 534 dumpClassPath(gDvm.bootClassPath); 535} 536 537/* 538 * Returns "true" if the class path contains the specified path. 539 */ 540bool dvmClassPathContains(const ClassPathEntry* cpe, const char* path) 541{ 542 while (cpe->kind != kCpeLastEntry) { 543 if (strcmp(cpe->fileName, path) == 0) 544 return true; 545 546 cpe++; 547 } 548 return false; 549} 550 551/* 552 * Free an array of ClassPathEntry structs. 553 * 554 * We release the contents of each entry, then free the array itself. 555 */ 556static void freeCpeArray(ClassPathEntry* cpe) 557{ 558 ClassPathEntry* cpeStart = cpe; 559 560 if (cpe == NULL) 561 return; 562 563 while (cpe->kind != kCpeLastEntry) { 564 switch (cpe->kind) { 565 case kCpeJar: 566 /* free JarFile */ 567 dvmJarFileFree((JarFile*) cpe->ptr); 568 break; 569 case kCpeDex: 570 /* free RawDexFile */ 571 dvmRawDexFileFree((RawDexFile*) cpe->ptr); 572 break; 573 default: 574 assert(false); 575 break; 576 } 577 578 free(cpe->fileName); 579 cpe++; 580 } 581 582 free(cpeStart); 583} 584 585/* 586 * Get the filename suffix of the given file (everything after the 587 * last "." if any, or "<none>" if there's no apparent suffix). The 588 * passed-in buffer will always be '\0' terminated. 589 */ 590static void getFileNameSuffix(const char* fileName, char* suffixBuf, size_t suffixBufLen) 591{ 592 const char* lastDot = strrchr(fileName, '.'); 593 594 strlcpy(suffixBuf, (lastDot == NULL) ? "<none>" : (lastDot + 1), suffixBufLen); 595} 596 597/* 598 * Prepare a ClassPathEntry struct, which at this point only has a valid 599 * filename. We need to figure out what kind of file it is, and for 600 * everything other than directories we need to open it up and see 601 * what's inside. 602 */ 603static bool prepareCpe(ClassPathEntry* cpe, bool isBootstrap) 604{ 605 struct stat sb; 606 607 if (stat(cpe->fileName, &sb) < 0) { 608 ALOGD("Unable to stat classpath element '%s'", cpe->fileName); 609 return false; 610 } 611 if (S_ISDIR(sb.st_mode)) { 612 ALOGE("Directory classpath elements are not supported: %s", cpe->fileName); 613 return false; 614 } 615 616 char suffix[10]; 617 getFileNameSuffix(cpe->fileName, suffix, sizeof(suffix)); 618 619 if ((strcmp(suffix, "jar") == 0) || (strcmp(suffix, "zip") == 0) || 620 (strcmp(suffix, "apk") == 0)) { 621 JarFile* pJarFile = NULL; 622 if (dvmJarFileOpen(cpe->fileName, NULL, &pJarFile, isBootstrap) == 0) { 623 cpe->kind = kCpeJar; 624 cpe->ptr = pJarFile; 625 return true; 626 } 627 } else if (strcmp(suffix, "dex") == 0) { 628 RawDexFile* pRawDexFile = NULL; 629 if (dvmRawDexFileOpen(cpe->fileName, NULL, &pRawDexFile, isBootstrap) == 0) { 630 cpe->kind = kCpeDex; 631 cpe->ptr = pRawDexFile; 632 return true; 633 } 634 } else { 635 ALOGE("Unknown type suffix '%s'", suffix); 636 } 637 638 ALOGD("Unable to process classpath element '%s'", cpe->fileName); 639 return false; 640} 641 642/* 643 * Convert a colon-separated list of directories, Zip files, and DEX files 644 * into an array of ClassPathEntry structs. 645 * 646 * During normal startup we fail if there are no entries, because we won't 647 * get very far without the basic language support classes, but if we're 648 * optimizing a DEX file we allow it. 649 * 650 * If entries are added or removed from the bootstrap class path, the 651 * dependencies in the DEX files will break, and everything except the 652 * very first entry will need to be regenerated. 653 */ 654static ClassPathEntry* processClassPath(const char* pathStr, bool isBootstrap) 655{ 656 ClassPathEntry* cpe = NULL; 657 char* mangle; 658 char* cp; 659 const char* end; 660 int idx, count; 661 662 assert(pathStr != NULL); 663 664 mangle = strdup(pathStr); 665 666 /* 667 * Run through and essentially strtok() the string. Get a count of 668 * the #of elements while we're at it. 669 * 670 * If the path was constructed strangely (e.g. ":foo::bar:") this will 671 * over-allocate, which isn't ideal but is mostly harmless. 672 */ 673 count = 1; 674 for (cp = mangle; *cp != '\0'; cp++) { 675 if (*cp == ':') { /* separates two entries */ 676 count++; 677 *cp = '\0'; 678 } 679 } 680 end = cp; 681 682 /* 683 * Allocate storage. We over-alloc by one so we can set an "end" marker. 684 */ 685 cpe = (ClassPathEntry*) calloc(count+1, sizeof(ClassPathEntry)); 686 687 /* 688 * Set the global pointer so the DEX file dependency stuff can find it. 689 */ 690 gDvm.bootClassPath = cpe; 691 692 /* 693 * Go through a second time, pulling stuff out. 694 */ 695 cp = mangle; 696 idx = 0; 697 while (cp < end) { 698 if (*cp == '\0') { 699 /* leading, trailing, or doubled ':'; ignore it */ 700 } else { 701 if (isBootstrap && 702 dvmPathToAbsolutePortion(cp) == NULL) { 703 ALOGE("Non-absolute bootclasspath entry '%s'", cp); 704 free(cpe); 705 cpe = NULL; 706 goto bail; 707 } 708 709 ClassPathEntry tmp; 710 tmp.kind = kCpeUnknown; 711 tmp.fileName = strdup(cp); 712 tmp.ptr = NULL; 713 714 /* 715 * Drop an end marker here so DEX loader can walk unfinished 716 * list. 717 */ 718 cpe[idx].kind = kCpeLastEntry; 719 cpe[idx].fileName = NULL; 720 cpe[idx].ptr = NULL; 721 722 if (!prepareCpe(&tmp, isBootstrap)) { 723 /* drop from list and continue on */ 724 free(tmp.fileName); 725 } else { 726 /* copy over, pointers and all */ 727 cpe[idx] = tmp; 728 idx++; 729 } 730 } 731 732 cp += strlen(cp) +1; 733 } 734 assert(idx <= count); 735 if (idx == 0 && !gDvm.optimizing) { 736 /* 737 * There's no way the vm will be doing anything if this is the 738 * case, so just bail out (reasonably) gracefully. 739 */ 740 ALOGE("No valid entries found in bootclasspath '%s'", pathStr); 741 gDvm.lastMessage = pathStr; 742 dvmAbort(); 743 } 744 745 LOGVV(" (filled %d of %d slots)", idx, count); 746 747 /* put end marker in over-alloc slot */ 748 cpe[idx].kind = kCpeLastEntry; 749 cpe[idx].fileName = NULL; 750 cpe[idx].ptr = NULL; 751 752 //dumpClassPath(cpe); 753 754bail: 755 free(mangle); 756 gDvm.bootClassPath = cpe; 757 return cpe; 758} 759 760/* 761 * Search the DEX files we loaded from the bootstrap class path for a DEX 762 * file that has the class with the matching descriptor. 763 * 764 * Returns the matching DEX file and DexClassDef entry if found, otherwise 765 * returns NULL. 766 */ 767static DvmDex* searchBootPathForClass(const char* descriptor, 768 const DexClassDef** ppClassDef) 769{ 770 const ClassPathEntry* cpe = gDvm.bootClassPath; 771 const DexClassDef* pFoundDef = NULL; 772 DvmDex* pFoundFile = NULL; 773 774 LOGVV("+++ class '%s' not yet loaded, scanning bootclasspath...", 775 descriptor); 776 777 while (cpe->kind != kCpeLastEntry) { 778 //ALOGV("+++ checking '%s' (%d)", cpe->fileName, cpe->kind); 779 780 switch (cpe->kind) { 781 case kCpeJar: 782 { 783 JarFile* pJarFile = (JarFile*) cpe->ptr; 784 const DexClassDef* pClassDef; 785 DvmDex* pDvmDex; 786 787 pDvmDex = dvmGetJarFileDex(pJarFile); 788 pClassDef = dexFindClass(pDvmDex->pDexFile, descriptor); 789 if (pClassDef != NULL) { 790 /* found */ 791 pFoundDef = pClassDef; 792 pFoundFile = pDvmDex; 793 goto found; 794 } 795 } 796 break; 797 case kCpeDex: 798 { 799 RawDexFile* pRawDexFile = (RawDexFile*) cpe->ptr; 800 const DexClassDef* pClassDef; 801 DvmDex* pDvmDex; 802 803 pDvmDex = dvmGetRawDexFileDex(pRawDexFile); 804 pClassDef = dexFindClass(pDvmDex->pDexFile, descriptor); 805 if (pClassDef != NULL) { 806 /* found */ 807 pFoundDef = pClassDef; 808 pFoundFile = pDvmDex; 809 goto found; 810 } 811 } 812 break; 813 default: 814 ALOGE("Unknown kind %d", cpe->kind); 815 assert(false); 816 break; 817 } 818 819 cpe++; 820 } 821 822 /* 823 * Special handling during verification + optimization. 824 * 825 * The DEX optimizer needs to load classes from the DEX file it's working 826 * on. Rather than trying to insert it into the bootstrap class path 827 * or synthesizing a class loader to manage it, we just make it available 828 * here. It logically comes after all existing entries in the bootstrap 829 * class path. 830 */ 831 if (gDvm.bootClassPathOptExtra != NULL) { 832 const DexClassDef* pClassDef; 833 834 pClassDef = 835 dexFindClass(gDvm.bootClassPathOptExtra->pDexFile, descriptor); 836 if (pClassDef != NULL) { 837 /* found */ 838 pFoundDef = pClassDef; 839 pFoundFile = gDvm.bootClassPathOptExtra; 840 } 841 } 842 843found: 844 *ppClassDef = pFoundDef; 845 return pFoundFile; 846} 847 848/* 849 * Set the "extra" DEX, which becomes a de facto member of the bootstrap 850 * class set. 851 */ 852void dvmSetBootPathExtraDex(DvmDex* pDvmDex) 853{ 854 gDvm.bootClassPathOptExtra = pDvmDex; 855} 856 857 858/* 859 * Return the #of entries in the bootstrap class path. 860 * 861 * (Used for ClassLoader.getResources().) 862 */ 863int dvmGetBootPathSize() 864{ 865 const ClassPathEntry* cpe = gDvm.bootClassPath; 866 867 while (cpe->kind != kCpeLastEntry) 868 cpe++; 869 870 return cpe - gDvm.bootClassPath; 871} 872 873/* 874 * Find a resource with the specified name in entry N of the boot class path. 875 * 876 * We return a newly-allocated String of one of these forms: 877 * file://path/name 878 * jar:file://path!/name 879 * Where "path" is the bootstrap class path entry and "name" is the string 880 * passed into this method. "path" needs to be an absolute path (starting 881 * with '/'); if it's not we'd need to "absolutify" it as part of forming 882 * the URL string. 883 */ 884StringObject* dvmGetBootPathResource(const char* name, int idx) 885{ 886 const int kUrlOverhead = 13; // worst case for Jar URL 887 const ClassPathEntry* cpe = gDvm.bootClassPath; 888 StringObject* urlObj = NULL; 889 890 ALOGV("+++ searching for resource '%s' in %d(%s)", 891 name, idx, cpe[idx].fileName); 892 893 /* we could use direct array index, but I don't entirely trust "idx" */ 894 while (idx-- && cpe->kind != kCpeLastEntry) 895 cpe++; 896 if (cpe->kind == kCpeLastEntry) { 897 assert(false); 898 return NULL; 899 } 900 901 char urlBuf[strlen(name) + strlen(cpe->fileName) + kUrlOverhead +1]; 902 903 switch (cpe->kind) { 904 case kCpeJar: 905 { 906 JarFile* pJarFile = (JarFile*) cpe->ptr; 907 if (dexZipFindEntry(&pJarFile->archive, name) == NULL) 908 goto bail; 909 sprintf(urlBuf, "jar:file://%s!/%s", cpe->fileName, name); 910 } 911 break; 912 case kCpeDex: 913 ALOGV("No resources in DEX files"); 914 goto bail; 915 default: 916 assert(false); 917 goto bail; 918 } 919 920 ALOGV("+++ using URL='%s'", urlBuf); 921 urlObj = dvmCreateStringFromCstr(urlBuf); 922 923bail: 924 return urlObj; 925} 926 927 928/* 929 * =========================================================================== 930 * Class list management 931 * =========================================================================== 932 */ 933 934/* search for these criteria in the Class hash table */ 935struct ClassMatchCriteria { 936 const char* descriptor; 937 Object* loader; 938}; 939 940#define kInitLoaderInc 4 /* must be power of 2 */ 941 942static InitiatingLoaderList *dvmGetInitiatingLoaderList(ClassObject* clazz) 943{ 944 assert(clazz->serialNumber >= INITIAL_CLASS_SERIAL_NUMBER); 945 int classIndex = clazz->serialNumber-INITIAL_CLASS_SERIAL_NUMBER; 946 if (gDvm.initiatingLoaderList != NULL && 947 classIndex < ZYGOTE_CLASS_CUTOFF) { 948 return &(gDvm.initiatingLoaderList[classIndex]); 949 } else { 950 return &(clazz->initiatingLoaderList); 951 } 952} 953 954/* 955 * Determine if "loader" appears in clazz' initiating loader list. 956 * 957 * The class hash table lock must be held when calling here, since 958 * it's also used when updating a class' initiating loader list. 959 * 960 * TODO: switch to some sort of lock-free data structure so we don't have 961 * to grab the lock to do a lookup. Among other things, this would improve 962 * the speed of compareDescriptorClasses(). 963 */ 964bool dvmLoaderInInitiatingList(const ClassObject* clazz, const Object* loader) 965{ 966 /* 967 * The bootstrap class loader can't be just an initiating loader for 968 * anything (it's always the defining loader if the class is visible 969 * to it). We don't put defining loaders in the initiating list. 970 */ 971 if (loader == NULL) 972 return false; 973 974 /* 975 * Scan the list for a match. The list is expected to be short. 976 */ 977 /* Cast to remove the const from clazz, but use const loaderList */ 978 ClassObject* nonConstClazz = (ClassObject*) clazz; 979 const InitiatingLoaderList *loaderList = 980 dvmGetInitiatingLoaderList(nonConstClazz); 981 int i; 982 for (i = loaderList->initiatingLoaderCount-1; i >= 0; --i) { 983 if (loaderList->initiatingLoaders[i] == loader) { 984 //ALOGI("+++ found initiating match %p in %s", 985 // loader, clazz->descriptor); 986 return true; 987 } 988 } 989 return false; 990} 991 992/* 993 * Add "loader" to clazz's initiating loader set, unless it's the defining 994 * class loader. 995 * 996 * In the common case this will be a short list, so we don't need to do 997 * anything too fancy here. 998 * 999 * This locks gDvm.loadedClasses for synchronization, so don't hold it 1000 * when calling here. 1001 */ 1002void dvmAddInitiatingLoader(ClassObject* clazz, Object* loader) 1003{ 1004 if (loader != clazz->classLoader) { 1005 assert(loader != NULL); 1006 1007 LOGVV("Adding %p to '%s' init list", loader, clazz->descriptor); 1008 dvmHashTableLock(gDvm.loadedClasses); 1009 1010 /* 1011 * Make sure nobody snuck in. The penalty for adding twice is 1012 * pretty minor, and probably outweighs the O(n^2) hit for 1013 * checking before every add, so we may not want to do this. 1014 */ 1015 //if (dvmLoaderInInitiatingList(clazz, loader)) { 1016 // ALOGW("WOW: simultaneous add of initiating class loader"); 1017 // goto bail_unlock; 1018 //} 1019 1020 /* 1021 * The list never shrinks, so we just keep a count of the 1022 * number of elements in it, and reallocate the buffer when 1023 * we run off the end. 1024 * 1025 * The pointer is initially NULL, so we *do* want to call realloc 1026 * when count==0. 1027 */ 1028 InitiatingLoaderList *loaderList = dvmGetInitiatingLoaderList(clazz); 1029 if ((loaderList->initiatingLoaderCount & (kInitLoaderInc-1)) == 0) { 1030 Object** newList; 1031 1032 newList = (Object**) realloc(loaderList->initiatingLoaders, 1033 (loaderList->initiatingLoaderCount + kInitLoaderInc) 1034 * sizeof(Object*)); 1035 if (newList == NULL) { 1036 /* this is mainly a cache, so it's not the EotW */ 1037 assert(false); 1038 goto bail_unlock; 1039 } 1040 loaderList->initiatingLoaders = newList; 1041 1042 //ALOGI("Expanded init list to %d (%s)", 1043 // loaderList->initiatingLoaderCount+kInitLoaderInc, 1044 // clazz->descriptor); 1045 } 1046 loaderList->initiatingLoaders[loaderList->initiatingLoaderCount++] = 1047 loader; 1048 1049bail_unlock: 1050 dvmHashTableUnlock(gDvm.loadedClasses); 1051 } 1052} 1053 1054/* 1055 * (This is a dvmHashTableLookup callback.) 1056 * 1057 * Entries in the class hash table are stored as { descriptor, d-loader } 1058 * tuples. If the hashed class descriptor matches the requested descriptor, 1059 * and the hashed defining class loader matches the requested class 1060 * loader, we're good. If only the descriptor matches, we check to see if the 1061 * loader is in the hashed class' initiating loader list. If so, we 1062 * can return "true" immediately and skip some of the loadClass melodrama. 1063 * 1064 * The caller must lock the hash table before calling here. 1065 * 1066 * Returns 0 if a matching entry is found, nonzero otherwise. 1067 */ 1068static int hashcmpClassByCrit(const void* vclazz, const void* vcrit) 1069{ 1070 const ClassObject* clazz = (const ClassObject*) vclazz; 1071 const ClassMatchCriteria* pCrit = (const ClassMatchCriteria*) vcrit; 1072 bool match; 1073 1074 match = (strcmp(clazz->descriptor, pCrit->descriptor) == 0 && 1075 (clazz->classLoader == pCrit->loader || 1076 (pCrit->loader != NULL && 1077 dvmLoaderInInitiatingList(clazz, pCrit->loader)) )); 1078 //if (match) 1079 // ALOGI("+++ %s %p matches existing %s %p", 1080 // pCrit->descriptor, pCrit->loader, 1081 // clazz->descriptor, clazz->classLoader); 1082 return !match; 1083} 1084 1085/* 1086 * Like hashcmpClassByCrit, but passing in a fully-formed ClassObject 1087 * instead of a ClassMatchCriteria. 1088 */ 1089static int hashcmpClassByClass(const void* vclazz, const void* vaddclazz) 1090{ 1091 const ClassObject* clazz = (const ClassObject*) vclazz; 1092 const ClassObject* addClazz = (const ClassObject*) vaddclazz; 1093 bool match; 1094 1095 match = (strcmp(clazz->descriptor, addClazz->descriptor) == 0 && 1096 (clazz->classLoader == addClazz->classLoader || 1097 (addClazz->classLoader != NULL && 1098 dvmLoaderInInitiatingList(clazz, addClazz->classLoader)) )); 1099 return !match; 1100} 1101 1102/* 1103 * Search through the hash table to find an entry with a matching descriptor 1104 * and an initiating class loader that matches "loader". 1105 * 1106 * The table entries are hashed on descriptor only, because they're unique 1107 * on *defining* class loader, not *initiating* class loader. This isn't 1108 * great, because it guarantees we will have to probe when multiple 1109 * class loaders are used. 1110 * 1111 * Note this does NOT try to load a class; it just finds a class that 1112 * has already been loaded. 1113 * 1114 * If "unprepOkay" is set, this will return classes that have been added 1115 * to the hash table but are not yet fully loaded and linked. Otherwise, 1116 * such classes are ignored. (The only place that should set "unprepOkay" 1117 * is findClassNoInit(), which will wait for the prep to finish.) 1118 * 1119 * Returns NULL if not found. 1120 */ 1121ClassObject* dvmLookupClass(const char* descriptor, Object* loader, 1122 bool unprepOkay) 1123{ 1124 ClassMatchCriteria crit; 1125 void* found; 1126 u4 hash; 1127 1128 crit.descriptor = descriptor; 1129 crit.loader = loader; 1130 hash = dvmComputeUtf8Hash(descriptor); 1131 1132 LOGVV("threadid=%d: dvmLookupClass searching for '%s' %p", 1133 dvmThreadSelf()->threadId, descriptor, loader); 1134 1135 dvmHashTableLock(gDvm.loadedClasses); 1136 found = dvmHashTableLookup(gDvm.loadedClasses, hash, &crit, 1137 hashcmpClassByCrit, false); 1138 dvmHashTableUnlock(gDvm.loadedClasses); 1139 1140 /* 1141 * The class has been added to the hash table but isn't ready for use. 1142 * We're going to act like we didn't see it, so that the caller will 1143 * go through the full "find class" path, which includes locking the 1144 * object and waiting until it's ready. We could do that lock/wait 1145 * here, but this is an extremely rare case, and it's simpler to have 1146 * the wait-for-class code centralized. 1147 */ 1148 if (found && !unprepOkay && !dvmIsClassLinked((ClassObject*)found)) { 1149 ALOGV("Ignoring not-yet-ready %s, using slow path", 1150 ((ClassObject*)found)->descriptor); 1151 found = NULL; 1152 } 1153 1154 return (ClassObject*) found; 1155} 1156 1157/* 1158 * Add a new class to the hash table. 1159 * 1160 * The class is considered "new" if it doesn't match on both the class 1161 * descriptor and the defining class loader. 1162 * 1163 * TODO: we should probably have separate hash tables for each 1164 * ClassLoader. This could speed up dvmLookupClass and 1165 * other common operations. It does imply a VM-visible data structure 1166 * for each ClassLoader object with loaded classes, which we don't 1167 * have yet. 1168 */ 1169bool dvmAddClassToHash(ClassObject* clazz) 1170{ 1171 void* found; 1172 u4 hash; 1173 1174 hash = dvmComputeUtf8Hash(clazz->descriptor); 1175 1176 dvmHashTableLock(gDvm.loadedClasses); 1177 found = dvmHashTableLookup(gDvm.loadedClasses, hash, clazz, 1178 hashcmpClassByClass, true); 1179 dvmHashTableUnlock(gDvm.loadedClasses); 1180 1181 ALOGV("+++ dvmAddClassToHash '%s' %p (isnew=%d) --> %p", 1182 clazz->descriptor, clazz->classLoader, 1183 (found == (void*) clazz), clazz); 1184 1185 //dvmCheckClassTablePerf(); 1186 1187 /* can happen if two threads load the same class simultaneously */ 1188 return (found == (void*) clazz); 1189} 1190 1191#if 0 1192/* 1193 * Compute hash value for a class. 1194 */ 1195u4 hashcalcClass(const void* item) 1196{ 1197 return dvmComputeUtf8Hash(((const ClassObject*) item)->descriptor); 1198} 1199 1200/* 1201 * Check the performance of the "loadedClasses" hash table. 1202 */ 1203void dvmCheckClassTablePerf() 1204{ 1205 dvmHashTableLock(gDvm.loadedClasses); 1206 dvmHashTableProbeCount(gDvm.loadedClasses, hashcalcClass, 1207 hashcmpClassByClass); 1208 dvmHashTableUnlock(gDvm.loadedClasses); 1209} 1210#endif 1211 1212/* 1213 * Remove a class object from the hash table. 1214 */ 1215static void removeClassFromHash(ClassObject* clazz) 1216{ 1217 ALOGV("+++ removeClassFromHash '%s'", clazz->descriptor); 1218 1219 u4 hash = dvmComputeUtf8Hash(clazz->descriptor); 1220 1221 dvmHashTableLock(gDvm.loadedClasses); 1222 if (!dvmHashTableRemove(gDvm.loadedClasses, hash, clazz)) 1223 ALOGW("Hash table remove failed on class '%s'", clazz->descriptor); 1224 dvmHashTableUnlock(gDvm.loadedClasses); 1225} 1226 1227 1228/* 1229 * =========================================================================== 1230 * Class creation 1231 * =========================================================================== 1232 */ 1233 1234/* 1235 * Set clazz->serialNumber to the next available value. 1236 * 1237 * This usually happens *very* early in class creation, so don't expect 1238 * anything else in the class to be ready. 1239 */ 1240void dvmSetClassSerialNumber(ClassObject* clazz) 1241{ 1242 assert(clazz->serialNumber == 0); 1243 clazz->serialNumber = android_atomic_inc(&gDvm.classSerialNumber); 1244} 1245 1246 1247/* 1248 * Find the named class (by descriptor), using the specified 1249 * initiating ClassLoader. 1250 * 1251 * The class will be loaded and initialized if it has not already been. 1252 * If necessary, the superclass will be loaded. 1253 * 1254 * If the class can't be found, returns NULL with an appropriate exception 1255 * raised. 1256 */ 1257ClassObject* dvmFindClass(const char* descriptor, Object* loader) 1258{ 1259 ClassObject* clazz; 1260 1261 clazz = dvmFindClassNoInit(descriptor, loader); 1262 if (clazz != NULL && clazz->status < CLASS_INITIALIZED) { 1263 /* initialize class */ 1264 if (!dvmInitClass(clazz)) { 1265 /* init failed; leave it in the list, marked as bad */ 1266 assert(dvmCheckException(dvmThreadSelf())); 1267 assert(clazz->status == CLASS_ERROR); 1268 return NULL; 1269 } 1270 } 1271 1272 return clazz; 1273} 1274 1275/* 1276 * Find the named class (by descriptor), using the specified 1277 * initiating ClassLoader. 1278 * 1279 * The class will be loaded if it has not already been, as will its 1280 * superclass. It will not be initialized. 1281 * 1282 * If the class can't be found, returns NULL with an appropriate exception 1283 * raised. 1284 */ 1285ClassObject* dvmFindClassNoInit(const char* descriptor, 1286 Object* loader) 1287{ 1288 assert(descriptor != NULL); 1289 //assert(loader != NULL); 1290 1291 LOGVV("FindClassNoInit '%s' %p", descriptor, loader); 1292 1293 if (*descriptor == '[') { 1294 /* 1295 * Array class. Find in table, generate if not found. 1296 */ 1297 return dvmFindArrayClass(descriptor, loader); 1298 } else { 1299 /* 1300 * Regular class. Find in table, load if not found. 1301 */ 1302 if (loader != NULL) { 1303 return findClassFromLoaderNoInit(descriptor, loader); 1304 } else { 1305 return dvmFindSystemClassNoInit(descriptor); 1306 } 1307 } 1308} 1309 1310/* 1311 * Load the named class (by descriptor) from the specified class 1312 * loader. This calls out to let the ClassLoader object do its thing. 1313 * 1314 * Returns with NULL and an exception raised on error. 1315 */ 1316static ClassObject* findClassFromLoaderNoInit(const char* descriptor, 1317 Object* loader) 1318{ 1319 //ALOGI("##### findClassFromLoaderNoInit (%s,%p)", 1320 // descriptor, loader); 1321 1322 Thread* self = dvmThreadSelf(); 1323 1324 assert(loader != NULL); 1325 1326 /* 1327 * Do we already have it? 1328 * 1329 * The class loader code does the "is it already loaded" check as 1330 * well. However, this call is much faster than calling through 1331 * interpreted code. Doing this does mean that in the common case 1332 * (365 out of 420 calls booting the sim) we're doing the 1333 * lookup-by-descriptor twice. It appears this is still a win, so 1334 * I'm keeping it in. 1335 */ 1336 ClassObject* clazz = dvmLookupClass(descriptor, loader, false); 1337 if (clazz != NULL) { 1338 LOGVV("Already loaded: %s %p", descriptor, loader); 1339 return clazz; 1340 } else { 1341 LOGVV("Not already loaded: %s %p", descriptor, loader); 1342 } 1343 1344 char* dotName = NULL; 1345 StringObject* nameObj = NULL; 1346 1347 /* convert "Landroid/debug/Stuff;" to "android.debug.Stuff" */ 1348 dotName = dvmDescriptorToDot(descriptor); 1349 if (dotName == NULL) { 1350 dvmThrowOutOfMemoryError(NULL); 1351 return NULL; 1352 } 1353 nameObj = dvmCreateStringFromCstr(dotName); 1354 if (nameObj == NULL) { 1355 assert(dvmCheckException(self)); 1356 goto bail; 1357 } 1358 1359 dvmMethodTraceClassPrepBegin(); 1360 1361 /* 1362 * Invoke loadClass(). This will probably result in a couple of 1363 * exceptions being thrown, because the ClassLoader.loadClass() 1364 * implementation eventually calls VMClassLoader.loadClass to see if 1365 * the bootstrap class loader can find it before doing its own load. 1366 */ 1367 LOGVV("--- Invoking loadClass(%s, %p)", dotName, loader); 1368 { 1369 const Method* loadClass = 1370 loader->clazz->vtable[gDvm.voffJavaLangClassLoader_loadClass]; 1371 JValue result; 1372 dvmCallMethod(self, loadClass, loader, &result, nameObj); 1373 clazz = (ClassObject*) result.l; 1374 1375 dvmMethodTraceClassPrepEnd(); 1376 Object* excep = dvmGetException(self); 1377 if (excep != NULL) { 1378#if DVM_SHOW_EXCEPTION >= 2 1379 ALOGD("NOTE: loadClass '%s' %p threw exception %s", 1380 dotName, loader, excep->clazz->descriptor); 1381#endif 1382 dvmAddTrackedAlloc(excep, self); 1383 dvmClearException(self); 1384 dvmThrowChainedNoClassDefFoundError(descriptor, excep); 1385 dvmReleaseTrackedAlloc(excep, self); 1386 clazz = NULL; 1387 goto bail; 1388 } else if (clazz == NULL) { 1389 ALOGW("ClassLoader returned NULL w/o exception pending"); 1390 dvmThrowNullPointerException("ClassLoader returned null"); 1391 goto bail; 1392 } 1393 } 1394 1395 /* not adding clazz to tracked-alloc list, because it's a ClassObject */ 1396 1397 dvmAddInitiatingLoader(clazz, loader); 1398 1399 LOGVV("--- Successfully loaded %s %p (thisldr=%p clazz=%p)", 1400 descriptor, clazz->classLoader, loader, clazz); 1401 1402bail: 1403 dvmReleaseTrackedAlloc((Object*)nameObj, NULL); 1404 free(dotName); 1405 return clazz; 1406} 1407 1408/* 1409 * Load the named class (by descriptor) from the specified DEX file. 1410 * Used by class loaders to instantiate a class object from a 1411 * VM-managed DEX. 1412 */ 1413ClassObject* dvmDefineClass(DvmDex* pDvmDex, const char* descriptor, 1414 Object* classLoader) 1415{ 1416 assert(pDvmDex != NULL); 1417 1418 return findClassNoInit(descriptor, classLoader, pDvmDex); 1419} 1420 1421 1422/* 1423 * Find the named class (by descriptor), scanning through the 1424 * bootclasspath if it hasn't already been loaded. 1425 * 1426 * "descriptor" looks like "Landroid/debug/Stuff;". 1427 * 1428 * Uses NULL as the defining class loader. 1429 */ 1430ClassObject* dvmFindSystemClass(const char* descriptor) 1431{ 1432 ClassObject* clazz; 1433 1434 clazz = dvmFindSystemClassNoInit(descriptor); 1435 if (clazz != NULL && clazz->status < CLASS_INITIALIZED) { 1436 /* initialize class */ 1437 if (!dvmInitClass(clazz)) { 1438 /* init failed; leave it in the list, marked as bad */ 1439 assert(dvmCheckException(dvmThreadSelf())); 1440 assert(clazz->status == CLASS_ERROR); 1441 return NULL; 1442 } 1443 } 1444 1445 return clazz; 1446} 1447 1448/* 1449 * Find the named class (by descriptor), searching for it in the 1450 * bootclasspath. 1451 * 1452 * On failure, this returns NULL with an exception raised. 1453 */ 1454ClassObject* dvmFindSystemClassNoInit(const char* descriptor) 1455{ 1456 return findClassNoInit(descriptor, NULL, NULL); 1457} 1458 1459/* 1460 * Find the named class (by descriptor). If it's not already loaded, 1461 * we load it and link it, but don't execute <clinit>. (The VM has 1462 * specific limitations on which events can cause initialization.) 1463 * 1464 * If "pDexFile" is NULL, we will search the bootclasspath for an entry. 1465 * 1466 * On failure, this returns NULL with an exception raised. 1467 * 1468 * TODO: we need to return an indication of whether we loaded the class or 1469 * used an existing definition. If somebody deliberately tries to load a 1470 * class twice in the same class loader, they should get a LinkageError, 1471 * but inadvertent simultaneous class references should "just work". 1472 */ 1473static ClassObject* findClassNoInit(const char* descriptor, Object* loader, 1474 DvmDex* pDvmDex) 1475{ 1476 Thread* self = dvmThreadSelf(); 1477 ClassObject* clazz; 1478 bool profilerNotified = false; 1479 1480 if (loader != NULL) { 1481 LOGVV("#### findClassNoInit(%s,%p,%p)", descriptor, loader, 1482 pDvmDex->pDexFile); 1483 } 1484 1485 /* 1486 * We don't expect an exception to be raised at this point. The 1487 * exception handling code is good about managing this. This *can* 1488 * happen if a JNI lookup fails and the JNI code doesn't do any 1489 * error checking before doing another class lookup, so we may just 1490 * want to clear this and restore it on exit. If we don't, some kinds 1491 * of failures can't be detected without rearranging other stuff. 1492 * 1493 * Most often when we hit this situation it means that something is 1494 * broken in the VM or in JNI code, so I'm keeping it in place (and 1495 * making it an informative abort rather than an assert). 1496 */ 1497 if (dvmCheckException(self)) { 1498 ALOGE("Class lookup %s attempted with exception pending", descriptor); 1499 ALOGW("Pending exception is:"); 1500 dvmLogExceptionStackTrace(); 1501 dvmDumpAllThreads(false); 1502 dvmAbort(); 1503 } 1504 1505 clazz = dvmLookupClass(descriptor, loader, true); 1506 if (clazz == NULL) { 1507 const DexClassDef* pClassDef; 1508 1509 dvmMethodTraceClassPrepBegin(); 1510 profilerNotified = true; 1511 1512#if LOG_CLASS_LOADING 1513 u8 startTime = dvmGetThreadCpuTimeNsec(); 1514#endif 1515 1516 if (pDvmDex == NULL) { 1517 assert(loader == NULL); /* shouldn't be here otherwise */ 1518 pDvmDex = searchBootPathForClass(descriptor, &pClassDef); 1519 } else { 1520 pClassDef = dexFindClass(pDvmDex->pDexFile, descriptor); 1521 } 1522 1523 if (pDvmDex == NULL || pClassDef == NULL) { 1524 if (gDvm.noClassDefFoundErrorObj != NULL) { 1525 /* usual case -- use prefabricated object */ 1526 dvmSetException(self, gDvm.noClassDefFoundErrorObj); 1527 } else { 1528 /* dexopt case -- can't guarantee prefab (core.jar) */ 1529 dvmThrowNoClassDefFoundError(descriptor); 1530 } 1531 goto bail; 1532 } 1533 1534 /* found a match, try to load it */ 1535 clazz = loadClassFromDex(pDvmDex, pClassDef, loader); 1536 if (dvmCheckException(self)) { 1537 /* class was found but had issues */ 1538 if (clazz != NULL) { 1539 dvmFreeClassInnards(clazz); 1540 dvmReleaseTrackedAlloc((Object*) clazz, NULL); 1541 } 1542 goto bail; 1543 } 1544 1545 /* 1546 * Lock the class while we link it so other threads must wait for us 1547 * to finish. Set the "initThreadId" so we can identify recursive 1548 * invocation. (Note all accesses to initThreadId here are 1549 * guarded by the class object's lock.) 1550 */ 1551 dvmLockObject(self, (Object*) clazz); 1552 clazz->initThreadId = self->threadId; 1553 1554 /* 1555 * Add to hash table so lookups succeed. 1556 * 1557 * [Are circular references possible when linking a class?] 1558 */ 1559 assert(clazz->classLoader == loader); 1560 if (!dvmAddClassToHash(clazz)) { 1561 /* 1562 * Another thread must have loaded the class after we 1563 * started but before we finished. Discard what we've 1564 * done and leave some hints for the GC. 1565 * 1566 * (Yes, this happens.) 1567 */ 1568 //ALOGW("WOW: somebody loaded %s simultaneously", descriptor); 1569 clazz->initThreadId = 0; 1570 dvmUnlockObject(self, (Object*) clazz); 1571 1572 /* Let the GC free the class. 1573 */ 1574 dvmFreeClassInnards(clazz); 1575 dvmReleaseTrackedAlloc((Object*) clazz, NULL); 1576 1577 /* Grab the winning class. 1578 */ 1579 clazz = dvmLookupClass(descriptor, loader, true); 1580 assert(clazz != NULL); 1581 goto got_class; 1582 } 1583 dvmReleaseTrackedAlloc((Object*) clazz, NULL); 1584 1585#if LOG_CLASS_LOADING 1586 logClassLoadWithTime('>', clazz, startTime); 1587#endif 1588 /* 1589 * Prepare and resolve. 1590 */ 1591 if (!dvmLinkClass(clazz)) { 1592 assert(dvmCheckException(self)); 1593 1594 /* Make note of the error and clean up the class. 1595 */ 1596 removeClassFromHash(clazz); 1597 clazz->status = CLASS_ERROR; 1598 dvmFreeClassInnards(clazz); 1599 1600 /* Let any waiters know. 1601 */ 1602 clazz->initThreadId = 0; 1603 dvmObjectNotifyAll(self, (Object*) clazz); 1604 dvmUnlockObject(self, (Object*) clazz); 1605 1606#if LOG_CLASS_LOADING 1607 ALOG(LOG_INFO, "DVMLINK FAILED FOR CLASS ", "%s in %s", 1608 clazz->descriptor, get_process_name()); 1609 1610 /* 1611 * TODO: It would probably be better to use a new type code here (instead of '<') to 1612 * indicate the failure. This change would require a matching change in the parser 1613 * and analysis code in frameworks/base/tools/preload. 1614 */ 1615 logClassLoad('<', clazz); 1616#endif 1617 clazz = NULL; 1618 if (gDvm.optimizing) { 1619 /* happens with "external" libs */ 1620 ALOGV("Link of class '%s' failed", descriptor); 1621 } else { 1622 ALOGW("Link of class '%s' failed", descriptor); 1623 } 1624 goto bail; 1625 } 1626 dvmObjectNotifyAll(self, (Object*) clazz); 1627 dvmUnlockObject(self, (Object*) clazz); 1628 1629 /* 1630 * Add class stats to global counters. 1631 * 1632 * TODO: these should probably be atomic ops. 1633 */ 1634 gDvm.numLoadedClasses++; 1635 gDvm.numDeclaredMethods += 1636 clazz->virtualMethodCount + clazz->directMethodCount; 1637 gDvm.numDeclaredInstFields += clazz->ifieldCount; 1638 gDvm.numDeclaredStaticFields += clazz->sfieldCount; 1639 1640 /* 1641 * Cache pointers to basic classes. We want to use these in 1642 * various places, and it's easiest to initialize them on first 1643 * use rather than trying to force them to initialize (startup 1644 * ordering makes it weird). 1645 */ 1646 if (gDvm.classJavaLangObject == NULL && 1647 strcmp(descriptor, "Ljava/lang/Object;") == 0) 1648 { 1649 /* It should be impossible to get here with anything 1650 * but the bootclasspath loader. 1651 */ 1652 assert(loader == NULL); 1653 gDvm.classJavaLangObject = clazz; 1654 } 1655 1656#if LOG_CLASS_LOADING 1657 logClassLoad('<', clazz); 1658#endif 1659 1660 } else { 1661got_class: 1662 if (!dvmIsClassLinked(clazz) && clazz->status != CLASS_ERROR) { 1663 /* 1664 * We can race with other threads for class linking. We should 1665 * never get here recursively; doing so indicates that two 1666 * classes have circular dependencies. 1667 * 1668 * One exception: we force discovery of java.lang.Class in 1669 * dvmLinkClass(), and Class has Object as its superclass. So 1670 * if the first thing we ever load is Object, we will init 1671 * Object->Class->Object. The easiest way to avoid this is to 1672 * ensure that Object is never the first thing we look up, so 1673 * we get Foo->Class->Object instead. 1674 */ 1675 dvmLockObject(self, (Object*) clazz); 1676 if (!dvmIsClassLinked(clazz) && 1677 clazz->initThreadId == self->threadId) 1678 { 1679 ALOGW("Recursive link on class %s", clazz->descriptor); 1680 dvmUnlockObject(self, (Object*) clazz); 1681 dvmThrowClassCircularityError(clazz->descriptor); 1682 clazz = NULL; 1683 goto bail; 1684 } 1685 //ALOGI("WAITING for '%s' (owner=%d)", 1686 // clazz->descriptor, clazz->initThreadId); 1687 while (!dvmIsClassLinked(clazz) && clazz->status != CLASS_ERROR) { 1688 dvmObjectWait(self, (Object*) clazz, 0, 0, false); 1689 } 1690 dvmUnlockObject(self, (Object*) clazz); 1691 } 1692 if (clazz->status == CLASS_ERROR) { 1693 /* 1694 * Somebody else tried to load this and failed. We need to raise 1695 * an exception and report failure. 1696 */ 1697 throwEarlierClassFailure(clazz); 1698 clazz = NULL; 1699 goto bail; 1700 } 1701 } 1702 1703 /* check some invariants */ 1704 assert(dvmIsClassLinked(clazz)); 1705 assert(gDvm.classJavaLangClass != NULL); 1706 assert(clazz->clazz == gDvm.classJavaLangClass); 1707 assert(dvmIsClassObject(clazz)); 1708 assert(clazz == gDvm.classJavaLangObject || clazz->super != NULL); 1709 if (!dvmIsInterfaceClass(clazz)) { 1710 //ALOGI("class=%s vtableCount=%d, virtualMeth=%d", 1711 // clazz->descriptor, clazz->vtableCount, 1712 // clazz->virtualMethodCount); 1713 assert(clazz->vtableCount >= clazz->virtualMethodCount); 1714 } 1715 1716bail: 1717 if (profilerNotified) 1718 dvmMethodTraceClassPrepEnd(); 1719 assert(clazz != NULL || dvmCheckException(self)); 1720 return clazz; 1721} 1722 1723/* 1724 * Helper for loadClassFromDex, which takes a DexClassDataHeader and 1725 * encoded data pointer in addition to the other arguments. 1726 */ 1727static ClassObject* loadClassFromDex0(DvmDex* pDvmDex, 1728 const DexClassDef* pClassDef, const DexClassDataHeader* pHeader, 1729 const u1* pEncodedData, Object* classLoader) 1730{ 1731 ClassObject* newClass = NULL; 1732 const DexFile* pDexFile; 1733 const char* descriptor; 1734 int i; 1735 1736 pDexFile = pDvmDex->pDexFile; 1737 descriptor = dexGetClassDescriptor(pDexFile, pClassDef); 1738 1739 /* 1740 * Make sure the aren't any "bonus" flags set, since we use them for 1741 * runtime state. 1742 */ 1743 if ((pClassDef->accessFlags & ~EXPECTED_FILE_FLAGS) != 0) { 1744 ALOGW("Invalid file flags in class %s: %04x", 1745 descriptor, pClassDef->accessFlags); 1746 return NULL; 1747 } 1748 1749 /* 1750 * Allocate storage for the class object on the GC heap, so that other 1751 * objects can have references to it. We bypass the usual mechanism 1752 * (allocObject), because we don't have all the bits and pieces yet. 1753 * 1754 * Note that we assume that java.lang.Class does not override 1755 * finalize(). 1756 */ 1757 /* TODO: Can there be fewer special checks in the usual path? */ 1758 assert(descriptor != NULL); 1759 if (classLoader == NULL && 1760 strcmp(descriptor, "Ljava/lang/Class;") == 0) { 1761 assert(gDvm.classJavaLangClass != NULL); 1762 newClass = gDvm.classJavaLangClass; 1763 } else { 1764 size_t size = classObjectSize(pHeader->staticFieldsSize); 1765 newClass = (ClassObject*) dvmMalloc(size, ALLOC_NON_MOVING); 1766 } 1767 if (newClass == NULL) 1768 return NULL; 1769 1770 DVM_OBJECT_INIT(newClass, gDvm.classJavaLangClass); 1771 dvmSetClassSerialNumber(newClass); 1772 newClass->descriptor = descriptor; 1773 assert(newClass->descriptorAlloc == NULL); 1774 SET_CLASS_FLAG(newClass, pClassDef->accessFlags); 1775 dvmSetFieldObject((Object *)newClass, 1776 OFFSETOF_MEMBER(ClassObject, classLoader), 1777 (Object *)classLoader); 1778 newClass->pDvmDex = pDvmDex; 1779 newClass->primitiveType = PRIM_NOT; 1780 newClass->status = CLASS_IDX; 1781 1782 /* 1783 * Stuff the superclass index into the object pointer field. The linker 1784 * pulls it out and replaces it with a resolved ClassObject pointer. 1785 * I'm doing it this way (rather than having a dedicated superclassIdx 1786 * field) to save a few bytes of overhead per class. 1787 * 1788 * newClass->super is not traversed or freed by dvmFreeClassInnards, so 1789 * this is safe. 1790 */ 1791 assert(sizeof(u4) == sizeof(ClassObject*)); /* 32-bit check */ 1792 newClass->super = (ClassObject*) pClassDef->superclassIdx; 1793 1794 /* 1795 * Stuff class reference indices into the pointer fields. 1796 * 1797 * The elements of newClass->interfaces are not traversed or freed by 1798 * dvmFreeClassInnards, so this is GC-safe. 1799 */ 1800 const DexTypeList* pInterfacesList; 1801 pInterfacesList = dexGetInterfacesList(pDexFile, pClassDef); 1802 if (pInterfacesList != NULL) { 1803 newClass->interfaceCount = pInterfacesList->size; 1804 newClass->interfaces = (ClassObject**) dvmLinearAlloc(classLoader, 1805 newClass->interfaceCount * sizeof(ClassObject*)); 1806 1807 for (i = 0; i < newClass->interfaceCount; i++) { 1808 const DexTypeItem* pType = dexGetTypeItem(pInterfacesList, i); 1809 newClass->interfaces[i] = (ClassObject*)(u4) pType->typeIdx; 1810 } 1811 dvmLinearReadOnly(classLoader, newClass->interfaces); 1812 } 1813 1814 /* load field definitions */ 1815 1816 /* 1817 * Over-allocate the class object and append static field info 1818 * onto the end. It's fixed-size and known at alloc time. This 1819 * seems to increase zygote sharing. Heap compaction will have to 1820 * be careful if it ever tries to move ClassObject instances, 1821 * because we pass Field pointers around internally. But at least 1822 * now these Field pointers are in the object heap. 1823 */ 1824 1825 if (pHeader->staticFieldsSize != 0) { 1826 /* static fields stay on system heap; field data isn't "write once" */ 1827 int count = (int) pHeader->staticFieldsSize; 1828 u4 lastIndex = 0; 1829 DexField field; 1830 1831 newClass->sfieldCount = count; 1832 for (i = 0; i < count; i++) { 1833 dexReadClassDataField(&pEncodedData, &field, &lastIndex); 1834 loadSFieldFromDex(newClass, &field, &newClass->sfields[i]); 1835 } 1836 } 1837 1838 if (pHeader->instanceFieldsSize != 0) { 1839 int count = (int) pHeader->instanceFieldsSize; 1840 u4 lastIndex = 0; 1841 DexField field; 1842 1843 newClass->ifieldCount = count; 1844 newClass->ifields = (InstField*) dvmLinearAlloc(classLoader, 1845 count * sizeof(InstField)); 1846 for (i = 0; i < count; i++) { 1847 dexReadClassDataField(&pEncodedData, &field, &lastIndex); 1848 loadIFieldFromDex(newClass, &field, &newClass->ifields[i]); 1849 } 1850 dvmLinearReadOnly(classLoader, newClass->ifields); 1851 } 1852 1853 /* 1854 * Load method definitions. We do this in two batches, direct then 1855 * virtual. 1856 * 1857 * If register maps have already been generated for this class, and 1858 * precise GC is enabled, we pull out pointers to them. We know that 1859 * they were streamed to the DEX file in the same order in which the 1860 * methods appear. 1861 * 1862 * If the class wasn't pre-verified, the maps will be generated when 1863 * the class is verified during class initialization. 1864 */ 1865 u4 classDefIdx = dexGetIndexForClassDef(pDexFile, pClassDef); 1866 const void* classMapData; 1867 u4 numMethods; 1868 1869 if (gDvm.preciseGc) { 1870 classMapData = 1871 dvmRegisterMapGetClassData(pDexFile, classDefIdx, &numMethods); 1872 1873 /* sanity check */ 1874 if (classMapData != NULL && 1875 pHeader->directMethodsSize + pHeader->virtualMethodsSize != numMethods) 1876 { 1877 ALOGE("ERROR: in %s, direct=%d virtual=%d, maps have %d", 1878 newClass->descriptor, pHeader->directMethodsSize, 1879 pHeader->virtualMethodsSize, numMethods); 1880 assert(false); 1881 classMapData = NULL; /* abandon */ 1882 } 1883 } else { 1884 classMapData = NULL; 1885 } 1886 1887 if (pHeader->directMethodsSize != 0) { 1888 int count = (int) pHeader->directMethodsSize; 1889 u4 lastIndex = 0; 1890 DexMethod method; 1891 1892 newClass->directMethodCount = count; 1893 newClass->directMethods = (Method*) dvmLinearAlloc(classLoader, 1894 count * sizeof(Method)); 1895 for (i = 0; i < count; i++) { 1896 dexReadClassDataMethod(&pEncodedData, &method, &lastIndex); 1897 loadMethodFromDex(newClass, &method, &newClass->directMethods[i]); 1898 if (classMapData != NULL) { 1899 const RegisterMap* pMap = dvmRegisterMapGetNext(&classMapData); 1900 if (dvmRegisterMapGetFormat(pMap) != kRegMapFormatNone) { 1901 newClass->directMethods[i].registerMap = pMap; 1902 /* TODO: add rigorous checks */ 1903 assert((newClass->directMethods[i].registersSize+7) / 8 == 1904 newClass->directMethods[i].registerMap->regWidth); 1905 } 1906 } 1907 } 1908 dvmLinearReadOnly(classLoader, newClass->directMethods); 1909 } 1910 1911 if (pHeader->virtualMethodsSize != 0) { 1912 int count = (int) pHeader->virtualMethodsSize; 1913 u4 lastIndex = 0; 1914 DexMethod method; 1915 1916 newClass->virtualMethodCount = count; 1917 newClass->virtualMethods = (Method*) dvmLinearAlloc(classLoader, 1918 count * sizeof(Method)); 1919 for (i = 0; i < count; i++) { 1920 dexReadClassDataMethod(&pEncodedData, &method, &lastIndex); 1921 loadMethodFromDex(newClass, &method, &newClass->virtualMethods[i]); 1922 if (classMapData != NULL) { 1923 const RegisterMap* pMap = dvmRegisterMapGetNext(&classMapData); 1924 if (dvmRegisterMapGetFormat(pMap) != kRegMapFormatNone) { 1925 newClass->virtualMethods[i].registerMap = pMap; 1926 /* TODO: add rigorous checks */ 1927 assert((newClass->virtualMethods[i].registersSize+7) / 8 == 1928 newClass->virtualMethods[i].registerMap->regWidth); 1929 } 1930 } 1931 } 1932 dvmLinearReadOnly(classLoader, newClass->virtualMethods); 1933 } 1934 1935 newClass->sourceFile = dexGetSourceFile(pDexFile, pClassDef); 1936 1937 /* caller must call dvmReleaseTrackedAlloc */ 1938 return newClass; 1939} 1940 1941/* 1942 * Try to load the indicated class from the specified DEX file. 1943 * 1944 * This is effectively loadClass()+defineClass() for a DexClassDef. The 1945 * loading was largely done when we crunched through the DEX. 1946 * 1947 * Returns NULL on failure. If we locate the class but encounter an error 1948 * while processing it, an appropriate exception is thrown. 1949 */ 1950static ClassObject* loadClassFromDex(DvmDex* pDvmDex, 1951 const DexClassDef* pClassDef, Object* classLoader) 1952{ 1953 ClassObject* result; 1954 DexClassDataHeader header; 1955 const u1* pEncodedData; 1956 const DexFile* pDexFile; 1957 1958 assert((pDvmDex != NULL) && (pClassDef != NULL)); 1959 pDexFile = pDvmDex->pDexFile; 1960 1961 if (gDvm.verboseClass) { 1962 ALOGV("CLASS: loading '%s'...", 1963 dexGetClassDescriptor(pDexFile, pClassDef)); 1964 } 1965 1966 pEncodedData = dexGetClassData(pDexFile, pClassDef); 1967 1968 if (pEncodedData != NULL) { 1969 dexReadClassDataHeader(&pEncodedData, &header); 1970 } else { 1971 // Provide an all-zeroes header for the rest of the loading. 1972 memset(&header, 0, sizeof(header)); 1973 } 1974 1975 result = loadClassFromDex0(pDvmDex, pClassDef, &header, pEncodedData, 1976 classLoader); 1977 1978 if (gDvm.verboseClass && (result != NULL)) { 1979 ALOGI("[Loaded %s from DEX %p (cl=%p)]", 1980 result->descriptor, pDvmDex, classLoader); 1981 } 1982 1983 return result; 1984} 1985 1986/* 1987 * Free anything in a ClassObject that was allocated on the system heap. 1988 * 1989 * The ClassObject itself is allocated on the GC heap, so we leave it for 1990 * the garbage collector. 1991 * 1992 * NOTE: this may be called with a partially-constructed object. 1993 * NOTE: there is no particular ordering imposed, so don't go poking at 1994 * superclasses. 1995 */ 1996void dvmFreeClassInnards(ClassObject* clazz) 1997{ 1998 void *tp; 1999 int i; 2000 2001 if (clazz == NULL) 2002 return; 2003 2004 assert(clazz->clazz == gDvm.classJavaLangClass); 2005 assert(dvmIsClassObject(clazz)); 2006 2007 /* Guarantee that dvmFreeClassInnards can be called on a given 2008 * class multiple times by clearing things out as we free them. 2009 * We don't make any attempt at real atomicity here; higher 2010 * levels need to make sure that no two threads can free the 2011 * same ClassObject at the same time. 2012 * 2013 * TODO: maybe just make it so the GC will never free the 2014 * innards of an already-freed class. 2015 * 2016 * TODO: this #define isn't MT-safe -- the compiler could rearrange it. 2017 */ 2018#define NULL_AND_FREE(p) \ 2019 do { \ 2020 if ((p) != NULL) { \ 2021 tp = (p); \ 2022 (p) = NULL; \ 2023 free(tp); \ 2024 } \ 2025 } while (0) 2026#define NULL_AND_LINEAR_FREE(p) \ 2027 do { \ 2028 if ((p) != NULL) { \ 2029 tp = (p); \ 2030 (p) = NULL; \ 2031 dvmLinearFree(clazz->classLoader, tp); \ 2032 } \ 2033 } while (0) 2034 2035 /* arrays just point at Object's vtable; don't free vtable in this case. 2036 */ 2037 clazz->vtableCount = -1; 2038 if (clazz->vtable == gDvm.classJavaLangObject->vtable) { 2039 clazz->vtable = NULL; 2040 } else { 2041 NULL_AND_LINEAR_FREE(clazz->vtable); 2042 } 2043 2044 clazz->descriptor = NULL; 2045 NULL_AND_FREE(clazz->descriptorAlloc); 2046 2047 if (clazz->directMethods != NULL) { 2048 Method *directMethods = clazz->directMethods; 2049 int directMethodCount = clazz->directMethodCount; 2050 clazz->directMethods = NULL; 2051 clazz->directMethodCount = -1; 2052 dvmLinearReadWrite(clazz->classLoader, directMethods); 2053 for (i = 0; i < directMethodCount; i++) { 2054 freeMethodInnards(&directMethods[i]); 2055 } 2056 dvmLinearReadOnly(clazz->classLoader, directMethods); 2057 dvmLinearFree(clazz->classLoader, directMethods); 2058 } 2059 if (clazz->virtualMethods != NULL) { 2060 Method *virtualMethods = clazz->virtualMethods; 2061 int virtualMethodCount = clazz->virtualMethodCount; 2062 clazz->virtualMethodCount = -1; 2063 clazz->virtualMethods = NULL; 2064 dvmLinearReadWrite(clazz->classLoader, virtualMethods); 2065 for (i = 0; i < virtualMethodCount; i++) { 2066 freeMethodInnards(&virtualMethods[i]); 2067 } 2068 dvmLinearReadOnly(clazz->classLoader, virtualMethods); 2069 dvmLinearFree(clazz->classLoader, virtualMethods); 2070 } 2071 2072 InitiatingLoaderList *loaderList = dvmGetInitiatingLoaderList(clazz); 2073 loaderList->initiatingLoaderCount = -1; 2074 NULL_AND_FREE(loaderList->initiatingLoaders); 2075 2076 clazz->interfaceCount = -1; 2077 NULL_AND_LINEAR_FREE(clazz->interfaces); 2078 2079 clazz->iftableCount = -1; 2080 NULL_AND_LINEAR_FREE(clazz->iftable); 2081 2082 clazz->ifviPoolCount = -1; 2083 NULL_AND_LINEAR_FREE(clazz->ifviPool); 2084 2085 clazz->sfieldCount = -1; 2086 /* The sfields are attached to the ClassObject, and will be freed 2087 * with it. */ 2088 2089 clazz->ifieldCount = -1; 2090 NULL_AND_LINEAR_FREE(clazz->ifields); 2091 2092#undef NULL_AND_FREE 2093#undef NULL_AND_LINEAR_FREE 2094} 2095 2096/* 2097 * Free anything in a Method that was allocated on the system heap. 2098 * 2099 * The containing class is largely torn down by this point. 2100 */ 2101static void freeMethodInnards(Method* meth) 2102{ 2103#if 0 2104 free(meth->exceptions); 2105 free(meth->lines); 2106 free(meth->locals); 2107#endif 2108 2109 /* 2110 * Some register maps are allocated on the heap, either because of late 2111 * verification or because we're caching an uncompressed form. 2112 */ 2113 const RegisterMap* pMap = meth->registerMap; 2114 if (pMap != NULL && dvmRegisterMapGetOnHeap(pMap)) { 2115 dvmFreeRegisterMap((RegisterMap*) pMap); 2116 meth->registerMap = NULL; 2117 } 2118 2119 /* 2120 * We may have copied the instructions. 2121 */ 2122 if (IS_METHOD_FLAG_SET(meth, METHOD_ISWRITABLE)) { 2123 DexCode* methodDexCode = (DexCode*) dvmGetMethodCode(meth); 2124 dvmLinearFree(meth->clazz->classLoader, methodDexCode); 2125 } 2126} 2127 2128/* 2129 * Clone a Method, making new copies of anything that will be freed up 2130 * by freeMethodInnards(). This is used for "miranda" methods. 2131 */ 2132static void cloneMethod(Method* dst, const Method* src) 2133{ 2134 if (src->registerMap != NULL) { 2135 ALOGE("GLITCH: only expected abstract methods here"); 2136 ALOGE(" cloning %s.%s", src->clazz->descriptor, src->name); 2137 dvmAbort(); 2138 } 2139 memcpy(dst, src, sizeof(Method)); 2140} 2141 2142/* 2143 * Pull the interesting pieces out of a DexMethod. 2144 * 2145 * The DEX file isn't going anywhere, so we don't need to make copies of 2146 * the code area. 2147 */ 2148static void loadMethodFromDex(ClassObject* clazz, const DexMethod* pDexMethod, 2149 Method* meth) 2150{ 2151 DexFile* pDexFile = clazz->pDvmDex->pDexFile; 2152 const DexMethodId* pMethodId; 2153 const DexCode* pDexCode; 2154 2155 pMethodId = dexGetMethodId(pDexFile, pDexMethod->methodIdx); 2156 2157 meth->name = dexStringById(pDexFile, pMethodId->nameIdx); 2158 dexProtoSetFromMethodId(&meth->prototype, pDexFile, pMethodId); 2159 meth->shorty = dexProtoGetShorty(&meth->prototype); 2160 meth->accessFlags = pDexMethod->accessFlags; 2161 meth->clazz = clazz; 2162 meth->jniArgInfo = 0; 2163 2164 if (dvmCompareNameDescriptorAndMethod("finalize", "()V", meth) == 0) { 2165 /* 2166 * The Enum class declares a "final" finalize() method to 2167 * prevent subclasses from introducing a finalizer. We don't 2168 * want to set the finalizable flag for Enum or its subclasses, 2169 * so we check for it here. 2170 * 2171 * We also want to avoid setting it on Object, but it's easier 2172 * to just strip that out later. 2173 */ 2174 if (clazz->classLoader != NULL || 2175 strcmp(clazz->descriptor, "Ljava/lang/Enum;") != 0) 2176 { 2177 SET_CLASS_FLAG(clazz, CLASS_ISFINALIZABLE); 2178 } 2179 } 2180 2181 pDexCode = dexGetCode(pDexFile, pDexMethod); 2182 if (pDexCode != NULL) { 2183 /* integer constants, copy over for faster access */ 2184 meth->registersSize = pDexCode->registersSize; 2185 meth->insSize = pDexCode->insSize; 2186 meth->outsSize = pDexCode->outsSize; 2187 2188 /* pointer to code area */ 2189 meth->insns = pDexCode->insns; 2190 } else { 2191 /* 2192 * We don't have a DexCode block, but we still want to know how 2193 * much space is needed for the arguments (so we don't have to 2194 * compute it later). We also take this opportunity to compute 2195 * JNI argument info. 2196 * 2197 * We do this for abstract methods as well, because we want to 2198 * be able to substitute our exception-throwing "stub" in. 2199 */ 2200 int argsSize = dvmComputeMethodArgsSize(meth); 2201 if (!dvmIsStaticMethod(meth)) 2202 argsSize++; 2203 meth->registersSize = meth->insSize = argsSize; 2204 assert(meth->outsSize == 0); 2205 assert(meth->insns == NULL); 2206 2207 if (dvmIsNativeMethod(meth)) { 2208 meth->nativeFunc = dvmResolveNativeMethod; 2209 meth->jniArgInfo = computeJniArgInfo(&meth->prototype); 2210 } 2211 } 2212} 2213 2214#if 0 /* replaced with private/read-write mapping */ 2215/* 2216 * We usually map bytecode directly out of the DEX file, which is mapped 2217 * shared read-only. If we want to be able to modify it, we have to make 2218 * a new copy. 2219 * 2220 * Once copied, the code will be in the LinearAlloc region, which may be 2221 * marked read-only. 2222 * 2223 * The bytecode instructions are embedded inside a DexCode structure, so we 2224 * need to copy all of that. (The dvmGetMethodCode function backs up the 2225 * instruction pointer to find the start of the DexCode.) 2226 */ 2227void dvmMakeCodeReadWrite(Method* meth) 2228{ 2229 DexCode* methodDexCode = (DexCode*) dvmGetMethodCode(meth); 2230 2231 if (IS_METHOD_FLAG_SET(meth, METHOD_ISWRITABLE)) { 2232 dvmLinearReadWrite(meth->clazz->classLoader, methodDexCode); 2233 return; 2234 } 2235 2236 assert(!dvmIsNativeMethod(meth) && !dvmIsAbstractMethod(meth)); 2237 2238 size_t dexCodeSize = dexGetDexCodeSize(methodDexCode); 2239 ALOGD("Making a copy of %s.%s code (%d bytes)", 2240 meth->clazz->descriptor, meth->name, dexCodeSize); 2241 2242 DexCode* newCode = 2243 (DexCode*) dvmLinearAlloc(meth->clazz->classLoader, dexCodeSize); 2244 memcpy(newCode, methodDexCode, dexCodeSize); 2245 2246 meth->insns = newCode->insns; 2247 SET_METHOD_FLAG(meth, METHOD_ISWRITABLE); 2248} 2249 2250/* 2251 * Mark the bytecode read-only. 2252 * 2253 * If the contents of the DexCode haven't actually changed, we could revert 2254 * to the original shared page. 2255 */ 2256void dvmMakeCodeReadOnly(Method* meth) 2257{ 2258 DexCode* methodDexCode = (DexCode*) dvmGetMethodCode(meth); 2259 ALOGV("+++ marking %p read-only", methodDexCode); 2260 dvmLinearReadOnly(meth->clazz->classLoader, methodDexCode); 2261} 2262#endif 2263 2264 2265/* 2266 * jniArgInfo (32-bit int) layout: 2267 * SRRRHHHH HHHHHHHH HHHHHHHH HHHHHHHH 2268 * 2269 * S - if set, do things the hard way (scan the signature) 2270 * R - return-type enumeration 2271 * H - target-specific hints 2272 * 2273 * This info is used at invocation time by dvmPlatformInvoke. In most 2274 * cases, the target-specific hints allow dvmPlatformInvoke to avoid 2275 * having to fully parse the signature. 2276 * 2277 * The return-type bits are always set, even if target-specific hint bits 2278 * are unavailable. 2279 */ 2280static int computeJniArgInfo(const DexProto* proto) 2281{ 2282 const char* sig = dexProtoGetShorty(proto); 2283 int returnType, jniArgInfo; 2284 u4 hints; 2285 2286 /* The first shorty character is the return type. */ 2287 switch (*(sig++)) { 2288 case 'V': 2289 returnType = DALVIK_JNI_RETURN_VOID; 2290 break; 2291 case 'F': 2292 returnType = DALVIK_JNI_RETURN_FLOAT; 2293 break; 2294 case 'D': 2295 returnType = DALVIK_JNI_RETURN_DOUBLE; 2296 break; 2297 case 'J': 2298 returnType = DALVIK_JNI_RETURN_S8; 2299 break; 2300 case 'Z': 2301 case 'B': 2302 returnType = DALVIK_JNI_RETURN_S1; 2303 break; 2304 case 'C': 2305 returnType = DALVIK_JNI_RETURN_U2; 2306 break; 2307 case 'S': 2308 returnType = DALVIK_JNI_RETURN_S2; 2309 break; 2310 default: 2311 returnType = DALVIK_JNI_RETURN_S4; 2312 break; 2313 } 2314 2315 jniArgInfo = returnType << DALVIK_JNI_RETURN_SHIFT; 2316 2317 hints = dvmPlatformInvokeHints(proto); 2318 2319 if (hints & DALVIK_JNI_NO_ARG_INFO) { 2320 jniArgInfo |= DALVIK_JNI_NO_ARG_INFO; 2321 } else { 2322 assert((hints & DALVIK_JNI_RETURN_MASK) == 0); 2323 jniArgInfo |= hints; 2324 } 2325 2326 return jniArgInfo; 2327} 2328 2329/* 2330 * Load information about a static field. 2331 * 2332 * This also "prepares" static fields by initializing them 2333 * to their "standard default values". 2334 */ 2335static void loadSFieldFromDex(ClassObject* clazz, 2336 const DexField* pDexSField, StaticField* sfield) 2337{ 2338 DexFile* pDexFile = clazz->pDvmDex->pDexFile; 2339 const DexFieldId* pFieldId; 2340 2341 pFieldId = dexGetFieldId(pDexFile, pDexSField->fieldIdx); 2342 2343 sfield->clazz = clazz; 2344 sfield->name = dexStringById(pDexFile, pFieldId->nameIdx); 2345 sfield->signature = dexStringByTypeIdx(pDexFile, pFieldId->typeIdx); 2346 sfield->accessFlags = pDexSField->accessFlags; 2347 2348 /* Static object field values are set to "standard default values" 2349 * (null or 0) until the class is initialized. We delay loading 2350 * constant values from the class until that time. 2351 */ 2352 //sfield->value.j = 0; 2353 assert(sfield->value.j == 0LL); // cleared earlier with calloc 2354} 2355 2356/* 2357 * Load information about an instance field. 2358 */ 2359static void loadIFieldFromDex(ClassObject* clazz, 2360 const DexField* pDexIField, InstField* ifield) 2361{ 2362 DexFile* pDexFile = clazz->pDvmDex->pDexFile; 2363 const DexFieldId* pFieldId; 2364 2365 pFieldId = dexGetFieldId(pDexFile, pDexIField->fieldIdx); 2366 2367 ifield->clazz = clazz; 2368 ifield->name = dexStringById(pDexFile, pFieldId->nameIdx); 2369 ifield->signature = dexStringByTypeIdx(pDexFile, pFieldId->typeIdx); 2370 ifield->accessFlags = pDexIField->accessFlags; 2371#ifndef NDEBUG 2372 assert(ifield->byteOffset == 0); // cleared earlier with calloc 2373 ifield->byteOffset = -1; // make it obvious if we fail to set later 2374#endif 2375} 2376 2377/* 2378 * Cache java.lang.ref.Reference fields and methods. 2379 */ 2380static bool precacheReferenceOffsets(ClassObject* clazz) 2381{ 2382 int i; 2383 2384 /* We trick the GC object scanner by not counting 2385 * java.lang.ref.Reference.referent as an object 2386 * field. It will get explicitly scanned as part 2387 * of the reference-walking process. 2388 * 2389 * Find the object field named "referent" and put it 2390 * just after the list of object reference fields. 2391 */ 2392 dvmLinearReadWrite(clazz->classLoader, clazz->ifields); 2393 for (i = 0; i < clazz->ifieldRefCount; i++) { 2394 InstField *pField = &clazz->ifields[i]; 2395 if (strcmp(pField->name, "referent") == 0) { 2396 int targetIndex; 2397 2398 /* Swap this field with the last object field. 2399 */ 2400 targetIndex = clazz->ifieldRefCount - 1; 2401 if (i != targetIndex) { 2402 InstField *swapField = &clazz->ifields[targetIndex]; 2403 InstField tmpField; 2404 int tmpByteOffset; 2405 2406 /* It's not currently strictly necessary 2407 * for the fields to be in byteOffset order, 2408 * but it's more predictable that way. 2409 */ 2410 tmpByteOffset = swapField->byteOffset; 2411 swapField->byteOffset = pField->byteOffset; 2412 pField->byteOffset = tmpByteOffset; 2413 2414 tmpField = *swapField; 2415 *swapField = *pField; 2416 *pField = tmpField; 2417 } 2418 2419 /* One fewer object field (wink wink). 2420 */ 2421 clazz->ifieldRefCount--; 2422 i--; /* don't trip "didn't find it" test if field was last */ 2423 break; 2424 } 2425 } 2426 dvmLinearReadOnly(clazz->classLoader, clazz->ifields); 2427 if (i == clazz->ifieldRefCount) { 2428 ALOGE("Unable to reorder 'referent' in %s", clazz->descriptor); 2429 return false; 2430 } 2431 2432 /* 2433 * Now that the above has been done, it is safe to cache 2434 * info about the class. 2435 */ 2436 if (!dvmFindReferenceMembers(clazz)) { 2437 ALOGE("Trouble with Reference setup"); 2438 return false; 2439 } 2440 2441 return true; 2442} 2443 2444 2445/* 2446 * Set the bitmap of reference offsets, refOffsets, from the ifields 2447 * list. 2448 */ 2449static void computeRefOffsets(ClassObject* clazz) 2450{ 2451 if (clazz->super != NULL) { 2452 clazz->refOffsets = clazz->super->refOffsets; 2453 } else { 2454 clazz->refOffsets = 0; 2455 } 2456 /* 2457 * If our superclass overflowed, we don't stand a chance. 2458 */ 2459 if (clazz->refOffsets != CLASS_WALK_SUPER) { 2460 InstField *f; 2461 int i; 2462 2463 /* All of the fields that contain object references 2464 * are guaranteed to be at the beginning of the ifields list. 2465 */ 2466 f = clazz->ifields; 2467 const int ifieldRefCount = clazz->ifieldRefCount; 2468 for (i = 0; i < ifieldRefCount; i++) { 2469 /* 2470 * Note that, per the comment on struct InstField, 2471 * f->byteOffset is the offset from the beginning of 2472 * obj, not the offset into obj->instanceData. 2473 */ 2474 assert(f->byteOffset >= (int) CLASS_SMALLEST_OFFSET); 2475 assert((f->byteOffset & (CLASS_OFFSET_ALIGNMENT - 1)) == 0); 2476 if (CLASS_CAN_ENCODE_OFFSET(f->byteOffset)) { 2477 u4 newBit = CLASS_BIT_FROM_OFFSET(f->byteOffset); 2478 assert(newBit != 0); 2479 clazz->refOffsets |= newBit; 2480 } else { 2481 clazz->refOffsets = CLASS_WALK_SUPER; 2482 break; 2483 } 2484 f++; 2485 } 2486 } 2487} 2488 2489 2490/* 2491 * Link (prepare and resolve). Verification is deferred until later. 2492 * 2493 * This converts symbolic references into pointers. It's independent of 2494 * the source file format. 2495 * 2496 * If clazz->status is CLASS_IDX, then clazz->super and interfaces[] are 2497 * holding class reference indices rather than pointers. The class 2498 * references will be resolved during link. (This is done when 2499 * loading from DEX to avoid having to create additional storage to 2500 * pass the indices around.) 2501 * 2502 * Returns "false" with an exception pending on failure. 2503 */ 2504bool dvmLinkClass(ClassObject* clazz) 2505{ 2506 u4 superclassIdx = 0; 2507 u4 *interfaceIdxArray = NULL; 2508 bool okay = false; 2509 int i; 2510 2511 assert(clazz != NULL); 2512 assert(clazz->descriptor != NULL); 2513 assert(clazz->status == CLASS_IDX || clazz->status == CLASS_LOADED); 2514 if (gDvm.verboseClass) 2515 ALOGV("CLASS: linking '%s'...", clazz->descriptor); 2516 2517 assert(gDvm.classJavaLangClass != NULL); 2518 assert(clazz->clazz == gDvm.classJavaLangClass); 2519 assert(dvmIsClassObject(clazz)); 2520 if (clazz->classLoader == NULL && 2521 (strcmp(clazz->descriptor, "Ljava/lang/Class;") == 0)) 2522 { 2523 if (gDvm.classJavaLangClass->ifieldCount > CLASS_FIELD_SLOTS) { 2524 ALOGE("java.lang.Class has %d instance fields (expected at most %d)", 2525 gDvm.classJavaLangClass->ifieldCount, CLASS_FIELD_SLOTS); 2526 dvmAbort(); 2527 } 2528 if (gDvm.classJavaLangClass->sfieldCount != CLASS_SFIELD_SLOTS) { 2529 ALOGE("java.lang.Class has %d static fields (expected %d)", 2530 gDvm.classJavaLangClass->sfieldCount, CLASS_SFIELD_SLOTS); 2531 dvmAbort(); 2532 } 2533 } 2534 2535 /* "Resolve" the class. 2536 * 2537 * At this point, clazz's reference fields may contain Dex file 2538 * indices instead of direct object references. Proxy objects are 2539 * an exception, and may be the only exception. We need to 2540 * translate those indices into real references, and let the GC 2541 * look inside this ClassObject. 2542 */ 2543 if (clazz->status == CLASS_IDX) { 2544 if (clazz->interfaceCount > 0) { 2545 /* Copy u4 DEX idx values out of the ClassObject* array 2546 * where we stashed them. 2547 */ 2548 assert(sizeof(*interfaceIdxArray) == sizeof(*clazz->interfaces)); 2549 size_t len = clazz->interfaceCount * sizeof(*interfaceIdxArray); 2550 interfaceIdxArray = (u4*)malloc(len); 2551 if (interfaceIdxArray == NULL) { 2552 ALOGW("Unable to allocate memory to link %s", clazz->descriptor); 2553 goto bail; 2554 } 2555 memcpy(interfaceIdxArray, clazz->interfaces, len); 2556 2557 dvmLinearReadWrite(clazz->classLoader, clazz->interfaces); 2558 memset(clazz->interfaces, 0, len); 2559 dvmLinearReadOnly(clazz->classLoader, clazz->interfaces); 2560 } 2561 2562 assert(sizeof(superclassIdx) == sizeof(clazz->super)); 2563 superclassIdx = (u4) clazz->super; 2564 clazz->super = NULL; 2565 /* After this line, clazz will be fair game for the GC. The 2566 * superclass and interfaces are all NULL. 2567 */ 2568 clazz->status = CLASS_LOADED; 2569 2570 if (superclassIdx != kDexNoIndex) { 2571 ClassObject* super = dvmResolveClass(clazz, superclassIdx, false); 2572 if (super == NULL) { 2573 assert(dvmCheckException(dvmThreadSelf())); 2574 if (gDvm.optimizing) { 2575 /* happens with "external" libs */ 2576 ALOGV("Unable to resolve superclass of %s (%d)", 2577 clazz->descriptor, superclassIdx); 2578 } else { 2579 ALOGW("Unable to resolve superclass of %s (%d)", 2580 clazz->descriptor, superclassIdx); 2581 } 2582 goto bail; 2583 } 2584 dvmSetFieldObject((Object *)clazz, 2585 OFFSETOF_MEMBER(ClassObject, super), 2586 (Object *)super); 2587 } 2588 2589 if (clazz->interfaceCount > 0) { 2590 /* Resolve the interfaces implemented directly by this class. */ 2591 assert(interfaceIdxArray != NULL); 2592 dvmLinearReadWrite(clazz->classLoader, clazz->interfaces); 2593 for (i = 0; i < clazz->interfaceCount; i++) { 2594 assert(interfaceIdxArray[i] != kDexNoIndex); 2595 clazz->interfaces[i] = 2596 dvmResolveClass(clazz, interfaceIdxArray[i], false); 2597 if (clazz->interfaces[i] == NULL) { 2598 const DexFile* pDexFile = clazz->pDvmDex->pDexFile; 2599 2600 assert(dvmCheckException(dvmThreadSelf())); 2601 dvmLinearReadOnly(clazz->classLoader, clazz->interfaces); 2602 2603 const char* classDescriptor; 2604 classDescriptor = 2605 dexStringByTypeIdx(pDexFile, interfaceIdxArray[i]); 2606 if (gDvm.optimizing) { 2607 /* happens with "external" libs */ 2608 ALOGV("Failed resolving %s interface %d '%s'", 2609 clazz->descriptor, interfaceIdxArray[i], 2610 classDescriptor); 2611 } else { 2612 ALOGI("Failed resolving %s interface %d '%s'", 2613 clazz->descriptor, interfaceIdxArray[i], 2614 classDescriptor); 2615 } 2616 goto bail; 2617 } 2618 2619 /* are we allowed to implement this interface? */ 2620 if (!dvmCheckClassAccess(clazz, clazz->interfaces[i])) { 2621 dvmLinearReadOnly(clazz->classLoader, clazz->interfaces); 2622 ALOGW("Interface '%s' is not accessible to '%s'", 2623 clazz->interfaces[i]->descriptor, clazz->descriptor); 2624 dvmThrowIllegalAccessError("interface not accessible"); 2625 goto bail; 2626 } 2627 LOGVV("+++ found interface '%s'", 2628 clazz->interfaces[i]->descriptor); 2629 } 2630 dvmLinearReadOnly(clazz->classLoader, clazz->interfaces); 2631 } 2632 } 2633 /* 2634 * There are now Class references visible to the GC in super and 2635 * interfaces. 2636 */ 2637 2638 /* 2639 * All classes have a direct superclass, except for 2640 * java/lang/Object and primitive classes. Primitive classes are 2641 * are created CLASS_INITIALIZED, so won't get here. 2642 */ 2643 assert(clazz->primitiveType == PRIM_NOT); 2644 if (strcmp(clazz->descriptor, "Ljava/lang/Object;") == 0) { 2645 if (clazz->super != NULL) { 2646 /* TODO: is this invariant true for all java/lang/Objects, 2647 * regardless of the class loader? For now, assume it is. 2648 */ 2649 dvmThrowClassFormatError("java.lang.Object has a superclass"); 2650 goto bail; 2651 } 2652 2653 /* Don't finalize objects whose classes use the 2654 * default (empty) Object.finalize(). 2655 */ 2656 CLEAR_CLASS_FLAG(clazz, CLASS_ISFINALIZABLE); 2657 } else { 2658 if (clazz->super == NULL) { 2659 dvmThrowLinkageError("no superclass defined"); 2660 goto bail; 2661 } 2662 /* verify */ 2663 if (dvmIsFinalClass(clazz->super)) { 2664 ALOGW("Superclass of '%s' is final '%s'", 2665 clazz->descriptor, clazz->super->descriptor); 2666 dvmThrowIncompatibleClassChangeError("superclass is final"); 2667 goto bail; 2668 } else if (dvmIsInterfaceClass(clazz->super)) { 2669 ALOGW("Superclass of '%s' is interface '%s'", 2670 clazz->descriptor, clazz->super->descriptor); 2671 dvmThrowIncompatibleClassChangeError("superclass is an interface"); 2672 goto bail; 2673 } else if (!dvmCheckClassAccess(clazz, clazz->super)) { 2674 ALOGW("Superclass of '%s' (%s) is not accessible", 2675 clazz->descriptor, clazz->super->descriptor); 2676 dvmThrowIllegalAccessError("superclass not accessible"); 2677 goto bail; 2678 } 2679 2680 /* Inherit finalizability from the superclass. If this 2681 * class also overrides finalize(), its CLASS_ISFINALIZABLE 2682 * bit will already be set. 2683 */ 2684 if (IS_CLASS_FLAG_SET(clazz->super, CLASS_ISFINALIZABLE)) { 2685 SET_CLASS_FLAG(clazz, CLASS_ISFINALIZABLE); 2686 } 2687 2688 /* See if this class descends from java.lang.Reference 2689 * and set the class flags appropriately. 2690 */ 2691 if (IS_CLASS_FLAG_SET(clazz->super, CLASS_ISREFERENCE)) { 2692 u4 superRefFlags; 2693 2694 /* We've already determined the reference type of this 2695 * inheritance chain. Inherit reference-ness from the superclass. 2696 */ 2697 superRefFlags = GET_CLASS_FLAG_GROUP(clazz->super, 2698 CLASS_ISREFERENCE | 2699 CLASS_ISWEAKREFERENCE | 2700 CLASS_ISFINALIZERREFERENCE | 2701 CLASS_ISPHANTOMREFERENCE); 2702 SET_CLASS_FLAG(clazz, superRefFlags); 2703 } else if (clazz->classLoader == NULL && 2704 clazz->super->classLoader == NULL && 2705 strcmp(clazz->super->descriptor, 2706 "Ljava/lang/ref/Reference;") == 0) 2707 { 2708 u4 refFlags; 2709 2710 /* This class extends Reference, which means it should 2711 * be one of the magic Soft/Weak/PhantomReference classes. 2712 */ 2713 refFlags = CLASS_ISREFERENCE; 2714 if (strcmp(clazz->descriptor, 2715 "Ljava/lang/ref/SoftReference;") == 0) 2716 { 2717 /* Only CLASS_ISREFERENCE is set for soft references. 2718 */ 2719 } else if (strcmp(clazz->descriptor, 2720 "Ljava/lang/ref/WeakReference;") == 0) 2721 { 2722 refFlags |= CLASS_ISWEAKREFERENCE; 2723 } else if (strcmp(clazz->descriptor, 2724 "Ljava/lang/ref/FinalizerReference;") == 0) 2725 { 2726 refFlags |= CLASS_ISFINALIZERREFERENCE; 2727 } else if (strcmp(clazz->descriptor, 2728 "Ljava/lang/ref/PhantomReference;") == 0) 2729 { 2730 refFlags |= CLASS_ISPHANTOMREFERENCE; 2731 } else { 2732 /* No-one else is allowed to inherit directly 2733 * from Reference. 2734 */ 2735//xxx is this the right exception? better than an assertion. 2736 dvmThrowLinkageError("illegal inheritance from Reference"); 2737 goto bail; 2738 } 2739 2740 /* The class should not have any reference bits set yet. 2741 */ 2742 assert(GET_CLASS_FLAG_GROUP(clazz, 2743 CLASS_ISREFERENCE | 2744 CLASS_ISWEAKREFERENCE | 2745 CLASS_ISFINALIZERREFERENCE | 2746 CLASS_ISPHANTOMREFERENCE) == 0); 2747 2748 SET_CLASS_FLAG(clazz, refFlags); 2749 } 2750 } 2751 2752 /* 2753 * Populate vtable. 2754 */ 2755 if (dvmIsInterfaceClass(clazz)) { 2756 /* no vtable; just set the method indices */ 2757 int count = clazz->virtualMethodCount; 2758 2759 if (count != (u2) count) { 2760 ALOGE("Too many methods (%d) in interface '%s'", count, 2761 clazz->descriptor); 2762 goto bail; 2763 } 2764 2765 dvmLinearReadWrite(clazz->classLoader, clazz->virtualMethods); 2766 2767 for (i = 0; i < count; i++) 2768 clazz->virtualMethods[i].methodIndex = (u2) i; 2769 2770 dvmLinearReadOnly(clazz->classLoader, clazz->virtualMethods); 2771 } else { 2772 if (!createVtable(clazz)) { 2773 ALOGW("failed creating vtable"); 2774 goto bail; 2775 } 2776 } 2777 2778 /* 2779 * Populate interface method tables. Can alter the vtable. 2780 */ 2781 if (!createIftable(clazz)) 2782 goto bail; 2783 2784 /* 2785 * Insert special-purpose "stub" method implementations. 2786 */ 2787 if (!insertMethodStubs(clazz)) 2788 goto bail; 2789 2790 /* 2791 * Compute instance field offsets and, hence, the size of the object. 2792 */ 2793 if (!computeFieldOffsets(clazz)) 2794 goto bail; 2795 2796 /* 2797 * Cache field and method info for the class Reference (as loaded 2798 * by the boot classloader). This has to happen after the call to 2799 * computeFieldOffsets(). 2800 */ 2801 if ((clazz->classLoader == NULL) 2802 && (strcmp(clazz->descriptor, "Ljava/lang/ref/Reference;") == 0)) { 2803 if (!precacheReferenceOffsets(clazz)) { 2804 ALOGE("failed pre-caching Reference offsets"); 2805 dvmThrowInternalError(NULL); 2806 goto bail; 2807 } 2808 } 2809 2810 /* 2811 * Compact the offsets the GC has to examine into a bitmap, if 2812 * possible. (This has to happen after Reference.referent is 2813 * massaged in precacheReferenceOffsets.) 2814 */ 2815 computeRefOffsets(clazz); 2816 2817 /* 2818 * Done! 2819 */ 2820 if (IS_CLASS_FLAG_SET(clazz, CLASS_ISPREVERIFIED)) 2821 clazz->status = CLASS_VERIFIED; 2822 else 2823 clazz->status = CLASS_RESOLVED; 2824 okay = true; 2825 if (gDvm.verboseClass) 2826 ALOGV("CLASS: linked '%s'", clazz->descriptor); 2827 2828 /* 2829 * We send CLASS_PREPARE events to the debugger from here. The 2830 * definition of "preparation" is creating the static fields for a 2831 * class and initializing them to the standard default values, but not 2832 * executing any code (that comes later, during "initialization"). 2833 * 2834 * We did the static prep in loadSFieldFromDex() while loading the class. 2835 * 2836 * The class has been prepared and resolved but possibly not yet verified 2837 * at this point. 2838 */ 2839 if (gDvm.debuggerActive) { 2840 dvmDbgPostClassPrepare(clazz); 2841 } 2842 2843bail: 2844 if (!okay) { 2845 clazz->status = CLASS_ERROR; 2846 if (!dvmCheckException(dvmThreadSelf())) { 2847 dvmThrowVirtualMachineError(NULL); 2848 } 2849 } 2850 if (interfaceIdxArray != NULL) { 2851 free(interfaceIdxArray); 2852 } 2853 2854 return okay; 2855} 2856 2857/* 2858 * Create the virtual method table. 2859 * 2860 * The top part of the table is a copy of the table from our superclass, 2861 * with our local methods overriding theirs. The bottom part of the table 2862 * has any new methods we defined. 2863 */ 2864static bool createVtable(ClassObject* clazz) 2865{ 2866 bool result = false; 2867 int maxCount; 2868 int i; 2869 2870 if (clazz->super != NULL) { 2871 //ALOGI("SUPER METHODS %d %s->%s", clazz->super->vtableCount, 2872 // clazz->descriptor, clazz->super->descriptor); 2873 } 2874 2875 /* the virtual methods we define, plus the superclass vtable size */ 2876 maxCount = clazz->virtualMethodCount; 2877 if (clazz->super != NULL) { 2878 maxCount += clazz->super->vtableCount; 2879 } else { 2880 /* TODO: is this invariant true for all java/lang/Objects, 2881 * regardless of the class loader? For now, assume it is. 2882 */ 2883 assert(strcmp(clazz->descriptor, "Ljava/lang/Object;") == 0); 2884 } 2885 //ALOGD("+++ max vmethods for '%s' is %d", clazz->descriptor, maxCount); 2886 2887 /* 2888 * Over-allocate the table, then realloc it down if necessary. So 2889 * long as we don't allocate anything in between we won't cause 2890 * fragmentation, and reducing the size should be unlikely to cause 2891 * a buffer copy. 2892 */ 2893 dvmLinearReadWrite(clazz->classLoader, clazz->virtualMethods); 2894 clazz->vtable = (Method**) dvmLinearAlloc(clazz->classLoader, 2895 sizeof(Method*) * maxCount); 2896 if (clazz->vtable == NULL) 2897 goto bail; 2898 2899 if (clazz->super != NULL) { 2900 int actualCount; 2901 2902 memcpy(clazz->vtable, clazz->super->vtable, 2903 sizeof(*(clazz->vtable)) * clazz->super->vtableCount); 2904 actualCount = clazz->super->vtableCount; 2905 2906 /* 2907 * See if any of our virtual methods override the superclass. 2908 */ 2909 for (i = 0; i < clazz->virtualMethodCount; i++) { 2910 Method* localMeth = &clazz->virtualMethods[i]; 2911 int si; 2912 2913 for (si = 0; si < clazz->super->vtableCount; si++) { 2914 Method* superMeth = clazz->vtable[si]; 2915 2916 if (dvmCompareMethodNamesAndProtos(localMeth, superMeth) == 0) { 2917 if (dvmCheckMethodAccess(clazz, superMeth)) { 2918 /* verify */ 2919 if (dvmIsFinalMethod(superMeth)) { 2920 ALOGW("Method %s.%s overrides final %s.%s", 2921 localMeth->clazz->descriptor, localMeth->name, 2922 superMeth->clazz->descriptor, superMeth->name); 2923 goto bail; 2924 } 2925 clazz->vtable[si] = localMeth; 2926 localMeth->methodIndex = (u2) si; 2927 //ALOGV("+++ override %s.%s (slot %d)", 2928 // clazz->descriptor, localMeth->name, si); 2929 break; 2930 } else { 2931 ALOGW("in older versions of dalvik, method %s.%s would have incorrectly " 2932 "overridden package-private method with same name in %s", 2933 localMeth->clazz->descriptor, localMeth->name, 2934 superMeth->clazz->descriptor); 2935 } 2936 } 2937 } 2938 2939 if (si == clazz->super->vtableCount) { 2940 /* not an override, add to end */ 2941 clazz->vtable[actualCount] = localMeth; 2942 localMeth->methodIndex = (u2) actualCount; 2943 actualCount++; 2944 2945 //ALOGV("+++ add method %s.%s", 2946 // clazz->descriptor, localMeth->name); 2947 } 2948 } 2949 2950 if (actualCount != (u2) actualCount) { 2951 ALOGE("Too many methods (%d) in class '%s'", actualCount, 2952 clazz->descriptor); 2953 goto bail; 2954 } 2955 2956 assert(actualCount <= maxCount); 2957 2958 if (actualCount < maxCount) { 2959 assert(clazz->vtable != NULL); 2960 dvmLinearReadOnly(clazz->classLoader, clazz->vtable); 2961 clazz->vtable = (Method **)dvmLinearRealloc(clazz->classLoader, 2962 clazz->vtable, sizeof(*(clazz->vtable)) * actualCount); 2963 if (clazz->vtable == NULL) { 2964 ALOGE("vtable realloc failed"); 2965 goto bail; 2966 } else { 2967 LOGVV("+++ reduced vtable from %d to %d", 2968 maxCount, actualCount); 2969 } 2970 } 2971 2972 clazz->vtableCount = actualCount; 2973 } else { 2974 /* java/lang/Object case */ 2975 int count = clazz->virtualMethodCount; 2976 if (count != (u2) count) { 2977 ALOGE("Too many methods (%d) in base class '%s'", count, 2978 clazz->descriptor); 2979 goto bail; 2980 } 2981 2982 for (i = 0; i < count; i++) { 2983 clazz->vtable[i] = &clazz->virtualMethods[i]; 2984 clazz->virtualMethods[i].methodIndex = (u2) i; 2985 } 2986 clazz->vtableCount = clazz->virtualMethodCount; 2987 } 2988 2989 result = true; 2990 2991bail: 2992 dvmLinearReadOnly(clazz->classLoader, clazz->vtable); 2993 dvmLinearReadOnly(clazz->classLoader, clazz->virtualMethods); 2994 return result; 2995} 2996 2997/* 2998 * Create and populate "iftable". 2999 * 3000 * The set of interfaces we support is the combination of the interfaces 3001 * we implement directly and those implemented by our superclass. Each 3002 * interface can have one or more "superinterfaces", which we must also 3003 * support. For speed we flatten the tree out. 3004 * 3005 * We might be able to speed this up when there are lots of interfaces 3006 * by merge-sorting the class pointers and binary-searching when removing 3007 * duplicates. We could also drop the duplicate removal -- it's only 3008 * there to reduce the memory footprint. 3009 * 3010 * Because of "Miranda methods", this may reallocate clazz->virtualMethods. 3011 * 3012 * Returns "true" on success. 3013 */ 3014static bool createIftable(ClassObject* clazz) 3015{ 3016 bool result = false; 3017 bool zapIftable = false; 3018 bool zapVtable = false; 3019 bool zapIfvipool = false; 3020 int poolOffset = 0, poolSize = 0; 3021 Method** mirandaList = NULL; 3022 int mirandaCount = 0, mirandaAlloc = 0; 3023 3024 int superIfCount; 3025 if (clazz->super != NULL) 3026 superIfCount = clazz->super->iftableCount; 3027 else 3028 superIfCount = 0; 3029 3030 int ifCount = superIfCount; 3031 ifCount += clazz->interfaceCount; 3032 for (int i = 0; i < clazz->interfaceCount; i++) 3033 ifCount += clazz->interfaces[i]->iftableCount; 3034 3035 LOGVV("INTF: class '%s' direct w/supra=%d super=%d total=%d", 3036 clazz->descriptor, ifCount - superIfCount, superIfCount, ifCount); 3037 3038 if (ifCount == 0) { 3039 assert(clazz->iftableCount == 0); 3040 assert(clazz->iftable == NULL); 3041 return true; 3042 } 3043 3044 /* 3045 * Create a table with enough space for all interfaces, and copy the 3046 * superclass' table in. 3047 */ 3048 clazz->iftable = (InterfaceEntry*) dvmLinearAlloc(clazz->classLoader, 3049 sizeof(InterfaceEntry) * ifCount); 3050 zapIftable = true; 3051 memset(clazz->iftable, 0x00, sizeof(InterfaceEntry) * ifCount); 3052 if (superIfCount != 0) { 3053 memcpy(clazz->iftable, clazz->super->iftable, 3054 sizeof(InterfaceEntry) * superIfCount); 3055 } 3056 3057 /* 3058 * Create a flattened interface hierarchy of our immediate interfaces. 3059 */ 3060 int idx = superIfCount; 3061 3062 for (int i = 0; i < clazz->interfaceCount; i++) { 3063 ClassObject* interf = clazz->interfaces[i]; 3064 assert(interf != NULL); 3065 3066 /* make sure this is still an interface class */ 3067 if (!dvmIsInterfaceClass(interf)) { 3068 ALOGW("Class '%s' implements non-interface '%s'", 3069 clazz->descriptor, interf->descriptor); 3070 dvmThrowIncompatibleClassChangeErrorWithClassMessage( 3071 clazz->descriptor); 3072 goto bail; 3073 } 3074 3075 /* add entry for this interface */ 3076 clazz->iftable[idx++].clazz = interf; 3077 3078 /* add entries for the interface's superinterfaces */ 3079 for (int j = 0; j < interf->iftableCount; j++) { 3080 int k; 3081 ClassObject *cand; 3082 3083 cand = interf->iftable[j].clazz; 3084 3085 /* 3086 * Check if this interface was already added and add only if new. 3087 * This is to avoid a potential blowup in the number of 3088 * interfaces for sufficiently complicated interface hierarchies. 3089 * This has quadratic runtime in the number of interfaces. 3090 * However, in common cases with little interface inheritance, this 3091 * doesn't make much of a difference. 3092 */ 3093 for (k = 0; k < idx; k++) 3094 if (clazz->iftable[k].clazz == cand) 3095 break; 3096 3097 if (k == idx) 3098 clazz->iftable[idx++].clazz = cand; 3099 } 3100 } 3101 3102 assert(idx <= ifCount); 3103 3104 /* 3105 * Adjust the ifCount. We could reallocate the interface memory here, 3106 * but it's probably not worth the effort, the important thing here 3107 * is to avoid the interface blowup and keep the ifCount low. 3108 */ 3109 if (false) { 3110 if (idx != ifCount) { 3111 int newIfCount = idx; 3112 InterfaceEntry* oldmem = clazz->iftable; 3113 3114 clazz->iftable = (InterfaceEntry*) dvmLinearAlloc(clazz->classLoader, 3115 sizeof(InterfaceEntry) * newIfCount); 3116 memcpy(clazz->iftable, oldmem, sizeof(InterfaceEntry) * newIfCount); 3117 dvmLinearFree(clazz->classLoader, oldmem); 3118 } 3119 } 3120 3121 ifCount = idx; 3122 clazz->iftableCount = ifCount; 3123 3124 /* 3125 * If we're an interface, we don't need the vtable pointers, so 3126 * we're done. If this class doesn't implement an interface that our 3127 * superclass doesn't have, then we again have nothing to do. 3128 */ 3129 if (dvmIsInterfaceClass(clazz) || superIfCount == ifCount) { 3130 //dvmDumpClass(clazz, kDumpClassFullDetail); 3131 result = true; 3132 goto bail; 3133 } 3134 3135 /* 3136 * When we're handling invokeinterface, we probably have an object 3137 * whose type is an interface class rather than a concrete class. We 3138 * need to convert the method reference into a vtable index. So, for 3139 * every entry in "iftable", we create a list of vtable indices. 3140 * 3141 * Because our vtable encompasses the superclass vtable, we can use 3142 * the vtable indices from our superclass for all of the interfaces 3143 * that weren't directly implemented by us. 3144 * 3145 * Each entry in "iftable" has a pointer to the start of its set of 3146 * vtable offsets. The iftable entries in the superclass point to 3147 * storage allocated in the superclass, and the iftable entries added 3148 * for this class point to storage allocated in this class. "iftable" 3149 * is flat for fast access in a class and all of its subclasses, but 3150 * "ifviPool" is only created for the topmost implementor. 3151 */ 3152 for (int i = superIfCount; i < ifCount; i++) { 3153 /* 3154 * Note it's valid for an interface to have no methods (e.g. 3155 * java/io/Serializable). 3156 */ 3157 LOGVV("INTF: pool: %d from %s", 3158 clazz->iftable[i].clazz->virtualMethodCount, 3159 clazz->iftable[i].clazz->descriptor); 3160 poolSize += clazz->iftable[i].clazz->virtualMethodCount; 3161 } 3162 3163 if (poolSize == 0) { 3164 LOGVV("INTF: didn't find any new interfaces with methods"); 3165 result = true; 3166 goto bail; 3167 } 3168 3169 clazz->ifviPoolCount = poolSize; 3170 clazz->ifviPool = (int*) dvmLinearAlloc(clazz->classLoader, 3171 poolSize * sizeof(int*)); 3172 zapIfvipool = true; 3173 3174 /* 3175 * Fill in the vtable offsets for the interfaces that weren't part of 3176 * our superclass. 3177 */ 3178 for (int i = superIfCount; i < ifCount; i++) { 3179 ClassObject* interface; 3180 int methIdx; 3181 3182 clazz->iftable[i].methodIndexArray = clazz->ifviPool + poolOffset; 3183 interface = clazz->iftable[i].clazz; 3184 poolOffset += interface->virtualMethodCount; // end here 3185 3186 /* 3187 * For each method listed in the interface's method list, find the 3188 * matching method in our class's method list. We want to favor the 3189 * subclass over the superclass, which just requires walking 3190 * back from the end of the vtable. (This only matters if the 3191 * superclass defines a private method and this class redefines 3192 * it -- otherwise it would use the same vtable slot. In Dalvik 3193 * those don't end up in the virtual method table, so it shouldn't 3194 * matter which direction we go. We walk it backward anyway.) 3195 * 3196 * 3197 * Suppose we have the following arrangement: 3198 * public interface MyInterface 3199 * public boolean inInterface(); 3200 * public abstract class MirandaAbstract implements MirandaInterface 3201 * //public abstract boolean inInterface(); // not declared! 3202 * public boolean inAbstract() { stuff } // in vtable 3203 * public class MirandClass extends MirandaAbstract 3204 * public boolean inInterface() { stuff } 3205 * public boolean inAbstract() { stuff } // in vtable 3206 * 3207 * The javac compiler happily compiles MirandaAbstract even though 3208 * it doesn't declare all methods from its interface. When we try 3209 * to set up a vtable for MirandaAbstract, we find that we don't 3210 * have an slot for inInterface. To prevent this, we synthesize 3211 * abstract method declarations in MirandaAbstract. 3212 * 3213 * We have to expand vtable and update some things that point at it, 3214 * so we accumulate the method list and do it all at once below. 3215 */ 3216 for (methIdx = 0; methIdx < interface->virtualMethodCount; methIdx++) { 3217 Method* imeth = &interface->virtualMethods[methIdx]; 3218 int j; 3219 3220 IF_LOGVV() { 3221 char* desc = dexProtoCopyMethodDescriptor(&imeth->prototype); 3222 LOGVV("INTF: matching '%s' '%s'", imeth->name, desc); 3223 free(desc); 3224 } 3225 3226 for (j = clazz->vtableCount-1; j >= 0; j--) { 3227 if (dvmCompareMethodNamesAndProtos(imeth, clazz->vtable[j]) 3228 == 0) 3229 { 3230 LOGVV("INTF: matched at %d", j); 3231 if (!dvmIsPublicMethod(clazz->vtable[j])) { 3232 ALOGW("Implementation of %s.%s is not public", 3233 clazz->descriptor, clazz->vtable[j]->name); 3234 dvmThrowIllegalAccessError( 3235 "interface implementation not public"); 3236 goto bail; 3237 } 3238 clazz->iftable[i].methodIndexArray[methIdx] = j; 3239 break; 3240 } 3241 } 3242 if (j < 0) { 3243 IF_ALOGV() { 3244 char* desc = 3245 dexProtoCopyMethodDescriptor(&imeth->prototype); 3246 ALOGV("No match for '%s' '%s' in '%s' (creating miranda)", 3247 imeth->name, desc, clazz->descriptor); 3248 free(desc); 3249 } 3250 //dvmThrowRuntimeException("Miranda!"); 3251 //return false; 3252 3253 if (mirandaCount == mirandaAlloc) { 3254 mirandaAlloc += 8; 3255 if (mirandaList == NULL) { 3256 mirandaList = (Method**)dvmLinearAlloc( 3257 clazz->classLoader, 3258 mirandaAlloc * sizeof(Method*)); 3259 } else { 3260 dvmLinearReadOnly(clazz->classLoader, mirandaList); 3261 mirandaList = (Method**)dvmLinearRealloc( 3262 clazz->classLoader, 3263 mirandaList, mirandaAlloc * sizeof(Method*)); 3264 } 3265 assert(mirandaList != NULL); // mem failed + we leaked 3266 } 3267 3268 /* 3269 * These may be redundant (e.g. method with same name and 3270 * signature declared in two interfaces implemented by the 3271 * same abstract class). We can squeeze the duplicates 3272 * out here. 3273 */ 3274 int mir; 3275 for (mir = 0; mir < mirandaCount; mir++) { 3276 if (dvmCompareMethodNamesAndProtos( 3277 mirandaList[mir], imeth) == 0) 3278 { 3279 IF_LOGVV() { 3280 char* desc = dexProtoCopyMethodDescriptor( 3281 &imeth->prototype); 3282 LOGVV("MIRANDA dupe: %s and %s %s%s", 3283 mirandaList[mir]->clazz->descriptor, 3284 imeth->clazz->descriptor, 3285 imeth->name, desc); 3286 free(desc); 3287 } 3288 break; 3289 } 3290 } 3291 3292 /* point the iftable at a phantom slot index */ 3293 clazz->iftable[i].methodIndexArray[methIdx] = 3294 clazz->vtableCount + mir; 3295 LOGVV("MIRANDA: %s points at slot %d", 3296 imeth->name, clazz->vtableCount + mir); 3297 3298 /* if non-duplicate among Mirandas, add to Miranda list */ 3299 if (mir == mirandaCount) { 3300 //ALOGV("MIRANDA: holding '%s' in slot %d", 3301 // imeth->name, mir); 3302 mirandaList[mirandaCount++] = imeth; 3303 } 3304 } 3305 } 3306 } 3307 3308 if (mirandaCount != 0) { 3309 static const int kManyMirandas = 150; /* arbitrary */ 3310 Method* newVirtualMethods; 3311 Method* meth; 3312 int oldMethodCount, oldVtableCount; 3313 3314 for (int i = 0; i < mirandaCount; i++) { 3315 LOGVV("MIRANDA %d: %s.%s", i, 3316 mirandaList[i]->clazz->descriptor, mirandaList[i]->name); 3317 } 3318 if (mirandaCount > kManyMirandas) { 3319 /* 3320 * Some obfuscators like to create an interface with a huge 3321 * pile of methods, declare classes as implementing it, and then 3322 * only define a couple of methods. This leads to a rather 3323 * massive collection of Miranda methods and a lot of wasted 3324 * space, sometimes enough to blow out the LinearAlloc cap. 3325 */ 3326 ALOGD("Note: class %s has %d unimplemented (abstract) methods", 3327 clazz->descriptor, mirandaCount); 3328 } 3329 3330 /* 3331 * We found methods in one or more interfaces for which we do not 3332 * have vtable entries. We have to expand our virtualMethods 3333 * table (which might be empty) to hold some new entries. 3334 */ 3335 if (clazz->virtualMethods == NULL) { 3336 newVirtualMethods = (Method*) dvmLinearAlloc(clazz->classLoader, 3337 sizeof(Method) * (clazz->virtualMethodCount + mirandaCount)); 3338 } else { 3339 //dvmLinearReadOnly(clazz->classLoader, clazz->virtualMethods); 3340 newVirtualMethods = (Method*) dvmLinearRealloc(clazz->classLoader, 3341 clazz->virtualMethods, 3342 sizeof(Method) * (clazz->virtualMethodCount + mirandaCount)); 3343 } 3344 if (newVirtualMethods != clazz->virtualMethods) { 3345 /* 3346 * Table was moved in memory. We have to run through the 3347 * vtable and fix the pointers. The vtable entries might be 3348 * pointing at superclasses, so we flip it around: run through 3349 * all locally-defined virtual methods, and fix their entries 3350 * in the vtable. (This would get really messy if sub-classes 3351 * had already been loaded.) 3352 * 3353 * Reminder: clazz->virtualMethods and clazz->virtualMethodCount 3354 * hold the virtual methods declared by this class. The 3355 * method's methodIndex is the vtable index, and is the same 3356 * for all sub-classes (and all super classes in which it is 3357 * defined). We're messing with these because the Miranda 3358 * stuff makes it look like the class actually has an abstract 3359 * method declaration in it. 3360 */ 3361 LOGVV("MIRANDA fixing vtable pointers"); 3362 dvmLinearReadWrite(clazz->classLoader, clazz->vtable); 3363 Method* meth = newVirtualMethods; 3364 for (int i = 0; i < clazz->virtualMethodCount; i++, meth++) 3365 clazz->vtable[meth->methodIndex] = meth; 3366 dvmLinearReadOnly(clazz->classLoader, clazz->vtable); 3367 } 3368 3369 oldMethodCount = clazz->virtualMethodCount; 3370 clazz->virtualMethods = newVirtualMethods; 3371 clazz->virtualMethodCount += mirandaCount; 3372 3373 dvmLinearReadOnly(clazz->classLoader, clazz->virtualMethods); 3374 3375 /* 3376 * We also have to expand the vtable. 3377 */ 3378 assert(clazz->vtable != NULL); 3379 clazz->vtable = (Method**) dvmLinearRealloc(clazz->classLoader, 3380 clazz->vtable, 3381 sizeof(Method*) * (clazz->vtableCount + mirandaCount)); 3382 if (clazz->vtable == NULL) { 3383 assert(false); 3384 goto bail; 3385 } 3386 zapVtable = true; 3387 3388 oldVtableCount = clazz->vtableCount; 3389 clazz->vtableCount += mirandaCount; 3390 3391 /* 3392 * Now we need to create the fake methods. We clone the abstract 3393 * method definition from the interface and then replace a few 3394 * things. 3395 * 3396 * The Method will be an "abstract native", with nativeFunc set to 3397 * dvmAbstractMethodStub(). 3398 */ 3399 meth = clazz->virtualMethods + oldMethodCount; 3400 for (int i = 0; i < mirandaCount; i++, meth++) { 3401 dvmLinearReadWrite(clazz->classLoader, clazz->virtualMethods); 3402 cloneMethod(meth, mirandaList[i]); 3403 meth->clazz = clazz; 3404 meth->accessFlags |= ACC_MIRANDA; 3405 meth->methodIndex = (u2) (oldVtableCount + i); 3406 dvmLinearReadOnly(clazz->classLoader, clazz->virtualMethods); 3407 3408 /* point the new vtable entry at the new method */ 3409 clazz->vtable[oldVtableCount + i] = meth; 3410 } 3411 3412 dvmLinearReadOnly(clazz->classLoader, mirandaList); 3413 dvmLinearFree(clazz->classLoader, mirandaList); 3414 3415 } 3416 3417 /* 3418 * TODO? 3419 * Sort the interfaces by number of declared methods. All we really 3420 * want is to get the interfaces with zero methods at the end of the 3421 * list, so that when we walk through the list during invoke-interface 3422 * we don't examine interfaces that can't possibly be useful. 3423 * 3424 * The set will usually be small, so a simple insertion sort works. 3425 * 3426 * We have to be careful not to change the order of two interfaces 3427 * that define the same method. (Not a problem if we only move the 3428 * zero-method interfaces to the end.) 3429 * 3430 * PROBLEM: 3431 * If we do this, we will no longer be able to identify super vs. 3432 * current class interfaces by comparing clazz->super->iftableCount. This 3433 * breaks anything that only wants to find interfaces declared directly 3434 * by the class (dvmFindStaticFieldHier, ReferenceType.Interfaces, 3435 * dvmDbgOutputAllInterfaces, etc). Need to provide a workaround. 3436 * 3437 * We can sort just the interfaces implemented directly by this class, 3438 * but that doesn't seem like it would provide much of an advantage. I'm 3439 * not sure this is worthwhile. 3440 * 3441 * (This has been made largely obsolete by the interface cache mechanism.) 3442 */ 3443 3444 //dvmDumpClass(clazz); 3445 3446 result = true; 3447 3448bail: 3449 if (zapIftable) 3450 dvmLinearReadOnly(clazz->classLoader, clazz->iftable); 3451 if (zapVtable) 3452 dvmLinearReadOnly(clazz->classLoader, clazz->vtable); 3453 if (zapIfvipool) 3454 dvmLinearReadOnly(clazz->classLoader, clazz->ifviPool); 3455 return result; 3456} 3457 3458 3459/* 3460 * Provide "stub" implementations for methods without them. 3461 * 3462 * Currently we provide an implementation for all abstract methods that 3463 * throws an AbstractMethodError exception. This allows us to avoid an 3464 * explicit check for abstract methods in every virtual call. 3465 * 3466 * NOTE: for Miranda methods, the method declaration is a clone of what 3467 * was found in the interface class. That copy may already have had the 3468 * function pointer filled in, so don't be surprised if it's not NULL. 3469 * 3470 * NOTE: this sets the "native" flag, giving us an "abstract native" method, 3471 * which is nonsensical. Need to make sure that this doesn't escape the 3472 * VM. We can either mask it out in reflection calls, or copy "native" 3473 * into the high 16 bits of accessFlags and check that internally. 3474 */ 3475static bool insertMethodStubs(ClassObject* clazz) 3476{ 3477 dvmLinearReadWrite(clazz->classLoader, clazz->virtualMethods); 3478 3479 Method* meth; 3480 int i; 3481 3482 meth = clazz->virtualMethods; 3483 for (i = 0; i < clazz->virtualMethodCount; i++, meth++) { 3484 if (dvmIsAbstractMethod(meth)) { 3485 assert(meth->insns == NULL); 3486 assert(meth->nativeFunc == NULL || 3487 meth->nativeFunc == (DalvikBridgeFunc)dvmAbstractMethodStub); 3488 3489 meth->accessFlags |= ACC_NATIVE; 3490 meth->nativeFunc = (DalvikBridgeFunc) dvmAbstractMethodStub; 3491 } 3492 } 3493 3494 dvmLinearReadOnly(clazz->classLoader, clazz->virtualMethods); 3495 return true; 3496} 3497 3498 3499/* 3500 * Swap two instance fields. 3501 */ 3502static inline void swapField(InstField* pOne, InstField* pTwo) 3503{ 3504 InstField swap; 3505 3506 LOGVV(" --- swap '%s' and '%s'", pOne->name, pTwo->name); 3507 swap = *pOne; 3508 *pOne = *pTwo; 3509 *pTwo = swap; 3510} 3511 3512/* 3513 * Assign instance fields to u4 slots. 3514 * 3515 * The top portion of the instance field area is occupied by the superclass 3516 * fields, the bottom by the fields for this class. 3517 * 3518 * "long" and "double" fields occupy two adjacent slots. On some 3519 * architectures, 64-bit quantities must be 64-bit aligned, so we need to 3520 * arrange fields (or introduce padding) to ensure this. We assume the 3521 * fields of the topmost superclass (i.e. Object) are 64-bit aligned, so 3522 * we can just ensure that the offset is "even". To avoid wasting space, 3523 * we want to move non-reference 32-bit fields into gaps rather than 3524 * creating pad words. 3525 * 3526 * In the worst case we will waste 4 bytes, but because objects are 3527 * allocated on >= 64-bit boundaries, those bytes may well be wasted anyway 3528 * (assuming this is the most-derived class). 3529 * 3530 * Pad words are not represented in the field table, so the field table 3531 * itself does not change size. 3532 * 3533 * The number of field slots determines the size of the object, so we 3534 * set that here too. 3535 * 3536 * This function feels a little more complicated than I'd like, but it 3537 * has the property of moving the smallest possible set of fields, which 3538 * should reduce the time required to load a class. 3539 * 3540 * NOTE: reference fields *must* come first, or precacheReferenceOffsets() 3541 * will break. 3542 */ 3543static bool computeFieldOffsets(ClassObject* clazz) 3544{ 3545 int fieldOffset; 3546 int i, j; 3547 3548 dvmLinearReadWrite(clazz->classLoader, clazz->ifields); 3549 3550 if (clazz->super != NULL) 3551 fieldOffset = clazz->super->objectSize; 3552 else 3553 fieldOffset = OFFSETOF_MEMBER(DataObject, instanceData); 3554 3555 LOGVV("--- computeFieldOffsets '%s'", clazz->descriptor); 3556 3557 //ALOGI("OFFSETS fieldCount=%d", clazz->ifieldCount); 3558 //ALOGI("dataobj, instance: %d", offsetof(DataObject, instanceData)); 3559 //ALOGI("classobj, access: %d", offsetof(ClassObject, accessFlags)); 3560 //ALOGI("super=%p, fieldOffset=%d", clazz->super, fieldOffset); 3561 3562 /* 3563 * Start by moving all reference fields to the front. 3564 */ 3565 clazz->ifieldRefCount = 0; 3566 j = clazz->ifieldCount - 1; 3567 for (i = 0; i < clazz->ifieldCount; i++) { 3568 InstField* pField = &clazz->ifields[i]; 3569 char c = pField->signature[0]; 3570 3571 if (c != '[' && c != 'L') { 3572 /* This isn't a reference field; see if any reference fields 3573 * follow this one. If so, we'll move it to this position. 3574 * (quicksort-style partitioning) 3575 */ 3576 while (j > i) { 3577 InstField* refField = &clazz->ifields[j--]; 3578 char rc = refField->signature[0]; 3579 3580 if (rc == '[' || rc == 'L') { 3581 /* Here's a reference field that follows at least one 3582 * non-reference field. Swap it with the current field. 3583 * (When this returns, "pField" points to the reference 3584 * field, and "refField" points to the non-ref field.) 3585 */ 3586 swapField(pField, refField); 3587 3588 /* Fix the signature. 3589 */ 3590 c = rc; 3591 3592 clazz->ifieldRefCount++; 3593 break; 3594 } 3595 } 3596 /* We may or may not have swapped a field. 3597 */ 3598 } else { 3599 /* This is a reference field. 3600 */ 3601 clazz->ifieldRefCount++; 3602 } 3603 3604 /* 3605 * If we've hit the end of the reference fields, break. 3606 */ 3607 if (c != '[' && c != 'L') 3608 break; 3609 3610 pField->byteOffset = fieldOffset; 3611 fieldOffset += sizeof(u4); 3612 LOGVV(" --- offset1 '%s'=%d", pField->name,pField->byteOffset); 3613 } 3614 3615 /* 3616 * Now we want to pack all of the double-wide fields together. If we're 3617 * not aligned, though, we want to shuffle one 32-bit field into place. 3618 * If we can't find one, we'll have to pad it. 3619 */ 3620 if (i != clazz->ifieldCount && (fieldOffset & 0x04) != 0) { 3621 LOGVV(" +++ not aligned"); 3622 3623 InstField* pField = &clazz->ifields[i]; 3624 char c = pField->signature[0]; 3625 3626 if (c != 'J' && c != 'D') { 3627 /* 3628 * The field that comes next is 32-bit, so just advance past it. 3629 */ 3630 assert(c != '[' && c != 'L'); 3631 pField->byteOffset = fieldOffset; 3632 fieldOffset += sizeof(u4); 3633 i++; 3634 LOGVV(" --- offset2 '%s'=%d", 3635 pField->name, pField->byteOffset); 3636 } else { 3637 /* 3638 * Next field is 64-bit, so search for a 32-bit field we can 3639 * swap into it. 3640 */ 3641 bool found = false; 3642 j = clazz->ifieldCount - 1; 3643 while (j > i) { 3644 InstField* singleField = &clazz->ifields[j--]; 3645 char rc = singleField->signature[0]; 3646 3647 if (rc != 'J' && rc != 'D') { 3648 swapField(pField, singleField); 3649 //c = rc; 3650 LOGVV(" +++ swapped '%s' for alignment", 3651 pField->name); 3652 pField->byteOffset = fieldOffset; 3653 fieldOffset += sizeof(u4); 3654 LOGVV(" --- offset3 '%s'=%d", 3655 pField->name, pField->byteOffset); 3656 found = true; 3657 i++; 3658 break; 3659 } 3660 } 3661 if (!found) { 3662 ALOGV(" +++ inserting pad field in '%s'", clazz->descriptor); 3663 fieldOffset += sizeof(u4); 3664 } 3665 } 3666 } 3667 3668 /* 3669 * Alignment is good, shuffle any double-wide fields forward, and 3670 * finish assigning field offsets to all fields. 3671 */ 3672 assert(i == clazz->ifieldCount || (fieldOffset & 0x04) == 0); 3673 j = clazz->ifieldCount - 1; 3674 for ( ; i < clazz->ifieldCount; i++) { 3675 InstField* pField = &clazz->ifields[i]; 3676 char c = pField->signature[0]; 3677 3678 if (c != 'D' && c != 'J') { 3679 /* This isn't a double-wide field; see if any double fields 3680 * follow this one. If so, we'll move it to this position. 3681 * (quicksort-style partitioning) 3682 */ 3683 while (j > i) { 3684 InstField* doubleField = &clazz->ifields[j--]; 3685 char rc = doubleField->signature[0]; 3686 3687 if (rc == 'D' || rc == 'J') { 3688 /* Here's a double-wide field that follows at least one 3689 * non-double field. Swap it with the current field. 3690 * (When this returns, "pField" points to the reference 3691 * field, and "doubleField" points to the non-double field.) 3692 */ 3693 swapField(pField, doubleField); 3694 c = rc; 3695 3696 break; 3697 } 3698 } 3699 /* We may or may not have swapped a field. 3700 */ 3701 } else { 3702 /* This is a double-wide field, leave it be. 3703 */ 3704 } 3705 3706 pField->byteOffset = fieldOffset; 3707 LOGVV(" --- offset4 '%s'=%d", pField->name,pField->byteOffset); 3708 fieldOffset += sizeof(u4); 3709 if (c == 'J' || c == 'D') 3710 fieldOffset += sizeof(u4); 3711 } 3712 3713#ifndef NDEBUG 3714 /* Make sure that all reference fields appear before 3715 * non-reference fields, and all double-wide fields are aligned. 3716 */ 3717 j = 0; // seen non-ref 3718 for (i = 0; i < clazz->ifieldCount; i++) { 3719 InstField *pField = &clazz->ifields[i]; 3720 char c = pField->signature[0]; 3721 3722 if (c == 'D' || c == 'J') { 3723 assert((pField->byteOffset & 0x07) == 0); 3724 } 3725 3726 if (c != '[' && c != 'L') { 3727 if (!j) { 3728 assert(i == clazz->ifieldRefCount); 3729 j = 1; 3730 } 3731 } else if (j) { 3732 assert(false); 3733 } 3734 } 3735 if (!j) { 3736 assert(clazz->ifieldRefCount == clazz->ifieldCount); 3737 } 3738#endif 3739 3740 /* 3741 * We map a C struct directly on top of java/lang/Class objects. Make 3742 * sure we left enough room for the instance fields. 3743 */ 3744 assert(!dvmIsTheClassClass(clazz) || (size_t)fieldOffset < 3745 OFFSETOF_MEMBER(ClassObject, instanceData) + sizeof(clazz->instanceData)); 3746 3747 clazz->objectSize = fieldOffset; 3748 3749 dvmLinearReadOnly(clazz->classLoader, clazz->ifields); 3750 return true; 3751} 3752 3753/* 3754 * The class failed to initialize on a previous attempt, so we want to throw 3755 * a NoClassDefFoundError (v2 2.17.5). The exception to this rule is if we 3756 * failed in verification, in which case v2 5.4.1 says we need to re-throw 3757 * the previous error. 3758 */ 3759static void throwEarlierClassFailure(ClassObject* clazz) 3760{ 3761 ALOGI("Rejecting re-init on previously-failed class %s v=%p", 3762 clazz->descriptor, clazz->verifyErrorClass); 3763 3764 if (clazz->verifyErrorClass == NULL) { 3765 dvmThrowNoClassDefFoundError(clazz->descriptor); 3766 } else { 3767 dvmThrowExceptionWithClassMessage(clazz->verifyErrorClass, 3768 clazz->descriptor); 3769 } 3770} 3771 3772/* 3773 * Initialize any static fields whose values are stored in 3774 * the DEX file. This must be done during class initialization. 3775 */ 3776static void initSFields(ClassObject* clazz) 3777{ 3778 Thread* self = dvmThreadSelf(); /* for dvmReleaseTrackedAlloc() */ 3779 DexFile* pDexFile; 3780 const DexClassDef* pClassDef; 3781 const DexEncodedArray* pValueList; 3782 EncodedArrayIterator iterator; 3783 int i; 3784 3785 if (clazz->sfieldCount == 0) { 3786 return; 3787 } 3788 if (clazz->pDvmDex == NULL) { 3789 /* generated class; any static fields should already be set up */ 3790 ALOGV("Not initializing static fields in %s", clazz->descriptor); 3791 return; 3792 } 3793 pDexFile = clazz->pDvmDex->pDexFile; 3794 3795 pClassDef = dexFindClass(pDexFile, clazz->descriptor); 3796 assert(pClassDef != NULL); 3797 3798 pValueList = dexGetStaticValuesList(pDexFile, pClassDef); 3799 if (pValueList == NULL) { 3800 return; 3801 } 3802 3803 dvmEncodedArrayIteratorInitialize(&iterator, pValueList, clazz); 3804 3805 /* 3806 * Iterate over the initial values array, setting the corresponding 3807 * static field for each array element. 3808 */ 3809 3810 for (i = 0; dvmEncodedArrayIteratorHasNext(&iterator); i++) { 3811 AnnotationValue value; 3812 bool parsed = dvmEncodedArrayIteratorGetNext(&iterator, &value); 3813 StaticField* sfield = &clazz->sfields[i]; 3814 const char* descriptor = sfield->signature; 3815 bool isObj = false; 3816 3817 if (! parsed) { 3818 /* 3819 * TODO: Eventually verification should attempt to ensure 3820 * that this can't happen at least due to a data integrity 3821 * problem. 3822 */ 3823 ALOGE("Static initializer parse failed for %s at index %d", 3824 clazz->descriptor, i); 3825 dvmAbort(); 3826 } 3827 3828 /* Verify that the value we got was of a valid type. */ 3829 3830 switch (descriptor[0]) { 3831 case 'Z': parsed = (value.type == kDexAnnotationBoolean); break; 3832 case 'B': parsed = (value.type == kDexAnnotationByte); break; 3833 case 'C': parsed = (value.type == kDexAnnotationChar); break; 3834 case 'S': parsed = (value.type == kDexAnnotationShort); break; 3835 case 'I': parsed = (value.type == kDexAnnotationInt); break; 3836 case 'J': parsed = (value.type == kDexAnnotationLong); break; 3837 case 'F': parsed = (value.type == kDexAnnotationFloat); break; 3838 case 'D': parsed = (value.type == kDexAnnotationDouble); break; 3839 case '[': parsed = (value.type == kDexAnnotationNull); break; 3840 case 'L': { 3841 switch (value.type) { 3842 case kDexAnnotationNull: { 3843 /* No need for further tests. */ 3844 break; 3845 } 3846 case kDexAnnotationString: { 3847 parsed = 3848 (strcmp(descriptor, "Ljava/lang/String;") == 0); 3849 isObj = true; 3850 break; 3851 } 3852 case kDexAnnotationType: { 3853 parsed = 3854 (strcmp(descriptor, "Ljava/lang/Class;") == 0); 3855 isObj = true; 3856 break; 3857 } 3858 default: { 3859 parsed = false; 3860 break; 3861 } 3862 } 3863 break; 3864 } 3865 default: { 3866 parsed = false; 3867 break; 3868 } 3869 } 3870 3871 if (parsed) { 3872 /* 3873 * All's well, so store the value. 3874 */ 3875 if (isObj) { 3876 dvmSetStaticFieldObject(sfield, (Object*)value.value.l); 3877 dvmReleaseTrackedAlloc((Object*)value.value.l, self); 3878 } else { 3879 /* 3880 * Note: This always stores the full width of a 3881 * JValue, even though most of the time only the first 3882 * word is needed. 3883 */ 3884 sfield->value = value.value; 3885 } 3886 } else { 3887 /* 3888 * Something up above had a problem. TODO: See comment 3889 * above the switch about verfication. 3890 */ 3891 ALOGE("Bogus static initialization: value type %d in field type " 3892 "%s for %s at index %d", 3893 value.type, descriptor, clazz->descriptor, i); 3894 dvmAbort(); 3895 } 3896 } 3897} 3898 3899 3900/* 3901 * Determine whether "descriptor" yields the same class object in the 3902 * context of clazz1 and clazz2. 3903 * 3904 * The caller must hold gDvm.loadedClasses. 3905 * 3906 * Returns "true" if they match. 3907 */ 3908static bool compareDescriptorClasses(const char* descriptor, 3909 const ClassObject* clazz1, const ClassObject* clazz2) 3910{ 3911 ClassObject* result1; 3912 ClassObject* result2; 3913 3914 /* 3915 * Do the first lookup by name. 3916 */ 3917 result1 = dvmFindClassNoInit(descriptor, clazz1->classLoader); 3918 3919 /* 3920 * We can skip a second lookup by name if the second class loader is 3921 * in the initiating loader list of the class object we retrieved. 3922 * (This means that somebody already did a lookup of this class through 3923 * the second loader, and it resolved to the same class.) If it's not 3924 * there, we may simply not have had an opportunity to add it yet, so 3925 * we do the full lookup. 3926 * 3927 * The initiating loader test should catch the majority of cases 3928 * (in particular, the zillions of references to String/Object). 3929 * 3930 * Unfortunately we're still stuck grabbing a mutex to do the lookup. 3931 * 3932 * For this to work, the superclass/interface should be the first 3933 * argument, so that way if it's from the bootstrap loader this test 3934 * will work. (The bootstrap loader, by definition, never shows up 3935 * as the initiating loader of a class defined by some other loader.) 3936 */ 3937 dvmHashTableLock(gDvm.loadedClasses); 3938 bool isInit = dvmLoaderInInitiatingList(result1, clazz2->classLoader); 3939 dvmHashTableUnlock(gDvm.loadedClasses); 3940 3941 if (isInit) { 3942 //printf("%s(obj=%p) / %s(cl=%p): initiating\n", 3943 // result1->descriptor, result1, 3944 // clazz2->descriptor, clazz2->classLoader); 3945 return true; 3946 } else { 3947 //printf("%s(obj=%p) / %s(cl=%p): RAW\n", 3948 // result1->descriptor, result1, 3949 // clazz2->descriptor, clazz2->classLoader); 3950 result2 = dvmFindClassNoInit(descriptor, clazz2->classLoader); 3951 } 3952 3953 if (result1 == NULL || result2 == NULL) { 3954 dvmClearException(dvmThreadSelf()); 3955 if (result1 == result2) { 3956 /* 3957 * Neither class loader could find this class. Apparently it 3958 * doesn't exist. 3959 * 3960 * We can either throw some sort of exception now, or just 3961 * assume that it'll fail later when something actually tries 3962 * to use the class. For strict handling we should throw now, 3963 * because a "tricky" class loader could start returning 3964 * something later, and a pair of "tricky" loaders could set 3965 * us up for confusion. 3966 * 3967 * I'm not sure if we're allowed to complain about nonexistent 3968 * classes in method signatures during class init, so for now 3969 * this will just return "true" and let nature take its course. 3970 */ 3971 return true; 3972 } else { 3973 /* only one was found, so clearly they're not the same */ 3974 return false; 3975 } 3976 } 3977 3978 return result1 == result2; 3979} 3980 3981/* 3982 * For every component in the method descriptor, resolve the class in the 3983 * context of the two classes and compare the results. 3984 * 3985 * For best results, the "superclass" class should be first. 3986 * 3987 * Returns "true" if the classes match, "false" otherwise. 3988 */ 3989static bool checkMethodDescriptorClasses(const Method* meth, 3990 const ClassObject* clazz1, const ClassObject* clazz2) 3991{ 3992 DexParameterIterator iterator; 3993 const char* descriptor; 3994 3995 /* walk through the list of parameters */ 3996 dexParameterIteratorInit(&iterator, &meth->prototype); 3997 while (true) { 3998 descriptor = dexParameterIteratorNextDescriptor(&iterator); 3999 4000 if (descriptor == NULL) 4001 break; 4002 4003 if (descriptor[0] == 'L' || descriptor[0] == '[') { 4004 /* non-primitive type */ 4005 if (!compareDescriptorClasses(descriptor, clazz1, clazz2)) 4006 return false; 4007 } 4008 } 4009 4010 /* check the return type */ 4011 descriptor = dexProtoGetReturnType(&meth->prototype); 4012 if (descriptor[0] == 'L' || descriptor[0] == '[') { 4013 if (!compareDescriptorClasses(descriptor, clazz1, clazz2)) 4014 return false; 4015 } 4016 return true; 4017} 4018 4019/* 4020 * Validate the descriptors in the superclass and interfaces. 4021 * 4022 * What we need to do is ensure that the classes named in the method 4023 * descriptors in our ancestors and ourselves resolve to the same class 4024 * objects. We can get conflicts when the classes come from different 4025 * class loaders, and the resolver comes up with different results for 4026 * the same class name in different contexts. 4027 * 4028 * An easy way to cause the problem is to declare a base class that uses 4029 * class Foo in a method signature (e.g. as the return type). Then, 4030 * define a subclass and a different version of Foo, and load them from a 4031 * different class loader. If the subclass overrides the method, it will 4032 * have a different concept of what Foo is than its parent does, so even 4033 * though the method signature strings are identical, they actually mean 4034 * different things. 4035 * 4036 * A call to the method through a base-class reference would be treated 4037 * differently than a call to the method through a subclass reference, which 4038 * isn't the way polymorphism works, so we have to reject the subclass. 4039 * If the subclass doesn't override the base method, then there's no 4040 * problem, because calls through base-class references and subclass 4041 * references end up in the same place. 4042 * 4043 * We don't need to check to see if an interface's methods match with its 4044 * superinterface's methods, because you can't instantiate an interface 4045 * and do something inappropriate with it. If interface I1 extends I2 4046 * and is implemented by C, and I1 and I2 are in separate class loaders 4047 * and have conflicting views of other classes, we will catch the conflict 4048 * when we process C. Anything that implements I1 is doomed to failure, 4049 * but we don't need to catch that while processing I1. 4050 * 4051 * On failure, throws an exception and returns "false". 4052 */ 4053static bool validateSuperDescriptors(const ClassObject* clazz) 4054{ 4055 int i; 4056 4057 if (dvmIsInterfaceClass(clazz)) 4058 return true; 4059 4060 /* 4061 * Start with the superclass-declared methods. 4062 */ 4063 if (clazz->super != NULL && 4064 clazz->classLoader != clazz->super->classLoader) 4065 { 4066 /* 4067 * Walk through every overridden method and compare resolved 4068 * descriptor components. We pull the Method structs out of 4069 * the vtable. It doesn't matter whether we get the struct from 4070 * the parent or child, since we just need the UTF-8 descriptor, 4071 * which must match. 4072 * 4073 * We need to do this even for the stuff inherited from Object, 4074 * because it's possible that the new class loader has redefined 4075 * a basic class like String. 4076 * 4077 * We don't need to check stuff defined in a superclass because 4078 * it was checked when the superclass was loaded. 4079 */ 4080 const Method* meth; 4081 4082 //printf("Checking %s %p vs %s %p\n", 4083 // clazz->descriptor, clazz->classLoader, 4084 // clazz->super->descriptor, clazz->super->classLoader); 4085 for (i = clazz->super->vtableCount - 1; i >= 0; i--) { 4086 meth = clazz->vtable[i]; 4087 if (meth != clazz->super->vtable[i] && 4088 !checkMethodDescriptorClasses(meth, clazz->super, clazz)) 4089 { 4090 ALOGW("Method mismatch: %s in %s (cl=%p) and super %s (cl=%p)", 4091 meth->name, clazz->descriptor, clazz->classLoader, 4092 clazz->super->descriptor, clazz->super->classLoader); 4093 dvmThrowLinkageError( 4094 "Classes resolve differently in superclass"); 4095 return false; 4096 } 4097 } 4098 } 4099 4100 /* 4101 * Check the methods defined by this class against the interfaces it 4102 * implements. If we inherited the implementation from a superclass, 4103 * we have to check it against the superclass (which might be in a 4104 * different class loader). If the superclass also implements the 4105 * interface, we could skip the check since by definition it was 4106 * performed when the class was loaded. 4107 */ 4108 for (i = 0; i < clazz->iftableCount; i++) { 4109 const InterfaceEntry* iftable = &clazz->iftable[i]; 4110 4111 if (clazz->classLoader != iftable->clazz->classLoader) { 4112 const ClassObject* iface = iftable->clazz; 4113 int j; 4114 4115 for (j = 0; j < iface->virtualMethodCount; j++) { 4116 const Method* meth; 4117 int vtableIndex; 4118 4119 vtableIndex = iftable->methodIndexArray[j]; 4120 meth = clazz->vtable[vtableIndex]; 4121 4122 if (!checkMethodDescriptorClasses(meth, iface, meth->clazz)) { 4123 ALOGW("Method mismatch: %s in %s (cl=%p) and " 4124 "iface %s (cl=%p)", 4125 meth->name, clazz->descriptor, clazz->classLoader, 4126 iface->descriptor, iface->classLoader); 4127 dvmThrowLinkageError( 4128 "Classes resolve differently in interface"); 4129 return false; 4130 } 4131 } 4132 } 4133 } 4134 4135 return true; 4136} 4137 4138/* 4139 * Returns true if the class is being initialized by us (which means that 4140 * calling dvmInitClass will return immediately after fiddling with locks). 4141 * Returns false if it's not being initialized, or if it's being 4142 * initialized by another thread. 4143 * 4144 * The value for initThreadId is always set to "self->threadId", by the 4145 * thread doing the initializing. If it was done by the current thread, 4146 * we are guaranteed to see "initializing" and our thread ID, even on SMP. 4147 * If it was done by another thread, the only bad situation is one in 4148 * which we see "initializing" and a stale copy of our own thread ID 4149 * while another thread is actually handling init. 4150 * 4151 * The initThreadId field is used during class linking, so it *is* 4152 * possible to have a stale value floating around. We need to ensure 4153 * that memory accesses happen in the correct order. 4154 */ 4155bool dvmIsClassInitializing(const ClassObject* clazz) 4156{ 4157 const int32_t* addr = (const int32_t*)(const void*)&clazz->status; 4158 int32_t value = android_atomic_acquire_load(addr); 4159 ClassStatus status = static_cast<ClassStatus>(value); 4160 return (status == CLASS_INITIALIZING && 4161 clazz->initThreadId == dvmThreadSelf()->threadId); 4162} 4163 4164/* 4165 * If a class has not been initialized, do so by executing the code in 4166 * <clinit>. The sequence is described in the VM spec v2 2.17.5. 4167 * 4168 * It is possible for multiple threads to arrive here simultaneously, so 4169 * we need to lock the class while we check stuff. We know that no 4170 * interpreted code has access to the class yet, so we can use the class's 4171 * monitor lock. 4172 * 4173 * We will often be called recursively, e.g. when the <clinit> code resolves 4174 * one of its fields, the field resolution will try to initialize the class. 4175 * In that case we will return "true" even though the class isn't actually 4176 * ready to go. The ambiguity can be resolved with dvmIsClassInitializing(). 4177 * (TODO: consider having this return an enum to avoid the extra call -- 4178 * return -1 on failure, 0 on success, 1 on still-initializing. Looks like 4179 * dvmIsClassInitializing() is always paired with *Initialized()) 4180 * 4181 * This can get very interesting if a class has a static field initialized 4182 * to a new instance of itself. <clinit> will end up calling <init> on 4183 * the members it is initializing, which is fine unless it uses the contents 4184 * of static fields to initialize instance fields. This will leave the 4185 * static-referenced objects in a partially initialized state. This is 4186 * reasonably rare and can sometimes be cured with proper field ordering. 4187 * 4188 * On failure, returns "false" with an exception raised. 4189 * 4190 * ----- 4191 * 4192 * It is possible to cause a deadlock by having a situation like this: 4193 * class A { static { sleep(10000); new B(); } } 4194 * class B { static { sleep(10000); new A(); } } 4195 * new Thread() { public void run() { new A(); } }.start(); 4196 * new Thread() { public void run() { new B(); } }.start(); 4197 * This appears to be expected under the spec. 4198 * 4199 * The interesting question is what to do if somebody calls Thread.interrupt() 4200 * on one of the deadlocked threads. According to the VM spec, they're both 4201 * sitting in "wait". Should the interrupt code quietly raise the 4202 * "interrupted" flag, or should the "wait" return immediately with an 4203 * exception raised? 4204 * 4205 * This gets a little murky. The VM spec says we call "wait", and the 4206 * spec for Thread.interrupt says Object.wait is interruptible. So it 4207 * seems that, if we get unlucky and interrupt class initialization, we 4208 * are expected to throw (which gets converted to ExceptionInInitializerError 4209 * since InterruptedException is checked). 4210 * 4211 * There are a couple of problems here. First, all threads are expected to 4212 * present a consistent view of class initialization, so we can't have it 4213 * fail in one thread and succeed in another. Second, once a class fails 4214 * to initialize, it must *always* fail. This means that a stray interrupt() 4215 * call could render a class unusable for the lifetime of the VM. 4216 * 4217 * In most cases -- the deadlock example above being a counter-example -- 4218 * the interrupting thread can't tell whether the target thread handled 4219 * the initialization itself or had to wait while another thread did the 4220 * work. Refusing to interrupt class initialization is, in most cases, 4221 * not something that a program can reliably detect. 4222 * 4223 * On the assumption that interrupting class initialization is highly 4224 * undesirable in most circumstances, and that failing to do so does not 4225 * deviate from the spec in a meaningful way, we don't allow class init 4226 * to be interrupted by Thread.interrupt(). 4227 */ 4228bool dvmInitClass(ClassObject* clazz) 4229{ 4230 u8 startWhen = 0; 4231 4232#if LOG_CLASS_LOADING 4233 bool initializedByUs = false; 4234#endif 4235 4236 Thread* self = dvmThreadSelf(); 4237 const Method* method; 4238 4239 dvmLockObject(self, (Object*) clazz); 4240 assert(dvmIsClassLinked(clazz) || clazz->status == CLASS_ERROR); 4241 4242 /* 4243 * If the class hasn't been verified yet, do so now. 4244 */ 4245 if (clazz->status < CLASS_VERIFIED) { 4246 /* 4247 * If we're in an "erroneous" state, throw an exception and bail. 4248 */ 4249 if (clazz->status == CLASS_ERROR) { 4250 throwEarlierClassFailure(clazz); 4251 goto bail_unlock; 4252 } 4253 4254 assert(clazz->status == CLASS_RESOLVED); 4255 assert(!IS_CLASS_FLAG_SET(clazz, CLASS_ISPREVERIFIED)); 4256 4257 if (gDvm.classVerifyMode == VERIFY_MODE_NONE || 4258 (gDvm.classVerifyMode == VERIFY_MODE_REMOTE && 4259 clazz->classLoader == NULL)) 4260 { 4261 /* advance to "verified" state */ 4262 ALOGV("+++ not verifying class %s (cl=%p)", 4263 clazz->descriptor, clazz->classLoader); 4264 clazz->status = CLASS_VERIFIED; 4265 goto noverify; 4266 } 4267 4268 if (!gDvm.optimizing) 4269 ALOGV("+++ late verify on %s", clazz->descriptor); 4270 4271 /* 4272 * We're not supposed to optimize an unverified class, but during 4273 * development this mode was useful. We can't verify an optimized 4274 * class because the optimization process discards information. 4275 */ 4276 if (IS_CLASS_FLAG_SET(clazz, CLASS_ISOPTIMIZED)) { 4277 ALOGW("Class '%s' was optimized without verification; " 4278 "not verifying now", 4279 clazz->descriptor); 4280 ALOGW(" ('rm /data/dalvik-cache/*' and restart to fix this)"); 4281 goto verify_failed; 4282 } 4283 4284 clazz->status = CLASS_VERIFYING; 4285 if (!dvmVerifyClass(clazz)) { 4286verify_failed: 4287 dvmThrowVerifyError(clazz->descriptor); 4288 dvmSetFieldObject((Object*) clazz, 4289 OFFSETOF_MEMBER(ClassObject, verifyErrorClass), 4290 (Object*) dvmGetException(self)->clazz); 4291 clazz->status = CLASS_ERROR; 4292 goto bail_unlock; 4293 } 4294 4295 clazz->status = CLASS_VERIFIED; 4296 } 4297noverify: 4298 4299 /* 4300 * We need to ensure that certain instructions, notably accesses to 4301 * volatile fields, are replaced before any code is executed. This 4302 * must happen even if DEX optimizations are disabled. 4303 * 4304 * The only exception to this rule is that we don't want to do this 4305 * during dexopt. We don't generally initialize classes at all 4306 * during dexopt, but because we're loading classes we need Class and 4307 * Object (and possibly some Throwable stuff if a class isn't found). 4308 * If optimizations are disabled, we don't want to output optimized 4309 * instructions at this time. This means we will be executing <clinit> 4310 * code with un-fixed volatiles, but we're only doing it for a few 4311 * system classes, and dexopt runs single-threaded. 4312 */ 4313 if (!IS_CLASS_FLAG_SET(clazz, CLASS_ISOPTIMIZED) && !gDvm.optimizing) { 4314 ALOGV("+++ late optimize on %s (pv=%d)", 4315 clazz->descriptor, IS_CLASS_FLAG_SET(clazz, CLASS_ISPREVERIFIED)); 4316 bool essentialOnly = (gDvm.dexOptMode != OPTIMIZE_MODE_FULL); 4317 dvmOptimizeClass(clazz, essentialOnly); 4318 SET_CLASS_FLAG(clazz, CLASS_ISOPTIMIZED); 4319 } 4320 4321 /* update instruction stream now that verification + optimization is done */ 4322 dvmFlushBreakpoints(clazz); 4323 4324 if (clazz->status == CLASS_INITIALIZED) 4325 goto bail_unlock; 4326 4327 while (clazz->status == CLASS_INITIALIZING) { 4328 /* we caught somebody else in the act; was it us? */ 4329 if (clazz->initThreadId == self->threadId) { 4330 //ALOGV("HEY: found a recursive <clinit>"); 4331 goto bail_unlock; 4332 } 4333 4334 if (dvmCheckException(self)) { 4335 ALOGW("GLITCH: exception pending at start of class init"); 4336 dvmAbort(); 4337 } 4338 4339 /* 4340 * Wait for the other thread to finish initialization. We pass 4341 * "false" for the "interruptShouldThrow" arg so it doesn't throw 4342 * an exception on interrupt. 4343 */ 4344 dvmObjectWait(self, (Object*) clazz, 0, 0, false); 4345 4346 /* 4347 * When we wake up, repeat the test for init-in-progress. If there's 4348 * an exception pending (only possible if "interruptShouldThrow" 4349 * was set), bail out. 4350 */ 4351 if (dvmCheckException(self)) { 4352 ALOGI("Class init of '%s' failing with wait() exception", 4353 clazz->descriptor); 4354 /* 4355 * TODO: this is bogus, because it means the two threads have a 4356 * different idea of the class status. We need to flag the 4357 * class as bad and ensure that the initializer thread respects 4358 * our notice. If we get lucky and wake up after the class has 4359 * finished initialization but before being woken, we have to 4360 * swallow the exception, perhaps raising thread->interrupted 4361 * to preserve semantics. 4362 * 4363 * Since we're not currently allowing interrupts, this should 4364 * never happen and we don't need to fix this. 4365 */ 4366 assert(false); 4367 dvmThrowExceptionInInitializerError(); 4368 clazz->status = CLASS_ERROR; 4369 goto bail_unlock; 4370 } 4371 if (clazz->status == CLASS_INITIALIZING) { 4372 ALOGI("Waiting again for class init"); 4373 continue; 4374 } 4375 assert(clazz->status == CLASS_INITIALIZED || 4376 clazz->status == CLASS_ERROR); 4377 if (clazz->status == CLASS_ERROR) { 4378 /* 4379 * The caller wants an exception, but it was thrown in a 4380 * different thread. Synthesize one here. 4381 */ 4382 dvmThrowUnsatisfiedLinkError( 4383 "(<clinit> failed, see exception in other thread)"); 4384 } 4385 goto bail_unlock; 4386 } 4387 4388 /* see if we failed previously */ 4389 if (clazz->status == CLASS_ERROR) { 4390 // might be wise to unlock before throwing; depends on which class 4391 // it is that we have locked 4392 dvmUnlockObject(self, (Object*) clazz); 4393 throwEarlierClassFailure(clazz); 4394 return false; 4395 } 4396 4397 if (gDvm.allocProf.enabled) { 4398 startWhen = dvmGetRelativeTimeNsec(); 4399 } 4400 4401 /* 4402 * We're ready to go, and have exclusive access to the class. 4403 * 4404 * Before we start initialization, we need to do one extra bit of 4405 * validation: make sure that the methods declared here match up 4406 * with our superclass and interfaces. We know that the UTF-8 4407 * descriptors match, but classes from different class loaders can 4408 * have the same name. 4409 * 4410 * We do this now, rather than at load/link time, for the same reason 4411 * that we defer verification. 4412 * 4413 * It's unfortunate that we need to do this at all, but we risk 4414 * mixing reference types with identical names (see Dalvik test 068). 4415 */ 4416 if (!validateSuperDescriptors(clazz)) { 4417 assert(dvmCheckException(self)); 4418 clazz->status = CLASS_ERROR; 4419 goto bail_unlock; 4420 } 4421 4422 /* 4423 * Let's initialize this thing. 4424 * 4425 * We unlock the object so that other threads can politely sleep on 4426 * our mutex with Object.wait(), instead of hanging or spinning trying 4427 * to grab our mutex. 4428 */ 4429 assert(clazz->status < CLASS_INITIALIZING); 4430 4431#if LOG_CLASS_LOADING 4432 // We started initializing. 4433 logClassLoad('+', clazz); 4434 initializedByUs = true; 4435#endif 4436 4437 /* order matters here, esp. interaction with dvmIsClassInitializing */ 4438 clazz->initThreadId = self->threadId; 4439 android_atomic_release_store(CLASS_INITIALIZING, 4440 (int32_t*)(void*)&clazz->status); 4441 dvmUnlockObject(self, (Object*) clazz); 4442 4443 /* init our superclass */ 4444 if (clazz->super != NULL && clazz->super->status != CLASS_INITIALIZED) { 4445 assert(!dvmIsInterfaceClass(clazz)); 4446 if (!dvmInitClass(clazz->super)) { 4447 assert(dvmCheckException(self)); 4448 clazz->status = CLASS_ERROR; 4449 /* wake up anybody who started waiting while we were unlocked */ 4450 dvmLockObject(self, (Object*) clazz); 4451 goto bail_notify; 4452 } 4453 } 4454 4455 /* Initialize any static fields whose values are 4456 * stored in the Dex file. This should include all of the 4457 * simple "final static" fields, which are required to 4458 * be initialized first. (vmspec 2 sec 2.17.5 item 8) 4459 * More-complicated final static fields should be set 4460 * at the beginning of <clinit>; all we can do is trust 4461 * that the compiler did the right thing. 4462 */ 4463 initSFields(clazz); 4464 4465 /* Execute any static initialization code. 4466 */ 4467 method = dvmFindDirectMethodByDescriptor(clazz, "<clinit>", "()V"); 4468 if (method == NULL) { 4469 LOGVV("No <clinit> found for %s", clazz->descriptor); 4470 } else { 4471 LOGVV("Invoking %s.<clinit>", clazz->descriptor); 4472 JValue unused; 4473 dvmCallMethod(self, method, NULL, &unused); 4474 } 4475 4476 if (dvmCheckException(self)) { 4477 /* 4478 * We've had an exception thrown during static initialization. We 4479 * need to throw an ExceptionInInitializerError, but we want to 4480 * tuck the original exception into the "cause" field. 4481 */ 4482 ALOGW("Exception %s thrown while initializing %s", 4483 (dvmGetException(self)->clazz)->descriptor, clazz->descriptor); 4484 dvmThrowExceptionInInitializerError(); 4485 //ALOGW("+++ replaced"); 4486 4487 dvmLockObject(self, (Object*) clazz); 4488 clazz->status = CLASS_ERROR; 4489 } else { 4490 /* success! */ 4491 dvmLockObject(self, (Object*) clazz); 4492 clazz->status = CLASS_INITIALIZED; 4493 LOGVV("Initialized class: %s", clazz->descriptor); 4494 4495 /* 4496 * Update alloc counters. TODO: guard with mutex. 4497 */ 4498 if (gDvm.allocProf.enabled && startWhen != 0) { 4499 u8 initDuration = dvmGetRelativeTimeNsec() - startWhen; 4500 gDvm.allocProf.classInitTime += initDuration; 4501 self->allocProf.classInitTime += initDuration; 4502 gDvm.allocProf.classInitCount++; 4503 self->allocProf.classInitCount++; 4504 } 4505 } 4506 4507bail_notify: 4508 /* 4509 * Notify anybody waiting on the object. 4510 */ 4511 dvmObjectNotifyAll(self, (Object*) clazz); 4512 4513bail_unlock: 4514 4515#if LOG_CLASS_LOADING 4516 if (initializedByUs) { 4517 // We finished initializing. 4518 logClassLoad('-', clazz); 4519 } 4520#endif 4521 4522 dvmUnlockObject(self, (Object*) clazz); 4523 4524 return (clazz->status != CLASS_ERROR); 4525} 4526 4527/* 4528 * Replace method->nativeFunc and method->insns with new values. This is 4529 * commonly performed after successful resolution of a native method. 4530 * 4531 * There are three basic states: 4532 * (1) (initial) nativeFunc = dvmResolveNativeMethod, insns = NULL 4533 * (2) (internal native) nativeFunc = <impl>, insns = NULL 4534 * (3) (JNI) nativeFunc = JNI call bridge, insns = <impl> 4535 * 4536 * nativeFunc must never be NULL for a native method. 4537 * 4538 * The most common transitions are (1)->(2) and (1)->(3). The former is 4539 * atomic, since only one field is updated; the latter is not, but since 4540 * dvmResolveNativeMethod ignores the "insns" field we just need to make 4541 * sure the update happens in the correct order. 4542 * 4543 * A transition from (2)->(1) would work fine, but (3)->(1) will not, 4544 * because both fields change. If we did this while a thread was executing 4545 * in the call bridge, we could null out the "insns" field right before 4546 * the bridge tried to call through it. So, once "insns" is set, we do 4547 * not allow it to be cleared. A NULL value for the "insns" argument is 4548 * treated as "do not change existing value". 4549 */ 4550void dvmSetNativeFunc(Method* method, DalvikBridgeFunc func, 4551 const u2* insns) 4552{ 4553 ClassObject* clazz = method->clazz; 4554 4555 assert(func != NULL); 4556 4557 /* just open up both; easier that way */ 4558 dvmLinearReadWrite(clazz->classLoader, clazz->virtualMethods); 4559 dvmLinearReadWrite(clazz->classLoader, clazz->directMethods); 4560 4561 if (insns != NULL) { 4562 /* update both, ensuring that "insns" is observed first */ 4563 method->insns = insns; 4564 android_atomic_release_store((int32_t) func, 4565 (volatile int32_t*)(void*) &method->nativeFunc); 4566 } else { 4567 /* only update nativeFunc */ 4568 method->nativeFunc = func; 4569 } 4570 4571 dvmLinearReadOnly(clazz->classLoader, clazz->virtualMethods); 4572 dvmLinearReadOnly(clazz->classLoader, clazz->directMethods); 4573} 4574 4575/* 4576 * Add a RegisterMap to a Method. This is done when we verify the class 4577 * and compute the register maps at class initialization time (i.e. when 4578 * we don't have a pre-generated map). This means "pMap" is on the heap 4579 * and should be freed when the Method is discarded. 4580 */ 4581void dvmSetRegisterMap(Method* method, const RegisterMap* pMap) 4582{ 4583 ClassObject* clazz = method->clazz; 4584 4585 if (method->registerMap != NULL) { 4586 /* unexpected during class loading, okay on first use (uncompress) */ 4587 ALOGV("NOTE: registerMap already set for %s.%s", 4588 method->clazz->descriptor, method->name); 4589 /* keep going */ 4590 } 4591 assert(!dvmIsNativeMethod(method) && !dvmIsAbstractMethod(method)); 4592 4593 /* might be virtual or direct */ 4594 dvmLinearReadWrite(clazz->classLoader, clazz->virtualMethods); 4595 dvmLinearReadWrite(clazz->classLoader, clazz->directMethods); 4596 4597 method->registerMap = pMap; 4598 4599 dvmLinearReadOnly(clazz->classLoader, clazz->virtualMethods); 4600 dvmLinearReadOnly(clazz->classLoader, clazz->directMethods); 4601} 4602 4603/* 4604 * dvmHashForeach callback. A nonzero return value causes foreach to 4605 * bail out. 4606 */ 4607static int findClassCallback(void* vclazz, void* arg) 4608{ 4609 ClassObject* clazz = (ClassObject*)vclazz; 4610 const char* descriptor = (const char*) arg; 4611 4612 if (strcmp(clazz->descriptor, descriptor) == 0) 4613 return (int) clazz; 4614 return 0; 4615} 4616 4617/* 4618 * Find a loaded class by descriptor. Returns the first one found. 4619 * Because there can be more than one if class loaders are involved, 4620 * this is not an especially good API. (Currently only used by the 4621 * debugger and "checking" JNI.) 4622 * 4623 * "descriptor" should have the form "Ljava/lang/Class;" or 4624 * "[Ljava/lang/Class;", i.e. a descriptor and not an internal-form 4625 * class name. 4626 */ 4627ClassObject* dvmFindLoadedClass(const char* descriptor) 4628{ 4629 int result; 4630 4631 dvmHashTableLock(gDvm.loadedClasses); 4632 result = dvmHashForeach(gDvm.loadedClasses, findClassCallback, 4633 (void*) descriptor); 4634 dvmHashTableUnlock(gDvm.loadedClasses); 4635 4636 return (ClassObject*) result; 4637} 4638 4639/* 4640 * Retrieve the system (a/k/a application) class loader. 4641 * 4642 * The caller must call dvmReleaseTrackedAlloc on the result. 4643 */ 4644Object* dvmGetSystemClassLoader() 4645{ 4646 Thread* self = dvmThreadSelf(); 4647 ClassObject* clClass = gDvm.classJavaLangClassLoader; 4648 4649 if (!dvmIsClassInitialized(clClass) && !dvmInitClass(clClass)) 4650 return NULL; 4651 4652 JValue result; 4653 dvmCallMethod(self, gDvm.methJavaLangClassLoader_getSystemClassLoader, 4654 NULL, &result); 4655 Object* loader = (Object*)result.l; 4656 dvmAddTrackedAlloc(loader, self); 4657 return loader; 4658} 4659 4660 4661/* 4662 * This is a dvmHashForeach callback. 4663 */ 4664static int dumpClass(void* vclazz, void* varg) 4665{ 4666 const ClassObject* clazz = (const ClassObject*) vclazz; 4667 const ClassObject* super; 4668 int flags = (int) varg; 4669 char* desc; 4670 int i; 4671 4672 if (clazz == NULL) { 4673 ALOGI("dumpClass: ignoring request to dump null class"); 4674 return 0; 4675 } 4676 4677 if ((flags & kDumpClassFullDetail) == 0) { 4678 bool showInit = (flags & kDumpClassInitialized) != 0; 4679 bool showLoader = (flags & kDumpClassClassLoader) != 0; 4680 const char* initStr; 4681 4682 initStr = dvmIsClassInitialized(clazz) ? "true" : "false"; 4683 4684 if (showInit && showLoader) 4685 ALOGI("%s %p %s", clazz->descriptor, clazz->classLoader, initStr); 4686 else if (showInit) 4687 ALOGI("%s %s", clazz->descriptor, initStr); 4688 else if (showLoader) 4689 ALOGI("%s %p", clazz->descriptor, clazz->classLoader); 4690 else 4691 ALOGI("%s", clazz->descriptor); 4692 4693 return 0; 4694 } 4695 4696 /* clazz->super briefly holds the superclass index during class prep */ 4697 if ((u4)clazz->super > 0x10000 && (u4) clazz->super != (u4)-1) 4698 super = clazz->super; 4699 else 4700 super = NULL; 4701 4702 ALOGI("----- %s '%s' cl=%p ser=0x%08x -----", 4703 dvmIsInterfaceClass(clazz) ? "interface" : "class", 4704 clazz->descriptor, clazz->classLoader, clazz->serialNumber); 4705 ALOGI(" objectSize=%d (%d from super)", (int) clazz->objectSize, 4706 super != NULL ? (int) super->objectSize : -1); 4707 ALOGI(" access=0x%04x.%04x", clazz->accessFlags >> 16, 4708 clazz->accessFlags & JAVA_FLAGS_MASK); 4709 if (super != NULL) 4710 ALOGI(" super='%s' (cl=%p)", super->descriptor, super->classLoader); 4711 if (dvmIsArrayClass(clazz)) { 4712 ALOGI(" dimensions=%d elementClass=%s", 4713 clazz->arrayDim, clazz->elementClass->descriptor); 4714 } 4715 if (clazz->iftableCount > 0) { 4716 ALOGI(" interfaces (%d):", clazz->iftableCount); 4717 for (i = 0; i < clazz->iftableCount; i++) { 4718 InterfaceEntry* ent = &clazz->iftable[i]; 4719 int j; 4720 4721 ALOGI(" %2d: %s (cl=%p)", 4722 i, ent->clazz->descriptor, ent->clazz->classLoader); 4723 4724 /* enable when needed */ 4725 if (false && ent->methodIndexArray != NULL) { 4726 for (j = 0; j < ent->clazz->virtualMethodCount; j++) 4727 ALOGI(" %2d: %d %s %s", 4728 j, ent->methodIndexArray[j], 4729 ent->clazz->virtualMethods[j].name, 4730 clazz->vtable[ent->methodIndexArray[j]]->name); 4731 } 4732 } 4733 } 4734 if (!dvmIsInterfaceClass(clazz)) { 4735 ALOGI(" vtable (%d entries, %d in super):", clazz->vtableCount, 4736 super != NULL ? super->vtableCount : 0); 4737 for (i = 0; i < clazz->vtableCount; i++) { 4738 desc = dexProtoCopyMethodDescriptor(&clazz->vtable[i]->prototype); 4739 ALOGI(" %s%2d: %p %20s %s", 4740 (i != clazz->vtable[i]->methodIndex) ? "*** " : "", 4741 (u4) clazz->vtable[i]->methodIndex, clazz->vtable[i], 4742 clazz->vtable[i]->name, desc); 4743 free(desc); 4744 } 4745 ALOGI(" direct methods (%d entries):", clazz->directMethodCount); 4746 for (i = 0; i < clazz->directMethodCount; i++) { 4747 desc = dexProtoCopyMethodDescriptor( 4748 &clazz->directMethods[i].prototype); 4749 ALOGI(" %2d: %20s %s", i, clazz->directMethods[i].name, 4750 desc); 4751 free(desc); 4752 } 4753 } else { 4754 ALOGI(" interface methods (%d):", clazz->virtualMethodCount); 4755 for (i = 0; i < clazz->virtualMethodCount; i++) { 4756 desc = dexProtoCopyMethodDescriptor( 4757 &clazz->virtualMethods[i].prototype); 4758 ALOGI(" %2d: %2d %20s %s", i, 4759 (u4) clazz->virtualMethods[i].methodIndex, 4760 clazz->virtualMethods[i].name, 4761 desc); 4762 free(desc); 4763 } 4764 } 4765 if (clazz->sfieldCount > 0) { 4766 ALOGI(" static fields (%d entries):", clazz->sfieldCount); 4767 for (i = 0; i < clazz->sfieldCount; i++) { 4768 ALOGI(" %2d: %20s %s", i, clazz->sfields[i].name, 4769 clazz->sfields[i].signature); 4770 } 4771 } 4772 if (clazz->ifieldCount > 0) { 4773 ALOGI(" instance fields (%d entries):", clazz->ifieldCount); 4774 for (i = 0; i < clazz->ifieldCount; i++) { 4775 ALOGI(" %2d: %20s %s", i, clazz->ifields[i].name, 4776 clazz->ifields[i].signature); 4777 } 4778 } 4779 return 0; 4780} 4781 4782/* 4783 * Dump the contents of a single class. 4784 * 4785 * Pass kDumpClassFullDetail into "flags" to get lots of detail. 4786 */ 4787void dvmDumpClass(const ClassObject* clazz, int flags) 4788{ 4789 dumpClass((void*) clazz, (void*) flags); 4790} 4791 4792/* 4793 * Dump the contents of all classes. 4794 */ 4795void dvmDumpAllClasses(int flags) 4796{ 4797 dvmHashTableLock(gDvm.loadedClasses); 4798 dvmHashForeach(gDvm.loadedClasses, dumpClass, (void*) flags); 4799 dvmHashTableUnlock(gDvm.loadedClasses); 4800} 4801 4802/* 4803 * Get the number of loaded classes 4804 */ 4805int dvmGetNumLoadedClasses() 4806{ 4807 int count; 4808 dvmHashTableLock(gDvm.loadedClasses); 4809 count = dvmHashTableNumEntries(gDvm.loadedClasses); 4810 dvmHashTableUnlock(gDvm.loadedClasses); 4811 return count; 4812} 4813 4814/* 4815 * Write some statistics to the log file. 4816 */ 4817void dvmDumpLoaderStats(const char* msg) 4818{ 4819 ALOGV("VM stats (%s): cls=%d/%d meth=%d ifld=%d sfld=%d linear=%d", 4820 msg, gDvm.numLoadedClasses, dvmHashTableNumEntries(gDvm.loadedClasses), 4821 gDvm.numDeclaredMethods, gDvm.numDeclaredInstFields, 4822 gDvm.numDeclaredStaticFields, gDvm.pBootLoaderAlloc->curOffset); 4823#ifdef COUNT_PRECISE_METHODS 4824 ALOGI("GC precise methods: %d", 4825 dvmPointerSetGetCount(gDvm.preciseMethods)); 4826#endif 4827} 4828 4829/* 4830 * =========================================================================== 4831 * Method Prototypes and Descriptors 4832 * =========================================================================== 4833 */ 4834 4835/* 4836 * Compare the two method names and prototypes, a la strcmp(). The 4837 * name is considered the "major" order and the prototype the "minor" 4838 * order. The prototypes are compared as if by dvmCompareMethodProtos(). 4839 */ 4840int dvmCompareMethodNamesAndProtos(const Method* method1, 4841 const Method* method2) 4842{ 4843 int result = strcmp(method1->name, method2->name); 4844 4845 if (result != 0) { 4846 return result; 4847 } 4848 4849 return dvmCompareMethodProtos(method1, method2); 4850} 4851 4852/* 4853 * Compare the two method names and prototypes, a la strcmp(), ignoring 4854 * the return value. The name is considered the "major" order and the 4855 * prototype the "minor" order. The prototypes are compared as if by 4856 * dvmCompareMethodArgProtos(). 4857 */ 4858int dvmCompareMethodNamesAndParameterProtos(const Method* method1, 4859 const Method* method2) 4860{ 4861 int result = strcmp(method1->name, method2->name); 4862 4863 if (result != 0) { 4864 return result; 4865 } 4866 4867 return dvmCompareMethodParameterProtos(method1, method2); 4868} 4869 4870/* 4871 * Compare a (name, prototype) pair with the (name, prototype) of 4872 * a method, a la strcmp(). The name is considered the "major" order and 4873 * the prototype the "minor" order. The descriptor and prototype are 4874 * compared as if by dvmCompareDescriptorAndMethodProto(). 4875 */ 4876int dvmCompareNameProtoAndMethod(const char* name, 4877 const DexProto* proto, const Method* method) 4878{ 4879 int result = strcmp(name, method->name); 4880 4881 if (result != 0) { 4882 return result; 4883 } 4884 4885 return dexProtoCompare(proto, &method->prototype); 4886} 4887 4888/* 4889 * Compare a (name, method descriptor) pair with the (name, prototype) of 4890 * a method, a la strcmp(). The name is considered the "major" order and 4891 * the prototype the "minor" order. The descriptor and prototype are 4892 * compared as if by dvmCompareDescriptorAndMethodProto(). 4893 */ 4894int dvmCompareNameDescriptorAndMethod(const char* name, 4895 const char* descriptor, const Method* method) 4896{ 4897 int result = strcmp(name, method->name); 4898 4899 if (result != 0) { 4900 return result; 4901 } 4902 4903 return dvmCompareDescriptorAndMethodProto(descriptor, method); 4904} 4905