DECLARE(char*, strtok, char *str, const char *delim)
{
BEGIN(strtok);
char *ret_ptr = REAL(strtok)(str, delim);
/* ret_ptr points to a private libc-side buffer. */
RETURN_PTR(ret_ptr, ret_ptr, (char*) ret_ptr + (ret_ptr ? strlen(ret_ptr) + 1 : 1));
}
java_lang_String_ap fastiva_Dalvik_dalvik_system_VMRuntime_properties(dalvik_system_VMRuntime_p self) {
#endif
ArrayObject* result = dvmCreateStringArray(*gDvm.properties);
dvmReleaseTrackedAlloc((Object*) result, dvmThreadSelf());
RETURN_PTR((java_lang_String_ap)result);
}
java_lang_String_p fastiva_Dalvik_java_lang_System_mapLibraryName(java_lang_String_p nameObj) {
#endif
StringObject* result = NULL;
char* name;
char* mappedName;
if (nameObj == NULL) {
dvmThrowNullPointerException("userLibName == null");
THROW_V();
}
name = dvmCreateCstrFromString(nameObj);
#ifdef _DEBUG
assert(strstr(name, "cfb") == NULL);
#endif
mappedName = dvmCreateSystemLibraryName(name);
if (mappedName != NULL) {
result = dvmCreateStringFromCstr(mappedName);
dvmReleaseTrackedAlloc((Object*) result, NULL);
}
free(name);
free(mappedName);
RETURN_PTR((java_lang_String_p)result);
}
/*
* private Object getField(Object o, Class declaringClass, Class type,
* int slot, boolean noAccessCheck)
*
* Primitive types need to be boxed.
*/
static void Dalvik_java_lang_reflect_Field_getField(const u4* args,
JValue* pResult)
{
// ignore thisPtr in args[0]
Object* obj = (Object*) args[1];
ClassObject* declaringClass = (ClassObject*) args[2];
ClassObject* fieldType = (ClassObject*) args[3];
int slot = args[4];
bool noAccessCheck = (args[5] != 0);
JValue value;
const JValue* fieldPtr;
DataObject* result;
//dvmDumpClass(obj->clazz, kDumpClassFullDetail);
/* get a pointer to the field's data; performs access checks */
fieldPtr = getFieldDataAddr(obj, declaringClass, slot, false,noAccessCheck);
if (fieldPtr == NULL)
RETURN_VOID();
/* copy 4 or 8 bytes out */
if (fieldType->primitiveType == PRIM_LONG ||
fieldType->primitiveType == PRIM_DOUBLE)
{
value.j = fieldPtr->j;
} else {
value.i = fieldPtr->i;
}
result = dvmWrapPrimitive(value, fieldType);
dvmReleaseTrackedAlloc((Object*) result, NULL);
RETURN_PTR(result);
}
/*
* static Class findLoadedClass(ClassLoader cl, String name)
*/
static void Dalvik_java_lang_VMClassLoader_findLoadedClass(const u4* args,
JValue* pResult)
{
Object* loader = (Object*) args[0];
StringObject* nameObj = (StringObject*) args[1];
ClassObject* clazz = NULL;
char* name = NULL;
char* descriptor = NULL;
if (nameObj == NULL) {
dvmThrowException("Ljava/lang/NullPointerException;", NULL);
goto bail;
}
/*
* Get a UTF-8 copy of the string, and convert dots to slashes.
*/
name = dvmCreateCstrFromString(nameObj);
if (name == NULL)
goto bail;
descriptor = dvmDotToDescriptor(name);
if (descriptor == NULL)
goto bail;
clazz = dvmLookupClass(descriptor, loader, false);
LOGVV("look: %s ldr=%p --> %p\n", descriptor, loader, clazz);
bail:
free(name);
free(descriptor);
RETURN_PTR(clazz);
}
static void Dalvik_dalvik_system_VMRuntime_properties(const u4* args,
JValue* pResult)
{
ArrayObject* result = dvmCreateStringArray(*gDvm.properties);
dvmReleaseTrackedAlloc((Object*) result, dvmThreadSelf());
RETURN_PTR(result);
}
static void Dalvik_dalvik_system_VMRuntime_newNonMovableArray(const u4* args,
JValue* pResult)
{
ClassObject* elementClass = (ClassObject*) args[1];
int length = args[2];
if (elementClass == NULL) {
dvmThrowNullPointerException("elementClass == null");
RETURN_VOID();
}
if (length < 0) {
dvmThrowNegativeArraySizeException(length);
RETURN_VOID();
}
// TODO: right now, we don't have a copying collector, so there's no need
// to do anything special here, but we ought to pass the non-movability
// through to the allocator.
ClassObject* arrayClass = dvmFindArrayClassForElement(elementClass);
ArrayObject* newArray = dvmAllocArrayByClass(arrayClass,
length,
ALLOC_NON_MOVING);
if (newArray == NULL) {
assert(dvmCheckException(dvmThreadSelf()));
RETURN_VOID();
}
dvmReleaseTrackedAlloc((Object*) newArray, NULL);
RETURN_PTR(newArray);
}
java_lang_Object_p fastiva_Dalvik_dalvik_system_VMRuntime_newNonMovableArray(dalvik_system_VMRuntime_p self, java_lang_Class_p elementClass, jint length) {
#endif
if (elementClass == NULL) {
dvmThrowNullPointerException("elementClass == null");
THROW_V();
}
if (length < 0) {
dvmThrowNegativeArraySizeException(length);
THROW_V();
}
// TODO: right now, we don't have a copying collector, so there's no need
// to do anything special here, but we ought to pass the non-movability
// through to the allocator.
ClassObject* arrayClass = dvmFindArrayClassForElement(elementClass);
ArrayObject* newArray = dvmAllocArrayByClass(arrayClass,
length,
ALLOC_NON_MOVING);
if (newArray == NULL) {
assert(dvmCheckException(dvmThreadSelf()));
THROW_V();
}
dvmReleaseTrackedAlloc((Object*) newArray, NULL);
RETURN_PTR(newArray);
}
/*
* static Thread currentThread()
*/
static void Dalvik_java_lang_VMThread_currentThread(const u4* args,
JValue* pResult)
{
UNUSED_PARAMETER(args);
RETURN_PTR(dvmThreadSelf()->threadObj);
}
/*
* private static String getBootClassPathResource(String name, int index)
*
* Find a resource with a matching name in a boot class path entry.
*
* This mimics the previous VM interface, since we're sharing class libraries.
*/
static void Dalvik_java_lang_VMClassLoader_getBootClassPathResource(
const u4* args, JValue* pResult)
{
StringObject* nameObj = (StringObject*) args[0];
StringObject* result;
int idx = args[1];
char* name;
name = dvmCreateCstrFromString(nameObj);
if (name == NULL)
RETURN_PTR(NULL);
result = dvmGetBootPathResource(name, idx);
free(name);
dvmReleaseTrackedAlloc((Object*)result, NULL);
RETURN_PTR(result);
}
DECLARE(char*, getenv, const char *s)
{
BEGIN(getenv);
char *ret_ptr = REAL(getenv)(s);
if (ret_ptr) { RETURN_PTR(ret_ptr, ret_ptr, ret_ptr + strlen(ret_ptr) + 1); }
else RETURN_NULL;
}
/*
* public String intern()
*
* Intern a string in the VM string table.
*/
static void Dalvik_java_lang_String_intern(const u4* args, JValue* pResult)
{
StringObject* str = (StringObject*) args[0];
StringObject* interned;
interned = dvmLookupInternedString(str);
RETURN_PTR(interned);
}
/*
* public native Object getObject(Object obj, long offset);
*/
static void Dalvik_sun_misc_Unsafe_getObject(const u4 *args, JValue *pResult) {
// We ignore the this pointer in args[0].
Object *obj = (Object *) args[1];
s8 offset = GET_ARG_LONG(args, 2);
Object **address = (Object **) (((u1 *) obj) + offset);
RETURN_PTR(*address);
}
/*
* private Object internalClone()
*
* Implements most of Object.clone().
*/
static void Dalvik_java_lang_Object_internalClone(const u4* args,
JValue* pResult)
{
Object* thisPtr = (Object*) args[0];
Object* clone = dvmCloneObject(thisPtr);
dvmReleaseTrackedAlloc(clone, NULL);
RETURN_PTR(clone);
}
/*
* private static Object[] getClassSignatureAnnotation(Class clazz)
*
* Return the Signature annotation for the specified class. Equivalent to
* Class.getSignatureAnnotation(), but available to java.lang.reflect.
*/
static void Dalvik_java_lang_reflect_AccessibleObject_getClassSignatureAnnotation(
const u4* args, JValue* pResult)
{
ClassObject* clazz = (ClassObject*) args[0];
ArrayObject* arr = dvmGetClassSignatureAnnotation(clazz);
dvmReleaseTrackedAlloc((Object*) arr, NULL);
RETURN_PTR(arr);
}
/*
* public static byte[] getThreadStats()
*
* Get a buffer full of thread info.
*/
static void Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_getThreadStats(
const u4* args, JValue* pResult)
{
UNUSED_PARAMETER(args);
ArrayObject* result = dvmDdmGenerateThreadStats();
dvmReleaseTrackedAlloc((Object*) result, NULL);
RETURN_PTR(result);
}
/*
* public native Object getObjectVolatile(Object obj, long offset);
*/
static void Dalvik_sun_misc_Unsafe_getObjectVolatile(const u4 *args,
JValue *pResult) {
// We ignore the this pointer in args[0].
Object *obj = (Object *) args[1];
s8 offset = GET_ARG_LONG(args, 2);
volatile int32_t *address = (volatile int32_t *) (((u1 *) obj) + offset);
RETURN_PTR((Object *) android_atomic_acquire_load(address));
}
/*
* public static byte[] getRecentAllocations()
*
* Fill a buffer with data on recent heap allocations.
*/
static void
Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_getRecentAllocations(
const u4* args, JValue* pResult)
{
ArrayObject* data;
data = dvmDdmGetRecentAllocations();
dvmReleaseTrackedAlloc((Object*) data, NULL);
RETURN_PTR(data);
}
/*
* static Annotation getAnnotation(
* Class declaringClass, int slot, Class annotationType);
*/
static void Dalvik_java_lang_reflect_Method_getAnnotation(const u4* args,
JValue* pResult)
{
ClassObject* clazz = (ClassObject*) args[0];
int slot = args[1];
ClassObject* annotationClazz = (ClassObject*) args[2];
Method* meth = dvmSlotToMethod(clazz, slot);
RETURN_PTR(dvmGetMethodAnnotation(clazz, meth, annotationClazz));
}
/*
* public static StackTraceElement[] getStackTraceById(int threadId)
*
* Get a stack trace as an array of StackTraceElement objects. Returns
* NULL on failure, e.g. if the threadId couldn't be found.
*/
static void
Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_getStackTraceById(
const u4* args, JValue* pResult)
{
u4 threadId = args[0];
ArrayObject* trace;
trace = dvmDdmGetStackTraceById(threadId);
RETURN_PTR(trace);
}
/*
* private Object getDefaultValue(Class declaringClass, int slot)
*
* Return the default value for the annotation member represented by
* this Method instance. Returns NULL if none is defined.
*/
static void Dalvik_java_lang_reflect_Method_getDefaultValue(const u4* args,
JValue* pResult)
{
// ignore thisPtr in args[0]
ClassObject* declaringClass = (ClassObject*) args[1];
int slot = args[2];
Method* meth;
/* make sure this is an annotation class member */
if (!dvmIsAnnotationClass(declaringClass))
RETURN_PTR(NULL);
meth = dvmSlotToMethod(declaringClass, slot);
assert(meth != NULL);
Object* def = dvmGetAnnotationDefaultValue(meth);
dvmReleaseTrackedAlloc(def, NULL);
RETURN_PTR(def);
}
/*
* static Class loadClass(String name, boolean resolve)
* throws ClassNotFoundException
*
* Load class using bootstrap class loader.
*
* Return the Class object associated with the class or interface with
* the specified name.
*
* "name" is in "binary name" format, e.g. "dalvik.system.Debug$1".
*/
static void Dalvik_java_lang_VMClassLoader_loadClass(const u4* args,
JValue* pResult)
{
StringObject* nameObj = (StringObject*) args[0];
bool resolve = (args[1] != 0);
ClassObject* clazz;
clazz = dvmFindClassByName(nameObj, NULL, resolve);
assert(clazz == NULL || dvmIsClassLinked(clazz));
RETURN_PTR(clazz);
}
/*
* static String[] getVmFeatureList()
*
* Return a set of strings describing available VM features (this is chiefly
* of interest to DDMS).
*/
static void Dalvik_dalvik_system_VMDebug_getVmFeatureList(const u4* args, JValue* pResult) {
std::vector<std::string> features;
features.push_back("method-trace-profiling");
features.push_back("method-trace-profiling-streaming");
features.push_back("hprof-heap-dump");
features.push_back("hprof-heap-dump-streaming");
ArrayObject* result = dvmCreateStringArray(features);
dvmReleaseTrackedAlloc((Object*) result, dvmThreadSelf());
RETURN_PTR(result);
}
/*
* static Class generateProxy(String name, Class[] interfaces,
* ClassLoader loader)
*
* Generate a proxy class with the specified characteristics. Throws an
* exception on error.
*/
static void Dalvik_java_lang_reflect_Proxy_generateProxy(const u4* args,
JValue* pResult)
{
StringObject* str = (StringObject*) args[0];
ArrayObject* interfaces = (ArrayObject*) args[1];
Object* loader = (Object*) args[2];
ClassObject* result;
result = dvmGenerateProxyClass(str, interfaces, loader);
RETURN_PTR(result);
}
/*
* 从指定的DEX文件中加载一个类，使用类加载器去初始化一个类对象
*/
static void Dalvik_dalvik_system_DexFile_defineClass(const u4* args,
JValue* pResult)
{
StringObject* nameObj = (StringObject*) args[0];
Object* loader = (Object*) args[1];
int cookie = args[2];
ClassObject* clazz = NULL;
DexOrJar* pDexOrJar = (DexOrJar*) cookie;
DvmDex* pDvmDex;
char* name;
char* descriptor;
name = dvmCreateCstrFromString(nameObj);
descriptor = dvmDotToDescriptor(name);
ALOGV("--- Explicit class load '%s' l=%p c=0x%08x",
descriptor, loader, cookie);
free(name);
if (!validateCookie(cookie))
RETURN_VOID();
if (pDexOrJar->isDex)
pDvmDex = dvmGetRawDexFileDex(pDexOrJar->pRawDexFile);
else
pDvmDex = dvmGetJarFileDex(pDexOrJar->pJarFile);
/* once we load something, we can't unmap the storage */
pDexOrJar->okayToFree = false;
clazz = dvmDefineClass(pDvmDex, descriptor, loader);
Thread* self = dvmThreadSelf();
if (dvmCheckException(self)) {
/*
* If we threw a "class not found" exception, stifle it, since the
* contract in the higher method says we simply return null if
* the class is not found.
*/
Object* excep = dvmGetException(self);
if (strcmp(excep->clazz->descriptor,
"Ljava/lang/ClassNotFoundException;") == 0 ||
strcmp(excep->clazz->descriptor,
"Ljava/lang/NoClassDefFoundError;") == 0)
{
dvmClearException(self);
}
clazz = NULL;
}
free(descriptor);
RETURN_PTR(clazz);
}
/*
* public int constructNative(Object[] args, Class declaringClass,
* Class[] parameterTypes, int slot, boolean noAccessCheck)
*
* We get here through Constructor.newInstance(). The Constructor object
* would not be available if the constructor weren't public (per the
* definition of Class.getConstructor), so we can skip the method access
* check. We can also safely assume the constructor isn't associated
* with an interface, array, or primitive class.
*/
static void Dalvik_java_lang_reflect_Constructor_constructNative(
const u4* args, JValue* pResult)
{
// ignore thisPtr in args[0]
ArrayObject* argList = (ArrayObject*) args[1];
ClassObject* declaringClass = (ClassObject*) args[2];
ArrayObject* params = (ArrayObject*) args[3];
int slot = args[4];
bool noAccessCheck = (args[5] != 0);
Object* newObj;
Method* meth;
if (dvmIsAbstractClass(declaringClass)) {
dvmThrowInstantiationException(declaringClass, NULL);
RETURN_VOID();
}
/* initialize the class if it hasn't been already */
if (!dvmIsClassInitialized(declaringClass)) {
if (!dvmInitClass(declaringClass)) {
ALOGW("Class init failed in Constructor.constructNative (%s)",
declaringClass->descriptor);
assert(dvmCheckException(dvmThreadSelf()));
RETURN_VOID();
}
}
newObj = dvmAllocObject(declaringClass, ALLOC_DEFAULT);
if (newObj == NULL)
RETURN_PTR(NULL);
meth = dvmSlotToMethod(declaringClass, slot);
assert(meth != NULL);
(void) dvmInvokeMethod(newObj, meth, argList, params, NULL, noAccessCheck);
dvmReleaseTrackedAlloc(newObj, NULL);
RETURN_PTR(newObj);
}
/*
* public int constructNative(Object[] args, Class declaringClass,
* Class[] parameterTypes, int slot, boolean noAccessCheck)
*/
static void Dalvik_java_lang_reflect_Constructor_constructNative(
const u4* args, JValue* pResult)
{
// ignore thisPtr in args[0]
ArrayObject* argList = (ArrayObject*) args[1];
ClassObject* declaringClass = (ClassObject*) args[2];
ArrayObject* params = (ArrayObject*) args[3];
int slot = args[4];
bool noAccessCheck = (args[5] != 0);
Object* newObj;
Method* meth;
newObj = dvmAllocObject(declaringClass, ALLOC_DEFAULT);
if (newObj == NULL)
RETURN_PTR(NULL);
meth = dvmSlotToMethod(declaringClass, slot);
assert(meth != NULL);
(void) dvmInvokeMethod(newObj, meth, argList, params, NULL, noAccessCheck);
dvmReleaseTrackedAlloc(newObj, NULL);
RETURN_PTR(newObj);
}
/*
* static Object[] getSignatureAnnotation()
*
* Returns the signature annotation.
*/
static void Dalvik_java_lang_reflect_Method_getSignatureAnnotation(
const u4* args, JValue* pResult)
{
ClassObject* declaringClass = (ClassObject*) args[0];
int slot = args[1];
Method* meth;
meth = dvmSlotToMethod(declaringClass, slot);
assert(meth != NULL);
ArrayObject* arr = dvmGetMethodSignatureAnnotation(meth);
dvmReleaseTrackedAlloc((Object*) arr, NULL);
RETURN_PTR(arr);
}
/*
* public Annotation[][] getParameterAnnotations(Class declaringClass, int slot)
*
* Return the annotations declared for this constructor's parameters.
*/
static void Dalvik_java_lang_reflect_Constructor_getParameterAnnotations(
const u4* args, JValue* pResult)
{
// ignore thisPtr in args[0]
ClassObject* declaringClass = (ClassObject*) args[1];
int slot = args[2];
Method* meth;
meth = dvmSlotToMethod(declaringClass, slot);
assert(meth != NULL);
ArrayObject* annos = dvmGetParameterAnnotations(meth);
dvmReleaseTrackedAlloc((Object*)annos, NULL);
RETURN_PTR(annos);
}
/*
* private Object[] getSignatureAnnotation()
*
* Returns the signature annotation.
*/
static void Dalvik_java_lang_reflect_Field_getSignatureAnnotation(const u4* args,
JValue* pResult)
{
// ignore thisPtr in args[0]
ClassObject* declaringClass = (ClassObject*) args[1];
int slot = args[2];
Field* field;
field = dvmSlotToField(declaringClass, slot);
assert(field != NULL);
ArrayObject* arr = dvmGetFieldSignatureAnnotation(field);
dvmReleaseTrackedAlloc((Object*) arr, NULL);
RETURN_PTR(arr);
}
