Switch dvmHumanReadableDescriptor over to std::string.

(Prep work before making a change to stack dumps.)

Change-Id: I0af49b920f450fd2611e4b96e717a637483122d6

2 files changed, 63 insertions, 100 deletions

diff --git a/vm/interp/Interp.cpp b/vm/interp/Interp.cpp
index 57c900bdc..430d669e1 100644
--- a/vm/interp/Interp.cpp
+++ b/vm/interp/Interp.cpp
@@ -1314,12 +1314,10 @@ Method* dvmInterpFindInterfaceMethod(ClassObject* thisClass, u4 methodIdx,
  * Each returns a newly-allocated string.
  */
 #define kThrowShow_accessFromClass     1
-static char* classNameFromIndex(const Method* method, int ref,
+static std::string classNameFromIndex(const Method* method, int ref,
     VerifyErrorRefType refType, int flags)
 {
-    static const int kBufLen = 256;
     const DvmDex* pDvmDex = method->clazz->pDvmDex;
-
     if (refType == VERIFY_ERROR_REF_FIELD) {
         /* get class ID from field ID */
         const DexFieldId* pFieldId = dexGetFieldId(pDvmDex->pDexFile, ref);
@@ -1331,96 +1329,71 @@ static char* classNameFromIndex(const Method* method, int ref,
     }
 
     const char* className = dexStringByTypeIdx(pDvmDex->pDexFile, ref);
-    char* dotClassName = dvmHumanReadableDescriptor(className);
-    if (flags == 0)
+    std::string dotClassName(dvmHumanReadableDescriptor(className));
+    if (flags == 0) {
         return dotClassName;
+    }
 
-    char* result = (char*) malloc(kBufLen);
-
+    std::string result;
     if ((flags & kThrowShow_accessFromClass) != 0) {
-        char* dotFromName =
-            dvmHumanReadableDescriptor(method->clazz->descriptor);
-        snprintf(result, kBufLen, "tried to access class %s from class %s",
-            dotClassName, dotFromName);
-        free(dotFromName);
+        result += "tried to access class " + dotClassName;
+        result += " from class " + dvmHumanReadableDescriptor(method->clazz->descriptor);
     } else {
         assert(false);      // should've been caught above
-        result[0] = '\0';
     }
 
-    free(dotClassName);
     return result;
 }
-static char* fieldNameFromIndex(const Method* method, int ref,
+static std::string fieldNameFromIndex(const Method* method, int ref,
     VerifyErrorRefType refType, int flags)
 {
-    static const int kBufLen = 256;
-    const DvmDex* pDvmDex = method->clazz->pDvmDex;
-    const DexFieldId* pFieldId;
-    const char* className;
-    const char* fieldName;
-
     if (refType != VERIFY_ERROR_REF_FIELD) {
         LOGW("Expected ref type %d, got %d", VERIFY_ERROR_REF_FIELD, refType);
         return NULL;    /* no message */
     }
 
-    pFieldId = dexGetFieldId(pDvmDex->pDexFile, ref);
-    className = dexStringByTypeIdx(pDvmDex->pDexFile, pFieldId->classIdx);
-    fieldName = dexStringById(pDvmDex->pDexFile, pFieldId->nameIdx);
+    const DvmDex* pDvmDex = method->clazz->pDvmDex;
+    const DexFieldId* pFieldId = dexGetFieldId(pDvmDex->pDexFile, ref);
+    const char* className = dexStringByTypeIdx(pDvmDex->pDexFile, pFieldId->classIdx);
+    const char* fieldName = dexStringById(pDvmDex->pDexFile, pFieldId->nameIdx);
 
-    char* dotName = dvmHumanReadableDescriptor(className);
-    char* result = (char*) malloc(kBufLen);
+    std::string dotName(dvmHumanReadableDescriptor(className));
 
     if ((flags & kThrowShow_accessFromClass) != 0) {
-        char* dotFromName =
-            dvmHumanReadableDescriptor(method->clazz->descriptor);
-        snprintf(result, kBufLen, "tried to access field %s.%s from class %s",
-            dotName, fieldName, dotFromName);
-        free(dotFromName);
-    } else {
-        snprintf(result, kBufLen, "%s.%s", dotName, fieldName);
+        std::string result;
+        result += "tried to access field ";
+        result += dotName + "." + fieldName;
+        result += " from class ";
+        result += dvmHumanReadableDescriptor(method->clazz->descriptor);
+        return result;
     }
-
-    free(dotName);
-    return result;
+    return dotName + "." + fieldName;
 }
-static char* methodNameFromIndex(const Method* method, int ref,
+static std::string methodNameFromIndex(const Method* method, int ref,
     VerifyErrorRefType refType, int flags)
 {
-    static const int kBufLen = 384;
-    const DvmDex* pDvmDex = method->clazz->pDvmDex;
-    const DexMethodId* pMethodId;
-    const char* className;
-    const char* methodName;
-
     if (refType != VERIFY_ERROR_REF_METHOD) {
         LOGW("Expected ref type %d, got %d", VERIFY_ERROR_REF_METHOD,refType);
         return NULL;    /* no message */
     }
 
-    pMethodId = dexGetMethodId(pDvmDex->pDexFile, ref);
-    className = dexStringByTypeIdx(pDvmDex->pDexFile, pMethodId->classIdx);
-    methodName = dexStringById(pDvmDex->pDexFile, pMethodId->nameIdx);
+    const DvmDex* pDvmDex = method->clazz->pDvmDex;
+    const DexMethodId* pMethodId = dexGetMethodId(pDvmDex->pDexFile, ref);
+    const char* className = dexStringByTypeIdx(pDvmDex->pDexFile, pMethodId->classIdx);
+    const char* methodName = dexStringById(pDvmDex->pDexFile, pMethodId->nameIdx);
 
-    char* dotName = dvmHumanReadableDescriptor(className);
-    char* result = (char*) malloc(kBufLen);
+    std::string dotName(dvmHumanReadableDescriptor(className));
 
     if ((flags & kThrowShow_accessFromClass) != 0) {
-        char* dotFromName =
-            dvmHumanReadableDescriptor(method->clazz->descriptor);
         char* desc = dexProtoCopyMethodDescriptor(&method->prototype);
-        snprintf(result, kBufLen,
-            "tried to access method %s.%s:%s from class %s",
-            dotName, methodName, desc, dotFromName);
-        free(dotFromName);
+        std::string result;
+        result += "tried to access method ";
+        result += dotName + "." + methodName + ":" + desc;
+        result += " from class " + dvmHumanReadableDescriptor(method->clazz->descriptor);
         free(desc);
-    } else {
-        snprintf(result, kBufLen, "%s.%s", dotName, methodName);
+        return result;
     }
-
-    free(dotName);
-    return result;
+    return dotName + "." + methodName;
 }
 
 /*
@@ -1439,7 +1412,7 @@ void dvmThrowVerificationError(const Method* method, int kind, int ref)
     VerifyError errorKind = static_cast<VerifyError>(errorPart);
     VerifyErrorRefType refType = static_cast<VerifyErrorRefType>(errorRefPart);
     ClassObject* exceptionClass = gDvm.exVerifyError;
-    char* msg = NULL;
+    std::string msg;
 
     switch ((VerifyError) errorKind) {
     case VERIFY_ERROR_NO_CLASS:
@@ -1490,8 +1463,7 @@ void dvmThrowVerificationError(const Method* method, int kind, int ref)
     /* no default clause -- want warning if enum updated */
     }
 
-    dvmThrowException(exceptionClass, msg);
-    free(msg);
+    dvmThrowException(exceptionClass, msg.c_str());
 }
 
 /*
diff --git a/vm/interp/Stack.cpp b/vm/interp/Stack.cpp
index 978d26b5b..bbce74133 100644
--- a/vm/interp/Stack.cpp
+++ b/vm/interp/Stack.cpp
@@ -633,18 +633,16 @@ bail:
     dvmPopFrame(self);
 }
 
-static void throwArgumentTypeMismatch(int argIndex, ClassObject* expected,
-    DataObject* arg)
-{
-    char* expectedClassName = dvmHumanReadableDescriptor(expected->descriptor);
-    char* actualClassName = (arg != NULL)
-        ? dvmHumanReadableDescriptor(arg->clazz->descriptor)
-        : strdup("null");
-    dvmThrowExceptionFmt(gDvm.exIllegalArgumentException,
-        "argument %d should have type %s, got %s",
-        argIndex + 1, expectedClassName, actualClassName);
-    free(expectedClassName);
-    free(actualClassName);
+static void throwArgumentTypeMismatch(int argIndex, ClassObject* expected, DataObject* arg) {
+    std::string expectedClassName(dvmHumanReadableDescriptor(expected->descriptor));
+    std::string actualClassName;
+    if (arg != NULL) {
+        actualClassName = dvmHumanReadableDescriptor(arg->clazz->descriptor);
+    } else {
+        actualClassName = "null";
+    }
+    dvmThrowExceptionFmt(gDvm.exIllegalArgumentException, "argument %d should have type %s, got %s",
+            argIndex + 1, expectedClassName.c_str(), actualClassName.c_str());
 }
 
 /*
@@ -1211,19 +1209,16 @@ static void dumpFrames(const DebugOutputTarget* target, void* framePtr,
             else
                 relPc = -1;
 
-            char* className =
-                dvmHumanReadableDescriptor(method->clazz->descriptor);
-            if (dvmIsNativeMethod(method))
-                dvmPrintDebugMessage(target,
-                    "  at %s.%s(Native Method)\n", className, method->name);
-            else {
-                dvmPrintDebugMessage(target,
-                    "  at %s.%s(%s:%s%d)\n",
-                    className, method->name, dvmGetMethodSourceFile(method),
-                    (relPc >= 0 && first) ? "~" : "",
-                    relPc < 0 ? -1 : dvmLineNumFromPC(method, relPc));
+            std::string className(dvmHumanReadableDescriptor(method->clazz->descriptor));
+            if (dvmIsNativeMethod(method)) {
+                dvmPrintDebugMessage(target, "  at %s.%s(Native Method)\n",
+                        className.c_str(), method->name);
+            } else {
+                dvmPrintDebugMessage(target, "  at %s.%s(%s:%s%d)\n",
+                        className.c_str(), method->name, dvmGetMethodSourceFile(method),
+                        (relPc >= 0 && first) ? "~" : "",
+                        relPc < 0 ? -1 : dvmLineNumFromPC(method, relPc));
             }
-            free(className);
 
             if (first) {
                 /*
@@ -1239,39 +1234,35 @@ static void dumpFrames(const DebugOutputTarget* target, void* framePtr,
                     Object* obj = dvmGetMonitorObject(mon);
                     if (obj != NULL) {
                         Thread* joinThread = NULL;
-                        className =
-                            dvmHumanReadableDescriptor(obj->clazz->descriptor);
-                        if (strcmp(className, "java.lang.VMThread") == 0) {
+                        std::string className(dvmHumanReadableDescriptor(obj->clazz->descriptor));
+                        if (className == "java.lang.VMThread") {
                             joinThread = dvmGetThreadFromThreadObject(obj);
                         }
                         if (joinThread == NULL) {
                             dvmPrintDebugMessage(target,
-                                "  - waiting on <%p> (a %s)\n", obj, className);
+                                    "  - waiting on <%p> (a %s)\n", obj, className.c_str());
                         } else {
                             dvmPrintDebugMessage(target,
-                                "  - waiting on <%p> (a %s) tid=%d\n",
-                                obj, className, joinThread->threadId);
+                                    "  - waiting on <%p> (a %s) tid=%d\n", obj, className.c_str(),
+                                    joinThread->threadId);
                         }
-                        free(className);
                     }
                 } else if (thread->status == THREAD_MONITOR) {
                     Object* obj;
                     Thread* owner;
                     if (extractMonitorEnterObject(thread, &obj, &owner)) {
-                        className =
-                            dvmHumanReadableDescriptor(obj->clazz->descriptor);
+                        std::string className(dvmHumanReadableDescriptor(obj->clazz->descriptor));
                         if (owner != NULL) {
                             char* threadName = dvmGetThreadName(owner);
                             dvmPrintDebugMessage(target,
-                                "  - waiting to lock <%p> (a %s) held by threadid=%d (%s)\n",
-                                obj, className, owner->threadId, threadName);
+                                    "  - waiting to lock <%p> (a %s) held by threadid=%d (%s)\n",
+                                    obj, className.c_str(), owner->threadId, threadName);
                             free(threadName);
                         } else {
                             dvmPrintDebugMessage(target,
-                                "  - waiting to lock <%p> (a %s) held by ???\n",
-                                obj, className);
+                                    "  - waiting to lock <%p> (a %s) held by ???\n",
+                                    obj, className.c_str());
                         }
-                        free(className);
                     }
                 }
             }