diff --git a/src/check_jni.cc b/src/check_jni.cc
index c724eb2..3b7c748 100644
--- a/src/check_jni.cc
+++ b/src/check_jni.cc
@@ -122,15 +122,15 @@
   // such as NewByteArray.
   // If -verbose:third-party-jni is on, we want to log any JNI function calls
   // made by a third-party native method.
-  std::string className(MethodHelper(method).GetDeclaringClassDescriptor());
-  if (!vm->trace.empty() && className.find(vm->trace) != std::string::npos) {
+  std::string class_name(MethodHelper(method).GetDeclaringClassDescriptor());
+  if (!vm->trace.empty() && class_name.find(vm->trace) != std::string::npos) {
     return true;
   }
   if (VLOG_IS_ON(third_party_jni)) {
     // Return true if we're trying to log all third-party JNI activity and 'method' doesn't look
     // like part of Android.
     for (size_t i = 0; gBuiltInPrefixes[i] != NULL; ++i) {
-      if (StartsWith(className, gBuiltInPrefixes[i])) {
+      if (StartsWith(class_name, gBuiltInPrefixes[i])) {
         return false;
       }
     }
@@ -148,30 +148,21 @@
   }
 
   // For JavaVM* functions.
-  explicit ScopedCheck(JavaVM* vm, bool hasMethod, const char* functionName) {
-    Init(NULL, vm, kFlag_Invocation, functionName, hasMethod);
+  explicit ScopedCheck(JavaVM* vm, bool has_method, const char* functionName) {
+    Init(NULL, vm, kFlag_Invocation, functionName, has_method);
   }
 
   bool ForceCopy() {
     return Runtime::Current()->GetJavaVM()->force_copy;
   }
 
-  /*
-   * In some circumstances the VM will screen class names, but it doesn't
-   * for class lookup.  When things get bounced through a class loader, they
-   * can actually get normalized a couple of times; as a result, passing in
-   * a class name like "java.lang.Thread" instead of "java/lang/Thread" will
-   * work in some circumstances.
-   *
-   * This is incorrect and could cause strange behavior or compatibility
-   * problems, so we want to screen that out here.
-   *
-   * We expect "fully-qualified" class names, like "java/lang/Thread" or
-   * "[Ljava/lang/Object;".
-   */
-  void CheckClassName(const char* className) {
-    if (!IsValidJniClassName(className)) {
-      LOG(ERROR) << "JNI ERROR: illegal class name '" << className << "' (" << function_name_ << ")\n"
+  // Checks that 'class_name' is a valid "fully-qualified" JNI class name, like "java/lang/Thread"
+  // or "[Ljava/lang/Object;". A ClassLoader can actually normalize class names a couple of
+  // times, so using "java.lang.Thread" instead of "java/lang/Thread" might work in some
+  // circumstances, but this is incorrect.
+  void CheckClassName(const char* class_name) {
+    if (!IsValidJniClassName(class_name)) {
+      LOG(ERROR) << "JNI ERROR: illegal class name '" << class_name << "' (" << function_name_ << ")\n"
                  << "           (should be of the form 'java/lang/String', [Ljava/lang/String;' or '[[B')\n";
       JniAbort();
     }
@@ -653,16 +644,15 @@
   }
 
  private:
-  void Init(JNIEnv* env, JavaVM* vm, int flags, const char* functionName, bool hasMethod) {
+  // Set "has_method" to true if we have a valid thread with a method pointer.
+  // We won't have one before attaching a thread, after detaching a thread, or
+  // when shutting down the runtime.
+  void Init(JNIEnv* env, JavaVM* vm, int flags, const char* functionName, bool has_method) {
     env_ = reinterpret_cast<JNIEnvExt*>(env);
     vm_ = reinterpret_cast<JavaVMExt*>(vm);
     flags_ = flags;
     function_name_ = functionName;
-
-    // Set "hasMethod" to true if we have a valid thread with a method pointer.
-    // We won't have one before attaching a thread, after detaching a thread, or
-    // after destroying the VM.
-    has_method_ = hasMethod;
+    has_method_ = has_method;
   }
 
   /*
@@ -760,7 +750,7 @@
   void CheckThread(int flags) {
     Thread* self = Thread::Current();
     if (self == NULL) {
-      LOG(ERROR) << "JNI ERROR: non-VM thread making JNI calls";
+      LOG(ERROR) << "JNI ERROR: a thread is making JNI calls without being attached";
       JniAbort();
       return;
     }
@@ -1124,7 +1114,7 @@
 
 /*
  * Perform the array "release" operation, which may or may not copy data
- * back into the VM, and may or may not release the underlying storage.
+ * back into the managed heap, and may or may not release the underlying storage.
  */
 void ReleaseGuardedPACopy(JNIEnv* env, jarray java_array, void* dataBuf, int mode) {
   if (reinterpret_cast<uintptr_t>(dataBuf) == kNoCopyMagic) {
diff --git a/src/compiler/codegen/arm/ArmLIR.h b/src/compiler/codegen/arm/ArmLIR.h
index a43702c..2d3028a 100644
--- a/src/compiler/codegen/arm/ArmLIR.h
+++ b/src/compiler/codegen/arm/ArmLIR.h
@@ -171,7 +171,6 @@
 
 /*
  * Annotate special-purpose core registers:
- *   - VM: r6SELF
  *   - ARM architecture: r13sp, r14lr, and r15pc
  *
  * rPC, rFP, and rSELF are for architecture-independent code to use.
diff --git a/src/dalvik_system_VMDebug.cc b/src/dalvik_system_VMDebug.cc
index 557a421..76750d7 100644
--- a/src/dalvik_system_VMDebug.cc
+++ b/src/dalvik_system_VMDebug.cc
@@ -29,10 +29,6 @@
 
 namespace art {
 
-/*
- * Return a set of strings describing available VM features (this is chiefly
- * of interest to DDMS).
- */
 static jobjectArray VMDebug_getVmFeatureList(JNIEnv* env, jclass) {
   std::vector<std::string> features;
   features.push_back("method-trace-profiling");
@@ -211,18 +207,10 @@
   LOG(INFO) << "---";
 }
 
-/*
- * Dump the current thread's interpreted stack and abort the VM.  Useful
- * for seeing both interpreted and native stack traces.
- */
 static void VMDebug_crash(JNIEnv*, jclass) {
-  LOG(FATAL) << "Crashing VM on request";
+  LOG(FATAL) << "Crashing runtime on request";
 }
 
-/*
- * Provide a hook for gdb to hang to so that the VM can be stopped when
- * user-tagged source locations are being executed.
- */
 static void VMDebug_infopoint(JNIEnv*, jclass, jint id) {
   LOG(INFO) << "VMDebug infopoint " << id << " hit";
 }
diff --git a/src/debugger.cc b/src/debugger.cc
index 78acf31..1f7b0de 100644
--- a/src/debugger.cc
+++ b/src/debugger.cc
@@ -433,11 +433,11 @@
 
 void Dbg::GcDidFinish() {
   if (gDdmHpifWhen != HPIF_WHEN_NEVER) {
-    LOG(DEBUG) << "Sending VM heap info to DDM";
+    LOG(DEBUG) << "Sending heap info to DDM";
     DdmSendHeapInfo(gDdmHpifWhen);
   }
   if (gDdmHpsgWhen != HPSG_WHEN_NEVER) {
-    LOG(DEBUG) << "Dumping VM heap to DDM";
+    LOG(DEBUG) << "Dumping heap to DDM";
     DdmSendHeapSegments(false);
   }
   if (gDdmNhsgWhen != HPSG_WHEN_NEVER) {
@@ -2167,7 +2167,7 @@
   {
     /*
      * We change our (JDWP thread) status, which should be THREAD_RUNNING,
-     * so the VM can suspend for a GC if the invoke request causes us to
+     * so we can suspend for a GC if the invoke request causes us to
      * run out of memory.  It's also a good idea to change it before locking
      * the invokeReq mutex, although that should never be held for long.
      */
@@ -2225,7 +2225,7 @@
 void Dbg::ExecuteMethod(DebugInvokeReq* pReq) {
   Thread* self = Thread::Current();
 
-  // We can be called while an exception is pending in the VM.  We need
+  // We can be called while an exception is pending. We need
   // to preserve that across the method invocation.
   SirtRef<Throwable> old_exception(self->GetException());
   self->ClearException();
@@ -2358,7 +2358,7 @@
    *
    * We could avoid this by returning type/data/offset/length and having
    * the caller be aware of the object lifetime issues, but that
-   * integrates the JDWP code more tightly into the VM, and doesn't work
+   * integrates the JDWP code more tightly into the rest of the runtime, and doesn't work
    * if we have responses for multiple chunks.
    *
    * So we're pretty much stuck with copying data around multiple times.
diff --git a/src/debugger.h b/src/debugger.h
index fac9705..77c307c 100644
--- a/src/debugger.h
+++ b/src/debugger.h
@@ -123,7 +123,6 @@
 
   static void UndoDebuggerSuspensions();
 
-  // The debugger wants the VM to exit.
   static void Exit(int status);
 
   static void VisitRoots(Heap::RootVisitor* visitor, void* arg);
diff --git a/src/dex_verifier.cc b/src/dex_verifier.cc
index 6fd7c20..aedd599 100644
--- a/src/dex_verifier.cc
+++ b/src/dex_verifier.cc
@@ -1489,8 +1489,8 @@
     Fail(VERIFY_ERROR_GENERIC) << "branch offset of zero not allowed at" << (void*) cur_offset;
     return false;
   }
-  // Check for 32-bit overflow. This isn't strictly necessary if we can depend on the VM to have
-  // identical "wrap-around" behavior, but it's unwise to depend on that.
+  // Check for 32-bit overflow. This isn't strictly necessary if we can depend on the runtime
+  // to have identical "wrap-around" behavior, but it's unwise to depend on that.
   if (((int64_t) cur_offset + (int64_t) offset) != (int64_t) (cur_offset + offset)) {
     Fail(VERIFY_ERROR_GENERIC) << "branch target overflow " << (void*) cur_offset << " +" << offset;
     return false;
diff --git a/src/heap.cc b/src/heap.cc
index b12ff2d..d847682 100644
--- a/src/heap.cc
+++ b/src/heap.cc
@@ -482,11 +482,9 @@
     return ptr;
   }
 
-  // Most allocations should have succeeded by now, so the heap is
-  // really full, really fragmented, or the requested size is really
-  // big.  Do another GC, collecting SoftReferences this time.  The VM
-  // spec requires that all SoftReferences have been collected and
-  // cleared before throwing an OOME.
+  // Most allocations should have succeeded by now, so the heap is really full, really fragmented,
+  // or the requested size is really big. Do another GC, collecting SoftReferences this time. The
+  // VM spec requires that all SoftReferences have been collected and cleared before throwing OOME.
 
   // OLD-TODO: wait for the finalizers from the previous GC to finish
   VLOG(gc) << "Forcing collection of SoftReferences for " << PrettySize(alloc_size) << " allocation";
diff --git a/src/indirect_reference_table.h b/src/indirect_reference_table.h
index 72ff1c8..b1f6d8c 100644
--- a/src/indirect_reference_table.h
+++ b/src/indirect_reference_table.h
@@ -35,8 +35,8 @@
  * The table contains object references that are part of the GC root set.
  * When an object is added we return an IndirectRef that is not a valid
  * pointer but can be used to find the original value in O(1) time.
- * Conversions to and from indirect refs are performed on JNI method calls
- * in and out of the VM, so they need to be very fast.
+ * Conversions to and from indirect references are performed on upcalls
+ * and downcalls, so they need to be very fast.
  *
  * To be efficient for JNI local variable storage, we need to provide
  * operations that allow us to operate on segments of the table, where
@@ -156,8 +156,7 @@
  *
  * To get the desired behavior for JNI locals, we need to know the bottom
  * and top of the current "segment".  The top is managed internally, and
- * the bottom is passed in as a function argument (the VM keeps it in a
- * slot in the interpreted stack frame).  When we call a native method or
+ * the bottom is passed in as a function argument.  When we call a native method or
  * push a local frame, the current top index gets pushed on, and serves
  * as the new bottom.  When we pop a frame off, the value from the stack
  * becomes the new top index, and the value stored in the previous frame
@@ -169,12 +168,6 @@
  * Instead of a "bottom" argument we take a "cookie", which includes the
  * bottom index and the count of holes below the bottom.
  *
- * We need to minimize method call/return overhead.  If we store the
- * "cookie" externally, on the interpreted call stack, the VM can handle
- * pushes and pops with a single 4-byte load and store.  (We could also
- * store it internally in a public structure, but the local JNI refs are
- * logically tied to interpreted stack frames anyway.)
- *
  * Common alternative implementation: make IndirectRef a pointer to the
  * actual reference slot.  Instead of getting a table and doing a lookup,
  * the lookup can be done instantly.  Operations like determining the
diff --git a/src/jni_compiler.cc b/src/jni_compiler.cc
index 25d76ca..08d3109 100644
--- a/src/jni_compiler.cc
+++ b/src/jni_compiler.cc
@@ -45,7 +45,7 @@
   if (new_state == Thread::kRunnable) {
     /*
      * Change our status to Thread::kRunnable.  The transition requires
-     * that we check for pending suspension, because the VM considers
+     * that we check for pending suspension, because the runtime considers
      * us to be "asleep" in all other states, and another thread could
      * be performing a GC now.
      */
diff --git a/src/jni_internal.cc b/src/jni_internal.cc
index 714ca96..dbee18b 100644
--- a/src/jni_internal.cc
+++ b/src/jni_internal.cc
@@ -841,22 +841,7 @@
   static jthrowable ExceptionOccurred(JNIEnv* env) {
     ScopedJniThreadState ts(env);
     Object* exception = ts.Self()->GetException();
-    if (exception == NULL) {
-      return NULL;
-    } else {
-      // TODO: if adding a local reference failing causes the VM to abort
-      // then the following check will never occur.
-      jthrowable localException = AddLocalReference<jthrowable>(env, exception);
-      if (localException == NULL) {
-        // We were unable to add a new local reference, and threw a new
-        // exception.  We can't return "exception", because it's not a
-        // local reference.  So we have to return NULL, indicating that
-        // there was no exception, even though it's pretty much raining
-        // exceptions in here.
-        LOG(WARNING) << "JNI WARNING: addLocal/exception combo";
-      }
-      return localException;
-    }
+    return (exception != NULL) ? AddLocalReference<jthrowable>(env, exception) : NULL;
   }
 
   static void FatalError(JNIEnv* env, const char* msg) {
diff --git a/src/monitor.cc b/src/monitor.cc
index 6a7b66f..cfc7d49 100644
--- a/src/monitor.cc
+++ b/src/monitor.cc
@@ -613,12 +613,9 @@
         Inflate(self, obj);
       }
     } else if (LW_LOCK_OWNER(thin) == 0) {
-      /*
-       * The lock is unowned.  Install the thread id of the
-       * calling thread into the owner field.  This is the
-       * common case.  In performance critical code the JIT
-       * will have tried this before calling out to the VM.
-       */
+      // The lock is unowned. Install the thread id of the calling thread into the owner field.
+      // This is the common case: compiled code will have tried this before calling back into
+      // the runtime.
       newThin = thin | (threadId << LW_LOCK_OWNER_SHIFT);
       if (android_atomic_acquire_cas(thin, newThin, thinp) != 0) {
         // The acquire failed. Try again.
@@ -626,8 +623,8 @@
       }
     } else {
       VLOG(monitor) << StringPrintf("monitor: thread %d spin on lock %p (a %s) owned by %d",
-          threadId, thinp, PrettyTypeOf(obj).c_str(), LW_LOCK_OWNER(thin));
-      // The lock is owned by another thread. Notify the VM that we are about to wait.
+                                    threadId, thinp, PrettyTypeOf(obj).c_str(), LW_LOCK_OWNER(thin));
+      // The lock is owned by another thread. Notify the runtime that we are about to wait.
       self->monitor_enter_object_ = obj;
       Thread::State oldStatus = self->SetState(Thread::kBlocked);
       // Spin until the thin lock is released or inflated.
@@ -663,7 +660,7 @@
             }
           }
         } else {
-          // The thin lock was inflated by another thread. Let the VM know we are no longer
+          // The thin lock was inflated by another thread. Let the runtime know we are no longer
           // waiting and try again.
           VLOG(monitor) << "monitor: thread " << threadId
                         << " found lock " << (void*) thinp << " surprise-fattened by another thread";
@@ -673,7 +670,7 @@
         }
       }
       VLOG(monitor) << StringPrintf("monitor: thread %d spin on lock %p done", threadId, thinp);
-      // We have acquired the thin lock. Let the VM know that we are no longer waiting.
+      // We have acquired the thin lock. Let the runtime know that we are no longer waiting.
       self->monitor_enter_object_ = NULL;
       self->SetState(oldStatus);
       // Fatten the lock.
diff --git a/src/oatexec.cc b/src/oatexec.cc
index 340c058..4f7228b 100644
--- a/src/oatexec.cc
+++ b/src/oatexec.cc
@@ -103,7 +103,7 @@
   return env->ExceptionCheck() ? EXIT_FAILURE : EXIT_SUCCESS;
 }
 
-// Parse arguments.  Most of it just gets passed through to the VM.
+// Parse arguments.  Most of it just gets passed through to the runtime.
 // The JNI spec defines a handful of standard arguments.
 int oatexec(int argc, char** argv) {
   setvbuf(stdout, NULL, _IONBF, 0);
@@ -115,7 +115,7 @@
   // If we're adding any additional stuff, e.g. function hook specifiers,
   // add them to the count here.
   //
-  // We're over-allocating, because this includes the options to the VM
+  // We're over-allocating, because this includes the options to the runtime
   // plus the options to the program.
   int option_count = argc;
   UniquePtr<JavaVMOption[]> options(new JavaVMOption[option_count]());
@@ -125,6 +125,7 @@
   //
   // [Do we need to catch & handle "-jar" here?]
   bool need_extra = false;
+  const char* what = NULL;
   int curr_opt, arg_idx;
   for (curr_opt = arg_idx = 0; arg_idx < argc; arg_idx++) {
     if (argv[arg_idx][0] != '-' && !need_extra) {
@@ -135,19 +136,17 @@
     // Some options require an additional argument.
     need_extra = false;
     if (strcmp(argv[arg_idx], "-classpath") == 0 || strcmp(argv[arg_idx], "-cp") == 0) {
-      // others?
       need_extra = true;
+      what = argv[arg_idx];
     }
   }
 
   if (need_extra) {
-    fprintf(stderr, "VM requires value after last option flag\n");
+    fprintf(stderr, "%s must be followed by an additional argument giving a value\n", what);
     return EXIT_FAILURE;
   }
 
-  // Make sure they provided a class name.  We do this after VM init
-  // so that things like "-Xrunjdwp:help" have the opportunity to emit
-  // a usage statement.
+  // Make sure they provided a class name.
   if (arg_idx == argc) {
     fprintf(stderr, "Class name required\n");
     return EXIT_FAILURE;
@@ -163,11 +162,11 @@
   init_args.nOptions = curr_opt;
   init_args.ignoreUnrecognized = JNI_FALSE;
 
-  // Start VM.  The current thread becomes the main thread of the VM.
+  // Start the runtime. The current thread becomes the main thread.
   JavaVM* vm = NULL;
   JNIEnv* env = NULL;
   if (JNI_CreateJavaVM(&vm, &env, &init_args) != JNI_OK) {
-    fprintf(stderr, "VM init failed (check log file)\n");
+    fprintf(stderr, "runtime failed to initialize (check log for details)\n");
     return EXIT_FAILURE;
   }
 
@@ -179,7 +178,7 @@
   }
 
   if (vm->DestroyJavaVM() != 0) {
-    fprintf(stderr, "Warning: VM did not shut down cleanly\n");
+    fprintf(stderr, "Warning: runtime did not shut down cleanly\n");
     rc = EXIT_FAILURE;
   }
 
diff --git a/src/object.cc b/src/object.cc
index 13e4732..f72dc28 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -1243,7 +1243,7 @@
   size_t component_shift = sizeof(size_t) * 8 - 1 - CLZ(component_size);
   if (data_size >> component_shift != size_t(component_count) || size < data_size) {
     Thread::Current()->ThrowNewExceptionF("Ljava/lang/OutOfMemoryError;",
-        "%s of length %d exceeds the VM limit",
+        "%s of length %d would overflow",
         PrettyDescriptor(array_class).c_str(), component_count);
     return NULL;
   }
diff --git a/src/object.h b/src/object.h
index fee4dd0..4e3e850 100644
--- a/src/object.h
+++ b/src/object.h
@@ -1805,8 +1805,8 @@
   // (for String[][][], this will be String[][]). NULL for non-array classes.
   Class* component_type_;
 
-  // DexCache of resolved constant pool entries
-  // (will be NULL for VM-generated, e.g. arrays and primitive classes)
+  // DexCache of resolved constant pool entries (will be NULL for classes generated by the
+  // runtime such as arrays and primitive classes).
   DexCache* dex_cache_;
 
   // static, private, and <init> methods
diff --git a/src/object_utils.h b/src/object_utils.h
index 631425e..d22098d 100644
--- a/src/object_utils.h
+++ b/src/object_utils.h
@@ -398,15 +398,15 @@
     } else {
       Runtime* runtime = Runtime::Current();
       if (method_ == runtime->GetResolutionMethod()) {
-        return "<VM internal resolution method>";
+        return "<runtime internal resolution method>";
       } else if (method_ == runtime->GetCalleeSaveMethod(Runtime::kSaveAll)) {
-        return "<VM internal callee-save all registers method>";
+        return "<runtime internal callee-save all registers method>";
       } else if (method_ == runtime->GetCalleeSaveMethod(Runtime::kRefsOnly)) {
-        return "<VM internal callee-save reference registers method>";
+        return "<runtime internal callee-save reference registers method>";
       } else if (method_ == runtime->GetCalleeSaveMethod(Runtime::kRefsAndArgs)) {
-        return "<VM internal callee-save reference and argument registers method>";
+        return "<runtime internal callee-save reference and argument registers method>";
       } else {
-        return "<unknown VM internal method>";
+        return "<unknown runtime internal method>";
       }
     }
   }
diff --git a/src/runtime.cc b/src/runtime.cc
index 1378229..d07a6e5 100644
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -166,7 +166,7 @@
   // thread, whether or not that was the thread that failed.  By
   // stuffing a value into a bogus address, we cause a segmentation
   // fault in the current thread, and get a useful log from debuggerd.
-  // We can also trivially tell the difference between a VM crash and
+  // We can also trivially tell the difference between a crash and
   // a deliberate abort by looking at the fault address.
   *reinterpret_cast<char*>(0xdeadd00d) = 38;
   abort();
diff --git a/src/thread.cc b/src/thread.cc
index ce81a8b..7faf8f5 100644
--- a/src/thread.cc
+++ b/src/thread.cc
@@ -697,7 +697,7 @@
   if (new_state == Thread::kRunnable) {
     /*
      * Change our status to Thread::kRunnable.  The transition requires
-     * that we check for pending suspension, because the VM considers
+     * that we check for pending suspension, because the runtime considers
      * us to be "asleep" in all other states, and another thread could
      * be performing a GC now.
      *
diff --git a/src/thread.h b/src/thread.h
index d764ff3..7bf9c41 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -80,7 +80,7 @@
     kInitializing = 5,        // allocated, not yet running --- TODO: unnecessary?
     kStarting     = 6,        // native thread started, not yet ready to run managed code
     kNative       = 7,        // off in a JNI native method
-    kVmWait       = 8,        // waiting on a VM resource
+    kVmWait       = 8,        // waiting on an internal runtime resource
     kSuspended    = 9,        // suspended, usually by GC or debugger
   };
 
@@ -567,7 +567,7 @@
   // JDWP invoke-during-breakpoint support.
   DebugInvokeReq* debug_invoke_req_;
 
-  // TLS key used to retrieve the VM thread object.
+  // TLS key used to retrieve the Thread*.
   static pthread_key_t pthread_key_self_;
 
   // Additional stack used by method tracer to store method and return pc values.