| /* |
| * Copyright (C) 2008 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /* |
| * java.lang.Class |
| */ |
| #include "Dalvik.h" |
| #include "native/InternalNativePriv.h" |
| |
| |
| /* |
| * public static void arraycopy(Object src, int srcPos, Object dest, |
| * int destPos, int length) |
| * |
| * The description of this function is long, and describes a multitude |
| * of checks and exceptions. |
| */ |
| static void Dalvik_java_lang_System_arraycopy(const u4* args, JValue* pResult) |
| { |
| void* (*copyFunc)(void *dest, const void *src, size_t n); |
| ArrayObject* srcArray; |
| ArrayObject* dstArray; |
| ClassObject* srcClass; |
| ClassObject* dstClass; |
| int srcPos, dstPos, length; |
| char srcType, dstType; |
| bool srcPrim, dstPrim; |
| |
| srcArray = (ArrayObject*) args[0]; |
| srcPos = args[1]; |
| dstArray = (ArrayObject*) args[2]; |
| dstPos = args[3]; |
| length = args[4]; |
| |
| if (srcArray == dstArray) |
| copyFunc = memmove; /* might overlap */ |
| else |
| copyFunc = memcpy; /* can't overlap, use faster func */ |
| |
| /* check for null or bad pointer */ |
| if (!dvmValidateObject((Object*)srcArray) || |
| !dvmValidateObject((Object*)dstArray)) |
| { |
| assert(dvmCheckException(dvmThreadSelf())); |
| RETURN_VOID(); |
| } |
| /* make sure it's an array */ |
| if (!dvmIsArray(srcArray) || !dvmIsArray(dstArray)) { |
| dvmThrowException("Ljava/lang/ArrayStoreException;", NULL); |
| RETURN_VOID(); |
| } |
| |
| // avoid int overflow |
| if (srcPos < 0 || dstPos < 0 || length < 0 || |
| srcPos > (int) srcArray->length - length || |
| dstPos > (int) dstArray->length - length) |
| { |
| dvmThrowException("Ljava/lang/ArrayIndexOutOfBoundsException;", NULL); |
| RETURN_VOID(); |
| } |
| |
| srcClass = srcArray->obj.clazz; |
| dstClass = dstArray->obj.clazz; |
| srcType = srcClass->descriptor[1]; |
| dstType = dstClass->descriptor[1]; |
| |
| /* |
| * If one of the arrays holds a primitive type, the other array must |
| * hold the same type. |
| */ |
| srcPrim = (srcType != '[' && srcType != 'L'); |
| dstPrim = (dstType != '[' && dstType != 'L'); |
| if (srcPrim || dstPrim) { |
| int width; |
| |
| if (srcPrim != dstPrim || srcType != dstType) { |
| dvmThrowException("Ljava/lang/ArrayStoreException;", NULL); |
| RETURN_VOID(); |
| } |
| |
| switch (srcClass->descriptor[1]) { |
| case 'B': |
| case 'Z': |
| width = 1; |
| break; |
| case 'C': |
| case 'S': |
| width = 2; |
| break; |
| case 'F': |
| case 'I': |
| width = 4; |
| break; |
| case 'D': |
| case 'J': |
| width = 8; |
| break; |
| default: /* 'V' or something weird */ |
| LOGE("Weird array type '%s'\n", srcClass->descriptor); |
| assert(false); |
| width = 0; |
| break; |
| } |
| |
| if (false) LOGVV("arraycopy prim dst=%p %d src=%p %d len=%d\n", |
| dstArray->contents, dstPos * width, |
| srcArray->contents, srcPos * width, |
| length * width); |
| (*copyFunc)((u1*)dstArray->contents + dstPos * width, |
| (const u1*)srcArray->contents + srcPos * width, |
| length * width); |
| } else { |
| /* |
| * Neither class is primitive. See if elements in "src" are instances |
| * of elements in "dst" (e.g. copy String to String or String to |
| * Object). |
| */ |
| int width = sizeof(Object*); |
| |
| if (srcClass->arrayDim == dstClass->arrayDim && |
| dvmInstanceof(srcClass, dstClass)) |
| { |
| /* |
| * "dst" can hold "src"; copy the whole thing. |
| */ |
| if (false) LOGVV("arraycopy ref dst=%p %d src=%p %d len=%d\n", |
| dstArray->contents, dstPos * width, |
| srcArray->contents, srcPos * width, |
| length * width); |
| (*copyFunc)((u1*)dstArray->contents + dstPos * width, |
| (const u1*)srcArray->contents + srcPos * width, |
| length * width); |
| } else { |
| /* |
| * The arrays are not fundamentally compatible. However, we may |
| * still be able to do this if the destination object is compatible |
| * (e.g. copy Object to String, but the Object being copied is |
| * actually a String). We need to copy elements one by one until |
| * something goes wrong. |
| * |
| * Because of overlapping moves, what we really want to do is |
| * compare the types and count up how many we can move, then call |
| * memmove() to shift the actual data. If we just start from the |
| * front we could do a smear rather than a move. |
| */ |
| Object** srcObj; |
| Object** dstObj; |
| int copyCount; |
| ClassObject* clazz = NULL; |
| |
| srcObj = ((Object**) srcArray->contents) + srcPos; |
| dstObj = ((Object**) dstArray->contents) + dstPos; |
| |
| if (length > 0 && srcObj[0] != NULL) |
| { |
| clazz = srcObj[0]->clazz; |
| if (!dvmCanPutArrayElement(clazz, dstClass)) |
| clazz = NULL; |
| } |
| |
| for (copyCount = 0; copyCount < length; copyCount++) |
| { |
| if (srcObj[copyCount] != NULL && |
| srcObj[copyCount]->clazz != clazz && |
| !dvmCanPutArrayElement(srcObj[copyCount]->clazz, dstClass)) |
| { |
| /* can't put this element into the array */ |
| break; |
| } |
| } |
| |
| if (false) LOGVV("arraycopy iref dst=%p %d src=%p %d count=%d of %d\n", |
| dstArray->contents, dstPos * width, |
| srcArray->contents, srcPos * width, |
| copyCount, length); |
| (*copyFunc)((u1*)dstArray->contents + dstPos * width, |
| (const u1*)srcArray->contents + srcPos * width, |
| copyCount * width); |
| |
| if (copyCount != length) { |
| dvmThrowException("Ljava/lang/ArrayStoreException;", NULL); |
| RETURN_VOID(); |
| } |
| } |
| } |
| |
| RETURN_VOID(); |
| } |
| |
| /* |
| * static long currentTimeMillis() |
| * |
| * Current time, in miliseconds. This doesn't need to be internal to the |
| * VM, but we're already handling java.lang.System here. |
| */ |
| static void Dalvik_java_lang_System_currentTimeMillis(const u4* args, |
| JValue* pResult) |
| { |
| struct timeval tv; |
| |
| UNUSED_PARAMETER(args); |
| |
| gettimeofday(&tv, (struct timezone *) NULL); |
| long long when = tv.tv_sec * 1000LL + tv.tv_usec / 1000; |
| |
| RETURN_LONG(when); |
| } |
| |
| /* |
| * static long nanoTime() |
| * |
| * Current monotonically-increasing time, in nanoseconds. This doesn't |
| * need to be internal to the VM, but we're already handling |
| * java.lang.System here. |
| */ |
| static void Dalvik_java_lang_System_nanoTime(const u4* args, JValue* pResult) |
| { |
| UNUSED_PARAMETER(args); |
| |
| u8 when = dvmGetRelativeTimeNsec(); |
| RETURN_LONG(when); |
| } |
| |
| /* |
| * static int identityHashCode(Object x) |
| * |
| * Returns that hash code that the default hashCode() |
| * method would return for "x", even if "x"s class |
| * overrides hashCode(). |
| */ |
| static void Dalvik_java_lang_System_identityHashCode(const u4* args, |
| JValue* pResult) |
| { |
| Object* thisPtr = (Object*) args[0]; |
| RETURN_INT(dvmGetObjectHashCode(thisPtr)); |
| } |
| |
| /* |
| * public static String mapLibraryName(String libname) |
| */ |
| static void Dalvik_java_lang_System_mapLibraryName(const u4* args, |
| JValue* pResult) |
| { |
| StringObject* nameObj = (StringObject*) args[0]; |
| StringObject* result = NULL; |
| char* name; |
| char* mappedName; |
| |
| if (nameObj == NULL) { |
| dvmThrowException("Ljava/lang/NullPointerException;", NULL); |
| RETURN_VOID(); |
| } |
| |
| name = dvmCreateCstrFromString(nameObj); |
| mappedName = dvmCreateSystemLibraryName(name); |
| if (mappedName != NULL) { |
| result = dvmCreateStringFromCstr(mappedName, ALLOC_DEFAULT); |
| dvmReleaseTrackedAlloc((Object*) result, NULL); |
| } |
| |
| free(name); |
| free(mappedName); |
| RETURN_PTR(result); |
| } |
| |
| const DalvikNativeMethod dvm_java_lang_System[] = { |
| { "arraycopy", "(Ljava/lang/Object;ILjava/lang/Object;II)V", |
| Dalvik_java_lang_System_arraycopy }, |
| { "currentTimeMillis", "()J", |
| Dalvik_java_lang_System_currentTimeMillis }, |
| { "nanoTime", "()J", |
| Dalvik_java_lang_System_nanoTime }, |
| { "identityHashCode", "(Ljava/lang/Object;)I", |
| Dalvik_java_lang_System_identityHashCode }, |
| { "mapLibraryName", "(Ljava/lang/String;)Ljava/lang/String;", |
| Dalvik_java_lang_System_mapLibraryName }, |
| { NULL, NULL, NULL }, |
| }; |
| |