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 * Resolve classes, methods, fields, and strings.
19 *
20 * According to the VM spec (v2 5.5), classes may be initialized by use
21 * of the "new", "getstatic", "putstatic", or "invokestatic" instructions.
22 * If we are resolving a static method or static field, we make the
23 * initialization check here.
24 *
25 * (NOTE: the verifier has its own resolve functions, which can be invoked
26 * if a class isn't pre-verified.  Those functions must not update the
27 * "resolved stuff" tables for static fields and methods, because they do
28 * not perform initialization.)
29 */
30#include "Dalvik.h"
31
32#include <stdlib.h>
33
34
35/*
36 * Find the class corresponding to "classIdx", which maps to a class name
37 * string.  It might be in the same DEX file as "referrer", in a different
38 * DEX file, generated by a class loader, or generated by the VM (e.g.
39 * array classes).
40 *
41 * Because the DexTypeId is associated with the referring class' DEX file,
42 * we may have to resolve the same class more than once if it's referred
43 * to from classes in multiple DEX files.  This is a necessary property for
44 * DEX files associated with different class loaders.
45 *
46 * We cache a copy of the lookup in the DexFile's "resolved class" table,
47 * so future references to "classIdx" are faster.
48 *
49 * Note that "referrer" may be in the process of being linked.
50 *
51 * Traditional VMs might do access checks here, but in Dalvik the class
52 * "constant pool" is shared between all classes in the DEX file.  We rely
53 * on the verifier to do the checks for us.
54 *
55 * Does not initialize the class.
56 *
57 * "fromUnverifiedConstant" should only be set if this call is the direct
58 * result of executing a "const-class" or "instance-of" instruction, which
59 * use class constants not resolved by the bytecode verifier.
60 *
61 * Returns NULL with an exception raised on failure.
62 */
63ClassObject* dvmResolveClass(const ClassObject* referrer, u4 classIdx,
64    bool fromUnverifiedConstant)
65{
66    DvmDex* pDvmDex = referrer->pDvmDex;
67    ClassObject* resClass;
68    const char* className;
69
70    /*
71     * Check the table first -- this gets called from the other "resolve"
72     * methods.
73     */
74    resClass = dvmDexGetResolvedClass(pDvmDex, classIdx);
75    if (resClass != NULL)
76        return resClass;
77
78    LOGVV("--- resolving class %u (referrer=%s cl=%p)",
79        classIdx, referrer->descriptor, referrer->classLoader);
80
81    /*
82     * Class hasn't been loaded yet, or is in the process of being loaded
83     * and initialized now.  Try to get a copy.  If we find one, put the
84     * pointer in the DexTypeId.  There isn't a race condition here --
85     * 32-bit writes are guaranteed atomic on all target platforms.  Worst
86     * case we have two threads storing the same value.
87     *
88     * If this is an array class, we'll generate it here.
89     */
90    className = dexStringByTypeIdx(pDvmDex->pDexFile, classIdx);
91    if (className[0] != '\0' && className[1] == '\0') {
92        /* primitive type */
93        resClass = dvmFindPrimitiveClass(className[0]);
94    } else {
95        resClass = dvmFindClassNoInit(className, referrer->classLoader);
96    }
97
98    if (resClass != NULL) {
99        /*
100         * If the referrer was pre-verified, the resolved class must come
101         * from the same DEX or from a bootstrap class.  The pre-verifier
102         * makes assumptions that could be invalidated by a wacky class
103         * loader.  (See the notes at the top of oo/Class.c.)
104         *
105         * The verifier does *not* fail a class for using a const-class
106         * or instance-of instruction referring to an unresolveable class,
107         * because the result of the instruction is simply a Class object
108         * or boolean -- there's no need to resolve the class object during
109         * verification.  Instance field and virtual method accesses can
110         * break dangerously if we get the wrong class, but const-class and
111         * instance-of are only interesting at execution time.  So, if we
112         * we got here as part of executing one of the "unverified class"
113         * instructions, we skip the additional check.
114         *
115         * Ditto for class references from annotations and exception
116         * handler lists.
117         */
118        if (!fromUnverifiedConstant &&
119            IS_CLASS_FLAG_SET(referrer, CLASS_ISPREVERIFIED))
120        {
121            ClassObject* resClassCheck = resClass;
122            if (dvmIsArrayClass(resClassCheck))
123                resClassCheck = resClassCheck->elementClass;
124
125            if (referrer->pDvmDex != resClassCheck->pDvmDex &&
126                resClassCheck->classLoader != NULL)
127            {
128                ALOGW("Class resolved by unexpected DEX:"
129                     " %s(%p):%p ref [%s] %s(%p):%p",
130                    referrer->descriptor, referrer->classLoader,
131                    referrer->pDvmDex,
132                    resClass->descriptor, resClassCheck->descriptor,
133                    resClassCheck->classLoader, resClassCheck->pDvmDex);
134                ALOGW("(%s had used a different %s during pre-verification)",
135                    referrer->descriptor, resClass->descriptor);
136                dvmThrowIllegalAccessError(
137                    "Class ref in pre-verified class resolved to unexpected "
138                    "implementation");
139                return NULL;
140            }
141        }
142
143        LOGVV("##### +ResolveClass(%s): referrer=%s dex=%p ldr=%p ref=%d",
144            resClass->descriptor, referrer->descriptor, referrer->pDvmDex,
145            referrer->classLoader, classIdx);
146
147        /*
148         * Add what we found to the list so we can skip the class search
149         * next time through.
150         *
151         * TODO: should we be doing this when fromUnverifiedConstant==true?
152         * (see comments at top of oo/Class.c)
153         */
154        dvmDexSetResolvedClass(pDvmDex, classIdx, resClass);
155    } else {
156        /* not found, exception should be raised */
157        LOGVV("Class not found: %s",
158            dexStringByTypeIdx(pDvmDex->pDexFile, classIdx));
159        assert(dvmCheckException(dvmThreadSelf()));
160    }
161
162    return resClass;
163}
164
165
166/*
167 * Find the method corresponding to "methodRef".
168 *
169 * We use "referrer" to find the DexFile with the constant pool that
170 * "methodRef" is an index into.  We also use its class loader.  The method
171 * being resolved may very well be in a different DEX file.
172 *
173 * If this is a static method, we ensure that the method's class is
174 * initialized.
175 */
176Method* dvmResolveMethod(const ClassObject* referrer, u4 methodIdx,
177    MethodType methodType)
178{
179    DvmDex* pDvmDex = referrer->pDvmDex;
180    ClassObject* resClass;
181    const DexMethodId* pMethodId;
182    Method* resMethod;
183
184    assert(methodType != METHOD_INTERFACE);
185
186    LOGVV("--- resolving method %u (referrer=%s)", methodIdx,
187        referrer->descriptor);
188    pMethodId = dexGetMethodId(pDvmDex->pDexFile, methodIdx);
189
190    resClass = dvmResolveClass(referrer, pMethodId->classIdx, false);
191    if (resClass == NULL) {
192        /* can't find the class that the method is a part of */
193        assert(dvmCheckException(dvmThreadSelf()));
194        return NULL;
195    }
196    if (dvmIsInterfaceClass(resClass)) {
197        /* method is part of an interface */
198        dvmThrowIncompatibleClassChangeErrorWithClassMessage(
199                resClass->descriptor);
200        return NULL;
201    }
202
203    const char* name = dexStringById(pDvmDex->pDexFile, pMethodId->nameIdx);
204    DexProto proto;
205    dexProtoSetFromMethodId(&proto, pDvmDex->pDexFile, pMethodId);
206
207    /*
208     * We need to chase up the class hierarchy to find methods defined
209     * in super-classes.  (We only want to check the current class
210     * if we're looking for a constructor; since DIRECT calls are only
211     * for constructors and private methods, we don't want to walk up.)
212     */
213    if (methodType == METHOD_DIRECT) {
214        resMethod = dvmFindDirectMethod(resClass, name, &proto);
215    } else if (methodType == METHOD_STATIC) {
216        resMethod = dvmFindDirectMethodHier(resClass, name, &proto);
217    } else {
218        resMethod = dvmFindVirtualMethodHier(resClass, name, &proto);
219    }
220
221    if (resMethod == NULL) {
222        std::string msg;
223        msg += resClass->descriptor;
224        msg += ".";
225        msg += name;
226        dvmThrowNoSuchMethodError(msg.c_str());
227        return NULL;
228    }
229
230    LOGVV("--- found method %d (%s.%s)",
231        methodIdx, resClass->descriptor, resMethod->name);
232
233    /* see if this is a pure-abstract method */
234    if (dvmIsAbstractMethod(resMethod) && !dvmIsAbstractClass(resClass)) {
235        dvmThrowAbstractMethodError(name);
236        return NULL;
237    }
238
239    /*
240     * If we're the first to resolve this class, we need to initialize
241     * it now.  Only necessary for METHOD_STATIC.
242     */
243    if (methodType == METHOD_STATIC) {
244        if (!dvmIsClassInitialized(resMethod->clazz) &&
245            !dvmInitClass(resMethod->clazz))
246        {
247            assert(dvmCheckException(dvmThreadSelf()));
248            return NULL;
249        } else {
250            assert(!dvmCheckException(dvmThreadSelf()));
251        }
252    } else {
253        /*
254         * Edge case: if the <clinit> for a class creates an instance
255         * of itself, we will call <init> on a class that is still being
256         * initialized by us.
257         */
258        assert(dvmIsClassInitialized(resMethod->clazz) ||
259               dvmIsClassInitializing(resMethod->clazz));
260    }
261
262    /*
263     * If the class has been initialized, add a pointer to our data structure
264     * so we don't have to jump through the hoops again.  If this is a
265     * static method and the defining class is still initializing (i.e. this
266     * thread is executing <clinit>), don't do the store, otherwise other
267     * threads could call the method without waiting for class init to finish.
268     */
269    if (methodType == METHOD_STATIC && !dvmIsClassInitialized(resMethod->clazz))
270    {
271        LOGVV("--- not caching resolved method %s.%s (class init=%d/%d)",
272            resMethod->clazz->descriptor, resMethod->name,
273            dvmIsClassInitializing(resMethod->clazz),
274            dvmIsClassInitialized(resMethod->clazz));
275    } else {
276        dvmDexSetResolvedMethod(pDvmDex, methodIdx, resMethod);
277    }
278
279    return resMethod;
280}
281
282/*
283 * Resolve an interface method reference.
284 *
285 * Returns NULL with an exception raised on failure.
286 */
287Method* dvmResolveInterfaceMethod(const ClassObject* referrer, u4 methodIdx)
288{
289    DvmDex* pDvmDex = referrer->pDvmDex;
290    ClassObject* resClass;
291    const DexMethodId* pMethodId;
292    Method* resMethod;
293
294    LOGVV("--- resolving interface method %d (referrer=%s)",
295        methodIdx, referrer->descriptor);
296    pMethodId = dexGetMethodId(pDvmDex->pDexFile, methodIdx);
297
298    resClass = dvmResolveClass(referrer, pMethodId->classIdx, false);
299    if (resClass == NULL) {
300        /* can't find the class that the method is a part of */
301        assert(dvmCheckException(dvmThreadSelf()));
302        return NULL;
303    }
304    if (!dvmIsInterfaceClass(resClass)) {
305        /* whoops */
306        dvmThrowIncompatibleClassChangeErrorWithClassMessage(
307                resClass->descriptor);
308        return NULL;
309    }
310
311    /*
312     * This is the first time the method has been resolved.  Set it in our
313     * resolved-method structure.  It always resolves to the same thing,
314     * so looking it up and storing it doesn't create a race condition.
315     *
316     * If we scan into the interface's superclass -- which is always
317     * java/lang/Object -- we will catch things like:
318     *   interface I ...
319     *   I myobj = (something that implements I)
320     *   myobj.hashCode()
321     * However, the Method->methodIndex will be an offset into clazz->vtable,
322     * rather than an offset into clazz->iftable.  The invoke-interface
323     * code can test to see if the method returned is abstract or concrete,
324     * and use methodIndex accordingly.  I'm not doing this yet because
325     * (a) we waste time in an unusual case, and (b) we're probably going
326     * to fix it in the DEX optimizer.
327     *
328     * We do need to scan the superinterfaces, in case we're invoking a
329     * superinterface method on an interface reference.  The class in the
330     * DexTypeId is for the static type of the object, not the class in
331     * which the method is first defined.  We have the full, flattened
332     * list in "iftable".
333     */
334    const char* methodName =
335        dexStringById(pDvmDex->pDexFile, pMethodId->nameIdx);
336
337    DexProto proto;
338    dexProtoSetFromMethodId(&proto, pDvmDex->pDexFile, pMethodId);
339
340    LOGVV("+++ looking for '%s' in resClass='%s'", methodName, resClass->descriptor);
341    resMethod = dvmFindInterfaceMethodHier(resClass, methodName, &proto);
342    if (resMethod == NULL) {
343        std::string msg;
344        msg += resClass->descriptor;
345        msg += ".";
346        msg += methodName;
347        dvmThrowNoSuchMethodError(msg.c_str());
348        return NULL;
349    }
350
351    LOGVV("--- found interface method %d (%s.%s)",
352        methodIdx, resClass->descriptor, resMethod->name);
353
354    /* we're expecting this to be abstract */
355    assert(dvmIsAbstractMethod(resMethod));
356
357    /* interface methods are always public; no need to check access */
358
359    /*
360     * The interface class *may* be initialized.  According to VM spec
361     * v2 2.17.4, the interfaces a class refers to "need not" be initialized
362     * when the class is initialized.
363     *
364     * It isn't necessary for an interface class to be initialized before
365     * we resolve methods on that interface.
366     *
367     * We choose not to do the initialization now.
368     */
369    //assert(dvmIsClassInitialized(resMethod->clazz));
370
371    /*
372     * Add a pointer to our data structure so we don't have to jump
373     * through the hoops again.
374     *
375     * As noted above, no need to worry about whether the interface that
376     * defines the method has been or is currently executing <clinit>.
377     */
378    dvmDexSetResolvedMethod(pDvmDex, methodIdx, resMethod);
379
380    return resMethod;
381}
382
383/*
384 * Resolve an instance field reference.
385 *
386 * Returns NULL and throws an exception on error (no such field, illegal
387 * access).
388 */
389InstField* dvmResolveInstField(const ClassObject* referrer, u4 ifieldIdx)
390{
391    DvmDex* pDvmDex = referrer->pDvmDex;
392    ClassObject* resClass;
393    const DexFieldId* pFieldId;
394    InstField* resField;
395
396    LOGVV("--- resolving field %u (referrer=%s cl=%p)",
397        ifieldIdx, referrer->descriptor, referrer->classLoader);
398
399    pFieldId = dexGetFieldId(pDvmDex->pDexFile, ifieldIdx);
400
401    /*
402     * Find the field's class.
403     */
404    resClass = dvmResolveClass(referrer, pFieldId->classIdx, false);
405    if (resClass == NULL) {
406        assert(dvmCheckException(dvmThreadSelf()));
407        return NULL;
408    }
409
410    resField = dvmFindInstanceFieldHier(resClass,
411        dexStringById(pDvmDex->pDexFile, pFieldId->nameIdx),
412        dexStringByTypeIdx(pDvmDex->pDexFile, pFieldId->typeIdx));
413    if (resField == NULL) {
414        dvmThrowNoSuchFieldError(
415            dexStringById(pDvmDex->pDexFile, pFieldId->nameIdx));
416        return NULL;
417    }
418
419    /*
420     * Class must be initialized by now (unless verifier is buggy).  We
421     * could still be in the process of initializing it if the field
422     * access is from a static initializer.
423     */
424    assert(dvmIsClassInitialized(resField->clazz) ||
425           dvmIsClassInitializing(resField->clazz));
426
427    /*
428     * The class is initialized (or initializing), the field has been
429     * found.  Add a pointer to our data structure so we don't have to
430     * jump through the hoops again.
431     *
432     * Anything that uses the resolved table entry must have an instance
433     * of the class, so any class init activity has already happened (or
434     * been deliberately bypassed when <clinit> created an instance).
435     * So it's always okay to update the table.
436     */
437    dvmDexSetResolvedField(pDvmDex, ifieldIdx, (Field*)resField);
438    LOGVV("    field %u is %s.%s",
439        ifieldIdx, resField->clazz->descriptor, resField->name);
440
441    return resField;
442}
443
444/*
445 * Resolve a static field reference.  The DexFile format doesn't distinguish
446 * between static and instance field references, so the "resolved" pointer
447 * in the Dex struct will have the wrong type.  We trivially cast it here.
448 *
449 * Causes the field's class to be initialized.
450 */
451StaticField* dvmResolveStaticField(const ClassObject* referrer, u4 sfieldIdx)
452{
453    DvmDex* pDvmDex = referrer->pDvmDex;
454    ClassObject* resClass;
455    const DexFieldId* pFieldId;
456    StaticField* resField;
457
458    pFieldId = dexGetFieldId(pDvmDex->pDexFile, sfieldIdx);
459
460    /*
461     * Find the field's class.
462     */
463    resClass = dvmResolveClass(referrer, pFieldId->classIdx, false);
464    if (resClass == NULL) {
465        assert(dvmCheckException(dvmThreadSelf()));
466        return NULL;
467    }
468
469    resField = dvmFindStaticFieldHier(resClass,
470                dexStringById(pDvmDex->pDexFile, pFieldId->nameIdx),
471                dexStringByTypeIdx(pDvmDex->pDexFile, pFieldId->typeIdx));
472    if (resField == NULL) {
473        dvmThrowNoSuchFieldError(
474            dexStringById(pDvmDex->pDexFile, pFieldId->nameIdx));
475        return NULL;
476    }
477
478    /*
479     * If we're the first to resolve the field in which this class resides,
480     * we need to do it now.  Note that, if the field was inherited from
481     * a superclass, it is not necessarily the same as "resClass".
482     */
483    if (!dvmIsClassInitialized(resField->clazz) &&
484        !dvmInitClass(resField->clazz))
485    {
486        assert(dvmCheckException(dvmThreadSelf()));
487        return NULL;
488    }
489
490    /*
491     * If the class has been initialized, add a pointer to our data structure
492     * so we don't have to jump through the hoops again.  If it's still
493     * initializing (i.e. this thread is executing <clinit>), don't do
494     * the store, otherwise other threads could use the field without waiting
495     * for class init to finish.
496     */
497    if (dvmIsClassInitialized(resField->clazz)) {
498        dvmDexSetResolvedField(pDvmDex, sfieldIdx, (Field*) resField);
499    } else {
500        LOGVV("--- not caching resolved field %s.%s (class init=%d/%d)",
501            resField->clazz->descriptor, resField->name,
502            dvmIsClassInitializing(resField->clazz),
503            dvmIsClassInitialized(resField->clazz));
504    }
505
506    return resField;
507}
508
509
510/*
511 * Resolve a string reference.
512 *
513 * Finding the string is easy.  We need to return a reference to a
514 * java/lang/String object, not a bunch of characters, which means the
515 * first time we get here we need to create an interned string.
516 */
517StringObject* dvmResolveString(const ClassObject* referrer, u4 stringIdx)
518{
519    DvmDex* pDvmDex = referrer->pDvmDex;
520    StringObject* strObj;
521    StringObject* internStrObj;
522    const char* utf8;
523    u4 utf16Size;
524
525    LOGVV("+++ resolving string, referrer is %s", referrer->descriptor);
526
527    /*
528     * Create a UTF-16 version so we can trivially compare it to what's
529     * already interned.
530     */
531    utf8 = dexStringAndSizeById(pDvmDex->pDexFile, stringIdx, &utf16Size);
532    strObj = dvmCreateStringFromCstrAndLength(utf8, utf16Size);
533    if (strObj == NULL) {
534        /* ran out of space in GC heap? */
535        assert(dvmCheckException(dvmThreadSelf()));
536        goto bail;
537    }
538
539    /*
540     * Add it to the intern list.  The return value is the one in the
541     * intern list, which (due to race conditions) may or may not be
542     * the one we just created.  The intern list is synchronized, so
543     * there will be only one "live" version.
544     *
545     * By requesting an immortal interned string, we guarantee that
546     * the returned object will never be collected by the GC.
547     *
548     * A NULL return here indicates some sort of hashing failure.
549     */
550    internStrObj = dvmLookupImmortalInternedString(strObj);
551    dvmReleaseTrackedAlloc((Object*) strObj, NULL);
552    strObj = internStrObj;
553    if (strObj == NULL) {
554        assert(dvmCheckException(dvmThreadSelf()));
555        goto bail;
556    }
557
558    /* save a reference so we can go straight to the object next time */
559    dvmDexSetResolvedString(pDvmDex, stringIdx, strObj);
560
561bail:
562    return strObj;
563}
564
565/*
566 * For debugging: return a string representing the methodType.
567 */
568const char* dvmMethodTypeStr(MethodType methodType)
569{
570    switch (methodType) {
571    case METHOD_DIRECT:         return "direct";
572    case METHOD_STATIC:         return "static";
573    case METHOD_VIRTUAL:        return "virtual";
574    case METHOD_INTERFACE:      return "interface";
575    case METHOD_UNKNOWN:        return "UNKNOWN";
576    }
577    assert(false);
578    return "BOGUS";
579}
580