Home | History | Annotate | Download | only in analysis 
      1 /*
      2  * Copyright 2013, Google Inc.
      3  * All rights reserved.
      4  *
      5  * Redistribution and use in source and binary forms, with or without
      6  * modification, are permitted provided that the following conditions are
      7  * met:
      8  *
      9  *     * Redistributions of source code must retain the above copyright
     10  * notice, this list of conditions and the following disclaimer.
     11  *     * Redistributions in binary form must reproduce the above
     12  * copyright notice, this list of conditions and the following disclaimer
     13  * in the documentation and/or other materials provided with the
     14  * distribution.
     15  *     * Neither the name of Google Inc. nor the names of its
     16  * contributors may be used to endorse or promote products derived from
     17  * this software without specific prior written permission.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     30  */
     31 
     32 package org.jf.dexlib2.analysis;
     33 
     34 import com.google.common.base.Strings;
     35 import org.jf.dexlib2.iface.Method;
     36 import org.jf.dexlib2.iface.reference.FieldReference;
     37 import org.jf.dexlib2.iface.reference.MethodReference;
     38 import org.jf.dexlib2.immutable.reference.ImmutableFieldReference;
     39 import org.jf.dexlib2.util.TypeUtils;
     40 import org.jf.util.ExceptionWithContext;
     41 
     42 import javax.annotation.Nonnull;
     43 import javax.annotation.Nullable;
     44 
     45 public class ArrayProto implements TypeProto {
     46     protected final ClassPath classPath;
     47     protected final int dimensions;
     48     protected final String elementType;
     49 
     50     public ArrayProto(@Nonnull ClassPath classPath, @Nonnull String type) {
     51         this.classPath = classPath;
     52         int i=0;
     53         while (type.charAt(i) == '[') {
     54             i++;
     55             if (i == type.length()) {
     56                 throw new ExceptionWithContext("Invalid array type: %s", type);
     57             }
     58         }
     59 
     60         if (i == 0) {
     61             throw new ExceptionWithContext("Invalid array type: %s", type);
     62         }
     63 
     64         dimensions = i;
     65         elementType = type.substring(i);
     66     }
     67 
     68     @Override public String toString() { return getType(); }
     69     @Nonnull @Override public ClassPath getClassPath() { return classPath; }
     70     @Nonnull @Override public String getType() { return makeArrayType(elementType, dimensions); }
     71     public int getDimensions() { return dimensions; }
     72     @Override public boolean isInterface() { return false; }
     73 
     74     /**
     75      * @return The base element type of this array. E.g. This would return Ljava/lang/String; for [[Ljava/lang/String;
     76      */
     77     @Nonnull public String getElementType() { return elementType; }
     78 
     79     /**
     80      * @return The immediate element type of this array. E.g. This would return [Ljava/lang/String; for
     81      * [[Ljava/lang/String;
     82      */
     83     @Nonnull public String getImmediateElementType() {
     84         if (dimensions > 1) {
     85             return makeArrayType(elementType, dimensions-1);
     86         }
     87         return elementType;
     88     }
     89 
     90     @Override public boolean implementsInterface(@Nonnull String iface) {
     91         return iface.equals("Ljava/lang/Cloneable;") || iface.equals("Ljava/io/Serializable;");
     92     }
     93 
     94     @Nullable @Override
     95     public String getSuperclass() {
     96         return "Ljava/lang/Object;";
     97     }
     98 
     99     @Nonnull @Override
    100     public TypeProto getCommonSuperclass(@Nonnull TypeProto other) {
    101         if (other instanceof ArrayProto) {
    102             if (TypeUtils.isPrimitiveType(getElementType()) ||
    103                     TypeUtils.isPrimitiveType(((ArrayProto)other).getElementType())) {
    104                 if (dimensions == ((ArrayProto)other).dimensions &&
    105                         getElementType().equals(((ArrayProto)other).getElementType())) {
    106                     return this;
    107                 }
    108                 return classPath.getClass("Ljava/lang/Object;");
    109             }
    110 
    111             if (dimensions == ((ArrayProto)other).dimensions) {
    112                 TypeProto thisClass = classPath.getClass(elementType);
    113                 TypeProto otherClass = classPath.getClass(((ArrayProto)other).elementType);
    114                 TypeProto mergedClass = thisClass.getCommonSuperclass(otherClass);
    115                 if (thisClass == mergedClass) {
    116                     return this;
    117                 }
    118                 if (otherClass == mergedClass) {
    119                     return other;
    120                 }
    121                 return classPath.getClass(makeArrayType(mergedClass.getType(), dimensions));
    122             }
    123 
    124             int dimensions = Math.min(this.dimensions, ((ArrayProto)other).dimensions);
    125             return classPath.getClass(makeArrayType("Ljava/lang/Object;", dimensions));
    126         }
    127 
    128         if (other instanceof ClassProto) {
    129             try {
    130                 if (other.isInterface()) {
    131                     if (implementsInterface(other.getType())) {
    132                         return other;
    133                     }
    134                 }
    135             } catch (UnresolvedClassException ex) {
    136                 // ignore
    137             }
    138             return classPath.getClass("Ljava/lang/Object;");
    139         }
    140 
    141         // otherwise, defer to the other class' getCommonSuperclass
    142         return other.getCommonSuperclass(this);
    143     }
    144 
    145     private static final String BRACKETS = Strings.repeat("[", 256);
    146 
    147     @Nonnull
    148     private static String makeArrayType(@Nonnull String elementType, int dimensions) {
    149         return BRACKETS.substring(0, dimensions) + elementType;
    150     }
    151 
    152 
    153     @Override
    154     @Nullable
    155     public FieldReference getFieldByOffset(int fieldOffset) {
    156         if (fieldOffset==8) {
    157             return new ImmutableFieldReference(getType(), "length", "int");
    158         }
    159         return null;
    160     }
    161 
    162     @Override
    163     @Nullable
    164     public Method getMethodByVtableIndex(int vtableIndex) {
    165         return classPath.getClass("Ljava/lang/Object;").getMethodByVtableIndex(vtableIndex);
    166     }
    167 
    168     @Override public int findMethodIndexInVtable(@Nonnull MethodReference method) {
    169         return classPath.getClass("Ljava/lang/Object;").findMethodIndexInVtable(method);
    170     }
    171 }
    172